// V8_HAS_CXX11_ALIGNOF - alignof(type) operator supported
// V8_HAS_CXX11_STATIC_ASSERT - static_assert() supported
// V8_HAS_CXX11_DELETE - deleted functions supported
-// V8_HAS_CXX11_FINAL - final marker supported
-// V8_HAS_CXX11_OVERRIDE - override marker supported
//
// Compiler-specific feature detection
//
# define V8_HAS_CXX11_ALIGNAS (__has_feature(cxx_alignas))
# define V8_HAS_CXX11_STATIC_ASSERT (__has_feature(cxx_static_assert))
# define V8_HAS_CXX11_DELETE (__has_feature(cxx_deleted_functions))
-# define V8_HAS_CXX11_FINAL (__has_feature(cxx_override_control))
-# define V8_HAS_CXX11_OVERRIDE (__has_feature(cxx_override_control))
#elif defined(__GNUC__)
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
masm->instr_at_put(pos, (masm->instr_at(pos) & ~B27) | (B24 | B20));
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
void GenerateCall(MacroAssembler* masm, Register target);
private:
- bool NeedsImmovableCode() OVERRIDE { return true; }
+ bool NeedsImmovableCode() override { return true; }
DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const OVERRIDE { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const override { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) { }
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
LOperand* length() { return inputs_[1]; }
LOperand* index() { return inputs_[2]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LModByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 2> {
+class LModI final : public LTemplateInstruction<1, 2, 2> {
public:
LModI(LOperand* left, LOperand* right, LOperand* temp, LOperand* temp2) {
inputs_[0] = left;
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
// Instruction for computing multiplier * multiplicand + addend.
-class LMultiplyAddD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplyAddD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplyAddD(LOperand* addend, LOperand* multiplier,
LOperand* multiplicand) {
// Instruction for computing minuend - multiplier * multiplicand.
-class LMultiplySubD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplySubD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplySubD(LOperand* minuend, LOperand* multiplier,
LOperand* multiplicand) {
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFloor(LOperand* value) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 3> {
+class LMathExp final : public LTemplateInstruction<1, 1, 3> {
public:
LMathExp(LOperand* value,
LOperand* double_temp,
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) {
inputs_[0] = value;
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathPowHalf(LOperand* value) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
Token::Value op() const { return hydrogen()->token(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasInstanceTypeAndBranch(LOperand* value) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 1> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 1> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LRSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LRSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LRSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 0> {
+class LBranch final : public LControlInstruction<1, 0> {
public:
explicit LBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 1> {
public:
LCmpMapAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* right() { return inputs_[2]; }
Token::Value op() const { return op_; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
inputs_[0] = value;
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadFunctionPrototype(LOperand* function) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 0> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreContextSlot(LOperand* context, LOperand* value) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagD(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 2> {
public:
LTaggedToI(LOperand* value,
LOperand* temp,
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LNumberUntagD(LOperand* value) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
bool NeedsCanonicalization() {
if (hydrogen()->value()->IsAdd() || hydrogen()->value()->IsSub() ||
hydrogen()->value()->IsMul() || hydrogen()->value()->IsDiv()) {
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* obj,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 1> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 1> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckInstanceType(LOperand* value) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 2> {
+class LAllocate final : public LTemplateInstruction<1, 2, 2> {
public:
LAllocate(LOperand* context,
LOperand* size,
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph) { }
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
namespace internal {
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) { }
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_,
&load_bool_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
Label* load_bool() { return &load_bool_; }
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_,
instr_->value(),
instr_->temp1(),
instr_->temp2(),
SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_,
instr_->value(),
instr_->temp1(),
instr_->temp2(),
UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
int* offset,
AllocationSiteMode mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static Mode GetMode(Code* stub) {
// Find the mode depending on the first two instructions.
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
void GenerateCall(MacroAssembler* masm, Register target);
private:
- bool NeedsImmovableCode() OVERRIDE { return true; }
+ bool NeedsImmovableCode() override { return true; }
DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
Register scratch1,
Register scratch2);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return (R != 0) && (result() != NULL); }
+ bool HasResult() const final { return (R != 0) && (result() != NULL); }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const OVERRIDE { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const override { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) { }
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments,
LOperand* length,
LOperand* length() { return inputs_[1]; }
LOperand* index() { return inputs_[2]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LAddE FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddE final : public LTemplateInstruction<1, 2, 0> {
public:
LAddE(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right)
: shift_(NO_SHIFT), shift_amount_(0) {
};
-class LAddS FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddS final : public LTemplateInstruction<1, 2, 0> {
public:
LAddS(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 3> {
+class LAllocate final : public LTemplateInstruction<1, 2, 3> {
public:
LAllocate(LOperand* context,
LOperand* size,
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 1> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 1> {
public:
explicit LArgumentsElements(LOperand* temp) {
temps_[0] = temp;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op,
LOperand* left,
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* right() { return inputs_[2]; }
Token::Value op() const { return op_; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
explicit LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right)
: shift_(NO_SHIFT), shift_amount_(0) {
};
-class LBitS FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitS final : public LTemplateInstruction<1, 2, 0> {
public:
LBitS(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LBranch FINAL : public LControlInstruction<1, 2> {
+class LBranch final : public LControlInstruction<1, 2> {
public:
explicit LBranch(LOperand* value, LOperand *temp1, LOperand *temp2) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 1> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 1> {
public:
explicit LCheckInstanceType(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 1> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 1> {
public:
explicit LCheckMaps(LOperand* value = NULL, LOperand* temp = NULL) {
inputs_[0] = value;
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped, LOperand* temp1) {
inputs_[0] = unclamped;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpHoleAndBranchD FINAL : public LControlInstruction<1, 1> {
+class LCmpHoleAndBranchD final : public LControlInstruction<1, 1> {
public:
explicit LCmpHoleAndBranchD(LOperand* object, LOperand* temp) {
inputs_[0] = object;
};
-class LCmpHoleAndBranchT FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranchT final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranchT(LOperand* object) {
inputs_[0] = object;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 1> {
public:
LCmpMapAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDateField final : public LTemplateInstruction<1, 1, 0> {
public:
LDateField(LOperand* date, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 1> {
public:
LDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LDoubleToIntOrSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToIntOrSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToIntOrSmi(LOperand* value) {
inputs_[0] = value;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 1> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 1> {
public:
LHasCachedArrayIndexAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 1> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 1> {
public:
LHasInstanceTypeAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LInnerAllocatedObject FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 0> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 2> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 2> {
public:
LIsConstructCallAndBranch(LOperand* temp1, LOperand* temp2) {
temps_[0] = temp1;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 2> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 2> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() const { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 1> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 1> {
public:
LLoadFunctionPrototype(LOperand* function, LOperand* temp) {
inputs_[0] = function;
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
uint32_t base_offset() const {
return this->hydrogen()->base_offset();
}
- void PrintDataTo(StringStream* stream) OVERRIDE {
+ void PrintDataTo(StringStream* stream) override {
this->elements()->PrintTo(stream);
stream->Add("[");
this->key()->PrintTo(stream);
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
LOperand* vector) {
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
LOperand* value() { return this->inputs_[0]; }
BuiltinFunctionId op() const { return this->hydrogen()->op(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)
};
-class LMathAbs FINAL : public LUnaryMathOperation<0> {
+class LMathAbs final : public LUnaryMathOperation<0> {
public:
explicit LMathAbs(LOperand* value) : LUnaryMathOperation<0>(value) {}
};
-class LMathExp FINAL : public LUnaryMathOperation<4> {
+class LMathExp final : public LUnaryMathOperation<4> {
public:
LMathExp(LOperand* value,
LOperand* double_temp1,
// Math.floor with a double result.
-class LMathFloorD FINAL : public LUnaryMathOperation<0> {
+class LMathFloorD final : public LUnaryMathOperation<0> {
public:
explicit LMathFloorD(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathFloorD, "math-floor-d")
// Math.floor with an integer result.
-class LMathFloorI FINAL : public LUnaryMathOperation<0> {
+class LMathFloorI final : public LUnaryMathOperation<0> {
public:
explicit LMathFloorI(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathFloorI, "math-floor-i")
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LMathLog FINAL : public LUnaryMathOperation<0> {
+class LMathLog final : public LUnaryMathOperation<0> {
public:
explicit LMathLog(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log")
};
-class LMathClz32 FINAL : public LUnaryMathOperation<0> {
+class LMathClz32 final : public LUnaryMathOperation<0> {
public:
explicit LMathClz32(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32")
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathPowHalf FINAL : public LUnaryMathOperation<0> {
+class LMathPowHalf final : public LUnaryMathOperation<0> {
public:
explicit LMathPowHalf(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half")
// Math.round with an integer result.
-class LMathRoundD FINAL : public LUnaryMathOperation<0> {
+class LMathRoundD final : public LUnaryMathOperation<0> {
public:
explicit LMathRoundD(LOperand* value)
: LUnaryMathOperation<0>(value) {
// Math.round with an integer result.
-class LMathRoundI FINAL : public LUnaryMathOperation<1> {
+class LMathRoundI final : public LUnaryMathOperation<1> {
public:
LMathRoundI(LOperand* value, LOperand* temp1)
: LUnaryMathOperation<1>(value) {
};
-class LMathFround FINAL : public LUnaryMathOperation<0> {
+class LMathFround final : public LUnaryMathOperation<0> {
public:
explicit LMathFround(LOperand* value) : LUnaryMathOperation<0>(value) {}
};
-class LMathSqrt FINAL : public LUnaryMathOperation<0> {
+class LMathSqrt final : public LUnaryMathOperation<0> {
public:
explicit LMathSqrt(LOperand* value) : LUnaryMathOperation<0>(value) { }
DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt")
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 1> {
public:
LModByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LModI final : public LTemplateInstruction<1, 2, 0> {
public:
LModI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMulConstIS FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulConstIS final : public LTemplateInstruction<1, 2, 0> {
public:
LMulConstIS(LOperand* left, LConstantOperand* right) {
inputs_[0] = left;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMulS FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulS final : public LTemplateInstruction<1, 2, 0> {
public:
LMulS(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagD(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
explicit LNumberTagU(LOperand* value,
LOperand* temp1,
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberUntagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPreparePushArguments FINAL : public LTemplateInstruction<0, 0, 0> {
+class LPreparePushArguments final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LPreparePushArguments(int argc) : argc_(argc) {}
};
-class LPushArguments FINAL : public LTemplateResultInstruction<0> {
+class LPushArguments final : public LTemplateResultInstruction<0> {
public:
explicit LPushArguments(Zone* zone,
int capacity = kRecommendedMaxPushedArgs)
private:
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
inputs_[0] = value;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 1> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 1> {
public:
LSeqStringGetChar(LOperand* string,
LOperand* index,
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 1> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 1> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
}
uint32_t base_offset() const { return this->hydrogen()->base_offset(); }
- void PrintDataTo(StringStream* stream) OVERRIDE {
+ void PrintDataTo(StringStream* stream) override {
this->elements()->PrintTo(stream);
stream->Add("[");
this->key()->PrintTo(stream);
};
-class LStoreKeyedExternal FINAL : public LStoreKeyed<1> {
+class LStoreKeyedExternal final : public LStoreKeyed<1> {
public:
LStoreKeyedExternal(LOperand* elements, LOperand* key, LOperand* value,
LOperand* temp) :
};
-class LStoreKeyedFixed FINAL : public LStoreKeyed<1> {
+class LStoreKeyedFixed final : public LStoreKeyed<1> {
public:
LStoreKeyedFixed(LOperand* elements, LOperand* key, LOperand* value,
LOperand* temp) :
};
-class LStoreKeyedFixedDouble FINAL : public LStoreKeyed<1> {
+class LStoreKeyedFixedDouble final : public LStoreKeyed<1> {
public:
LStoreKeyedFixedDouble(LOperand* elements, LOperand* key, LOperand* value,
LOperand* temp) :
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* obj,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 2> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 2> {
public:
LStoreNamedField(LOperand* object, LOperand* value,
LOperand* temp0, LOperand* temp1) {
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL: public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
Token::Value op() const { return hydrogen()->token(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 2> {
public:
explicit LTaggedToI(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LShiftS FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftS final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftS(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 1> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object,
LOperand* temp) {
LOperand* code_object() { return inputs_[1]; }
LOperand* temp() { return temps_[0]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right)
: shift_(NO_SHIFT), shift_amount_(0) {
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 2> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 2> {
public:
LTrapAllocationMemento(LOperand* object, LOperand* temp1, LOperand* temp2) {
inputs_[0] = object;
};
-class LTruncateDoubleToIntOrSmi FINAL
- : public LTemplateInstruction<1, 1, 0> {
+class LTruncateDoubleToIntOrSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LTruncateDoubleToIntOrSmi(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 2> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 2> {
public:
LTypeofIsAndBranch(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
Handle<String> type_literal() const { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 1> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 1> {
public:
LCheckMapValue(LOperand* value, LOperand* map, LOperand* temp) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph) { }
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
namespace internal {
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
void RestoreCallerDoubles();
// Code generation steps. Returns true if code generation should continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
LInstruction* instr);
// Support for recording safepoint and position information.
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
void RecordSafepoint(LPointerMap* pointers,
Safepoint::Kind kind,
int arguments,
void RecordSafepointWithLazyDeopt(LInstruction* instr,
SafepointMode safepoint_mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
ZoneList<LEnvironment*> deoptimizations_;
ZoneList<Deoptimizer::JumpTableEntry*> jump_table_;
namespace {
-struct PerThreadAssertKeyConstructTrait FINAL {
+struct PerThreadAssertKeyConstructTrait final {
static void Construct(base::Thread::LocalStorageKey* key) {
*key = base::Thread::CreateThreadLocalKey();
}
} // namespace
-class PerThreadAssertData FINAL {
+class PerThreadAssertData final {
public:
PerThreadAssertData() : nesting_level_(0) {
for (int i = 0; i < LAST_PER_THREAD_ASSERT_TYPE; i++) {
namespace internal {
-class AstNumberingVisitor FINAL : public AstVisitor {
+class AstNumberingVisitor final : public AstVisitor {
public:
explicit AstNumberingVisitor(Isolate* isolate, Zone* zone)
: AstVisitor(),
private:
// AST node visitor interface.
-#define DEFINE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DEFINE_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DEFINE_VISIT)
#undef DEFINE_VISIT
bool Finish(FunctionLiteral* node);
- void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitStatements(ZoneList<Statement*>* statements) override;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
void VisitArguments(ZoneList<Expression*>* arguments);
void VisitObjectLiteralProperty(ObjectLiteralProperty* property);
explicit AstRawStringInternalizationKey(const AstRawString* string)
: string_(string) {}
- bool IsMatch(Object* other) OVERRIDE {
+ bool IsMatch(Object* other) override {
if (string_->is_one_byte_)
return String::cast(other)->IsOneByteEqualTo(string_->literal_bytes_);
return String::cast(other)->IsTwoByteEqualTo(
Vector<const uint16_t>::cast(string_->literal_bytes_));
}
- uint32_t Hash() OVERRIDE { return string_->hash() >> Name::kHashShift; }
+ uint32_t Hash() override { return string_->hash() >> Name::kHashShift; }
- uint32_t HashForObject(Object* key) OVERRIDE {
+ uint32_t HashForObject(Object* key) override {
return String::cast(key)->Hash();
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
if (string_->is_one_byte_)
return isolate->factory()->NewOneByteInternalizedString(
string_->literal_bytes_, string_->hash());
class AstRawString : public AstString {
public:
- int length() const OVERRIDE {
+ int length() const override {
if (is_one_byte_)
return literal_bytes_.length();
return literal_bytes_.length() / 2;
int byte_length() const { return literal_bytes_.length(); }
- void Internalize(Isolate* isolate) OVERRIDE;
+ void Internalize(Isolate* isolate) override;
bool AsArrayIndex(uint32_t* index) const;
: left_(left),
right_(right) {}
- int length() const OVERRIDE { return left_->length() + right_->length(); }
+ int length() const override { return left_->length() + right_->length(); }
- void Internalize(Isolate* isolate) OVERRIDE;
+ void Internalize(Isolate* isolate) override;
private:
friend class AstValueFactory;
// in as many cases as possible, to make it more difficult for incorrect
// parses to look as correct ones which is likely if the input and
// output formats are alike.
-class RegExpUnparser FINAL : public RegExpVisitor {
+class RegExpUnparser final : public RegExpVisitor {
public:
RegExpUnparser(std::ostream& os, Zone* zone) : os_(os), zone_(zone) {}
void VisitCharacterRange(CharacterRange that);
-#define MAKE_CASE(Name) virtual void* Visit##Name(RegExp##Name*, \
- void* data) OVERRIDE;
+#define MAKE_CASE(Name) \
+ virtual void* Visit##Name(RegExp##Name*, void* data) override;
FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
#undef MAKE_CASE
private:
#define DECLARE_NODE_TYPE(type) \
- void Accept(AstVisitor* v) OVERRIDE; \
- AstNode::NodeType node_type() const FINAL { return AstNode::k##type; } \
+ void Accept(AstVisitor* v) override; \
+ AstNode::NodeType node_type() const final { return AstNode::k##type; } \
friend class AstNodeFactory;
};
-class VariableICSlotPair FINAL {
+class VariableICSlotPair final {
public:
VariableICSlotPair(Variable* variable, FeedbackVectorICSlot slot)
: variable_(variable), slot_(slot) {}
typedef List<VariableICSlotPair> ICSlotCache;
-class AstProperties FINAL BASE_EMBEDDED {
+class AstProperties final BASE_EMBEDDED {
public:
class Flags : public EnumSet<AstPropertiesFlag, int> {};
};
-class SmallMapList FINAL {
+class SmallMapList final {
public:
SmallMapList() {}
SmallMapList(int capacity, Zone* zone) : list_(capacity, zone) {}
ZoneList<const AstRawString*>* labels() const { return labels_; }
// Type testing & conversion.
- BreakableStatement* AsBreakableStatement() FINAL { return this; }
+ BreakableStatement* AsBreakableStatement() final { return this; }
// Code generation
Label* break_target() { return &break_target_; }
};
-class Block FINAL : public BreakableStatement {
+class Block final : public BreakableStatement {
public:
DECLARE_NODE_TYPE(Block)
static int num_ids() { return parent_num_ids() + 1; }
BailoutId DeclsId() const { return BailoutId(local_id(0)); }
- bool IsJump() const OVERRIDE {
+ bool IsJump() const override {
return !statements_.is_empty() && statements_.last()->IsJump()
&& labels() == NULL; // Good enough as an approximation...
}
};
-class VariableDeclaration FINAL : public Declaration {
+class VariableDeclaration final : public Declaration {
public:
DECLARE_NODE_TYPE(VariableDeclaration)
- InitializationFlag initialization() const OVERRIDE {
+ InitializationFlag initialization() const override {
return mode() == VAR ? kCreatedInitialized : kNeedsInitialization;
}
};
-class FunctionDeclaration FINAL : public Declaration {
+class FunctionDeclaration final : public Declaration {
public:
DECLARE_NODE_TYPE(FunctionDeclaration)
FunctionLiteral* fun() const { return fun_; }
- InitializationFlag initialization() const OVERRIDE {
+ InitializationFlag initialization() const override {
return kCreatedInitialized;
}
- bool IsInlineable() const OVERRIDE;
+ bool IsInlineable() const override;
protected:
FunctionDeclaration(Zone* zone,
};
-class ModuleDeclaration FINAL : public Declaration {
+class ModuleDeclaration final : public Declaration {
public:
DECLARE_NODE_TYPE(ModuleDeclaration)
Module* module() const { return module_; }
- InitializationFlag initialization() const OVERRIDE {
+ InitializationFlag initialization() const override {
return kCreatedInitialized;
}
};
-class ImportDeclaration FINAL : public Declaration {
+class ImportDeclaration final : public Declaration {
public:
DECLARE_NODE_TYPE(ImportDeclaration)
DCHECK(module_specifier_ == NULL);
module_specifier_ = module_specifier;
}
- InitializationFlag initialization() const OVERRIDE {
+ InitializationFlag initialization() const override {
return kNeedsInitialization;
}
};
-class ExportDeclaration FINAL : public Declaration {
+class ExportDeclaration final : public Declaration {
public:
DECLARE_NODE_TYPE(ExportDeclaration)
- InitializationFlag initialization() const OVERRIDE {
+ InitializationFlag initialization() const override {
return kCreatedInitialized;
}
};
-class ModuleLiteral FINAL : public Module {
+class ModuleLiteral final : public Module {
public:
DECLARE_NODE_TYPE(ModuleLiteral)
};
-class ModulePath FINAL : public Module {
+class ModulePath final : public Module {
public:
DECLARE_NODE_TYPE(ModulePath)
};
-class ModuleUrl FINAL : public Module {
+class ModuleUrl final : public Module {
public:
DECLARE_NODE_TYPE(ModuleUrl)
};
-class ModuleStatement FINAL : public Statement {
+class ModuleStatement final : public Statement {
public:
DECLARE_NODE_TYPE(ModuleStatement)
class IterationStatement : public BreakableStatement {
public:
// Type testing & conversion.
- IterationStatement* AsIterationStatement() FINAL { return this; }
+ IterationStatement* AsIterationStatement() final { return this; }
Statement* body() const { return body_; }
};
-class DoWhileStatement FINAL : public IterationStatement {
+class DoWhileStatement final : public IterationStatement {
public:
DECLARE_NODE_TYPE(DoWhileStatement)
Expression* cond() const { return cond_; }
static int num_ids() { return parent_num_ids() + 2; }
- BailoutId ContinueId() const OVERRIDE { return BailoutId(local_id(0)); }
- BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
+ BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
+ BailoutId StackCheckId() const override { return BackEdgeId(); }
BailoutId BackEdgeId() const { return BailoutId(local_id(1)); }
protected:
};
-class WhileStatement FINAL : public IterationStatement {
+class WhileStatement final : public IterationStatement {
public:
DECLARE_NODE_TYPE(WhileStatement)
Expression* cond() const { return cond_; }
static int num_ids() { return parent_num_ids() + 1; }
- BailoutId ContinueId() const OVERRIDE { return EntryId(); }
- BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+ BailoutId ContinueId() const override { return EntryId(); }
+ BailoutId StackCheckId() const override { return BodyId(); }
BailoutId BodyId() const { return BailoutId(local_id(0)); }
protected:
};
-class ForStatement FINAL : public IterationStatement {
+class ForStatement final : public IterationStatement {
public:
DECLARE_NODE_TYPE(ForStatement)
Statement* next() const { return next_; }
static int num_ids() { return parent_num_ids() + 2; }
- BailoutId ContinueId() const OVERRIDE { return BailoutId(local_id(0)); }
- BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+ BailoutId ContinueId() const override { return BailoutId(local_id(0)); }
+ BailoutId StackCheckId() const override { return BodyId(); }
BailoutId BodyId() const { return BailoutId(local_id(1)); }
protected:
};
-class ForInStatement FINAL : public ForEachStatement {
+class ForInStatement final : public ForEachStatement {
public:
DECLARE_NODE_TYPE(ForInStatement)
// Type feedback information.
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(1, 0);
}
- void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+ void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
for_in_feedback_slot_ = slot;
}
BailoutId ToObjectId() const { return BailoutId(local_id(3)); }
BailoutId FilterId() const { return BailoutId(local_id(4)); }
BailoutId AssignmentId() const { return BailoutId(local_id(5)); }
- BailoutId ContinueId() const OVERRIDE { return EntryId(); }
- BailoutId StackCheckId() const OVERRIDE { return BodyId(); }
+ BailoutId ContinueId() const override { return EntryId(); }
+ BailoutId StackCheckId() const override { return BodyId(); }
protected:
ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
};
-class ForOfStatement FINAL : public ForEachStatement {
+class ForOfStatement final : public ForEachStatement {
public:
DECLARE_NODE_TYPE(ForOfStatement)
return assign_each_;
}
- BailoutId ContinueId() const OVERRIDE { return EntryId(); }
- BailoutId StackCheckId() const OVERRIDE { return BackEdgeId(); }
+ BailoutId ContinueId() const override { return EntryId(); }
+ BailoutId StackCheckId() const override { return BackEdgeId(); }
static int num_ids() { return parent_num_ids() + 1; }
BailoutId BackEdgeId() const { return BailoutId(local_id(0)); }
};
-class ExpressionStatement FINAL : public Statement {
+class ExpressionStatement final : public Statement {
public:
DECLARE_NODE_TYPE(ExpressionStatement)
void set_expression(Expression* e) { expression_ = e; }
Expression* expression() const { return expression_; }
- bool IsJump() const OVERRIDE { return expression_->IsThrow(); }
+ bool IsJump() const override { return expression_->IsThrow(); }
protected:
ExpressionStatement(Zone* zone, Expression* expression, int pos)
class JumpStatement : public Statement {
public:
- bool IsJump() const FINAL { return true; }
+ bool IsJump() const final { return true; }
protected:
explicit JumpStatement(Zone* zone, int pos) : Statement(zone, pos) {}
};
-class ContinueStatement FINAL : public JumpStatement {
+class ContinueStatement final : public JumpStatement {
public:
DECLARE_NODE_TYPE(ContinueStatement)
};
-class BreakStatement FINAL : public JumpStatement {
+class BreakStatement final : public JumpStatement {
public:
DECLARE_NODE_TYPE(BreakStatement)
};
-class ReturnStatement FINAL : public JumpStatement {
+class ReturnStatement final : public JumpStatement {
public:
DECLARE_NODE_TYPE(ReturnStatement)
};
-class WithStatement FINAL : public Statement {
+class WithStatement final : public Statement {
public:
DECLARE_NODE_TYPE(WithStatement)
};
-class CaseClause FINAL : public Expression {
+class CaseClause final : public Expression {
public:
DECLARE_NODE_TYPE(CaseClause)
};
-class SwitchStatement FINAL : public BreakableStatement {
+class SwitchStatement final : public BreakableStatement {
public:
DECLARE_NODE_TYPE(SwitchStatement)
// the parser implicitly creates an empty statement. Use the
// HasThenStatement() and HasElseStatement() functions to check if a
// given if-statement has a then- or an else-part containing code.
-class IfStatement FINAL : public Statement {
+class IfStatement final : public Statement {
public:
DECLARE_NODE_TYPE(IfStatement)
Statement* then_statement() const { return then_statement_; }
Statement* else_statement() const { return else_statement_; }
- bool IsJump() const OVERRIDE {
+ bool IsJump() const override {
return HasThenStatement() && then_statement()->IsJump()
&& HasElseStatement() && else_statement()->IsJump();
}
};
-class TryCatchStatement FINAL : public TryStatement {
+class TryCatchStatement final : public TryStatement {
public:
DECLARE_NODE_TYPE(TryCatchStatement)
};
-class TryFinallyStatement FINAL : public TryStatement {
+class TryFinallyStatement final : public TryStatement {
public:
DECLARE_NODE_TYPE(TryFinallyStatement)
};
-class DebuggerStatement FINAL : public Statement {
+class DebuggerStatement final : public Statement {
public:
DECLARE_NODE_TYPE(DebuggerStatement)
};
-class EmptyStatement FINAL : public Statement {
+class EmptyStatement final : public Statement {
public:
DECLARE_NODE_TYPE(EmptyStatement)
};
-class Literal FINAL : public Expression {
+class Literal final : public Expression {
public:
DECLARE_NODE_TYPE(Literal)
- bool IsPropertyName() const OVERRIDE { return value_->IsPropertyName(); }
+ bool IsPropertyName() const override { return value_->IsPropertyName(); }
Handle<String> AsPropertyName() {
DCHECK(IsPropertyName());
return value_->AsString();
}
- bool ToBooleanIsTrue() const OVERRIDE { return value()->BooleanValue(); }
- bool ToBooleanIsFalse() const OVERRIDE { return !value()->BooleanValue(); }
+ bool ToBooleanIsTrue() const override { return value()->BooleanValue(); }
+ bool ToBooleanIsFalse() const override { return !value()->BooleanValue(); }
Handle<Object> value() const { return value_->value(); }
const AstValue* raw_value() const { return value_; }
// Property is used for passing information
// about an object literal's properties from the parser
// to the code generator.
-class ObjectLiteralProperty FINAL : public ZoneObject {
+class ObjectLiteralProperty final : public ZoneObject {
public:
enum Kind {
CONSTANT, // Property with constant value (compile time).
// An object literal has a boilerplate object that is used
// for minimizing the work when constructing it at runtime.
-class ObjectLiteral FINAL : public MaterializedLiteral {
+class ObjectLiteral final : public MaterializedLiteral {
public:
typedef ObjectLiteralProperty Property;
// Node for capturing a regexp literal.
-class RegExpLiteral FINAL : public MaterializedLiteral {
+class RegExpLiteral final : public MaterializedLiteral {
public:
DECLARE_NODE_TYPE(RegExpLiteral)
// An array literal has a literals object that is used
// for minimizing the work when constructing it at runtime.
-class ArrayLiteral FINAL : public MaterializedLiteral {
+class ArrayLiteral final : public MaterializedLiteral {
public:
DECLARE_NODE_TYPE(ArrayLiteral)
};
-class VariableProxy FINAL : public Expression {
+class VariableProxy final : public Expression {
public:
DECLARE_NODE_TYPE(VariableProxy)
- bool IsValidReferenceExpression() const OVERRIDE { return !is_this(); }
+ bool IsValidReferenceExpression() const override { return !is_this(); }
bool IsArguments() const { return is_resolved() && var()->is_arguments(); }
}
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE;
+ Isolate* isolate, const ICSlotCache* cache) override;
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE;
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+ ICSlotCache* cache) override;
+ Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
FeedbackVectorICSlot VariableFeedbackSlot() {
DCHECK(!UsesVariableFeedbackSlot() || !variable_feedback_slot_.IsInvalid());
return variable_feedback_slot_;
};
-class Property FINAL : public Expression {
+class Property final : public Expression {
public:
DECLARE_NODE_TYPE(Property)
- bool IsValidReferenceExpression() const OVERRIDE { return true; }
+ bool IsValidReferenceExpression() const override { return true; }
Expression* obj() const { return obj_; }
Expression* key() const { return key_; }
}
// Type feedback information.
- bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
- SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
- KeyedAccessStoreMode GetStoreMode() const OVERRIDE { return STANDARD_STORE; }
- IcCheckType GetKeyType() const OVERRIDE {
+ bool IsMonomorphic() override { return receiver_types_.length() == 1; }
+ SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+ KeyedAccessStoreMode GetStoreMode() const override { return STANDARD_STORE; }
+ IcCheckType GetKeyType() const override {
return KeyTypeField::decode(bit_field_);
}
bool IsUninitialized() const {
}
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
}
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE {
+ ICSlotCache* cache) override {
property_feedback_slot_ = slot;
}
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE {
+ Code::Kind FeedbackICSlotKind(int index) override {
return key()->IsPropertyName() ? Code::LOAD_IC : Code::KEYED_LOAD_IC;
}
};
-class Call FINAL : public Expression {
+class Call final : public Expression {
public:
DECLARE_NODE_TYPE(Call)
// Type feedback information.
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE;
+ Isolate* isolate, const ICSlotCache* cache) override;
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE {
+ ICSlotCache* cache) override {
ic_slot_or_slot_ = slot.ToInt();
}
- void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+ void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
ic_slot_or_slot_ = slot.ToInt();
}
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::CALL_IC; }
+ Code::Kind FeedbackICSlotKind(int index) override { return Code::CALL_IC; }
FeedbackVectorSlot CallFeedbackSlot() const {
DCHECK(ic_slot_or_slot_ != FeedbackVectorSlot::Invalid().ToInt());
return FeedbackVectorICSlot(ic_slot_or_slot_);
}
- SmallMapList* GetReceiverTypes() OVERRIDE {
+ SmallMapList* GetReceiverTypes() override {
if (expression()->IsProperty()) {
return expression()->AsProperty()->GetReceiverTypes();
}
return NULL;
}
- bool IsMonomorphic() OVERRIDE {
+ bool IsMonomorphic() override {
if (expression()->IsProperty()) {
return expression()->AsProperty()->IsMonomorphic();
}
};
-class CallNew FINAL : public Expression {
+class CallNew final : public Expression {
public:
DECLARE_NODE_TYPE(CallNew)
// Type feedback information.
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(FLAG_pretenuring_call_new ? 2 : 1, 0);
}
- void SetFirstFeedbackSlot(FeedbackVectorSlot slot) OVERRIDE {
+ void SetFirstFeedbackSlot(FeedbackVectorSlot slot) override {
callnew_feedback_slot_ = slot;
}
return CallNewFeedbackSlot().next();
}
- bool IsMonomorphic() OVERRIDE { return is_monomorphic_; }
+ bool IsMonomorphic() override { return is_monomorphic_; }
Handle<JSFunction> target() const { return target_; }
Handle<AllocationSite> allocation_site() const {
return allocation_site_;
// language construct. Instead it is used to call a C or JS function
// with a set of arguments. This is used from the builtins that are
// implemented in JavaScript (see "v8natives.js").
-class CallRuntime FINAL : public Expression {
+class CallRuntime final : public Expression {
public:
DECLARE_NODE_TYPE(CallRuntime)
return FLAG_vector_ics && is_jsruntime();
}
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(0, HasCallRuntimeFeedbackSlot() ? 1 : 0);
}
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE {
+ ICSlotCache* cache) override {
callruntime_feedback_slot_ = slot;
}
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+ Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
FeedbackVectorICSlot CallRuntimeFeedbackSlot() {
DCHECK(!HasCallRuntimeFeedbackSlot() ||
};
-class UnaryOperation FINAL : public Expression {
+class UnaryOperation final : public Expression {
public:
DECLARE_NODE_TYPE(UnaryOperation)
BailoutId MaterializeTrueId() const { return BailoutId(local_id(0)); }
BailoutId MaterializeFalseId() const { return BailoutId(local_id(1)); }
- virtual void RecordToBooleanTypeFeedback(
- TypeFeedbackOracle* oracle) OVERRIDE;
+ virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
protected:
UnaryOperation(Zone* zone, Token::Value op, Expression* expression, int pos)
};
-class BinaryOperation FINAL : public Expression {
+class BinaryOperation final : public Expression {
public:
DECLARE_NODE_TYPE(BinaryOperation)
if (arg.IsJust()) fixed_right_arg_value_ = arg.FromJust();
}
- virtual void RecordToBooleanTypeFeedback(
- TypeFeedbackOracle* oracle) OVERRIDE;
+ virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) override;
protected:
BinaryOperation(Zone* zone, Token::Value op, Expression* left,
};
-class CountOperation FINAL : public Expression {
+class CountOperation final : public Expression {
public:
DECLARE_NODE_TYPE(CountOperation)
Expression* expression() const { return expression_; }
- bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
- SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
- IcCheckType GetKeyType() const OVERRIDE {
+ bool IsMonomorphic() override { return receiver_types_.length() == 1; }
+ SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+ IcCheckType GetKeyType() const override {
return KeyTypeField::decode(bit_field_);
}
- KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+ KeyedAccessStoreMode GetStoreMode() const override {
return StoreModeField::decode(bit_field_);
}
Type* type() const { return type_; }
};
-class CompareOperation FINAL : public Expression {
+class CompareOperation final : public Expression {
public:
DECLARE_NODE_TYPE(CompareOperation)
};
-class Spread FINAL : public Expression {
+class Spread final : public Expression {
public:
DECLARE_NODE_TYPE(Spread)
};
-class Conditional FINAL : public Expression {
+class Conditional final : public Expression {
public:
DECLARE_NODE_TYPE(Conditional)
};
-class Assignment FINAL : public Expression {
+class Assignment final : public Expression {
public:
DECLARE_NODE_TYPE(Assignment)
// Type feedback information.
TypeFeedbackId AssignmentFeedbackId() { return TypeFeedbackId(local_id(1)); }
- bool IsMonomorphic() OVERRIDE { return receiver_types_.length() == 1; }
+ bool IsMonomorphic() override { return receiver_types_.length() == 1; }
bool IsUninitialized() const {
return IsUninitializedField::decode(bit_field_);
}
bool HasNoTypeInformation() {
return IsUninitializedField::decode(bit_field_);
}
- SmallMapList* GetReceiverTypes() OVERRIDE { return &receiver_types_; }
- IcCheckType GetKeyType() const OVERRIDE {
+ SmallMapList* GetReceiverTypes() override { return &receiver_types_; }
+ IcCheckType GetKeyType() const override {
return KeyTypeField::decode(bit_field_);
}
- KeyedAccessStoreMode GetStoreMode() const OVERRIDE {
+ KeyedAccessStoreMode GetStoreMode() const override {
return StoreModeField::decode(bit_field_);
}
void set_is_uninitialized(bool b) {
};
-class Yield FINAL : public Expression {
+class Yield final : public Expression {
public:
DECLARE_NODE_TYPE(Yield)
return FLAG_vector_ics && (yield_kind() == kDelegating);
}
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(0, HasFeedbackSlots() ? 3 : 0);
}
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE {
+ ICSlotCache* cache) override {
yield_first_feedback_slot_ = slot;
}
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE {
+ Code::Kind FeedbackICSlotKind(int index) override {
return index == 0 ? Code::KEYED_LOAD_IC : Code::LOAD_IC;
}
};
-class Throw FINAL : public Expression {
+class Throw final : public Expression {
public:
DECLARE_NODE_TYPE(Throw)
};
-class FunctionLiteral FINAL : public Expression {
+class FunctionLiteral final : public Expression {
public:
enum FunctionType {
ANONYMOUS_EXPRESSION,
};
-class ClassLiteral FINAL : public Expression {
+class ClassLiteral final : public Expression {
public:
typedef ObjectLiteralProperty Property;
};
-class NativeFunctionLiteral FINAL : public Expression {
+class NativeFunctionLiteral final : public Expression {
public:
DECLARE_NODE_TYPE(NativeFunctionLiteral)
};
-class ThisFunction FINAL : public Expression {
+class ThisFunction final : public Expression {
public:
DECLARE_NODE_TYPE(ThisFunction)
};
-class SuperReference FINAL : public Expression {
+class SuperReference final : public Expression {
public:
DECLARE_NODE_TYPE(SuperReference)
// Type feedback information.
virtual FeedbackVectorRequirements ComputeFeedbackRequirements(
- Isolate* isolate, const ICSlotCache* cache) OVERRIDE {
+ Isolate* isolate, const ICSlotCache* cache) override {
return FeedbackVectorRequirements(0, FLAG_vector_ics ? 1 : 0);
}
void SetFirstFeedbackICSlot(FeedbackVectorICSlot slot,
- ICSlotCache* cache) OVERRIDE {
+ ICSlotCache* cache) override {
homeobject_feedback_slot_ = slot;
}
- Code::Kind FeedbackICSlotKind(int index) OVERRIDE { return Code::LOAD_IC; }
+ Code::Kind FeedbackICSlotKind(int index) override { return Code::LOAD_IC; }
FeedbackVectorICSlot HomeObjectFeedbackSlot() {
DCHECK(!FLAG_vector_ics || !homeobject_feedback_slot_.IsInvalid());
};
-class RegExpDisjunction FINAL : public RegExpTree {
+class RegExpDisjunction final : public RegExpTree {
public:
explicit RegExpDisjunction(ZoneList<RegExpTree*>* alternatives);
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpDisjunction* AsDisjunction() OVERRIDE;
- Interval CaptureRegisters() OVERRIDE;
- bool IsDisjunction() OVERRIDE;
- bool IsAnchoredAtStart() OVERRIDE;
- bool IsAnchoredAtEnd() OVERRIDE;
- int min_match() OVERRIDE { return min_match_; }
- int max_match() OVERRIDE { return max_match_; }
+ RegExpNode* on_success) override;
+ RegExpDisjunction* AsDisjunction() override;
+ Interval CaptureRegisters() override;
+ bool IsDisjunction() override;
+ bool IsAnchoredAtStart() override;
+ bool IsAnchoredAtEnd() override;
+ int min_match() override { return min_match_; }
+ int max_match() override { return max_match_; }
ZoneList<RegExpTree*>* alternatives() { return alternatives_; }
private:
ZoneList<RegExpTree*>* alternatives_;
};
-class RegExpAlternative FINAL : public RegExpTree {
+class RegExpAlternative final : public RegExpTree {
public:
explicit RegExpAlternative(ZoneList<RegExpTree*>* nodes);
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpAlternative* AsAlternative() OVERRIDE;
- Interval CaptureRegisters() OVERRIDE;
- bool IsAlternative() OVERRIDE;
- bool IsAnchoredAtStart() OVERRIDE;
- bool IsAnchoredAtEnd() OVERRIDE;
- int min_match() OVERRIDE { return min_match_; }
- int max_match() OVERRIDE { return max_match_; }
+ RegExpNode* on_success) override;
+ RegExpAlternative* AsAlternative() override;
+ Interval CaptureRegisters() override;
+ bool IsAlternative() override;
+ bool IsAnchoredAtStart() override;
+ bool IsAnchoredAtEnd() override;
+ int min_match() override { return min_match_; }
+ int max_match() override { return max_match_; }
ZoneList<RegExpTree*>* nodes() { return nodes_; }
private:
ZoneList<RegExpTree*>* nodes_;
};
-class RegExpAssertion FINAL : public RegExpTree {
+class RegExpAssertion final : public RegExpTree {
public:
enum AssertionType {
START_OF_LINE,
NON_BOUNDARY
};
explicit RegExpAssertion(AssertionType type) : assertion_type_(type) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpAssertion* AsAssertion() OVERRIDE;
- bool IsAssertion() OVERRIDE;
- bool IsAnchoredAtStart() OVERRIDE;
- bool IsAnchoredAtEnd() OVERRIDE;
- int min_match() OVERRIDE { return 0; }
- int max_match() OVERRIDE { return 0; }
+ RegExpNode* on_success) override;
+ RegExpAssertion* AsAssertion() override;
+ bool IsAssertion() override;
+ bool IsAnchoredAtStart() override;
+ bool IsAnchoredAtEnd() override;
+ int min_match() override { return 0; }
+ int max_match() override { return 0; }
AssertionType assertion_type() { return assertion_type_; }
private:
AssertionType assertion_type_;
};
-class CharacterSet FINAL BASE_EMBEDDED {
+class CharacterSet final BASE_EMBEDDED {
public:
explicit CharacterSet(uc16 standard_set_type)
: ranges_(NULL),
};
-class RegExpCharacterClass FINAL : public RegExpTree {
+class RegExpCharacterClass final : public RegExpTree {
public:
RegExpCharacterClass(ZoneList<CharacterRange>* ranges, bool is_negated)
: set_(ranges),
explicit RegExpCharacterClass(uc16 type)
: set_(type),
is_negated_(false) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpCharacterClass* AsCharacterClass() OVERRIDE;
- bool IsCharacterClass() OVERRIDE;
- bool IsTextElement() OVERRIDE { return true; }
- int min_match() OVERRIDE { return 1; }
- int max_match() OVERRIDE { return 1; }
- void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+ RegExpNode* on_success) override;
+ RegExpCharacterClass* AsCharacterClass() override;
+ bool IsCharacterClass() override;
+ bool IsTextElement() override { return true; }
+ int min_match() override { return 1; }
+ int max_match() override { return 1; }
+ void AppendToText(RegExpText* text, Zone* zone) override;
CharacterSet character_set() { return set_; }
// TODO(lrn): Remove need for complex version if is_standard that
// recognizes a mangled standard set and just do { return set_.is_special(); }
};
-class RegExpAtom FINAL : public RegExpTree {
+class RegExpAtom final : public RegExpTree {
public:
explicit RegExpAtom(Vector<const uc16> data) : data_(data) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpAtom* AsAtom() OVERRIDE;
- bool IsAtom() OVERRIDE;
- bool IsTextElement() OVERRIDE { return true; }
- int min_match() OVERRIDE { return data_.length(); }
- int max_match() OVERRIDE { return data_.length(); }
- void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+ RegExpNode* on_success) override;
+ RegExpAtom* AsAtom() override;
+ bool IsAtom() override;
+ bool IsTextElement() override { return true; }
+ int min_match() override { return data_.length(); }
+ int max_match() override { return data_.length(); }
+ void AppendToText(RegExpText* text, Zone* zone) override;
Vector<const uc16> data() { return data_; }
int length() { return data_.length(); }
private:
};
-class RegExpText FINAL : public RegExpTree {
+class RegExpText final : public RegExpTree {
public:
explicit RegExpText(Zone* zone) : elements_(2, zone), length_(0) {}
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpText* AsText() OVERRIDE;
- bool IsText() OVERRIDE;
- bool IsTextElement() OVERRIDE { return true; }
- int min_match() OVERRIDE { return length_; }
- int max_match() OVERRIDE { return length_; }
- void AppendToText(RegExpText* text, Zone* zone) OVERRIDE;
+ RegExpNode* on_success) override;
+ RegExpText* AsText() override;
+ bool IsText() override;
+ bool IsTextElement() override { return true; }
+ int min_match() override { return length_; }
+ int max_match() override { return length_; }
+ void AppendToText(RegExpText* text, Zone* zone) override;
void AddElement(TextElement elm, Zone* zone) {
elements_.Add(elm, zone);
length_ += elm.length();
};
-class RegExpQuantifier FINAL : public RegExpTree {
+class RegExpQuantifier final : public RegExpTree {
public:
enum QuantifierType { GREEDY, NON_GREEDY, POSSESSIVE };
RegExpQuantifier(int min, int max, QuantifierType type, RegExpTree* body)
max_match_ = max * body->max_match();
}
}
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
+ RegExpNode* on_success) override;
static RegExpNode* ToNode(int min,
int max,
bool is_greedy,
RegExpCompiler* compiler,
RegExpNode* on_success,
bool not_at_start = false);
- RegExpQuantifier* AsQuantifier() OVERRIDE;
- Interval CaptureRegisters() OVERRIDE;
- bool IsQuantifier() OVERRIDE;
- int min_match() OVERRIDE { return min_match_; }
- int max_match() OVERRIDE { return max_match_; }
+ RegExpQuantifier* AsQuantifier() override;
+ Interval CaptureRegisters() override;
+ bool IsQuantifier() override;
+ int min_match() override { return min_match_; }
+ int max_match() override { return max_match_; }
int min() { return min_; }
int max() { return max_; }
bool is_possessive() { return quantifier_type_ == POSSESSIVE; }
};
-class RegExpCapture FINAL : public RegExpTree {
+class RegExpCapture final : public RegExpTree {
public:
explicit RegExpCapture(RegExpTree* body, int index)
: body_(body), index_(index) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
+ RegExpNode* on_success) override;
static RegExpNode* ToNode(RegExpTree* body,
int index,
RegExpCompiler* compiler,
RegExpNode* on_success);
- RegExpCapture* AsCapture() OVERRIDE;
- bool IsAnchoredAtStart() OVERRIDE;
- bool IsAnchoredAtEnd() OVERRIDE;
- Interval CaptureRegisters() OVERRIDE;
- bool IsCapture() OVERRIDE;
- int min_match() OVERRIDE { return body_->min_match(); }
- int max_match() OVERRIDE { return body_->max_match(); }
+ RegExpCapture* AsCapture() override;
+ bool IsAnchoredAtStart() override;
+ bool IsAnchoredAtEnd() override;
+ Interval CaptureRegisters() override;
+ bool IsCapture() override;
+ int min_match() override { return body_->min_match(); }
+ int max_match() override { return body_->max_match(); }
RegExpTree* body() { return body_; }
int index() { return index_; }
static int StartRegister(int index) { return index * 2; }
};
-class RegExpLookahead FINAL : public RegExpTree {
+class RegExpLookahead final : public RegExpTree {
public:
RegExpLookahead(RegExpTree* body,
bool is_positive,
capture_count_(capture_count),
capture_from_(capture_from) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpLookahead* AsLookahead() OVERRIDE;
- Interval CaptureRegisters() OVERRIDE;
- bool IsLookahead() OVERRIDE;
- bool IsAnchoredAtStart() OVERRIDE;
- int min_match() OVERRIDE { return 0; }
- int max_match() OVERRIDE { return 0; }
+ RegExpNode* on_success) override;
+ RegExpLookahead* AsLookahead() override;
+ Interval CaptureRegisters() override;
+ bool IsLookahead() override;
+ bool IsAnchoredAtStart() override;
+ int min_match() override { return 0; }
+ int max_match() override { return 0; }
RegExpTree* body() { return body_; }
bool is_positive() { return is_positive_; }
int capture_count() { return capture_count_; }
};
-class RegExpBackReference FINAL : public RegExpTree {
+class RegExpBackReference final : public RegExpTree {
public:
explicit RegExpBackReference(RegExpCapture* capture)
: capture_(capture) { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpBackReference* AsBackReference() OVERRIDE;
- bool IsBackReference() OVERRIDE;
- int min_match() OVERRIDE { return 0; }
- int max_match() OVERRIDE { return capture_->max_match(); }
+ RegExpNode* on_success) override;
+ RegExpBackReference* AsBackReference() override;
+ bool IsBackReference() override;
+ int min_match() override { return 0; }
+ int max_match() override { return capture_->max_match(); }
int index() { return capture_->index(); }
RegExpCapture* capture() { return capture_; }
private:
};
-class RegExpEmpty FINAL : public RegExpTree {
+class RegExpEmpty final : public RegExpTree {
public:
RegExpEmpty() { }
- void* Accept(RegExpVisitor* visitor, void* data) OVERRIDE;
+ void* Accept(RegExpVisitor* visitor, void* data) override;
virtual RegExpNode* ToNode(RegExpCompiler* compiler,
- RegExpNode* on_success) OVERRIDE;
- RegExpEmpty* AsEmpty() OVERRIDE;
- bool IsEmpty() OVERRIDE;
- int min_match() OVERRIDE { return 0; }
- int max_match() OVERRIDE { return 0; }
+ RegExpNode* on_success) override;
+ RegExpEmpty* AsEmpty() override;
+ bool IsEmpty() override;
+ int min_match() override { return 0; }
+ int max_match() override { return 0; }
};
#define DEFINE_AST_VISITOR_SUBCLASS_MEMBERS() \
public: \
- void Visit(AstNode* node) FINAL { \
+ void Visit(AstNode* node) final { \
if (!CheckStackOverflow()) node->Accept(this); \
} \
\
// ----------------------------------------------------------------------------
// AstNode factory
-class AstNodeFactory FINAL BASE_EMBEDDED {
+class AstNodeFactory final BASE_EMBEDDED {
public:
explicit AstNodeFactory(AstValueFactory* ast_value_factory)
: zone_(ast_value_factory->zone()),
#endif
-// Annotate a virtual method indicating it must be overriding a virtual
-// method in the parent class.
-// Use like:
-// virtual void bar() OVERRIDE;
-#if V8_HAS_CXX11_OVERRIDE
-#define OVERRIDE override
-#else
-#define OVERRIDE /* NOT SUPPORTED */
-#endif
-
-
-// Annotate a virtual method indicating that subclasses must not override it,
-// or annotate a class to indicate that it cannot be subclassed.
-// Use like:
-// class B FINAL : public A {};
-// virtual void bar() FINAL;
-#if V8_HAS_CXX11_FINAL
-#define FINAL final
-#elif V8_HAS___FINAL
-#define FINAL __final
-#else
-#define FINAL /* NOT SUPPORTED */
-#endif
-
-
// Annotate a function indicating the caller must examine the return value.
// Use like:
// int foo() WARN_UNUSED_RESULT;
#endif
// Extract the information exposed by the kernel via /proc/cpuinfo.
-class CPUInfo FINAL {
+class CPUInfo final {
public:
CPUInfo() : datalen_(0) {
// Get the size of the cpuinfo file by reading it until the end. This is
// architectures. For each architecture the file cpu_<arch>.cc contains the
// implementation of these static functions.
-class CPU FINAL {
+class CPU final {
public:
CPU();
// other enum value and passed on to a function that takes an int or unsigned
// int.
template <typename T, typename S = int>
-class Flags FINAL {
+class Flags final {
public:
typedef T flag_type;
typedef S mask_type;
// the mutex and suspend the execution of the calling thread. When the condition
// variable is notified, the thread is awakened, and the mutex is reacquired.
-class ConditionVariable FINAL {
+class ConditionVariable final {
public:
ConditionVariable();
~ConditionVariable();
typedef pthread_cond_t NativeHandle;
#elif V8_OS_WIN
struct Event;
- class NativeHandle FINAL {
+ class NativeHandle final {
public:
NativeHandle() : waitlist_(NULL), freelist_(NULL) {}
~NativeHandle();
namespace v8 {
namespace base {
-class ElapsedTimer FINAL {
+class ElapsedTimer final {
public:
#ifdef DEBUG
ElapsedTimer() : started_(false) {}
// |TryLock()|. The behavior of a program is undefined if a mutex is destroyed
// while still owned by some thread. The Mutex class is non-copyable.
-class Mutex FINAL {
+class Mutex final {
public:
Mutex();
~Mutex();
// The behavior of a program is undefined if a recursive mutex is destroyed
// while still owned by some thread. The RecursiveMutex class is non-copyable.
-class RecursiveMutex FINAL {
+class RecursiveMutex final {
public:
RecursiveMutex();
~RecursiveMutex();
// The LockGuard class is non-copyable.
template <typename Mutex>
-class LockGuard FINAL {
+class LockGuard final {
public:
explicit LockGuard(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }
~LockGuard() { mutex_->Unlock(); }
// count reaches zero, threads waiting for the semaphore blocks until the
// count becomes non-zero.
-class Semaphore FINAL {
+class Semaphore final {
public:
explicit Semaphore(int count);
~Semaphore();
// We implement time using the high-resolution timers so that we can get
// timeouts which are smaller than 10-15ms. To avoid any drift, we
// periodically resync the internal clock to the system clock.
-class Clock FINAL {
+class Clock final {
public:
Clock() : initial_ticks_(GetSystemTicks()), initial_time_(GetSystemTime()) {}
// (3) System time. The system time provides a low-resolution (typically 10ms
// to 55 milliseconds) time stamp but is comparatively less expensive to
// retrieve and more reliable.
-class HighResolutionTickClock FINAL : public TickClock {
+class HighResolutionTickClock final : public TickClock {
public:
explicit HighResolutionTickClock(int64_t ticks_per_second)
: ticks_per_second_(ticks_per_second) {
}
virtual ~HighResolutionTickClock() {}
- int64_t Now() OVERRIDE {
+ int64_t Now() override {
LARGE_INTEGER now;
BOOL result = QueryPerformanceCounter(&now);
DCHECK(result);
return ticks + 1;
}
- bool IsHighResolution() OVERRIDE { return true; }
+ bool IsHighResolution() override { return true; }
private:
int64_t ticks_per_second_;
};
-class RolloverProtectedTickClock FINAL : public TickClock {
+class RolloverProtectedTickClock final : public TickClock {
public:
// We initialize rollover_ms_ to 1 to ensure that we will never
// return 0 from TimeTicks::HighResolutionNow() and TimeTicks::Now() below.
RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
virtual ~RolloverProtectedTickClock() {}
- int64_t Now() OVERRIDE {
+ int64_t Now() override {
LockGuard<Mutex> lock_guard(&mutex_);
// We use timeGetTime() to implement TimeTicks::Now(), which rolls over
// every ~49.7 days. We try to track rollover ourselves, which works if
return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
}
- bool IsHighResolution() OVERRIDE { return false; }
+ bool IsHighResolution() override { return false; }
private:
Mutex mutex_;
// This class represents a duration of time, internally represented in
// microseonds.
-class TimeDelta FINAL {
+class TimeDelta final {
public:
TimeDelta() : delta_(0) {}
// This class represents an absolute point in time, internally represented as
// microseconds (s/1,000,000) since 00:00:00 UTC, January 1, 1970.
-class Time FINAL {
+class Time final {
public:
static const int64_t kMillisecondsPerSecond = 1000;
static const int64_t kMicrosecondsPerMillisecond = 1000;
// Time::Now() may actually decrease or jump). But note that TimeTicks may
// "stand still", for example if the computer suspended.
-class TimeTicks FINAL {
+class TimeTicks final {
public:
TimeTicks() : ticks_(0) {}
namespace v8 {
namespace base {
-class SysInfo FINAL {
+class SysInfo final {
public:
// Returns the number of logical processors/core on the current machine.
static int NumberOfProcessors();
// https://code.google.com/p/v8/issues/detail?id=2905
// This class is neither reentrant nor threadsafe.
-class RandomNumberGenerator FINAL {
+class RandomNumberGenerator final {
public:
// EntropySource is used as a callback function when V8 needs a source of
// entropy.
// (runtime.js, etc.) to precompiled functions. Instead of mapping
// names to functions it might make sense to let the JS2C tool
// generate an index for each native JS file.
-class SourceCodeCache FINAL BASE_EMBEDDED {
+class SourceCodeCache final BASE_EMBEDDED {
public:
explicit SourceCodeCache(Script::Type type): type_(type), cache_(NULL) { }
// The Boostrapper is the public interface for creating a JavaScript global
// context.
-class Bootstrapper FINAL {
+class Bootstrapper final {
public:
static void InitializeOncePerProcess();
static void TearDownExtensions();
};
-class BootstrapperActive FINAL BASE_EMBEDDED {
+class BootstrapperActive final BASE_EMBEDDED {
public:
explicit BootstrapperActive(Bootstrapper* bootstrapper)
: bootstrapper_(bootstrapper) {
};
-class NativesExternalStringResource FINAL
+class NativesExternalStringResource final
: public v8::String::ExternalOneByteStringResource {
public:
NativesExternalStringResource(const char* source, size_t length)
: data_(source), length_(length) {}
- const char* data() const OVERRIDE { return data_; }
- size_t length() const OVERRIDE { return length_; }
+ const char* data() const override { return data_; }
+ size_t length() const override { return length_; }
private:
const char* data_;
namespace internal {
// Associates a body of code with an interface descriptor.
-class Callable FINAL BASE_EMBEDDED {
+class Callable final BASE_EMBEDDED {
public:
Callable(Handle<Code> code, CallInterfaceDescriptor descriptor)
: code_(code), descriptor_(descriptor) {}
};
-class CodeFactory FINAL {
+class CodeFactory final {
public:
// Initial states for ICs.
static Callable LoadGlobalIC(Isolate* isolate, Handle<GlobalObject> global,
explicit FakeStubForTesting(Isolate* isolate) : CodeStub(isolate) {}
// Only used by pipeline.cc's GetDebugName in DEBUG mode.
- Major MajorKey() const OVERRIDE { return CodeStub::NoCache; }
+ Major MajorKey() const override { return CodeStub::NoCache; }
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
UNREACHABLE();
return CallInterfaceDescriptor();
}
- Handle<Code> GenerateCode() OVERRIDE {
+ Handle<Code> GenerateCode() override {
UNREACHABLE();
return Handle<Code>();
}
#define DEFINE_CODE_STUB(NAME, SUPER) \
protected: \
- inline Major MajorKey() const OVERRIDE { return NAME; }; \
+ inline Major MajorKey() const override { return NAME; }; \
DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)
#define DEFINE_PLATFORM_CODE_STUB(NAME, SUPER) \
private: \
- void Generate(MacroAssembler* masm) OVERRIDE; \
+ void Generate(MacroAssembler* masm) override; \
DEFINE_CODE_STUB(NAME, SUPER)
#define DEFINE_HYDROGEN_CODE_STUB(NAME, SUPER) \
public: \
- void InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE; \
- Handle<Code> GenerateCode() OVERRIDE; \
+ void InitializeDescriptor(CodeStubDescriptor* descriptor) override; \
+ Handle<Code> GenerateCode() override; \
DEFINE_CODE_STUB(NAME, SUPER)
#define DEFINE_HANDLER_CODE_STUB(NAME, SUPER) \
public: \
- Handle<Code> GenerateCode() OVERRIDE; \
+ Handle<Code> GenerateCode() override; \
DEFINE_CODE_STUB(NAME, SUPER)
#define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME) \
public: \
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE { \
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
return NAME##Descriptor(isolate()); \
}
// An attempt to retrieve a descriptor will fail.
#define DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR() \
public: \
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE { \
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
UNREACHABLE(); \
return CallInterfaceDescriptor(); \
}
class PlatformCodeStub : public CodeStub {
public:
// Retrieve the code for the stub. Generate the code if needed.
- Handle<Code> GenerateCode() OVERRIDE;
+ Handle<Code> GenerateCode() override;
- Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
+ Code::Kind GetCodeKind() const override { return Code::STUB; }
protected:
explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
INITIALIZED
};
- Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
+ Code::Kind GetCodeKind() const override { return Code::STUB; }
template<class SubClass>
static Handle<Code> GetUninitialized(Isolate* isolate) {
}
// Retrieve the code for the stub. Generate the code if needed.
- Handle<Code> GenerateCode() OVERRIDE = 0;
+ Handle<Code> GenerateCode() override = 0;
bool IsUninitialized() const { return IsMissBits::decode(minor_key_); }
};
-class NumberToStringStub FINAL : public HydrogenCodeStub {
+class NumberToStringStub final : public HydrogenCodeStub {
public:
explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
};
-class FastNewContextStub FINAL : public HydrogenCodeStub {
+class FastNewContextStub final : public HydrogenCodeStub {
public:
static const int kMaximumSlots = 64;
static Register left() { return InstanceofDescriptor::left(); }
static Register right() { return InstanceofDescriptor::right(); }
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (HasArgsInRegisters()) {
return InstanceofDescriptor(isolate());
}
return (flags() & kReturnTrueFalseObject) != 0;
}
- void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintName(std::ostream& os) const override; // NOLINT
class FlagBits : public BitField<Flags, 0, 3> {};
void GenerateDispatchToArrayStub(MacroAssembler* masm,
AllocationSiteOverrideMode mode);
- void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintName(std::ostream& os) const override; // NOLINT
class ArgumentCountBits : public BitField<ArgumentCountKey, 0, 2> {};
minor_key_ = ExponentTypeBits::encode(exponent_type);
}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (exponent_type() == TAGGED) {
return MathPowTaggedDescriptor(isolate());
} else if (exponent_type() == INTEGER) {
return state.arg_count();
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::CALL_IC; }
+ Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
- InlineCacheState GetICState() const OVERRIDE { return DEFAULT; }
+ InlineCacheState GetICState() const override { return DEFAULT; }
- ExtraICState GetExtraICState() const FINAL {
+ ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(minor_key_);
}
void GenerateMiss(MacroAssembler* masm);
private:
- void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintState(std::ostream& os) const override; // NOLINT
DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedbackAndVector);
DEFINE_PLATFORM_CODE_STUB(CallIC, PlatformCodeStub);
CallIC_ArrayStub(Isolate* isolate, const CallICState& state_in)
: CallICStub(isolate, state_in) {}
- InlineCacheState GetICState() const FINAL { return MONOMORPHIC; }
+ InlineCacheState GetICState() const final { return MONOMORPHIC; }
private:
- void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintState(std::ostream& os) const override; // NOLINT
DEFINE_PLATFORM_CODE_STUB(CallIC_Array, CallICStub);
};
explicit FunctionPrototypeStub(Isolate* isolate)
: PlatformCodeStub(isolate) {}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
+ Code::Kind GetCodeKind() const override { return Code::HANDLER; }
// TODO(mvstanton): only the receiver register is accessed. When this is
// translated to a hydrogen code stub, a new CallInterfaceDescriptor
// should be created that just uses that register for more efficient code.
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (FLAG_vector_ics) {
return VectorLoadICDescriptor(isolate());
}
explicit LoadIndexedInterceptorStub(Isolate* isolate)
: PlatformCodeStub(isolate) {}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
DEFINE_PLATFORM_CODE_STUB(LoadIndexedInterceptor, PlatformCodeStub);
explicit LoadIndexedStringStub(Isolate* isolate)
: PlatformCodeStub(isolate) {}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
DEFINE_PLATFORM_CODE_STUB(LoadIndexedString, PlatformCodeStub);
class HandlerStub : public HydrogenCodeStub {
public:
- Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
- ExtraICState GetExtraICState() const OVERRIDE { return kind(); }
- InlineCacheState GetICState() const OVERRIDE { return MONOMORPHIC; }
+ Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+ ExtraICState GetExtraICState() const override { return kind(); }
+ InlineCacheState GetICState() const override { return MONOMORPHIC; }
- void InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE;
+ void InitializeDescriptor(CodeStubDescriptor* descriptor) override;
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override;
protected:
explicit HandlerStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
}
protected:
- Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::LOAD_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
: HandlerStub(isolate) {}
protected:
- Code::Kind kind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::KEYED_LOAD_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
DEFINE_HANDLER_CODE_STUB(KeyedLoadSloppyArguments, HandlerStub);
}
protected:
- Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::LOAD_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
protected:
- Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::LOAD_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
DEFINE_HANDLER_CODE_STUB(StringLength, HandlerStub);
};
}
protected:
- Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::STORE_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
return StoreModeBits::decode(sub_minor_key());
}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override;
protected:
- Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::Kind kind() const override { return Code::STORE_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
}
}
- Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+ Code::Kind kind() const override { return Code::STORE_IC; }
bool is_constant() const { return IsConstantBits::decode(sub_minor_key()); }
static void GenerateAheadOfTime(Isolate* isolate);
- Code::Kind GetCodeKind() const OVERRIDE { return Code::BINARY_OP_IC; }
+ Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
- InlineCacheState GetICState() const FINAL { return state().GetICState(); }
+ InlineCacheState GetICState() const final { return state().GetICState(); }
- ExtraICState GetExtraICState() const FINAL {
+ ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(sub_minor_key());
}
return BinaryOpICState(isolate(), GetExtraICState());
}
- void PrintState(std::ostream& os) const FINAL; // NOLINT
+ void PrintState(std::ostream& os) const final; // NOLINT
// Parameters accessed via CodeStubGraphBuilder::GetParameter()
static const int kLeft = 0;
// TODO(bmeurer): Merge this into the BinaryOpICStub once we have proper tail
// call support for stubs in Hydrogen.
-class BinaryOpICWithAllocationSiteStub FINAL : public PlatformCodeStub {
+class BinaryOpICWithAllocationSiteStub final : public PlatformCodeStub {
public:
BinaryOpICWithAllocationSiteStub(Isolate* isolate,
const BinaryOpICState& state)
return CodeStub::GetCodeCopy(pattern);
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::BINARY_OP_IC; }
+ Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
- InlineCacheState GetICState() const OVERRIDE { return state().GetICState(); }
+ InlineCacheState GetICState() const override { return state().GetICState(); }
- ExtraICState GetExtraICState() const OVERRIDE {
+ ExtraICState GetExtraICState() const override {
return static_cast<ExtraICState>(minor_key_);
}
- void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintState(std::ostream& os) const override; // NOLINT
private:
BinaryOpICState state() const {
};
-class BinaryOpWithAllocationSiteStub FINAL : public BinaryOpICStub {
+class BinaryOpWithAllocationSiteStub final : public BinaryOpICStub {
public:
BinaryOpWithAllocationSiteStub(Isolate* isolate, Token::Value op)
: BinaryOpICStub(isolate, op) {}
BinaryOpWithAllocationSiteStub(Isolate* isolate, const BinaryOpICState& state)
: BinaryOpICStub(isolate, state) {}
- Code::Kind GetCodeKind() const FINAL { return Code::STUB; }
+ Code::Kind GetCodeKind() const final { return Code::STUB; }
// Parameters accessed via CodeStubGraphBuilder::GetParameter()
static const int kAllocationSite = 0;
};
-class StringAddStub FINAL : public HydrogenCodeStub {
+class StringAddStub final : public HydrogenCodeStub {
public:
StringAddStub(Isolate* isolate, StringAddFlags flags,
PretenureFlag pretenure_flag)
class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
- void PrintBaseName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintBaseName(std::ostream& os) const override; // NOLINT
DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
DEFINE_HYDROGEN_CODE_STUB(StringAdd, HydrogenCodeStub);
void set_known_map(Handle<Map> map) { known_map_ = map; }
- InlineCacheState GetICState() const OVERRIDE;
+ InlineCacheState GetICState() const override;
Token::Value op() const {
return static_cast<Token::Value>(Token::EQ + OpBits::decode(minor_key_));
CompareICState::State state() const { return StateBits::decode(minor_key_); }
private:
- Code::Kind GetCodeKind() const OVERRIDE { return Code::COMPARE_IC; }
+ Code::Kind GetCodeKind() const override { return Code::COMPARE_IC; }
void GenerateSmis(MacroAssembler* masm);
void GenerateNumbers(MacroAssembler* masm);
bool strict() const { return op() == Token::EQ_STRICT; }
Condition GetCondition() const;
- void AddToSpecialCache(Handle<Code> new_object) OVERRIDE;
- bool FindCodeInSpecialCache(Code** code_out) OVERRIDE;
- bool UseSpecialCache() OVERRIDE {
+ void AddToSpecialCache(Handle<Code> new_object) override;
+ bool FindCodeInSpecialCache(Code** code_out) override;
+ bool UseSpecialCache() override {
return state() == CompareICState::KNOWN_OBJECT;
}
return CompareNilICStub(isolate, nil, UNINITIALIZED).GetCode();
}
- InlineCacheState GetICState() const OVERRIDE {
+ InlineCacheState GetICState() const override {
State state = this->state();
if (state.Contains(GENERIC)) {
return MEGAMORPHIC;
}
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::COMPARE_NIL_IC; }
+ Code::Kind GetCodeKind() const override { return Code::COMPARE_NIL_IC; }
- ExtraICState GetExtraICState() const OVERRIDE { return sub_minor_key(); }
+ ExtraICState GetExtraICState() const override { return sub_minor_key(); }
void UpdateStatus(Handle<Object> object);
set_sub_minor_key(TypesBits::update(sub_minor_key(), 0));
}
- void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
- void PrintBaseName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintState(std::ostream& os) const override; // NOLINT
+ void PrintBaseName(std::ostream& os) const override; // NOLINT
private:
CompareNilICStub(Isolate* isolate, NilValue nil,
int result_size() const { return ResultSizeBits::decode(minor_key_); }
#endif // _WIN64
- bool NeedsImmovableCode() OVERRIDE;
+ bool NeedsImmovableCode() override;
class SaveDoublesBits : public BitField<bool, 0, 1> {};
class ResultSizeBits : public BitField<int, 1, 3> {};
}
private:
- void FinishCode(Handle<Code> code) OVERRIDE;
+ void FinishCode(Handle<Code> code) override;
- void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
+ void PrintName(std::ostream& os) const override { // NOLINT
os << (type() == StackFrame::ENTRY ? "JSEntryStub"
: "JSConstructEntryStub");
}
TypeBits::encode(type) | HasNewTargetBits::encode(has_new_target);
}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (type() == READ_ELEMENT) {
return ArgumentsAccessReadDescriptor(isolate());
}
void GenerateNewSloppyFast(MacroAssembler* masm);
void GenerateNewSloppySlow(MacroAssembler* masm);
- void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintName(std::ostream& os) const override; // NOLINT
class TypeBits : public BitField<Type, 0, 2> {};
class HasNewTargetBits : public BitField<HasNewTarget, 2, 1> {};
public:
explicit RestParamAccessStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
return ContextOnlyDescriptor(isolate());
}
private:
void GenerateNew(MacroAssembler* masm);
- virtual void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ virtual void PrintName(std::ostream& os) const override; // NOLINT
DEFINE_PLATFORM_CODE_STUB(RestParamAccess, PlatformCodeStub);
};
};
-class RegExpConstructResultStub FINAL : public HydrogenCodeStub {
+class RegExpConstructResultStub final : public HydrogenCodeStub {
public:
explicit RegExpConstructResultStub(Isolate* isolate)
: HydrogenCodeStub(isolate) { }
bool NeedsChecks() const { return flags() != WRAP_AND_CALL; }
- void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintName(std::ostream& os) const override; // NOLINT
// Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
class FlagBits : public BitField<CallFunctionFlags, 0, 2> {};
minor_key_ = FlagBits::encode(flags);
}
- void FinishCode(Handle<Code> code) OVERRIDE {
+ void FinishCode(Handle<Code> code) override {
code->set_has_function_cache(RecordCallTarget());
}
return (flags() & SUPER_CONSTRUCTOR_CALL) != 0;
}
- void PrintName(std::ostream& os) const OVERRIDE; // NOLINT
+ void PrintName(std::ostream& os) const override; // NOLINT
class FlagBits : public BitField<CallConstructorFlags, 0, 2> {};
explicit LoadDictionaryElementStub(Isolate* isolate)
: HydrogenCodeStub(isolate) {}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (FLAG_vector_ics) {
return VectorLoadICDescriptor(isolate());
}
public:
explicit KeyedLoadGenericStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
- InlineCacheState GetICState() const OVERRIDE { return GENERIC; }
+ Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
+ InlineCacheState GetICState() const override { return GENERIC; }
// Since KeyedLoadGeneric stub doesn't miss (simply calls runtime), it
// doesn't need to use the VectorLoadICDescriptor for the case when
minor_key_ = state.GetExtraICState();
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+ Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
- InlineCacheState GetICState() const FINAL { return DEFAULT; }
+ InlineCacheState GetICState() const final { return DEFAULT; }
- ExtraICState GetExtraICState() const FINAL {
+ ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(minor_key_);
}
explicit KeyedLoadICTrampolineStub(Isolate* isolate)
: LoadICTrampolineStub(isolate, LoadICState(0)) {}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
+ Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
DEFINE_PLATFORM_CODE_STUB(KeyedLoadICTrampoline, LoadICTrampolineStub);
};
minor_key_ = state.GetExtraICState();
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::CALL_IC; }
+ Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
- InlineCacheState GetICState() const FINAL { return DEFAULT; }
+ InlineCacheState GetICState() const final { return DEFAULT; }
- ExtraICState GetExtraICState() const FINAL {
+ ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(minor_key_);
}
set_sub_minor_key(state.GetExtraICState());
}
- Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+ Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
- InlineCacheState GetICState() const FINAL { return MEGAMORPHIC; }
+ InlineCacheState GetICState() const final { return MEGAMORPHIC; }
- ExtraICState GetExtraICState() const FINAL {
+ ExtraICState GetExtraICState() const final {
return static_cast<ExtraICState>(sub_minor_key());
}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (FLAG_vector_ics) {
return VectorLoadICDescriptor(isolate());
}
void GenerateForTrampoline(MacroAssembler* masm);
- virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+ virtual Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
- virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
+ virtual InlineCacheState GetICState() const final override { return DEFAULT; }
- virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
+ virtual ExtraICState GetExtraICState() const final override {
return static_cast<ExtraICState>(minor_key_);
}
void GenerateForTrampoline(MacroAssembler* masm);
- virtual Code::Kind GetCodeKind() const OVERRIDE {
+ virtual Code::Kind GetCodeKind() const override {
return Code::KEYED_LOAD_IC;
}
- virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
+ virtual InlineCacheState GetICState() const final override { return DEFAULT; }
DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorLoadIC);
DEFINE_PLATFORM_CODE_STUB(VectorRawKeyedLoad, PlatformCodeStub);
SSE3Bits::encode(CpuFeatures::IsSupported(SSE3) ? 1 : 0);
}
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
Register source() const {
class SlotIndexBits
: public BitField<int, kContextIndexBits, kSlotIndexBits> {};
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
DEFINE_CODE_STUB_BASE(ScriptContextFieldStub, HandlerStub);
};
: ScriptContextFieldStub(isolate, lookup_result) {}
private:
- Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
+ Code::Kind kind() const override { return Code::LOAD_IC; }
DEFINE_HANDLER_CODE_STUB(LoadScriptContextField, ScriptContextFieldStub);
};
: ScriptContextFieldStub(isolate, lookup_result) {}
private:
- Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+ Code::Kind kind() const override { return Code::STORE_IC; }
DEFINE_HANDLER_CODE_STUB(StoreScriptContextField, ScriptContextFieldStub);
};
class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
class IsJSArrayBits: public BitField<bool, 8, 1> {};
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
if (FLAG_vector_ics) {
return VectorLoadICDescriptor(isolate());
}
};
-class AllocateHeapNumberStub FINAL : public HydrogenCodeStub {
+class AllocateHeapNumberStub final : public HydrogenCodeStub {
public:
explicit AllocateHeapNumberStub(Isolate* isolate)
: HydrogenCodeStub(isolate) {}
}
private:
- void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
+ void PrintName(std::ostream& os) const override { // NOLINT
BasePrintName(os, "ArrayNoArgumentConstructorStub");
}
}
private:
- void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
+ void PrintName(std::ostream& os) const override { // NOLINT
BasePrintName(os, "ArraySingleArgumentConstructorStub");
}
}
private:
- void PrintName(std::ostream& os) const OVERRIDE { // NOLINT
+ void PrintName(std::ostream& os) const override { // NOLINT
BasePrintName(os, "ArrayNArgumentsConstructorStub");
}
Types types() const { return Types(TypesBits::decode(sub_minor_key())); }
ResultMode mode() const { return ResultModeBits::decode(sub_minor_key()); }
- Code::Kind GetCodeKind() const OVERRIDE { return Code::TO_BOOLEAN_IC; }
- void PrintState(std::ostream& os) const OVERRIDE; // NOLINT
+ Code::Kind GetCodeKind() const override { return Code::TO_BOOLEAN_IC; }
+ void PrintState(std::ostream& os) const override; // NOLINT
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static Handle<Code> GetUninitialized(Isolate* isolate) {
return ToBooleanStub(isolate, UNINITIALIZED).GetCode();
}
- ExtraICState GetExtraICState() const OVERRIDE { return types().ToIntegral(); }
+ ExtraICState GetExtraICState() const override { return types().ToIntegral(); }
- InlineCacheState GetICState() const OVERRIDE {
+ InlineCacheState GetICState() const override {
if (types().IsEmpty()) {
return ::v8::internal::UNINITIALIZED;
} else {
explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
// The profile entry hook function is not allowed to cause a GC.
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
// Generates a call to the entry hook if it's enabled.
static void MaybeCallEntryHook(MacroAssembler* masm);
}
static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
};
-class ToNumberStub FINAL : public PlatformCodeStub {
+class ToNumberStub final : public PlatformCodeStub {
public:
explicit ToNumberStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
class CompilationInfo;
-class CompilationStatistics FINAL : public Malloced {
+class CompilationStatistics final : public Malloced {
public:
CompilationStatistics() {}
}
#define DEF_VISIT(type) \
- void Visit##type(type* node) OVERRIDE { \
+ void Visit##type(type* node) override { \
SourcePosition old_position = SourcePosition::Unknown(); \
if (node->position() != RelocInfo::kNoPosition) { \
old_position = source_position(); \
#undef DEF_VISIT
#define DEF_VISIT(type) \
- void Visit##type(type* node) OVERRIDE { \
+ void Visit##type(type* node) override { \
SourcePosition old_position = SourcePosition::Unknown(); \
if (node->position() != RelocInfo::kNoPosition) { \
old_position = source_position(); \
#undef DEF_VISIT
#define DEF_VISIT(type) \
- void Visit##type(type* node) OVERRIDE { \
+ void Visit##type(type* node) override { \
HOptimizedGraphBuilder::Visit##type(node); \
}
MODULE_NODE_LIST(DEF_VISIT)
// This access builder provides a set of static methods constructing commonly
// used FieldAccess and ElementAccess descriptors. These descriptors serve as
// parameters to simplified load/store operators.
-class AccessBuilder FINAL : public AllStatic {
+class AccessBuilder final : public AllStatic {
public:
// Provides access to HeapObject::map() field.
static FieldAccess ForMap();
// Adds Arm-specific methods to convert InstructionOperands.
-class ArmOperandConverter FINAL : public InstructionOperandConverter {
+class ArmOperandConverter final : public InstructionOperandConverter {
public:
ArmOperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
namespace {
-class OutOfLineLoadFloat32 FINAL : public OutOfLineCode {
+class OutOfLineLoadFloat32 final : public OutOfLineCode {
public:
OutOfLineLoadFloat32(CodeGenerator* gen, SwVfpRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ vmov(result_, std::numeric_limits<float>::quiet_NaN());
}
};
-class OutOfLineLoadFloat64 FINAL : public OutOfLineCode {
+class OutOfLineLoadFloat64 final : public OutOfLineCode {
public:
OutOfLineLoadFloat64(CodeGenerator* gen, DwVfpRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ vmov(result_, std::numeric_limits<double>::quiet_NaN(), kScratchReg);
}
};
-class OutOfLineLoadInteger FINAL : public OutOfLineCode {
+class OutOfLineLoadInteger final : public OutOfLineCode {
public:
OutOfLineLoadInteger(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ mov(result_, Operand::Zero()); }
+ void Generate() final { __ mov(result_, Operand::Zero()); }
private:
Register const result_;
// Adds Arm64-specific methods to convert InstructionOperands.
-class Arm64OperandConverter FINAL : public InstructionOperandConverter {
+class Arm64OperandConverter final : public InstructionOperandConverter {
public:
Arm64OperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
namespace {
-class OutOfLineLoadNaN32 FINAL : public OutOfLineCode {
+class OutOfLineLoadNaN32 final : public OutOfLineCode {
public:
OutOfLineLoadNaN32(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Fmov(result_, std::numeric_limits<float>::quiet_NaN());
}
};
-class OutOfLineLoadNaN64 FINAL : public OutOfLineCode {
+class OutOfLineLoadNaN64 final : public OutOfLineCode {
public:
OutOfLineLoadNaN64(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Fmov(result_, std::numeric_limits<double>::quiet_NaN());
}
};
-class OutOfLineLoadZero FINAL : public OutOfLineCode {
+class OutOfLineLoadZero final : public OutOfLineCode {
public:
OutOfLineLoadZero(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ Mov(result_, 0); }
+ void Generate() final { __ Mov(result_, 0); }
private:
Register const result_;
// Adds Arm64-specific methods for generating operands.
-class Arm64OperandGenerator FINAL : public OperandGenerator {
+class Arm64OperandGenerator final : public OperandGenerator {
public:
explicit Arm64OperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
// Context to evaluate expression for its side effects only.
-class AstGraphBuilder::AstEffectContext FINAL : public AstContext {
+class AstGraphBuilder::AstEffectContext final : public AstContext {
public:
explicit AstEffectContext(AstGraphBuilder* owner)
: AstContext(owner, Expression::kEffect) {}
- ~AstEffectContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
+ ~AstEffectContext() final;
+ void ProduceValue(Node* value) final;
+ Node* ConsumeValue() final;
};
// Context to evaluate expression for its value (and side effects).
-class AstGraphBuilder::AstValueContext FINAL : public AstContext {
+class AstGraphBuilder::AstValueContext final : public AstContext {
public:
explicit AstValueContext(AstGraphBuilder* owner)
: AstContext(owner, Expression::kValue) {}
- ~AstValueContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
+ ~AstValueContext() final;
+ void ProduceValue(Node* value) final;
+ Node* ConsumeValue() final;
};
// Context to evaluate expression for a condition value (and side effects).
-class AstGraphBuilder::AstTestContext FINAL : public AstContext {
+class AstGraphBuilder::AstTestContext final : public AstContext {
public:
explicit AstTestContext(AstGraphBuilder* owner)
: AstContext(owner, Expression::kTest) {}
- ~AstTestContext() FINAL;
- void ProduceValue(Node* value) FINAL;
- Node* ConsumeValue() FINAL;
+ ~AstTestContext() final;
+ void ProduceValue(Node* value) final;
+ Node* ConsumeValue() final;
};
: ControlScope(owner), target_(target), control_(control) {}
protected:
- virtual bool Execute(Command cmd, Statement* target, Node* value) OVERRIDE {
+ virtual bool Execute(Command cmd, Statement* target, Node* value) override {
if (target != target_) return false; // We are not the command target.
switch (cmd) {
case CMD_BREAK:
: ControlScope(owner), target_(target), control_(control) {}
protected:
- virtual bool Execute(Command cmd, Statement* target, Node* value) OVERRIDE {
+ virtual bool Execute(Command cmd, Statement* target, Node* value) override {
if (target != target_) return false; // We are not the command target.
switch (cmd) {
case CMD_BREAK:
}
protected:
- virtual bool Execute(Command cmd, Statement* target, Node* value) OVERRIDE {
+ virtual bool Execute(Command cmd, Statement* target, Node* value) override {
switch (cmd) {
case CMD_THROW:
control_->Throw(value);
}
protected:
- virtual bool Execute(Command cmd, Statement* target, Node* value) OVERRIDE {
+ virtual bool Execute(Command cmd, Statement* target, Node* value) override {
Node* token = commands_->RecordCommand(cmd, target, value);
control_->LeaveTry(token, value);
return true;
}
protected:
-#define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
// Visiting functions for AST nodes make this an AstVisitor.
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
// Visiting function for declarations list is overridden.
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
private:
class AstContext;
LoopAssignmentAnalysis* Analyze();
-#define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
class MachineOperatorBuilder;
class Operator;
-class ChangeLowering FINAL : public Reducer {
+class ChangeLowering final : public Reducer {
public:
explicit ChangeLowering(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
- ~ChangeLowering() FINAL;
+ ~ChangeLowering() final;
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Node* HeapNumberValueIndexConstant();
namespace internal {
namespace compiler {
-class CodeGenerator::JumpTable FINAL : public ZoneObject {
+class CodeGenerator::JumpTable final : public ZoneObject {
public:
JumpTable(JumpTable* next, Label** targets, size_t target_count)
: next_(next), targets_(targets), target_count_(target_count) {}
// Generates native code for a sequence of instructions.
-class CodeGenerator FINAL : public GapResolver::Assembler {
+class CodeGenerator final : public GapResolver::Assembler {
public:
explicit CodeGenerator(Frame* frame, Linkage* linkage,
InstructionSequence* code, CompilationInfo* info);
// Interface used by the gap resolver to emit moves and swaps.
void AssembleMove(InstructionOperand* source,
- InstructionOperand* destination) FINAL;
+ InstructionOperand* destination) final;
void AssembleSwap(InstructionOperand* source,
- InstructionOperand* destination) FINAL;
+ InstructionOperand* destination) final;
// ===========================================================================
// =================== Jump table construction methods. ======================
namespace compiler {
// Bundles various caches for common nodes.
-class CommonNodeCache FINAL {
+class CommonNodeCache final {
public:
explicit CommonNodeCache(Zone* zone) : zone_(zone) {}
~CommonNodeCache() {}
// Performs strength reduction on nodes that have common operators.
-class CommonOperatorReducer FINAL : public Reducer {
+class CommonOperatorReducer final : public Reducer {
public:
explicit CommonOperatorReducer(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
- ~CommonOperatorReducer() FINAL {}
+ ~CommonOperatorReducer() final {}
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Reduction ReduceEffectPhi(Node* node);
V(14)
-struct CommonOperatorGlobalCache FINAL {
+struct CommonOperatorGlobalCache final {
#define CACHED(Name, properties, value_input_count, effect_input_count, \
control_input_count, value_output_count, effect_output_count, \
control_output_count) \
- struct Name##Operator FINAL : public Operator { \
+ struct Name##Operator final : public Operator { \
Name##Operator() \
: Operator(IrOpcode::k##Name, properties, #Name, value_input_count, \
effect_input_count, control_input_count, \
#undef CACHED
template <BranchHint kBranchHint>
- struct BranchOperator FINAL : public Operator1<BranchHint> {
+ struct BranchOperator final : public Operator1<BranchHint> {
BranchOperator()
: Operator1<BranchHint>( // --
IrOpcode::kBranch, Operator::kKontrol, // opcode
BranchOperator<BranchHint::kFalse> kBranchFalseOperator;
template <int kEffectInputCount>
- struct EffectPhiOperator FINAL : public Operator {
+ struct EffectPhiOperator final : public Operator {
EffectPhiOperator()
: Operator( // --
IrOpcode::kEffectPhi, Operator::kPure, // opcode
#undef CACHED_EFFECT_PHI
template <size_t kInputCount>
- struct LoopOperator FINAL : public Operator {
+ struct LoopOperator final : public Operator {
LoopOperator()
: Operator( // --
IrOpcode::kLoop, Operator::kKontrol, // opcode
#undef CACHED_LOOP
template <size_t kInputCount>
- struct MergeOperator FINAL : public Operator {
+ struct MergeOperator final : public Operator {
MergeOperator()
: Operator( // --
IrOpcode::kMerge, Operator::kKontrol, // opcode
#undef CACHED_MERGE
template <MachineType kType, int kInputCount>
- struct PhiOperator FINAL : public Operator1<MachineType> {
+ struct PhiOperator final : public Operator1<MachineType> {
PhiOperator()
: Operator1<MachineType>( //--
IrOpcode::kPhi, Operator::kPure, // opcode
#undef CACHED_PHI
template <int kIndex>
- struct ParameterOperator FINAL : public Operator1<int> {
+ struct ParameterOperator final : public Operator1<int> {
ParameterOperator()
: Operator1<int>( // --
IrOpcode::kParameter, Operator::kPure, // opcode
#undef CACHED_PARAMETER
template <size_t kIndex>
- struct ProjectionOperator FINAL : public Operator1<size_t> {
+ struct ProjectionOperator final : public Operator1<size_t> {
ProjectionOperator()
: Operator1<size_t>( // --
IrOpcode::kProjection, // opcode
#undef CACHED_PROJECTION
template <int kInputCount>
- struct StateValuesOperator FINAL : public Operator {
+ struct StateValuesOperator final : public Operator {
StateValuesOperator()
: Operator( // --
IrOpcode::kStateValues, // opcode
const Operator* CommonOperatorBuilder::Call(const CallDescriptor* descriptor) {
- class CallOperator FINAL : public Operator1<const CallDescriptor*> {
+ class CallOperator final : public Operator1<const CallDescriptor*> {
public:
CallOperator(const CallDescriptor* descriptor, const char* mnemonic)
: Operator1<const CallDescriptor*>(
Operator::ZeroIfPure(descriptor->properties()),
Operator::ZeroIfNoThrow(descriptor->properties()), descriptor) {}
- void PrintParameter(std::ostream& os) const OVERRIDE {
+ void PrintParameter(std::ostream& os) const override {
os << "[" << *parameter() << "]";
}
};
BranchHint BranchHintOf(const Operator* const);
-class SelectParameters FINAL {
+class SelectParameters final {
public:
explicit SelectParameters(MachineType type,
BranchHint hint = BranchHint::kNone)
};
-class FrameStateCallInfo FINAL {
+class FrameStateCallInfo final {
public:
FrameStateCallInfo(
FrameStateType type, BailoutId bailout_id,
// Interface for building common operators that can be used at any level of IR,
// including JavaScript, mid-level, and low-level.
-class CommonOperatorBuilder FINAL : public ZoneObject {
+class CommonOperatorBuilder final : public ZoneObject {
public:
explicit CommonOperatorBuilder(Zone* zone);
// Tracks control flow for a conditional statement.
-class IfBuilder FINAL : public ControlBuilder {
+class IfBuilder final : public ControlBuilder {
public:
explicit IfBuilder(AstGraphBuilder* builder)
: ControlBuilder(builder),
// Tracks control flow for an iteration statement.
-class LoopBuilder FINAL : public ControlBuilder {
+class LoopBuilder final : public ControlBuilder {
public:
explicit LoopBuilder(AstGraphBuilder* builder)
: ControlBuilder(builder),
void EndLoop();
// Primitive support for break.
- void Break() FINAL;
+ void Break() final;
// Compound control commands for conditional break.
void BreakUnless(Node* condition);
// Tracks control flow for a switch statement.
-class SwitchBuilder FINAL : public ControlBuilder {
+class SwitchBuilder final : public ControlBuilder {
public:
explicit SwitchBuilder(AstGraphBuilder* builder, int case_count)
: ControlBuilder(builder),
void EndSwitch();
// Primitive support for break.
- void Break() FINAL;
+ void Break() final;
// The number of cases within a switch is statically known.
size_t case_count() const { return body_environments_.size(); }
// Tracks control flow for a block statement.
-class BlockBuilder FINAL : public ControlBuilder {
+class BlockBuilder final : public ControlBuilder {
public:
explicit BlockBuilder(AstGraphBuilder* builder)
: ControlBuilder(builder), break_environment_(NULL) {}
void EndBlock();
// Primitive support for break.
- void Break() FINAL;
+ void Break() final;
private:
Environment* break_environment_; // Environment after the block exits.
// Tracks control flow for a try-catch statement.
-class TryCatchBuilder FINAL : public ControlBuilder {
+class TryCatchBuilder final : public ControlBuilder {
public:
explicit TryCatchBuilder(AstGraphBuilder* builder)
: ControlBuilder(builder),
// Tracks control flow for a try-finally statement.
-class TryFinallyBuilder FINAL : public ControlBuilder {
+class TryFinallyBuilder final : public ControlBuilder {
public:
explicit TryFinallyBuilder(AstGraphBuilder* builder)
: ControlBuilder(builder),
// control regions in linear time" by Johnson, Pearson & Pingali (PLDI94) which
// also contains proofs for the aforementioned equivalence. References to line
// numbers in the algorithm from figure 4 have been added [line:x].
-class ControlEquivalence FINAL : public ZoneObject {
+class ControlEquivalence final : public ZoneObject {
public:
ControlEquivalence(Zone* zone, Graph* graph)
: zone_(zone),
class Node;
-class ControlFlowOptimizer FINAL {
+class ControlFlowOptimizer final {
public:
ControlFlowOptimizer(JSGraph* jsgraph, Zone* zone);
namespace internal {
namespace compiler {
-class GapResolver FINAL {
+class GapResolver final {
public:
// Interface used by the gap resolver to emit moves and swaps.
class Assembler {
// Represents the result of trying to reduce a node in the graph.
-class Reduction FINAL {
+class Reduction final {
public:
explicit Reduction(Node* replacement = NULL) : replacement_(replacement) {}
// Performs an iterative reduction of a node graph.
-class GraphReducer FINAL {
+class GraphReducer final {
public:
GraphReducer(Graph* graph, Zone* zone);
void PrintType(Node* node);
void PrintLiveRange(LiveRange* range, const char* type);
- class Tag FINAL BASE_EMBEDDED {
+ class Tag final BASE_EMBEDDED {
public:
Tag(GraphC1Visualizer* visualizer, const char* name) {
name_ = name;
}
-class OutOfLineLoadInteger FINAL : public OutOfLineCode {
+class OutOfLineLoadInteger final : public OutOfLineCode {
public:
OutOfLineLoadInteger(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ xor_(result_, result_); }
+ void Generate() final { __ xor_(result_, result_); }
private:
Register const result_;
};
-class OutOfLineLoadFloat FINAL : public OutOfLineCode {
+class OutOfLineLoadFloat final : public OutOfLineCode {
public:
OutOfLineLoadFloat(CodeGenerator* gen, XMMRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ pcmpeqd(result_, result_); }
+ void Generate() final { __ pcmpeqd(result_, result_); }
private:
XMMRegister const result_;
};
-class OutOfLineTruncateDoubleToI FINAL : public OutOfLineCode {
+class OutOfLineTruncateDoubleToI final : public OutOfLineCode {
public:
OutOfLineTruncateDoubleToI(CodeGenerator* gen, Register result,
XMMRegister input)
: OutOfLineCode(gen), result_(result), input_(input) {}
- void Generate() FINAL {
+ void Generate() final {
__ sub(esp, Immediate(kDoubleSize));
__ movsd(MemOperand(esp, 0), input_);
__ SlowTruncateToI(result_, esp, 0);
namespace compiler {
// Adds IA32-specific methods for generating operands.
-class IA32OperandGenerator FINAL : public OperandGenerator {
+class IA32OperandGenerator final : public OperandGenerator {
public:
explicit IA32OperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
// The whole instruction is treated as a unit by the register allocator, and
// thus no spills or moves can be introduced between the flags-setting
// instruction and the branch or set it should be combined with.
-class FlagsContinuation FINAL {
+class FlagsContinuation final {
public:
FlagsContinuation() : mode_(kFlags_none) {}
// Instruction selection generates an InstructionSequence for a given Schedule.
-class InstructionSelector FINAL {
+class InstructionSelector final {
public:
// Forward declarations.
class Features;
// ============== Architecture-independent CPU feature methods. ==============
// ===========================================================================
- class Features FINAL {
+ class Features final {
public:
Features() : bits_(0) {}
explicit Features(unsigned bits) : bits_(bits) {}
#define ALLOCATED_OPERAND_CLASS(SubKind, kOperandKind) \
- class SubKind##Operand FINAL : public AllocatedOperand { \
+ class SubKind##Operand final : public AllocatedOperand { \
public: \
explicit SubKind##Operand(int index) \
: AllocatedOperand(kOperandKind, index) {} \
#undef ALLOCATED_OPERAND_CLASS
-class MoveOperands FINAL : public ZoneObject {
+class MoveOperands final : public ZoneObject {
public:
MoveOperands(const InstructionOperand& source,
const InstructionOperand& destination)
std::ostream& operator<<(std::ostream& os, const PrintableMoveOperands& mo);
-class ParallelMove FINAL : public ZoneVector<MoveOperands*>, public ZoneObject {
+class ParallelMove final : public ZoneVector<MoveOperands*>, public ZoneObject {
public:
explicit ParallelMove(Zone* zone) : ZoneVector<MoveOperands*>(zone) {
reserve(4);
std::ostream& operator<<(std::ostream& os, const PrintableParallelMove& pm);
-class ReferenceMap FINAL : public ZoneObject {
+class ReferenceMap final : public ZoneObject {
public:
explicit ReferenceMap(Zone* zone)
: reference_operands_(8, zone), instruction_position_(-1) {}
std::ostream& operator<<(std::ostream& os, const PrintableInstruction& instr);
-class RpoNumber FINAL {
+class RpoNumber final {
public:
static const int kInvalidRpoNumber = -1;
int ToInt() const {
std::ostream& operator<<(std::ostream&, const RpoNumber&);
-class Constant FINAL {
+class Constant final {
public:
enum Type {
kInt32,
std::ostream& operator<<(std::ostream& os, const Constant& constant);
-class PhiInstruction FINAL : public ZoneObject {
+class PhiInstruction final : public ZoneObject {
public:
typedef ZoneVector<InstructionOperand> Inputs;
// Analogue of BasicBlock for Instructions instead of Nodes.
-class InstructionBlock FINAL : public ZoneObject {
+class InstructionBlock final : public ZoneObject {
public:
InstructionBlock(Zone* zone, RpoNumber rpo_number, RpoNumber loop_header,
RpoNumber loop_end, bool deferred);
// Represents architecture-specific generated code before, during, and after
// register allocation.
// TODO(titzer): s/IsDouble/IsFloat64/
-class InstructionSequence FINAL : public ZoneObject {
+class InstructionSequence final : public ZoneObject {
public:
static InstructionBlocks* InstructionBlocksFor(Zone* zone,
const Schedule* schedule);
class MachineOperatorBuilder;
-class JSBuiltinReducer FINAL : public Reducer {
+class JSBuiltinReducer final : public Reducer {
public:
explicit JSBuiltinReducer(JSGraph* jsgraph);
- ~JSBuiltinReducer() FINAL {}
+ ~JSBuiltinReducer() final {}
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Reduction ReduceMathMax(Node* node);
public:
explicit JSContextSpecializer(JSGraph* jsgraph) : jsgraph_(jsgraph) {}
- Reduction Reduce(Node* node) OVERRIDE;
+ Reduction Reduce(Node* node) override;
// Visible for unit testing.
Reduction ReduceJSLoadContext(Node* node);
// Lowers JS-level operators to runtime and IC calls in the "generic" case.
-class JSGenericLowering FINAL : public Reducer {
+class JSGenericLowering final : public Reducer {
public:
JSGenericLowering(bool is_typing_enabled, JSGraph* jsgraph);
- ~JSGenericLowering() FINAL;
+ ~JSGenericLowering() final;
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
protected:
#define DECLARE_LOWER(x) void Lower##x(Node* node);
class JSCallFunctionAccessor;
-class JSInliner FINAL : public Reducer {
+class JSInliner final : public Reducer {
public:
enum Mode { kBuiltinsInlining, kGeneralInlining };
JSGraph* jsgraph)
: mode_(mode), local_zone_(local_zone), info_(info), jsgraph_(jsgraph) {}
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Mode const mode_;
// Lowers certain JS-level runtime calls.
-class JSIntrinsicLowering FINAL : public Reducer {
+class JSIntrinsicLowering final : public Reducer {
public:
explicit JSIntrinsicLowering(JSGraph* jsgraph);
- ~JSIntrinsicLowering() FINAL {}
+ ~JSIntrinsicLowering() final {}
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Reduction ReduceConstructDouble(Node* node);
V(CreateScriptContext, Operator::kNoProperties, 2, 1)
-struct JSOperatorGlobalCache FINAL {
+struct JSOperatorGlobalCache final {
#define CACHED(Name, properties, value_input_count, value_output_count) \
- struct Name##Operator FINAL : public Operator { \
+ struct Name##Operator final : public Operator { \
Name##Operator() \
: Operator(IrOpcode::kJS##Name, properties, "JS" #Name, \
value_input_count, Operator::ZeroIfPure(properties), \
#undef CACHED
template <LanguageMode kLanguageMode>
- struct StorePropertyOperator FINAL : public Operator1<LanguageMode> {
+ struct StorePropertyOperator final : public Operator1<LanguageMode> {
StorePropertyOperator()
: Operator1<LanguageMode>(IrOpcode::kJSStoreProperty,
Operator::kNoProperties, "JSStoreProperty", 3,
// Defines the arity and the call flags for a JavaScript function call. This is
// used as a parameter by JSCallFunction operators.
-class CallFunctionParameters FINAL {
+class CallFunctionParameters final {
public:
CallFunctionParameters(size_t arity, CallFunctionFlags flags)
: arity_(arity), flags_(flags) {}
// Defines the arity and the ID for a runtime function call. This is used as a
// parameter by JSCallRuntime operators.
-class CallRuntimeParameters FINAL {
+class CallRuntimeParameters final {
public:
CallRuntimeParameters(Runtime::FunctionId id, size_t arity)
: id_(id), arity_(arity) {}
// Defines the location of a context slot relative to a specific scope. This is
// used as a parameter by JSLoadContext and JSStoreContext operators and allows
// accessing a context-allocated variable without keeping track of the scope.
-class ContextAccess FINAL {
+class ContextAccess final {
public:
ContextAccess(size_t depth, size_t index, bool immutable);
// Defines the property being loaded from an object by a named load. This is
// used as a parameter by JSLoadNamed operators.
-class LoadNamedParameters FINAL {
+class LoadNamedParameters final {
public:
LoadNamedParameters(const Unique<Name>& name, const VectorSlotPair& feedback,
ContextualMode contextual_mode)
// Defines the property being loaded from an object. This is
// used as a parameter by JSLoadProperty operators.
-class LoadPropertyParameters FINAL {
+class LoadPropertyParameters final {
public:
explicit LoadPropertyParameters(const VectorSlotPair& feedback)
: feedback_(feedback) {}
// Defines the property being stored to an object by a named store. This is
// used as a parameter by JSStoreNamed operators.
-class StoreNamedParameters FINAL {
+class StoreNamedParameters final {
public:
StoreNamedParameters(LanguageMode language_mode, const Unique<Name>& name)
: language_mode_(language_mode), name_(name) {}
// Interface for building JavaScript-level operators, e.g. directly from the
// AST. Most operators have no parameters, thus can be globally shared for all
// graphs.
-class JSOperatorBuilder FINAL : public ZoneObject {
+class JSOperatorBuilder final : public ZoneObject {
public:
explicit JSOperatorBuilder(Zone* zone);
CHECK(js_type_feedback);
}
- Reduction Reduce(Node* node) OVERRIDE;
+ Reduction Reduce(Node* node) override;
// Visible for unit testing.
Reduction ReduceJSLoadNamed(Node* node);
// JSOperator. This class manages the rewriting of context, control, and effect
// dependencies during lowering of a binop and contains numerous helper
// functions for matching the types of inputs to an operation.
-class JSBinopReduction FINAL {
+class JSBinopReduction final {
public:
JSBinopReduction(JSTypedLowering* lowering, Node* node)
: lowering_(lowering), node_(node) {}
// Lowers JS-level operators to simplified operators based on types.
-class JSTypedLowering FINAL : public Reducer {
+class JSTypedLowering final : public Reducer {
public:
JSTypedLowering(JSGraph* jsgraph, Zone* zone);
- ~JSTypedLowering() FINAL {}
+ ~JSTypedLowering() final {}
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
friend class JSBinopReduction;
// Describes a call to various parts of the compiler. Every call has the notion
// of a "target", which is the first input to the call.
-class CallDescriptor FINAL : public ZoneObject {
+class CallDescriptor final : public ZoneObject {
public:
// Describes the kind of this call, which determines the target.
enum Kind {
namespace internal {
namespace compiler {
-class LoadElimination FINAL : public Reducer {
+class LoadElimination final : public Reducer {
public:
LoadElimination() {}
- ~LoadElimination() FINAL;
+ ~LoadElimination() final;
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Reduction ReduceLoadField(Node* node);
// Performs constant folding and strength reduction on nodes that have
// machine operators.
-class MachineOperatorReducer FINAL : public Reducer {
+class MachineOperatorReducer final : public Reducer {
public:
explicit MachineOperatorReducer(JSGraph* jsgraph);
~MachineOperatorReducer();
- Reduction Reduce(Node* node) OVERRIDE;
+ Reduction Reduce(Node* node) override;
private:
Node* Float32Constant(volatile float value);
struct MachineOperatorGlobalCache {
#define PURE(Name, properties, value_input_count, control_input_count, \
output_count) \
- struct Name##Operator FINAL : public Operator { \
+ struct Name##Operator final : public Operator { \
Name##Operator() \
: Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
value_input_count, 0, control_input_count, output_count, 0, \
#undef PURE
#define LOAD(Type) \
- struct Load##Type##Operator FINAL : public Operator1<LoadRepresentation> { \
+ struct Load##Type##Operator final : public Operator1<LoadRepresentation> { \
Load##Type##Operator() \
: Operator1<LoadRepresentation>( \
IrOpcode::kLoad, Operator::kNoThrow | Operator::kNoWrite, \
"Load", 2, 1, 1, 1, 1, 0, k##Type) {} \
}; \
- struct CheckedLoad##Type##Operator FINAL \
+ struct CheckedLoad##Type##Operator final \
: public Operator1<CheckedLoadRepresentation> { \
CheckedLoad##Type##Operator() \
: Operator1<CheckedLoadRepresentation>( \
"Store", 3, 1, 1, 0, 1, 0, \
StoreRepresentation(k##Type, write_barrier_kind)) {} \
}; \
- struct Store##Type##NoWriteBarrier##Operator FINAL \
+ struct Store##Type##NoWriteBarrier##Operator final \
: public Store##Type##Operator { \
Store##Type##NoWriteBarrier##Operator() \
: Store##Type##Operator(kNoWriteBarrier) {} \
}; \
- struct Store##Type##FullWriteBarrier##Operator FINAL \
+ struct Store##Type##FullWriteBarrier##Operator final \
: public Store##Type##Operator { \
Store##Type##FullWriteBarrier##Operator() \
: Store##Type##Operator(kFullWriteBarrier) {} \
}; \
- struct CheckedStore##Type##Operator FINAL \
+ struct CheckedStore##Type##Operator final \
: public Operator1<CheckedStoreRepresentation> { \
CheckedStore##Type##Operator() \
: Operator1<CheckedStoreRepresentation>( \
// A Store needs a MachineType and a WriteBarrierKind in order to emit the
// correct write barrier.
-class StoreRepresentation FINAL {
+class StoreRepresentation final {
public:
StoreRepresentation(MachineType machine_type,
WriteBarrierKind write_barrier_kind)
// Interface for building machine-level operators. These operators are
// machine-level but machine-independent and thus define a language suitable
// for generating code to run on architectures such as ia32, x64, arm, etc.
-class MachineOperatorBuilder FINAL : public ZoneObject {
+class MachineOperatorBuilder final : public ZoneObject {
public:
// Flags that specify which operations are available. This is useful
// for operations that are unsupported by some back-ends.
// Adds Mips-specific methods to convert InstructionOperands.
-class MipsOperandConverter FINAL : public InstructionOperandConverter {
+class MipsOperandConverter final : public InstructionOperandConverter {
public:
MipsOperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
namespace {
-class OutOfLineLoadSingle FINAL : public OutOfLineCode {
+class OutOfLineLoadSingle final : public OutOfLineCode {
public:
OutOfLineLoadSingle(CodeGenerator* gen, FloatRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Move(result_, std::numeric_limits<float>::quiet_NaN());
}
};
-class OutOfLineLoadDouble FINAL : public OutOfLineCode {
+class OutOfLineLoadDouble final : public OutOfLineCode {
public:
OutOfLineLoadDouble(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Move(result_, std::numeric_limits<double>::quiet_NaN());
}
};
-class OutOfLineLoadInteger FINAL : public OutOfLineCode {
+class OutOfLineLoadInteger final : public OutOfLineCode {
public:
OutOfLineLoadInteger(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ mov(result_, zero_reg); }
+ void Generate() final { __ mov(result_, zero_reg); }
private:
Register const result_;
OutOfLineRound(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
// Handle rounding to zero case where sign has to be preserved.
// High bits of double input already in kScratchReg.
__ srl(at, kScratchReg, 31);
};
-class OutOfLineTruncate FINAL : public OutOfLineRound {
+class OutOfLineTruncate final : public OutOfLineRound {
public:
OutOfLineTruncate(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
};
-class OutOfLineFloor FINAL : public OutOfLineRound {
+class OutOfLineFloor final : public OutOfLineRound {
public:
OutOfLineFloor(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
};
-class OutOfLineCeil FINAL : public OutOfLineRound {
+class OutOfLineCeil final : public OutOfLineRound {
public:
OutOfLineCeil(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
// Adds Mips-specific methods for generating InstructionOperands.
-class MipsOperandGenerator FINAL : public OperandGenerator {
+class MipsOperandGenerator final : public OperandGenerator {
public:
explicit MipsOperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
// Adds Mips-specific methods to convert InstructionOperands.
-class MipsOperandConverter FINAL : public InstructionOperandConverter {
+class MipsOperandConverter final : public InstructionOperandConverter {
public:
MipsOperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
namespace {
-class OutOfLineLoadSingle FINAL : public OutOfLineCode {
+class OutOfLineLoadSingle final : public OutOfLineCode {
public:
OutOfLineLoadSingle(CodeGenerator* gen, FloatRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Move(result_, std::numeric_limits<float>::quiet_NaN());
}
};
-class OutOfLineLoadDouble FINAL : public OutOfLineCode {
+class OutOfLineLoadDouble final : public OutOfLineCode {
public:
OutOfLineLoadDouble(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ Move(result_, std::numeric_limits<double>::quiet_NaN());
}
};
-class OutOfLineLoadInteger FINAL : public OutOfLineCode {
+class OutOfLineLoadInteger final : public OutOfLineCode {
public:
OutOfLineLoadInteger(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ mov(result_, zero_reg); }
+ void Generate() final { __ mov(result_, zero_reg); }
private:
Register const result_;
OutOfLineRound(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
// Handle rounding to zero case where sign has to be preserved.
// High bits of double input already in kScratchReg.
__ dsrl(at, kScratchReg, 31);
};
-class OutOfLineTruncate FINAL : public OutOfLineRound {
+class OutOfLineTruncate final : public OutOfLineRound {
public:
OutOfLineTruncate(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
};
-class OutOfLineFloor FINAL : public OutOfLineRound {
+class OutOfLineFloor final : public OutOfLineRound {
public:
OutOfLineFloor(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
};
-class OutOfLineCeil FINAL : public OutOfLineRound {
+class OutOfLineCeil final : public OutOfLineRound {
public:
OutOfLineCeil(CodeGenerator* gen, DoubleRegister result)
: OutOfLineRound(gen, result) {}
// Adds Mips-specific methods for generating InstructionOperands.
-class Mips64OperandGenerator FINAL : public OperandGenerator {
+class Mips64OperandGenerator final : public OperandGenerator {
public:
explicit Mips64OperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
namespace internal {
namespace compiler {
-class MoveOptimizer FINAL {
+class MoveOptimizer final {
public:
MoveOptimizer(Zone* local_zone, InstructionSequence* code);
void Run();
// nodes such as constants, parameters, etc.
template <typename Key, typename Hash = base::hash<Key>,
typename Pred = std::equal_to<Key> >
-class NodeCache FINAL {
+class NodeCache final {
public:
explicit NodeCache(unsigned max = 256)
: entries_(nullptr), size_(0), max_(max) {}
// A pattern matcher for integer constants.
template <typename T, IrOpcode::Value kOpcode>
-struct IntMatcher FINAL : public ValueMatcher<T, kOpcode> {
+struct IntMatcher final : public ValueMatcher<T, kOpcode> {
explicit IntMatcher(Node* node) : ValueMatcher<T, kOpcode>(node) {}
bool IsMultipleOf(T n) const {
// A pattern matcher for floating point constants.
template <typename T, IrOpcode::Value kOpcode>
-struct FloatMatcher FINAL : public ValueMatcher<T, kOpcode> {
+struct FloatMatcher final : public ValueMatcher<T, kOpcode> {
explicit FloatMatcher(Node* node) : ValueMatcher<T, kOpcode>(node) {}
bool IsMinusZero() const {
// A pattern matcher for heap object constants.
template <typename T>
-struct HeapObjectMatcher FINAL
+struct HeapObjectMatcher final
: public ValueMatcher<Unique<T>, IrOpcode::kHeapConstant> {
explicit HeapObjectMatcher(Node* node)
: ValueMatcher<Unique<T>, IrOpcode::kHeapConstant>(node) {}
// A pattern matcher for external reference constants.
-struct ExternalReferenceMatcher FINAL
+struct ExternalReferenceMatcher final
: public ValueMatcher<ExternalReference, IrOpcode::kExternalConstant> {
explicit ExternalReferenceMatcher(Node* node)
: ValueMatcher<ExternalReference, IrOpcode::kExternalConstant>(node) {}
class CommonOperatorBuilder;
// A facade that simplifies access to the different kinds of inputs to a node.
-class NodeProperties FINAL {
+class NodeProperties final {
public:
// ---------------------------------------------------------------------------
// Input layout.
// compilation, e.g. during lowering passes. Other information that needs to be
// associated with Nodes during compilation must be stored out-of-line indexed
// by the Node's id.
-class Node FINAL {
+class Node final {
public:
static Node* New(Zone* zone, NodeId id, const Operator* op, int input_count,
Node** inputs, bool has_extensible_inputs);
int UseCount() const;
void ReplaceUses(Node* replace_to);
- class InputEdges FINAL {
+ class InputEdges final {
public:
typedef Edge value_type;
InputEdges input_edges() { return InputEdges(this); }
- class Inputs FINAL {
+ class Inputs final {
public:
typedef Node* value_type;
Inputs inputs() { return Inputs(this); }
- class UseEdges FINAL {
+ class UseEdges final {
public:
typedef Edge value_type;
UseEdges use_edges() { return UseEdges(this); }
- class Uses FINAL {
+ class Uses final {
public:
typedef Node* value_type;
}
private:
- struct Use FINAL : public ZoneObject {
+ struct Use final : public ZoneObject {
Node* from;
Use* next;
Use* prev;
int input_index;
};
- class Input FINAL {
+ class Input final {
public:
Node* to;
Use* use;
// An encapsulation for information associated with a single use of node as a
// input from another node, allowing access to both the defining node and
// the node having the input.
-class Edge FINAL {
+class Edge final {
public:
Node* from() const { return input_->use->from; }
Node* to() const { return input_->to; }
// A forward iterator to visit the edges for the input dependencies of a node.
-class Node::InputEdges::iterator FINAL {
+class Node::InputEdges::iterator final {
public:
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
// A forward iterator to visit the inputs of a node.
-class Node::Inputs::const_iterator FINAL {
+class Node::Inputs::const_iterator final {
public:
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
// A forward iterator to visit the uses edges of a node. The edges are returned
// in
// the order in which they were added as inputs.
-class Node::UseEdges::iterator FINAL {
+class Node::UseEdges::iterator final {
public:
iterator(const iterator& other)
: current_(other.current_), next_(other.next_) {}
// A forward iterator to visit the uses of a node. The uses are returned in
// the order in which they were added as inputs.
-class Node::Uses::const_iterator FINAL {
+class Node::Uses::const_iterator final {
public:
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
class Operator;
-class OperatorProperties FINAL {
+class OperatorProperties final {
public:
static bool HasContextInput(const Operator* op);
static int GetContextInputCount(const Operator* op) {
T const& parameter() const { return parameter_; }
- bool Equals(const Operator* other) const FINAL {
+ bool Equals(const Operator* other) const final {
if (opcode() != other->opcode()) return false;
const Operator1<T>* that = reinterpret_cast<const Operator1<T>*>(other);
return this->pred_(this->parameter(), that->parameter());
}
- size_t HashCode() const FINAL {
+ size_t HashCode() const final {
return base::hash_combine(this->opcode(), this->hash_(this->parameter()));
}
virtual void PrintParameter(std::ostream& os) const {
}
protected:
- void PrintTo(std::ostream& os) const FINAL {
+ void PrintTo(std::ostream& os) const final {
os << mnemonic();
PrintParameter(os);
}
}
#define DEF_VISIT(type) \
- void Visit##type(type* node) OVERRIDE { \
+ void Visit##type(type* node) override { \
SourcePositionTable::Scope pos(source_positions_, \
SourcePosition(node->position())); \
AstGraphBuilder::Visit##type(node); \
// Adds PPC-specific methods to convert InstructionOperands.
-class PPCOperandConverter FINAL : public InstructionOperandConverter {
+class PPCOperandConverter final : public InstructionOperandConverter {
public:
PPCOperandConverter(CodeGenerator* gen, Instruction* instr)
: InstructionOperandConverter(gen, instr) {}
namespace {
-class OutOfLineLoadNAN32 FINAL : public OutOfLineCode {
+class OutOfLineLoadNAN32 final : public OutOfLineCode {
public:
OutOfLineLoadNAN32(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ LoadDoubleLiteral(result_, std::numeric_limits<float>::quiet_NaN(),
kScratchReg);
}
};
-class OutOfLineLoadNAN64 FINAL : public OutOfLineCode {
+class OutOfLineLoadNAN64 final : public OutOfLineCode {
public:
OutOfLineLoadNAN64(CodeGenerator* gen, DoubleRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL {
+ void Generate() final {
__ LoadDoubleLiteral(result_, std::numeric_limits<double>::quiet_NaN(),
kScratchReg);
}
};
-class OutOfLineLoadZero FINAL : public OutOfLineCode {
+class OutOfLineLoadZero final : public OutOfLineCode {
public:
OutOfLineLoadZero(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ li(result_, Operand::Zero()); }
+ void Generate() final { __ li(result_, Operand::Zero()); }
private:
Register const result_;
// Adds PPC-specific methods for generating operands.
-class PPCOperandGenerator FINAL : public OperandGenerator {
+class PPCOperandGenerator final : public OperandGenerator {
public:
explicit PPCOperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
MachineType word = kMachPtr,
MachineOperatorBuilder::Flags flags =
MachineOperatorBuilder::Flag::kNoFlags);
- ~RawMachineAssembler() OVERRIDE {}
+ ~RawMachineAssembler() override {}
Zone* zone() const { return graph()->zone(); }
MachineOperatorBuilder* machine() { return &machine_; }
protected:
Node* MakeNode(const Operator* op, int input_count, Node** inputs,
- bool incomplete) FINAL;
+ bool incomplete) final;
bool ScheduleValid() { return schedule_ != NULL; }
class InstructionOperand;
class InstructionSequence;
-class RegisterAllocatorVerifier FINAL : public ZoneObject {
+class RegisterAllocatorVerifier final : public ZoneObject {
public:
RegisterAllocatorVerifier(Zone* zone, const RegisterConfiguration* config,
const InstructionSequence* sequence);
//
// [Lifetime::USED_AT_START, Lifetime::USED_AT_END]
//
-class LifetimePosition FINAL {
+class LifetimePosition final {
public:
// Return the lifetime position that corresponds to the beginning of
// the gap with the given index.
// Representation of the non-empty interval [start,end[.
-class UseInterval FINAL : public ZoneObject {
+class UseInterval final : public ZoneObject {
public:
UseInterval(LifetimePosition start, LifetimePosition end)
: start_(start), end_(end), next_(nullptr) {
// Representation of a use position.
-class UsePosition FINAL : public ZoneObject {
+class UsePosition final : public ZoneObject {
public:
UsePosition(LifetimePosition pos, InstructionOperand* operand,
InstructionOperand* hint);
// Representation of SSA values' live ranges as a collection of (continuous)
// intervals over the instruction ordering.
-class LiveRange FINAL : public ZoneObject {
+class LiveRange final : public ZoneObject {
public:
static const int kInvalidAssignment = 0x7fffffff;
};
-class SpillRange FINAL : public ZoneObject {
+class SpillRange final : public ZoneObject {
public:
SpillRange(LiveRange* range, Zone* zone);
};
-class RegisterAllocator FINAL : public ZoneObject {
+class RegisterAllocator final : public ZoneObject {
public:
explicit RegisterAllocator(const RegisterConfiguration* config,
Zone* local_zone, Frame* frame,
// A basic block contains an ordered list of nodes and ends with a control
// node. Note that if a basic block has phis, then all phis must appear as the
// first nodes in the block.
-class BasicBlock FINAL : public ZoneObject {
+class BasicBlock final : public ZoneObject {
public:
// Possible control nodes that can end a block.
enum Control {
// and ordering them within basic blocks. Prior to computing a schedule,
// a graph has no notion of control flow ordering other than that induced
// by the graph's dependencies. A schedule is required to generate code.
-class Schedule FINAL : public ZoneObject {
+class Schedule final : public ZoneObject {
public:
explicit Schedule(Zone* zone, size_t node_count_hint = 0);
// Lowers Select nodes to diamonds.
-class SelectLowering FINAL : public Reducer {
+class SelectLowering final : public Reducer {
public:
SelectLowering(Graph* graph, CommonOperatorBuilder* common);
~SelectLowering();
- Reduction Reduce(Node* node) OVERRIDE;
+ Reduction Reduce(Node* node) override;
private:
typedef std::multimap<Node*, Node*, std::less<Node*>,
class RepresentationChanger;
class SourcePositionTable;
-class SimplifiedLowering FINAL {
+class SimplifiedLowering final {
public:
SimplifiedLowering(JSGraph* jsgraph, Zone* zone,
SourcePositionTable* source_positions)
class JSGraph;
class MachineOperatorBuilder;
-class SimplifiedOperatorReducer FINAL : public Reducer {
+class SimplifiedOperatorReducer final : public Reducer {
public:
explicit SimplifiedOperatorReducer(JSGraph* jsgraph);
- ~SimplifiedOperatorReducer() FINAL;
+ ~SimplifiedOperatorReducer() final;
- Reduction Reduce(Node* node) FINAL;
+ Reduction Reduce(Node* node) final;
private:
Reduction Change(Node* node, const Operator* op, Node* a);
V(ObjectIsNonNegativeSmi, Operator::kNoProperties, 1)
-struct SimplifiedOperatorGlobalCache FINAL {
+struct SimplifiedOperatorGlobalCache final {
#define PURE(Name, properties, input_count) \
- struct Name##Operator FINAL : public Operator { \
+ struct Name##Operator final : public Operator { \
Name##Operator() \
: Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name, \
input_count, 0, 0, 1, 0, 0) {} \
#undef PURE
#define BUFFER_ACCESS(Type, type, TYPE, ctype, size) \
- struct LoadBuffer##Type##Operator FINAL : public Operator1<BufferAccess> { \
+ struct LoadBuffer##Type##Operator final : public Operator1<BufferAccess> { \
LoadBuffer##Type##Operator() \
: Operator1<BufferAccess>(IrOpcode::kLoadBuffer, \
Operator::kNoThrow | Operator::kNoWrite, \
"LoadBuffer", 3, 1, 1, 1, 1, 0, \
BufferAccess(kExternal##Type##Array)) {} \
}; \
- struct StoreBuffer##Type##Operator FINAL : public Operator1<BufferAccess> { \
+ struct StoreBuffer##Type##Operator final : public Operator1<BufferAccess> { \
StoreBuffer##Type##Operator() \
: Operator1<BufferAccess>(IrOpcode::kStoreBuffer, \
Operator::kNoRead | Operator::kNoThrow, \
// An access descriptor for loads/stores of array buffers.
-class BufferAccess FINAL {
+class BufferAccess final {
public:
explicit BufferAccess(ExternalArrayType external_array_type)
: external_array_type_(external_array_type) {}
// - Bool: a tagged pointer to either the canonical JS #false or
// the canonical JS #true object
// - Bit: an untagged integer 0 or 1, but word-sized
-class SimplifiedOperatorBuilder FINAL {
+class SimplifiedOperatorBuilder final {
public:
explicit SimplifiedOperatorBuilder(Zone* zone);
namespace internal {
namespace compiler {
-class SourcePositionTable::Decorator FINAL : public GraphDecorator {
+class SourcePositionTable::Decorator final : public GraphDecorator {
public:
explicit Decorator(SourcePositionTable* source_positions)
: source_positions_(source_positions) {}
- void Decorate(Node* node, bool incomplete) FINAL {
+ void Decorate(Node* node, bool incomplete) final {
DCHECK(!source_positions_->current_position_.IsInvalid());
source_positions_->table_.Set(node, source_positions_->current_position_);
}
// Encapsulates encoding and decoding of sources positions from which Nodes
// originated.
-class SourcePosition FINAL {
+class SourcePosition final {
public:
explicit SourcePosition(int raw = kUnknownPosition) : raw_(raw) {}
}
-class SourcePositionTable FINAL {
+class SourcePositionTable final {
public:
class Scope {
public:
// Constructs and caches types lazily.
// TODO(turbofan): these types could be globally cached or cached per isolate.
-class LazyTypeCache FINAL : public ZoneObject {
+class LazyTypeCache final : public ZoneObject {
public:
explicit LazyTypeCache(Isolate* isolate, Zone* zone)
: isolate_(isolate), zone_(zone) {
};
-class Typer::Decorator FINAL : public GraphDecorator {
+class Typer::Decorator final : public GraphDecorator {
public:
explicit Decorator(Typer* typer) : typer_(typer) {}
- void Decorate(Node* node, bool incomplete) FINAL;
+ void Decorate(Node* node, bool incomplete) final;
private:
Typer* typer_;
explicit Visitor(Typer* typer)
: typer_(typer), weakened_nodes_(typer->zone()) {}
- Reduction Reduce(Node* node) OVERRIDE {
+ Reduction Reduce(Node* node) override {
if (node->op()->ValueOutputCount() == 0) return NoChange();
switch (node->opcode()) {
#define DECLARE_CASE(x) \
namespace internal {
namespace compiler {
-class ValueNumberingReducer FINAL : public Reducer {
+class ValueNumberingReducer final : public Reducer {
public:
explicit ValueNumberingReducer(Zone* zone);
~ValueNumberingReducer();
- Reduction Reduce(Node* node) OVERRIDE;
+ Reduction Reduce(Node* node) override;
private:
enum { kInitialCapacity = 256u, kCapacityToSizeRatio = 2u };
}
-class OutOfLineLoadZero FINAL : public OutOfLineCode {
+class OutOfLineLoadZero final : public OutOfLineCode {
public:
OutOfLineLoadZero(CodeGenerator* gen, Register result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ xorl(result_, result_); }
+ void Generate() final { __ xorl(result_, result_); }
private:
Register const result_;
};
-class OutOfLineLoadNaN FINAL : public OutOfLineCode {
+class OutOfLineLoadNaN final : public OutOfLineCode {
public:
OutOfLineLoadNaN(CodeGenerator* gen, XMMRegister result)
: OutOfLineCode(gen), result_(result) {}
- void Generate() FINAL { __ pcmpeqd(result_, result_); }
+ void Generate() final { __ pcmpeqd(result_, result_); }
private:
XMMRegister const result_;
};
-class OutOfLineTruncateDoubleToI FINAL : public OutOfLineCode {
+class OutOfLineTruncateDoubleToI final : public OutOfLineCode {
public:
OutOfLineTruncateDoubleToI(CodeGenerator* gen, Register result,
XMMRegister input)
: OutOfLineCode(gen), result_(result), input_(input) {}
- void Generate() FINAL {
+ void Generate() final {
__ subp(rsp, Immediate(kDoubleSize));
__ movsd(MemOperand(rsp, 0), input_);
__ SlowTruncateToI(result_, rsp, 0);
auto length = i.InputInt32(3); \
DCHECK_LE(index2, length); \
__ cmpq(index1, Immediate(length - index2)); \
- class OutOfLineLoadFloat FINAL : public OutOfLineCode { \
+ class OutOfLineLoadFloat final : public OutOfLineCode { \
public: \
OutOfLineLoadFloat(CodeGenerator* gen, XMMRegister result, \
Register buffer, Register index1, int32_t index2, \
index2_(index2), \
length_(length) {} \
\
- void Generate() FINAL { \
+ void Generate() final { \
__ leal(kScratchRegister, Operand(index1_, index2_)); \
__ pcmpeqd(result_, result_); \
__ cmpl(kScratchRegister, Immediate(length_)); \
auto length = i.InputInt32(3); \
DCHECK_LE(index2, length); \
__ cmpq(index1, Immediate(length - index2)); \
- class OutOfLineLoadInteger FINAL : public OutOfLineCode { \
+ class OutOfLineLoadInteger final : public OutOfLineCode { \
public: \
OutOfLineLoadInteger(CodeGenerator* gen, Register result, \
Register buffer, Register index1, int32_t index2, \
index2_(index2), \
length_(length) {} \
\
- void Generate() FINAL { \
+ void Generate() final { \
Label oob; \
__ leal(kScratchRegister, Operand(index1_, index2_)); \
__ cmpl(kScratchRegister, Immediate(length_)); \
auto length = i.InputInt32(3); \
DCHECK_LE(index2, length); \
__ cmpq(index1, Immediate(length - index2)); \
- class OutOfLineStoreFloat FINAL : public OutOfLineCode { \
+ class OutOfLineStoreFloat final : public OutOfLineCode { \
public: \
OutOfLineStoreFloat(CodeGenerator* gen, Register buffer, \
Register index1, int32_t index2, int32_t length, \
length_(length), \
value_(value) {} \
\
- void Generate() FINAL { \
+ void Generate() final { \
__ leal(kScratchRegister, Operand(index1_, index2_)); \
__ cmpl(kScratchRegister, Immediate(length_)); \
__ j(above_equal, exit()); \
auto length = i.InputInt32(3); \
DCHECK_LE(index2, length); \
__ cmpq(index1, Immediate(length - index2)); \
- class OutOfLineStoreInteger FINAL : public OutOfLineCode { \
+ class OutOfLineStoreInteger final : public OutOfLineCode { \
public: \
OutOfLineStoreInteger(CodeGenerator* gen, Register buffer, \
Register index1, int32_t index2, int32_t length, \
length_(length), \
value_(value) {} \
\
- void Generate() FINAL { \
+ void Generate() final { \
__ leal(kScratchRegister, Operand(index1_, index2_)); \
__ cmpl(kScratchRegister, Immediate(length_)); \
__ j(above_equal, exit()); \
namespace compiler {
// Adds X64-specific methods for generating operands.
-class X64OperandGenerator FINAL : public OperandGenerator {
+class X64OperandGenerator final : public OperandGenerator {
public:
explicit X64OperandGenerator(InstructionSelector* selector)
: OperandGenerator(selector) {}
namespace internal {
namespace compiler {
-class ZonePool FINAL {
+class ZonePool final {
public:
- class Scope FINAL {
+ class Scope final {
public:
explicit Scope(ZonePool* zone_pool) : zone_pool_(zone_pool), zone_(NULL) {}
~Scope() { Destroy(); }
DISALLOW_COPY_AND_ASSIGN(Scope);
};
- class StatsScope FINAL {
+ class StatsScope final {
public:
explicit StatsScope(ZonePool* zone_pool);
~StatsScope();
class MockArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
public:
- void* Allocate(size_t) OVERRIDE { return malloc(1); }
- void* AllocateUninitialized(size_t length) OVERRIDE { return malloc(1); }
- void Free(void* p, size_t) OVERRIDE { free(p); }
+ void* Allocate(size_t) override { return malloc(1); }
+ void* AllocateUninitialized(size_t length) override { return malloc(1); }
+ void Free(void* p, size_t) override { free(p); }
};
typedef ElementsTraitsParam ElementsTraits;
typedef typename ElementsTraitsParam::BackingStore BackingStore;
- ElementsKind kind() const FINAL { return ElementsTraits::Kind; }
+ ElementsKind kind() const final { return ElementsTraits::Kind; }
static void ValidateContents(Handle<JSObject> holder, int length) {
}
ElementsAccessorSubclass::ValidateContents(holder, length);
}
- void Validate(Handle<JSObject> holder) FINAL {
+ void Validate(Handle<JSObject> holder) final {
DisallowHeapAllocation no_gc;
ElementsAccessorSubclass::ValidateImpl(holder);
}
}
virtual bool HasElement(Handle<JSObject> holder, uint32_t key,
- Handle<FixedArrayBase> backing_store) FINAL {
+ Handle<FixedArrayBase> backing_store) final {
return ElementsAccessorSubclass::HasElementImpl(holder, key, backing_store);
}
MUST_USE_RESULT virtual MaybeHandle<Object> Get(
Handle<Object> receiver, Handle<JSObject> holder, uint32_t key,
- Handle<FixedArrayBase> backing_store) FINAL {
+ Handle<FixedArrayBase> backing_store) final {
if (!IsExternalArrayElementsKind(ElementsTraits::Kind) &&
FLAG_trace_js_array_abuse) {
CheckArrayAbuse(holder, "elements read", key);
MUST_USE_RESULT virtual PropertyAttributes GetAttributes(
Handle<JSObject> holder, uint32_t key,
- Handle<FixedArrayBase> backing_store) FINAL {
+ Handle<FixedArrayBase> backing_store) final {
return ElementsAccessorSubclass::GetAttributesImpl(holder, key,
backing_store);
}
MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair(
Handle<JSObject> holder, uint32_t key,
- Handle<FixedArrayBase> backing_store) FINAL {
+ Handle<FixedArrayBase> backing_store) final {
return ElementsAccessorSubclass::GetAccessorPairImpl(holder, key,
backing_store);
}
}
MUST_USE_RESULT virtual MaybeHandle<Object> SetLength(
- Handle<JSArray> array, Handle<Object> length) FINAL {
+ Handle<JSArray> array, Handle<Object> length) final {
return ElementsAccessorSubclass::SetLengthImpl(
array, length, handle(array->elements()));
}
Handle<FixedArrayBase> backing_store);
virtual void SetCapacityAndLength(Handle<JSArray> array, int capacity,
- int length) FINAL {
+ int length) final {
ElementsAccessorSubclass::
SetFastElementsCapacityAndLength(array, capacity, length);
}
MUST_USE_RESULT virtual MaybeHandle<Object> Delete(
Handle<JSObject> obj, uint32_t key,
- LanguageMode language_mode) OVERRIDE = 0;
+ LanguageMode language_mode) override = 0;
static void CopyElementsImpl(FixedArrayBase* from, uint32_t from_start,
FixedArrayBase* to, ElementsKind from_kind,
virtual void CopyElements(Handle<FixedArrayBase> from, uint32_t from_start,
ElementsKind from_kind, Handle<FixedArrayBase> to,
- uint32_t to_start, int copy_size) FINAL {
+ uint32_t to_start, int copy_size) final {
DCHECK(!from.is_null());
// NOTE: the ElementsAccessorSubclass::CopyElementsImpl() methods
// violate the handlified function signature convention:
virtual void CopyElements(JSObject* from_holder, uint32_t from_start,
ElementsKind from_kind, Handle<FixedArrayBase> to,
- uint32_t to_start, int copy_size) FINAL {
+ uint32_t to_start, int copy_size) final {
int packed_size = kPackedSizeNotKnown;
bool is_packed = IsFastPackedElementsKind(from_kind) &&
from_holder->IsJSArray();
virtual MaybeHandle<FixedArray> AddElementsToFixedArray(
Handle<Object> receiver, Handle<JSObject> holder, Handle<FixedArray> to,
- Handle<FixedArrayBase> from, FixedArray::KeyFilter filter) FINAL {
+ Handle<FixedArrayBase> from, FixedArray::KeyFilter filter) final {
int len0 = to->length();
#ifdef ENABLE_SLOW_DCHECKS
if (FLAG_enable_slow_asserts) {
return backing_store->length();
}
- uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) FINAL {
+ uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) final {
return ElementsAccessorSubclass::GetCapacityImpl(backing_store);
}
}
virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store,
- uint32_t index) FINAL {
+ uint32_t index) final {
return ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, index);
}
}
virtual MaybeHandle<Object> Delete(Handle<JSObject> obj, uint32_t key,
- LanguageMode language_mode) FINAL {
+ LanguageMode language_mode) final {
return DeleteCommon(obj, key, language_mode);
}
}
MUST_USE_RESULT virtual MaybeHandle<Object> Delete(
- Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) FINAL {
+ Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) final {
// External arrays always ignore deletes.
return obj->GetIsolate()->factory()->true_value();
}
ElementsKindTraits<DICTIONARY_ELEMENTS> >;
MUST_USE_RESULT virtual MaybeHandle<Object> Delete(
- Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) FINAL {
+ Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) final {
return DeleteCommon(obj, key, language_mode);
}
}
MUST_USE_RESULT virtual MaybeHandle<Object> Delete(
- Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) FINAL {
+ Handle<JSObject> obj, uint32_t key, LanguageMode language_mode) final {
Isolate* isolate = obj->GetIsolate();
Handle<FixedArray> parameter_map(FixedArray::cast(obj->elements()));
Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key);
namespace v8 {
namespace internal {
-class Execution FINAL : public AllStatic {
+class Execution final : public AllStatic {
public:
// Call a function, the caller supplies a receiver and an array
// of arguments. Arguments are Object* type. After function returns,
// StackGuard contains the handling of the limits that are used to limit the
// number of nested invocations of JavaScript and the stack size used in each
// invocation.
-class StackGuard FINAL {
+class StackGuard final {
public:
// Pass the address beyond which the stack should not grow. The stack
// is assumed to grow downwards.
void PushPostponeInterruptsScope(PostponeInterruptsScope* scope);
void PopPostponeInterruptsScope();
- class ThreadLocal FINAL {
+ class ThreadLocal final {
public:
ThreadLocal() { Clear(); }
// You should hold the ExecutionAccess lock when you call Initialize or
class FeedbackVectorSpec;
// Interface for handle based allocation.
-class Factory FINAL {
+class Factory final {
public:
Handle<Oddball> NewOddball(Handle<Map> map,
const char* to_string,
// from a property index. When available, the wrapper class captures additional
// information to allow the field index to be translated back into the property
// index it was originally generated from.
-class FieldIndex FINAL {
+class FieldIndex final {
public:
static FieldIndex ForPropertyIndex(Map* map,
int index,
private:
// AST node visit functions.
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
void VisitInDuplicateContext(Expression* expr);
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
void DeclareModules(Handle<FixedArray> descriptions);
void DeclareGlobals(Handle<FixedArray> pairs);
int DeclareGlobalsFlags();
void PushFunctionArgumentForContextAllocation();
// AST node visit functions.
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
private:
// v8::Task overrides.
- void Run() OVERRIDE {
+ void Run() override {
heap_->mark_compact_collector()->SweepInParallel(space_, 0);
heap_->mark_compact_collector()->pending_sweeper_jobs_semaphore_.Signal();
}
namespace v8 {
namespace internal {
-class HInstructionMap FINAL : public ZoneObject {
+class HInstructionMap final : public ZoneObject {
public:
HInstructionMap(Zone* zone, SideEffectsTracker* side_effects_tracker)
: array_size_(0),
};
-class HSideEffectMap FINAL BASE_EMBEDDED {
+class HSideEffectMap final BASE_EMBEDDED {
public:
HSideEffectMap();
explicit HSideEffectMap(HSideEffectMap* other);
// which can be used to represent side effects that cannot be expressed using
// the GVNFlags of an HInstruction. These special side effects are tracked by a
// SideEffectsTracker (see below).
-class SideEffects FINAL {
+class SideEffects final {
public:
static const int kNumberOfSpecials = 64 - kNumberOfFlags;
// SideEffects class (see above). This way unrelated global variable/inobject
// field stores don't prevent hoisting and merging of global variable/inobject
// field loads.
-class SideEffectsTracker FINAL BASE_EMBEDDED {
+class SideEffectsTracker final BASE_EMBEDDED {
public:
SideEffectsTracker() : num_global_vars_(0), num_inobject_fields_(0) {}
SideEffects ComputeChanges(HInstruction* instr);
// Perform common subexpression elimination and loop-invariant code motion.
-class HGlobalValueNumberingPhase FINAL : public HPhase {
+class HGlobalValueNumberingPhase final : public HPhase {
public:
explicit HGlobalValueNumberingPhase(HGraph* graph);
#define DECLARE_ABSTRACT_INSTRUCTION(type) \
- bool Is##type() const FINAL { return true; } \
+ bool Is##type() const final { return true; } \
static H##type* cast(HValue* value) { \
DCHECK(value->Is##type()); \
return reinterpret_cast<H##type*>(value); \
#define DECLARE_CONCRETE_INSTRUCTION(type) \
- LInstruction* CompileToLithium(LChunkBuilder* builder) FINAL; \
+ LInstruction* CompileToLithium(LChunkBuilder* builder) final; \
static H##type* cast(HValue* value) { \
DCHECK(value->Is##type()); \
return reinterpret_cast<H##type*>(value); \
} \
- Opcode opcode() const FINAL { return HValue::k##type; }
+ Opcode opcode() const final { return HValue::k##type; }
enum PropertyAccessType { LOAD, STORE };
-class Range FINAL : public ZoneObject {
+class Range final : public ZoneObject {
public:
Range()
: lower_(kMinInt),
// We reuse use list nodes behind the scenes as uses are added and deleted.
// This class is the safe way to iterate uses while deleting them.
-class HUseIterator FINAL BASE_EMBEDDED {
+class HUseIterator final BASE_EMBEDDED {
public:
bool Done() { return current_ == NULL; }
void Advance();
}
-class DecompositionResult FINAL BASE_EMBEDDED {
+class DecompositionResult final BASE_EMBEDDED {
public:
DecompositionResult() : base_(NULL), offset_(0), scale_(0) {}
HInstruction* next() const { return next_; }
HInstruction* previous() const { return previous_; }
- std::ostream& PrintTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintTo(std::ostream& os) const override; // NOLINT
virtual std::ostream& PrintDataTo(std::ostream& os) const; // NOLINT
bool IsLinked() const { return block() != NULL; }
}
// The position is a write-once variable.
- SourcePosition position() const OVERRIDE {
+ SourcePosition position() const override {
return SourcePosition(position_.position());
}
bool has_position() const {
position_.set_position(position);
}
- SourcePosition operand_position(int index) const OVERRIDE {
+ SourcePosition operand_position(int index) const override {
const SourcePosition pos = position_.operand_position(index);
return pos.IsUnknown() ? position() : pos;
}
virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
#ifdef DEBUG
- void Verify() OVERRIDE;
+ void Verify() override;
#endif
bool CanDeoptimize();
SetDependsOnFlag(kOsrEntries);
}
- void DeleteFromGraph() OVERRIDE { Unlink(); }
+ void DeleteFromGraph() override { Unlink(); }
private:
void InitializeAsFirst(HBasicBlock* block) {
template<int V>
class HTemplateInstruction : public HInstruction {
public:
- int OperandCount() const FINAL { return V; }
- HValue* OperandAt(int i) const FINAL { return inputs_[i]; }
+ int OperandCount() const final { return V; }
+ HValue* OperandAt(int i) const final { return inputs_[i]; }
protected:
explicit HTemplateInstruction(HType type = HType::Tagged())
: HInstruction(type) {}
- void InternalSetOperandAt(int i, HValue* value) FINAL { inputs_[i] = value; }
+ void InternalSetOperandAt(int i, HValue* value) final { inputs_[i] = value; }
private:
EmbeddedContainer<HValue*, V> inputs_;
virtual int SuccessorCount() const = 0;
virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
virtual bool KnownSuccessorBlock(HBasicBlock** block) {
*block = NULL;
};
-class HSuccessorIterator FINAL BASE_EMBEDDED {
+class HSuccessorIterator final BASE_EMBEDDED {
public:
explicit HSuccessorIterator(const HControlInstruction* instr)
: instr_(instr), current_(0) {}
template<int S, int V>
class HTemplateControlInstruction : public HControlInstruction {
public:
- int SuccessorCount() const OVERRIDE { return S; }
- HBasicBlock* SuccessorAt(int i) const OVERRIDE { return successors_[i]; }
- void SetSuccessorAt(int i, HBasicBlock* block) OVERRIDE {
+ int SuccessorCount() const override { return S; }
+ HBasicBlock* SuccessorAt(int i) const override { return successors_[i]; }
+ void SetSuccessorAt(int i, HBasicBlock* block) override {
successors_[i] = block;
}
- int OperandCount() const OVERRIDE { return V; }
- HValue* OperandAt(int i) const OVERRIDE { return inputs_[i]; }
+ int OperandCount() const override { return V; }
+ HValue* OperandAt(int i) const override { return inputs_[i]; }
protected:
- void InternalSetOperandAt(int i, HValue* value) OVERRIDE {
+ void InternalSetOperandAt(int i, HValue* value) override {
inputs_[i] = value;
}
};
-class HBlockEntry FINAL : public HTemplateInstruction<0> {
+class HBlockEntry final : public HTemplateInstruction<0> {
public:
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HDummyUse FINAL : public HTemplateInstruction<1> {
+class HDummyUse final : public HTemplateInstruction<1> {
public:
explicit HDummyUse(HValue* value)
: HTemplateInstruction<1>(HType::Smi()) {
HValue* value() const { return OperandAt(0); }
- bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return false; }
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(DummyUse);
};
// Inserts an int3/stop break instruction for debugging purposes.
-class HDebugBreak FINAL : public HTemplateInstruction<0> {
+class HDebugBreak final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P0(HDebugBreak);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HGoto FINAL : public HTemplateControlInstruction<1, 0> {
+class HGoto final : public HTemplateControlInstruction<1, 0> {
public:
explicit HGoto(HBasicBlock* target) {
SetSuccessorAt(0, target);
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE {
+ bool KnownSuccessorBlock(HBasicBlock** block) override {
*block = FirstSuccessor();
return true;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Goto)
};
-class HDeoptimize FINAL : public HTemplateControlInstruction<1, 0> {
+class HDeoptimize final : public HTemplateControlInstruction<1, 0> {
public:
static HDeoptimize* New(Isolate* isolate, Zone* zone, HValue* context,
Deoptimizer::DeoptReason reason,
return new(zone) HDeoptimize(reason, type, unreachable_continuation);
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE {
+ bool KnownSuccessorBlock(HBasicBlock** block) override {
*block = NULL;
return true;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
SetSuccessorAt(1, false_target);
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* value() const { return OperandAt(0); }
};
-class HBranch FINAL : public HUnaryControlInstruction {
+class HBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P2(HBranch, HValue*,
ToBooleanStub::Types,
HBasicBlock*, HBasicBlock*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- Representation observed_input_representation(int index) OVERRIDE;
+ Representation observed_input_representation(int index) override;
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
ToBooleanStub::Types expected_input_types() const {
return expected_input_types_;
};
-class HCompareMap FINAL : public HUnaryControlInstruction {
+class HCompareMap final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HCompareMap, HValue*, Handle<Map>);
DECLARE_INSTRUCTION_FACTORY_P4(HCompareMap, HValue*, Handle<Map>,
HBasicBlock*, HBasicBlock*);
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE {
+ bool KnownSuccessorBlock(HBasicBlock** block) override {
if (known_successor_index() != kNoKnownSuccessorIndex) {
*block = SuccessorAt(known_successor_index());
return true;
return false;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
static const int kNoKnownSuccessorIndex = -1;
int known_successor_index() const {
Unique<Map> map() const { return map_; }
bool map_is_stable() const { return MapIsStableField::decode(bit_field_); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
DECLARE_CONCRETE_INSTRUCTION(CompareMap)
protected:
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
private:
HCompareMap(HValue* value, Handle<Map> map, HBasicBlock* true_target = NULL,
};
-class HContext FINAL : public HTemplateInstruction<0> {
+class HContext final : public HTemplateInstruction<0> {
public:
static HContext* New(Zone* zone) {
return new(zone) HContext();
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
DECLARE_CONCRETE_INSTRUCTION(Context)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HContext() {
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HReturn FINAL : public HTemplateControlInstruction<0, 3> {
+class HReturn final : public HTemplateControlInstruction<0, 3> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HReturn, HValue*, HValue*);
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HReturn, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// TODO(titzer): require an Int32 input for faster returns.
if (index == 2) return Representation::Smi();
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* value() const { return OperandAt(0); }
HValue* context() const { return OperandAt(1); }
};
-class HAbnormalExit FINAL : public HTemplateControlInstruction<0, 0> {
+class HAbnormalExit final : public HTemplateControlInstruction<0, 0> {
public:
DECLARE_INSTRUCTION_FACTORY_P0(HAbnormalExit);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
}
HValue* value() const { return OperandAt(0); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
};
-class HUseConst FINAL : public HUnaryOperation {
+class HUseConst final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HForceRepresentation FINAL : public HTemplateInstruction<1> {
+class HForceRepresentation final : public HTemplateInstruction<1> {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* value,
HValue* value() const { return OperandAt(0); }
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
// We haven't actually *observed* this, but it's closer to the truth
// than 'None'.
return representation(); // Same as the output representation.
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation(); // Same as the output representation.
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation)
};
-class HChange FINAL : public HUnaryOperation {
+class HChange final : public HUnaryOperation {
public:
HChange(HValue* value,
Representation to,
return CheckUsesForFlag(kAllowUndefinedAsNaN);
}
- HType CalculateInferredType() OVERRIDE;
- HValue* Canonicalize() OVERRIDE;
+ HType CalculateInferredType() override;
+ HValue* Canonicalize() override;
Representation from() const { return value()->representation(); }
Representation to() const { return representation(); }
bool deoptimize_on_minus_zero() const {
return CheckFlag(kBailoutOnMinusZero);
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return from();
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Change)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
- bool IsDeletable() const OVERRIDE {
+ bool IsDeletable() const override {
return !from().IsTagged() || value()->type().IsSmi();
}
};
-class HClampToUint8 FINAL : public HUnaryOperation {
+class HClampToUint8 final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
DECLARE_CONCRETE_INSTRUCTION(ClampToUint8)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HClampToUint8(HValue* value)
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HDoubleBits FINAL : public HUnaryOperation {
+class HDoubleBits final : public HUnaryOperation {
public:
enum Bits { HIGH, LOW };
DECLARE_INSTRUCTION_FACTORY_P2(HDoubleBits, HValue*, Bits);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Double();
}
Bits bits() { return bits_; }
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return other->IsDoubleBits() && HDoubleBits::cast(other)->bits() == bits();
}
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
Bits bits_;
};
-class HConstructDouble FINAL : public HTemplateInstruction<2> {
+class HConstructDouble final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HConstructDouble, HValue*, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Integer32();
}
HValue* lo() { return OperandAt(1); }
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HConstructDouble(HValue* hi, HValue* lo) {
SetOperandAt(1, lo);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
};
-class HSimulate FINAL : public HInstruction {
+class HSimulate final : public HInstruction {
public:
HSimulate(BailoutId ast_id, int pop_count, Zone* zone,
RemovableSimulate removable)
DoneWithReplayField::encode(false)) {}
~HSimulate() {}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
bool HasAstId() const { return !ast_id_.IsNone(); }
BailoutId ast_id() const { return ast_id_; }
}
return -1;
}
- int OperandCount() const OVERRIDE { return values_.length(); }
- HValue* OperandAt(int index) const OVERRIDE { return values_[index]; }
+ int OperandCount() const override { return values_.length(); }
+ HValue* OperandAt(int index) const override { return values_[index]; }
- bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return false; }
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
DECLARE_CONCRETE_INSTRUCTION(Simulate)
#ifdef DEBUG
- void Verify() OVERRIDE;
+ void Verify() override;
void set_closure(Handle<JSFunction> closure) { closure_ = closure; }
Handle<JSFunction> closure() const { return closure_; }
#endif
protected:
- void InternalSetOperandAt(int index, HValue* value) OVERRIDE {
+ void InternalSetOperandAt(int index, HValue* value) override {
values_[index] = value;
}
};
-class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
+class HEnvironmentMarker final : public HTemplateInstruction<1> {
public:
enum Kind { BIND, LOOKUP };
next_simulate_ = simulate;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
#ifdef DEBUG
void set_closure(Handle<JSFunction> closure) {
};
-class HStackCheck FINAL : public HTemplateInstruction<1> {
+class HStackCheck final : public HTemplateInstruction<1> {
public:
enum Type {
kFunctionEntry,
HValue* context() { return OperandAt(0); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
class HConstant;
-class HEnterInlined FINAL : public HTemplateInstruction<0> {
+class HEnterInlined final : public HTemplateInstruction<0> {
public:
static HEnterInlined* New(Isolate* isolate, Zone* zone, HValue* context,
BailoutId return_id, Handle<JSFunction> closure,
void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone);
ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
Handle<JSFunction> closure() const { return closure_; }
HConstant* closure_context() const { return closure_context_; }
int inlining_id() const { return inlining_id_; }
void set_inlining_id(int inlining_id) { inlining_id_ = inlining_id; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HLeaveInlined FINAL : public HTemplateInstruction<0> {
+class HLeaveInlined final : public HTemplateInstruction<0> {
public:
HLeaveInlined(HEnterInlined* entry,
int drop_count)
: entry_(entry),
drop_count_(drop_count) { }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- int argument_delta() const OVERRIDE {
+ int argument_delta() const override {
return entry_->arguments_pushed() ? -drop_count_ : 0;
}
};
-class HPushArguments FINAL : public HInstruction {
+class HPushArguments final : public HInstruction {
public:
static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context) {
return new(zone) HPushArguments(zone);
return instr;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- int argument_delta() const OVERRIDE { return inputs_.length(); }
+ int argument_delta() const override { return inputs_.length(); }
HValue* argument(int i) { return OperandAt(i); }
- int OperandCount() const FINAL { return inputs_.length(); }
- HValue* OperandAt(int i) const FINAL { return inputs_[i]; }
+ int OperandCount() const final { return inputs_.length(); }
+ HValue* OperandAt(int i) const final { return inputs_[i]; }
void AddInput(HValue* value);
DECLARE_CONCRETE_INSTRUCTION(PushArguments)
protected:
- void InternalSetOperandAt(int i, HValue* value) FINAL { inputs_[i] = value; }
+ void InternalSetOperandAt(int i, HValue* value) final { inputs_[i] = value; }
private:
explicit HPushArguments(Zone* zone)
};
-class HThisFunction FINAL : public HTemplateInstruction<0> {
+class HThisFunction final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P0(HThisFunction);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
DECLARE_CONCRETE_INSTRUCTION(ThisFunction)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HThisFunction() {
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HDeclareGlobals FINAL : public HUnaryOperation {
+class HDeclareGlobals final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HDeclareGlobals,
Handle<FixedArray>,
DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
this->SetAllSideEffects();
}
- HType CalculateInferredType() FINAL { return HType::Tagged(); }
+ HType CalculateInferredType() final { return HType::Tagged(); }
virtual int argument_count() const {
return argument_count_;
}
- int argument_delta() const OVERRIDE { return -argument_count(); }
+ int argument_delta() const override { return -argument_count(); }
private:
int argument_count_;
SetOperandAt(0, value);
}
- Representation RequiredInputRepresentation(int index) FINAL {
+ Representation RequiredInputRepresentation(int index) final {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* value() const { return OperandAt(0); }
};
SetOperandAt(1, second);
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) FINAL {
+ Representation RequiredInputRepresentation(int index) final {
return Representation::Tagged();
}
};
-class HCallJSFunction FINAL : public HCall<1> {
+class HCallJSFunction final : public HCall<1> {
public:
static HCallJSFunction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* function, int argument_count,
HValue* function() const { return OperandAt(0); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) FINAL {
+ Representation RequiredInputRepresentation(int index) final {
DCHECK(index == 0);
return Representation::Tagged();
}
bool pass_argument_count() const { return pass_argument_count_; }
- bool HasStackCheck() FINAL { return has_stack_check_; }
+ bool HasStackCheck() final { return has_stack_check_; }
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction)
enum CallMode { NORMAL_CALL, TAIL_CALL };
-class HCallWithDescriptor FINAL : public HInstruction {
+class HCallWithDescriptor final : public HInstruction {
public:
static HCallWithDescriptor* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* target, int argument_count,
return res;
}
- int OperandCount() const FINAL { return values_.length(); }
- HValue* OperandAt(int index) const FINAL { return values_[index]; }
+ int OperandCount() const final { return values_.length(); }
+ HValue* OperandAt(int index) const final { return values_[index]; }
- Representation RequiredInputRepresentation(int index) FINAL {
+ Representation RequiredInputRepresentation(int index) final {
if (index == 0) {
return Representation::Tagged();
} else {
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor)
- HType CalculateInferredType() FINAL { return HType::Tagged(); }
+ HType CalculateInferredType() final { return HType::Tagged(); }
bool IsTailCall() const { return call_mode_ == TAIL_CALL; }
return argument_count_;
}
- int argument_delta() const OVERRIDE { return -argument_count_; }
+ int argument_delta() const override { return -argument_count_; }
CallInterfaceDescriptor descriptor() const { return descriptor_; }
return OperandAt(0);
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
private:
// The argument count includes the receiver.
SetOperandAt(values_.length() - 1, v);
}
- void InternalSetOperandAt(int index, HValue* value) FINAL {
+ void InternalSetOperandAt(int index, HValue* value) final {
values_[index] = value;
}
};
-class HInvokeFunction FINAL : public HBinaryCall {
+class HInvokeFunction final : public HBinaryCall {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInvokeFunction, HValue*, int);
Handle<JSFunction> known_function() { return known_function_; }
int formal_parameter_count() const { return formal_parameter_count_; }
- bool HasStackCheck() FINAL { return has_stack_check_; }
+ bool HasStackCheck() final { return has_stack_check_; }
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction)
};
-class HCallFunction FINAL : public HBinaryCall {
+class HCallFunction final : public HBinaryCall {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallFunction, HValue*, int);
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(
DECLARE_CONCRETE_INSTRUCTION(CallFunction)
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- int argument_delta() const OVERRIDE { return -argument_count(); }
+ int argument_delta() const override { return -argument_count(); }
private:
HCallFunction(HValue* context, HValue* function, int argument_count,
};
-class HCallNew FINAL : public HBinaryCall {
+class HCallNew final : public HBinaryCall {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallNew, HValue*, int);
};
-class HCallNewArray FINAL : public HBinaryCall {
+class HCallNewArray final : public HBinaryCall {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HCallNewArray, HValue*, int,
ElementsKind,
HValue* context() { return first(); }
HValue* constructor() { return second(); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
ElementsKind elements_kind() const { return elements_kind_; }
Handle<AllocationSite> site() const { return site_; }
};
-class HCallRuntime FINAL : public HCall<1> {
+class HCallRuntime final : public HCall<1> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCallRuntime,
Handle<String>,
const Runtime::Function*,
int);
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* context() { return OperandAt(0); }
const Runtime::Function* function() const { return c_function_; }
save_doubles_ = save_doubles;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HMapEnumLength FINAL : public HUnaryOperation {
+class HMapEnumLength final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HMapEnumLength(HValue* value)
SetDependsOnFlag(kMaps);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
+class HUnaryMathOperation final : public HTemplateInstruction<2> {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* value, BuiltinFunctionId op);
HValue* context() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 0) {
return Representation::Tagged();
} else {
}
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
- HValue* Canonicalize() OVERRIDE;
- Representation RepresentationFromUses() OVERRIDE;
- Representation RepresentationFromInputs() OVERRIDE;
+ HValue* Canonicalize() override;
+ Representation RepresentationFromUses() override;
+ Representation RepresentationFromInputs() override;
BuiltinFunctionId op() const { return op_; }
const char* OpName() const;
DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
return op_ == b->op();
}
SetFlag(kAllowUndefinedAsNaN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
HValue* SimplifiedDividendForMathFloorOfDiv(HDiv* hdiv);
HValue* SimplifiedDivisorForMathFloorOfDiv(HDiv* hdiv);
};
-class HLoadRoot FINAL : public HTemplateInstruction<0> {
+class HLoadRoot final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HLoadRoot, Heap::RootListIndex);
DECLARE_INSTRUCTION_FACTORY_P2(HLoadRoot, Heap::RootListIndex, HType);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
DECLARE_CONCRETE_INSTRUCTION(LoadRoot)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HLoadRoot* b = HLoadRoot::cast(other);
return index_ == b->index_;
}
set_representation(Representation::Tagged());
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
const Heap::RootListIndex index_;
};
-class HCheckMaps FINAL : public HTemplateInstruction<2> {
+class HCheckMaps final : public HTemplateInstruction<2> {
public:
static HCheckMaps* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* value, Handle<Map> map,
ClearDependsOnFlag(kMaps);
}
- bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return false; }
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- HType CalculateInferredType() OVERRIDE {
+ HType CalculateInferredType() override {
if (value()->type().IsHeapObject()) return value()->type();
return HType::HeapObject();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* value() const { return OperandAt(0); }
HValue* typecheck() const { return OperandAt(1); }
return HasMigrationTargetField::decode(bit_field_);
}
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
static HCheckMaps* CreateAndInsertAfter(Zone* zone,
HValue* value,
DECLARE_CONCRETE_INSTRUCTION(CheckMaps)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return this->maps()->Equals(HCheckMaps::cast(other)->maps());
}
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
private:
HCheckMaps(HValue* value, const UniqueSet<Map>* maps, bool maps_are_stable)
};
-class HCheckValue FINAL : public HUnaryOperation {
+class HCheckValue final : public HUnaryOperation {
public:
static HCheckValue* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* value, Handle<JSFunction> func) {
return new(zone) HCheckValue(value, target, object_in_new_space);
}
- void FinalizeUniqueness() OVERRIDE {
+ void FinalizeUniqueness() override {
object_ = Unique<HeapObject>(object_.handle());
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
#ifdef DEBUG
- void Verify() OVERRIDE;
+ void Verify() override;
#endif
Unique<HeapObject> object() const { return object_; }
DECLARE_CONCRETE_INSTRUCTION(CheckValue)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HCheckValue* b = HCheckValue::cast(other);
return object_ == b->object_;
}
};
-class HCheckInstanceType FINAL : public HUnaryOperation {
+class HCheckInstanceType final : public HUnaryOperation {
public:
enum Check {
IS_SPEC_OBJECT,
DECLARE_INSTRUCTION_FACTORY_P2(HCheckInstanceType, HValue*, Check);
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- HType CalculateInferredType() OVERRIDE {
+ HType CalculateInferredType() override {
switch (check_) {
case IS_SPEC_OBJECT: return HType::JSObject();
case IS_JS_ARRAY: return HType::JSArray();
return HType::Tagged();
}
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; }
void GetCheckInterval(InstanceType* first, InstanceType* last);
// TODO(ager): It could be nice to allow the ommision of instance
// type checks if we have already performed an instance type check
// with a larger range.
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HCheckInstanceType* b = HCheckInstanceType::cast(other);
return check_ == b->check_;
}
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
private:
const char* GetCheckName() const;
};
-class HCheckSmi FINAL : public HUnaryOperation {
+class HCheckSmi final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- HValue* Canonicalize() OVERRIDE {
+ HValue* Canonicalize() override {
HType value_type = value()->type();
if (value_type.IsSmi()) {
return NULL;
DECLARE_CONCRETE_INSTRUCTION(CheckSmi)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
};
-class HCheckHeapObject FINAL : public HUnaryOperation {
+class HCheckHeapObject final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*);
- bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return false; }
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- HType CalculateInferredType() OVERRIDE {
+ HType CalculateInferredType() override {
if (value()->type().IsHeapObject()) return value()->type();
return HType::HeapObject();
}
#ifdef DEBUG
- void Verify() OVERRIDE;
+ void Verify() override;
#endif
- HValue* Canonicalize() OVERRIDE {
+ HValue* Canonicalize() override {
return value()->type().IsHeapObject() ? NULL : this;
}
DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HCheckHeapObject(HValue* value) : HUnaryOperation(value) {
class HBitwise;
-class InductionVariableData FINAL : public ZoneObject {
+class InductionVariableData final : public ZoneObject {
public:
class InductionVariableCheck : public ZoneObject {
public:
};
-class HPhi FINAL : public HValue {
+class HPhi final : public HValue {
public:
HPhi(int merged_index, Zone* zone)
: inputs_(2, zone),
SetFlag(kAllowUndefinedAsNaN);
}
- Representation RepresentationFromInputs() OVERRIDE;
+ Representation RepresentationFromInputs() override;
- Range* InferRange(Zone* zone) OVERRIDE;
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Range* InferRange(Zone* zone) override;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
- Representation KnownOptimalRepresentation() OVERRIDE {
+ Representation KnownOptimalRepresentation() override {
return representation();
}
- HType CalculateInferredType() OVERRIDE;
- int OperandCount() const OVERRIDE { return inputs_.length(); }
- HValue* OperandAt(int index) const OVERRIDE { return inputs_[index]; }
+ HType CalculateInferredType() override;
+ int OperandCount() const override { return inputs_.length(); }
+ HValue* OperandAt(int index) const override { return inputs_[index]; }
HValue* GetRedundantReplacement();
void AddInput(HValue* value);
bool HasRealUses();
bool IsReceiver() const { return merged_index_ == 0; }
bool HasMergedIndex() const { return merged_index_ != kInvalidMergedIndex; }
- SourcePosition position() const OVERRIDE;
+ SourcePosition position() const override;
int merged_index() const { return merged_index_; }
induction_variable_data_ = InductionVariableData::ExaminePhi(this);
}
- std::ostream& PrintTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintTo(std::ostream& os) const override; // NOLINT
#ifdef DEBUG
- void Verify() OVERRIDE;
+ void Verify() override;
#endif
void InitRealUses(int id);
DCHECK(value->IsPhi());
return reinterpret_cast<HPhi*>(value);
}
- Opcode opcode() const OVERRIDE { return HValue::kPhi; }
+ Opcode opcode() const override { return HValue::kPhi; }
void SimplifyConstantInputs();
static const int kInvalidMergedIndex = -1;
protected:
- void DeleteFromGraph() OVERRIDE;
- void InternalSetOperandAt(int index, HValue* value) OVERRIDE {
+ void DeleteFromGraph() override;
+ void InternalSetOperandAt(int index, HValue* value) override {
inputs_[index] = value;
}
InductionVariableData* induction_variable_data_;
// TODO(titzer): we can't eliminate the receiver for generating backtraces
- bool IsDeletable() const OVERRIDE { return !IsReceiver(); }
+ bool IsDeletable() const override { return !IsReceiver(); }
};
public:
HDematerializedObject(int count, Zone* zone) : values_(count, zone) {}
- int OperandCount() const FINAL { return values_.length(); }
- HValue* OperandAt(int index) const FINAL { return values_[index]; }
+ int OperandCount() const final { return values_.length(); }
+ HValue* OperandAt(int index) const final { return values_[index]; }
- bool HasEscapingOperandAt(int index) FINAL { return false; }
- Representation RequiredInputRepresentation(int index) FINAL {
+ bool HasEscapingOperandAt(int index) final { return false; }
+ Representation RequiredInputRepresentation(int index) final {
return Representation::None();
}
protected:
- void InternalSetOperandAt(int index, HValue* value) FINAL {
+ void InternalSetOperandAt(int index, HValue* value) final {
values_[index] = value;
}
};
-class HArgumentsObject FINAL : public HDematerializedObject {
+class HArgumentsObject final : public HDematerializedObject {
public:
static HArgumentsObject* New(Isolate* isolate, Zone* zone, HValue* context,
int count) {
};
-class HCapturedObject FINAL : public HDematerializedObject {
+class HCapturedObject final : public HDematerializedObject {
public:
HCapturedObject(int length, int id, Zone* zone)
: HDematerializedObject(length, zone), capture_id_(id) {
// Replay effects of this instruction on the given environment.
void ReplayEnvironment(HEnvironment* env);
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CapturedObject)
// Note that we cannot DCE captured objects as they are used to replay
// the environment. This method is here as an explicit reminder.
// TODO(mstarzinger): Turn HSimulates into full snapshots maybe?
- bool IsDeletable() const FINAL { return false; }
+ bool IsDeletable() const final { return false; }
};
-class HConstant FINAL : public HTemplateInstruction<0> {
+class HConstant final : public HTemplateInstruction<0> {
public:
enum Special { kHoleNaN };
HConstant::New(isolate, zone, context, value, representation));
}
- Handle<Map> GetMonomorphicJSObjectMap() OVERRIDE {
+ Handle<Map> GetMonomorphicJSObjectMap() override {
Handle<Object> object = object_.handle();
if (!object.is_null() && object->IsHeapObject()) {
return v8::internal::handle(HeapObject::cast(*object)->map());
return instance_type == CELL_TYPE;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- Representation KnownOptimalRepresentation() OVERRIDE {
+ Representation KnownOptimalRepresentation() override {
if (HasSmiValue() && SmiValuesAre31Bits()) return Representation::Smi();
if (HasInteger32Value()) return Representation::Integer32();
if (HasNumberValue()) return Representation::Double();
return Representation::Tagged();
}
- bool EmitAtUses() OVERRIDE;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ bool EmitAtUses() override;
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HConstant* CopyToRepresentation(Representation r, Zone* zone) const;
Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone);
Maybe<HConstant*> CopyToTruncatedNumber(Isolate* isolate, Zone* zone);
return object_map_;
}
- intptr_t Hashcode() OVERRIDE {
+ intptr_t Hashcode() override {
if (HasInteger32Value()) {
return static_cast<intptr_t>(int32_value_);
} else if (HasDoubleValue()) {
}
}
- void FinalizeUniqueness() OVERRIDE {
+ void FinalizeUniqueness() override {
if (!HasDoubleValue() && !HasExternalReferenceValue()) {
DCHECK(!object_.handle().is_null());
object_ = Unique<Object>(object_.handle());
return object_.IsInitialized() && object_ == other;
}
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HConstant* other_constant = HConstant::cast(other);
if (HasInteger32Value()) {
return other_constant->HasInteger32Value() &&
}
#ifdef DEBUG
- void Verify() OVERRIDE {}
+ void Verify() override {}
#endif
DECLARE_CONCRETE_INSTRUCTION(Constant)
protected:
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
friend class HGraph;
void Initialize(Representation r);
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
// If object_ is a map, this indicates whether the map is stable.
class HasStableMapValueField : public BitField<bool, 0, 1> {};
observed_output_representation_ = observed;
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
if (index == 0) return Representation::Tagged();
return observed_input_representation_[index - 1];
}
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
Representation rep = !FLAG_smi_binop && new_rep.IsSmi()
? Representation::Integer32() : new_rep;
HValue::UpdateRepresentation(rep, h_infer, reason);
}
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
- Representation RepresentationFromInputs() OVERRIDE;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
+ Representation RepresentationFromInputs() override;
Representation RepresentationFromOutput();
- void AssumeRepresentation(Representation r) OVERRIDE;
+ void AssumeRepresentation(Representation r) override;
virtual bool IsCommutative() const { return false; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 0) return Representation::Tagged();
return representation();
}
};
-class HWrapReceiver FINAL : public HTemplateInstruction<2> {
+class HWrapReceiver final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
HValue* receiver() const { return OperandAt(0); }
HValue* function() const { return OperandAt(1); }
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
bool known_function() const { return known_function_; }
DECLARE_CONCRETE_INSTRUCTION(WrapReceiver)
};
-class HApplyArguments FINAL : public HTemplateInstruction<4> {
+class HApplyArguments final : public HTemplateInstruction<4> {
public:
DECLARE_INSTRUCTION_FACTORY_P4(HApplyArguments, HValue*, HValue*, HValue*,
HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// The length is untagged, all other inputs are tagged.
return (index == 2)
? Representation::Integer32()
};
-class HArgumentsElements FINAL : public HTemplateInstruction<0> {
+class HArgumentsElements final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool);
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
bool from_inlined() const { return from_inlined_; }
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) {
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
bool from_inlined_;
};
-class HArgumentsLength FINAL : public HUnaryOperation {
+class HArgumentsLength final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) {
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> {
+class HAccessArgumentsAt final : public HTemplateInstruction<3> {
public:
DECLARE_INSTRUCTION_FACTORY_P3(HAccessArgumentsAt, HValue*, HValue*, HValue*);
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// The arguments elements is considered tagged.
return index == 0
? Representation::Tagged()
SetOperandAt(2, index);
}
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
};
class HBoundsCheckBaseIndexInformation;
-class HBoundsCheck FINAL : public HTemplateInstruction<2> {
+class HBoundsCheck final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*);
}
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
HValue* index() const { return OperandAt(0); }
HValue* length() const { return OperandAt(1); }
bool allow_equality() const { return allow_equality_; }
void set_allow_equality(bool v) { allow_equality_ = v; }
- int RedefinedOperandIndex() OVERRIDE { return 0; }
- bool IsPurelyInformativeDefinition() OVERRIDE { return skip_check(); }
+ int RedefinedOperandIndex() override { return 0; }
+ bool IsPurelyInformativeDefinition() override { return skip_check(); }
DECLARE_CONCRETE_INSTRUCTION(BoundsCheck)
protected:
friend class HBoundsCheckBaseIndexInformation;
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
bool skip_check_;
HValue* base_;
int offset_;
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return skip_check() && !FLAG_debug_code; }
+ bool IsDeletable() const override { return skip_check() && !FLAG_debug_code; }
};
-class HBoundsCheckBaseIndexInformation FINAL
- : public HTemplateInstruction<2> {
+class HBoundsCheckBaseIndexInformation final : public HTemplateInstruction<2> {
public:
explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) {
DecompositionResult decomposition;
DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- int RedefinedOperandIndex() OVERRIDE { return 0; }
- bool IsPurelyInformativeDefinition() OVERRIDE { return true; }
+ int RedefinedOperandIndex() override { return 0; }
+ bool IsPurelyInformativeDefinition() override { return true; }
};
SetAllSideEffects();
}
- void RepresentationChanged(Representation to) OVERRIDE {
+ void RepresentationChanged(Representation to) override {
if (to.IsTagged() &&
(left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
SetAllSideEffects();
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
// We only generate either int32 or generic tagged bitwise operations.
if (new_rep.IsDouble()) new_rep = Representation::Integer32();
HBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
Representation r = HBinaryOperation::observed_input_representation(index);
if (r.IsDouble()) return Representation::Integer32();
return r;
}
virtual void initialize_output_representation(
- Representation observed) OVERRIDE {
+ Representation observed) override {
if (observed.IsDouble()) observed = Representation::Integer32();
HBinaryOperation::initialize_output_representation(observed);
}
DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation)
private:
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HMathFloorOfDiv FINAL : public HBinaryOperation {
+class HMathFloorOfDiv final : public HBinaryOperation {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HMathFloorOfDiv,
HValue*,
DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
SetFlag(kAllowUndefinedAsNaN);
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
SetFlag(kAllowUndefinedAsNaN);
}
- void RepresentationChanged(Representation to) OVERRIDE {
+ void RepresentationChanged(Representation to) override {
if (to.IsTagged() &&
(left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
SetAllSideEffects();
DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
private:
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HCompareGeneric FINAL : public HBinaryOperation {
+class HCompareGeneric final : public HBinaryOperation {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCompareGeneric, HValue*,
HValue*, Token::Value);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return index == 0
? Representation::Tagged()
: representation();
}
Token::Value token() const { return token_; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
observed_input_representation_[1] = right;
}
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
return observed_input_representation_[index];
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
void SetOperandPositions(Zone* zone, SourcePosition left_pos,
SourcePosition right_pos) {
};
-class HCompareHoleAndBranch FINAL : public HUnaryControlInstruction {
+class HCompareHoleAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HCompareHoleAndBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P3(HCompareHoleAndBranch, HValue*,
HBasicBlock*, HBasicBlock*);
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
};
-class HCompareMinusZeroAndBranch FINAL : public HUnaryControlInstruction {
+class HCompareMinusZeroAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HCompareMinusZeroAndBranch, HValue*);
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return representation();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch)
DECLARE_INSTRUCTION_FACTORY_P4(HCompareObjectEqAndBranch, HValue*, HValue*,
HBasicBlock*, HBasicBlock*);
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
static const int kNoKnownSuccessorIndex = -1;
int known_successor_index() const { return known_successor_index_; }
HValue* left() const { return OperandAt(0); }
HValue* right() const { return OperandAt(1); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
return Representation::Tagged();
}
};
-class HIsObjectAndBranch FINAL : public HUnaryControlInstruction {
+class HIsObjectAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HIsObjectAndBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P3(HIsObjectAndBranch, HValue*,
HBasicBlock*, HBasicBlock*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch)
};
-class HIsStringAndBranch FINAL : public HUnaryControlInstruction {
+class HIsStringAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HIsStringAndBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P3(HIsStringAndBranch, HValue*,
HBasicBlock*, HBasicBlock*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
static const int kNoKnownSuccessorIndex = -1;
int known_successor_index() const { return known_successor_index_; }
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch)
protected:
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
private:
HIsStringAndBranch(HValue* value, HBasicBlock* true_target = NULL,
};
-class HIsSmiAndBranch FINAL : public HUnaryControlInstruction {
+class HIsSmiAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HIsSmiAndBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P3(HIsSmiAndBranch, HValue*,
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ bool DataEquals(HValue* other) override { return true; }
+ int RedefinedOperandIndex() override { return 0; }
private:
HIsSmiAndBranch(HValue* value,
};
-class HIsUndetectableAndBranch FINAL : public HUnaryControlInstruction {
+class HIsUndetectableAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HIsUndetectableAndBranch, HValue*);
DECLARE_INSTRUCTION_FACTORY_P3(HIsUndetectableAndBranch, HValue*,
HBasicBlock*, HBasicBlock*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch)
HValue* right() { return OperandAt(2); }
Token::Value token() const { return token_; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
public:
DECLARE_INSTRUCTION_FACTORY_P0(HIsConstructCallAndBranch);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction {
+class HHasInstanceTypeAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P2(
HHasInstanceTypeAndBranch, HValue*, InstanceType);
InstanceType from() { return from_; }
InstanceType to() { return to_; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch)
};
-class HHasCachedArrayIndexAndBranch FINAL : public HUnaryControlInstruction {
+class HHasCachedArrayIndexAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HHasCachedArrayIndexAndBranch, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HGetCachedArrayIndex FINAL : public HUnaryOperation {
+class HGetCachedArrayIndex final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HGetCachedArrayIndex, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HGetCachedArrayIndex(HValue* value) : HUnaryOperation(value) {
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction {
+class HClassOfTestAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HClassOfTestAndBranch, HValue*,
Handle<String>);
DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
Handle<String> class_name() const { return class_name_; }
};
-class HTypeofIsAndBranch FINAL : public HUnaryControlInstruction {
+class HTypeofIsAndBranch final : public HUnaryControlInstruction {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HTypeofIsAndBranch, HValue*, Handle<String>);
Handle<String> type_literal() const { return type_literal_.handle(); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+ bool KnownSuccessorBlock(HBasicBlock** block) override;
- void FinalizeUniqueness() OVERRIDE {
+ void FinalizeUniqueness() override {
type_literal_ = Unique<String>(type_literal_.handle());
}
};
-class HInstanceOf FINAL : public HBinaryOperation {
+class HInstanceOf final : public HBinaryOperation {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOf, HValue*, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
};
-class HInstanceOfKnownGlobal FINAL : public HTemplateInstruction<2> {
+class HInstanceOfKnownGlobal final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOfKnownGlobal,
HValue*,
HValue* left() { return OperandAt(1); }
Handle<JSFunction> function() { return function_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HPower FINAL : public HTemplateInstruction<2> {
+class HPower final : public HTemplateInstruction<2> {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
HValue* left() { return OperandAt(0); }
HValue* right() const { return OperandAt(1); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return index == 0
? Representation::Double()
: Representation::None();
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
return RequiredInputRepresentation(index);
}
DECLARE_CONCRETE_INSTRUCTION(Power)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HPower(HValue* left, HValue* right) {
SetChangesFlag(kNewSpacePromotion);
}
- bool IsDeletable() const OVERRIDE {
+ bool IsDeletable() const override {
return !right()->representation().IsTagged();
}
};
-class HAdd FINAL : public HArithmeticBinaryOperation {
+class HAdd final : public HArithmeticBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
// Add is only commutative if two integer values are added and not if two
// tagged values are added (because it might be a String concatenation).
// We also do not commute (pointer + offset).
- bool IsCommutative() const OVERRIDE {
+ bool IsCommutative() const override {
return !representation().IsTagged() && !representation().IsExternal();
}
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
- bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+ bool TryDecompose(DecompositionResult* decomposition) override {
if (left()->IsInteger32Constant()) {
decomposition->Apply(right(), left()->GetInteger32Constant());
return true;
}
}
- void RepresentationChanged(Representation to) OVERRIDE {
+ void RepresentationChanged(Representation to) override {
if (to.IsTagged() &&
(left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved() ||
left()->ToStringCanBeObserved() || right()->ToStringCanBeObserved())) {
}
}
- Representation RepresentationFromInputs() OVERRIDE;
+ Representation RepresentationFromInputs() override;
- Representation RequiredInputRepresentation(int index) OVERRIDE;
+ Representation RequiredInputRepresentation(int index) override;
DECLARE_CONCRETE_INSTRUCTION(Add)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HAdd(HValue* context, HValue* left, HValue* right)
};
-class HSub FINAL : public HArithmeticBinaryOperation {
+class HSub final : public HArithmeticBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
- bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+ bool TryDecompose(DecompositionResult* decomposition) override {
if (right()->IsInteger32Constant()) {
decomposition->Apply(left(), -right()->GetInteger32Constant());
return true;
DECLARE_CONCRETE_INSTRUCTION(Sub)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HSub(HValue* context, HValue* left, HValue* right)
};
-class HMul FINAL : public HArithmeticBinaryOperation {
+class HMul final : public HArithmeticBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
return mul;
}
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
// Only commutative if it is certain that not two objects are multiplicated.
- bool IsCommutative() const OVERRIDE { return !representation().IsTagged(); }
+ bool IsCommutative() const override { return !representation().IsTagged(); }
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Mul)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HMul(HValue* context, HValue* left, HValue* right)
};
-class HMod FINAL : public HArithmeticBinaryOperation {
+class HMod final : public HArithmeticBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi()) new_rep = Representation::Integer32();
HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Mod)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HMod(HValue* context,
};
-class HDiv FINAL : public HArithmeticBinaryOperation {
+class HDiv final : public HArithmeticBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi()) new_rep = Representation::Integer32();
HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Div)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HDiv(HValue* context, HValue* left, HValue* right)
};
-class HMathMinMax FINAL : public HArithmeticBinaryOperation {
+class HMathMinMax final : public HArithmeticBinaryOperation {
public:
enum Operation { kMathMin, kMathMax };
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right, Operation op);
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
return RequiredInputRepresentation(index);
}
- virtual void InferRepresentation(
- HInferRepresentationPhase* h_infer) OVERRIDE;
+ virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
- Representation RepresentationFromInputs() OVERRIDE {
+ Representation RepresentationFromInputs() override {
Representation left_rep = left()->representation();
Representation right_rep = right()->representation();
Representation result = Representation::Smi();
return result;
}
- bool IsCommutative() const OVERRIDE { return true; }
+ bool IsCommutative() const override { return true; }
Operation operation() { return operation_; }
DECLARE_CONCRETE_INSTRUCTION(MathMinMax)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return other->IsMathMinMax() &&
HMathMinMax::cast(other)->operation_ == operation_;
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
};
-class HBitwise FINAL : public HBitwiseBinaryOperation {
+class HBitwise final : public HBitwiseBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
Token::Value op, HValue* left, HValue* right);
Token::Value op() const { return op_; }
- bool IsCommutative() const OVERRIDE { return true; }
+ bool IsCommutative() const override { return true; }
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Bitwise)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return op() == HBitwise::cast(other)->op();
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
private:
HBitwise(HValue* context,
};
-class HShl FINAL : public HBitwiseBinaryOperation {
+class HShl final : public HBitwiseBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi() &&
!(right()->IsInteger32Constant() &&
right()->GetInteger32Constant() >= 0)) {
DECLARE_CONCRETE_INSTRUCTION(Shl)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HShl(HValue* context, HValue* left, HValue* right)
};
-class HShr FINAL : public HBitwiseBinaryOperation {
+class HShr final : public HBitwiseBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+ bool TryDecompose(DecompositionResult* decomposition) override {
if (right()->IsInteger32Constant()) {
if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
// This is intended to look for HAdd and HSub, to handle compounds
return false;
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi()) new_rep = Representation::Integer32();
HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Shr)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HShr(HValue* context, HValue* left, HValue* right)
};
-class HSar FINAL : public HBitwiseBinaryOperation {
+class HSar final : public HBitwiseBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right);
- bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+ bool TryDecompose(DecompositionResult* decomposition) override {
if (right()->IsInteger32Constant()) {
if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
// This is intended to look for HAdd and HSub, to handle compounds
return false;
}
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi()) new_rep = Representation::Integer32();
HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Sar)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HSar(HValue* context, HValue* left, HValue* right)
};
-class HRor FINAL : public HBitwiseBinaryOperation {
+class HRor final : public HBitwiseBinaryOperation {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* left, HValue* right) {
virtual void UpdateRepresentation(Representation new_rep,
HInferRepresentationPhase* h_infer,
- const char* reason) OVERRIDE {
+ const char* reason) override {
if (new_rep.IsSmi()) new_rep = Representation::Integer32();
HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
}
DECLARE_CONCRETE_INSTRUCTION(Ror)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HRor(HValue* context, HValue* left, HValue* right)
};
-class HOsrEntry FINAL : public HTemplateInstruction<0> {
+class HOsrEntry final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId);
BailoutId ast_id() const { return ast_id_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
};
-class HParameter FINAL : public HTemplateInstruction<0> {
+class HParameter final : public HTemplateInstruction<0> {
public:
enum ParameterKind {
STACK_PARAMETER,
unsigned index() const { return index_; }
ParameterKind kind() const { return kind_; }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
- Representation KnownOptimalRepresentation() OVERRIDE {
+ Representation KnownOptimalRepresentation() override {
// If a parameter is an input to a phi, that phi should not
// choose any more optimistic representation than Tagged.
return Representation::Tagged();
};
-class HCallStub FINAL : public HUnaryCall {
+class HCallStub final : public HUnaryCall {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallStub, CodeStub::Major, int);
CodeStub::Major major_key() { return major_key_; }
HValue* context() { return value(); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(CallStub)
};
-class HTailCallThroughMegamorphicCache FINAL : public HInstruction {
+class HTailCallThroughMegamorphicCache final : public HInstruction {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HTailCallThroughMegamorphicCache,
HValue*, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- virtual int OperandCount() const FINAL OVERRIDE { return 3; }
- virtual HValue* OperandAt(int i) const FINAL OVERRIDE { return inputs_[i]; }
+ virtual int OperandCount() const final override { return 3; }
+ virtual HValue* OperandAt(int i) const final override { return inputs_[i]; }
HValue* context() const { return OperandAt(0); }
HValue* receiver() const { return OperandAt(1); }
HValue* name() const { return OperandAt(2); }
Code::Flags flags() const;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache)
protected:
- virtual void InternalSetOperandAt(int i, HValue* value) FINAL OVERRIDE {
+ virtual void InternalSetOperandAt(int i, HValue* value) final override {
inputs_[i] = value;
}
};
-class HUnknownOSRValue FINAL : public HTemplateInstruction<0> {
+class HUnknownOSRValue final : public HTemplateInstruction<0> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int);
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::None();
}
HEnvironment *environment() { return environment_; }
int index() { return index_; }
- Representation KnownOptimalRepresentation() OVERRIDE {
+ Representation KnownOptimalRepresentation() override {
if (incoming_value_ == NULL) return Representation::None();
return incoming_value_->KnownOptimalRepresentation();
}
};
-class HLoadGlobalGeneric FINAL : public HTemplateInstruction<2> {
+class HLoadGlobalGeneric final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadGlobalGeneric, HValue*,
Handle<String>, bool);
slot_ = slot;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HAllocate FINAL : public HTemplateInstruction<2> {
+class HAllocate final : public HTemplateInstruction<2> {
public:
static bool CompatibleInstanceTypes(InstanceType type1,
InstanceType type2) {
size_upper_bound_ = value;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 0) {
return Representation::Tagged();
} else {
}
}
- Handle<Map> GetMonomorphicJSObjectMap() OVERRIDE {
+ Handle<Map> GetMonomorphicJSObjectMap() override {
return known_initial_map_;
}
}
virtual bool HandleSideEffectDominator(GVNFlag side_effect,
- HValue* dominator) OVERRIDE;
+ HValue* dominator) override;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(Allocate)
};
-class HStoreCodeEntry FINAL: public HTemplateInstruction<2> {
+class HStoreCodeEntry final : public HTemplateInstruction<2> {
public:
static HStoreCodeEntry* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* function, HValue* code) {
return new(zone) HStoreCodeEntry(function, code);
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HInnerAllocatedObject FINAL : public HTemplateInstruction<2> {
+class HInnerAllocatedObject final : public HTemplateInstruction<2> {
public:
static HInnerAllocatedObject* New(Isolate* isolate, Zone* zone,
HValue* context, HValue* value,
HValue* base_object() const { return OperandAt(0); }
HValue* offset() const { return OperandAt(1); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return index == 0 ? Representation::Tagged() : Representation::Integer32();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject)
}
-class HLoadContextSlot FINAL : public HUnaryOperation {
+class HLoadContextSlot final : public HUnaryOperation {
public:
enum Mode {
// Perform a normal load of the context slot without checking its value.
return mode_ != kNoCheck;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HLoadContextSlot* b = HLoadContextSlot::cast(other);
return (slot_index() == b->slot_index());
}
private:
- bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
+ bool IsDeletable() const override { return !RequiresHoleCheck(); }
int slot_index_;
Mode mode_;
};
-class HStoreContextSlot FINAL : public HTemplateInstruction<2> {
+class HStoreContextSlot final : public HTemplateInstruction<2> {
public:
enum Mode {
// Perform a normal store to the context slot without checking its previous
return mode_ != kNoCheck;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot)
// Represents an access to a portion of an object, such as the map pointer,
// array elements pointer, etc, but not accesses to array elements themselves.
-class HObjectAccess FINAL {
+class HObjectAccess final {
public:
inline bool IsInobject() const {
return portion() != kBackingStore && portion() != kExternalMemory;
std::ostream& operator<<(std::ostream& os, const HObjectAccess& access);
-class HLoadNamedField FINAL : public HTemplateInstruction<2> {
+class HLoadNamedField final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*,
HValue*, HObjectAccess);
const UniqueSet<Map>* maps() const { return maps_; }
- bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
- bool HasOutOfBoundsAccess(int size) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return false; }
+ bool HasOutOfBoundsAccess(int size) override {
return !access().IsInobject() || access().offset() >= size;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 0) {
// object must be external in case of external memory access
return access().IsExternalMemory() ? Representation::External()
DCHECK(index == 1);
return Representation::None();
}
- Range* InferRange(Zone* zone) OVERRIDE;
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ Range* InferRange(Zone* zone) override;
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
bool CanBeReplacedWith(HValue* other) const {
if (!CheckFlag(HValue::kCantBeReplaced)) return false;
DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HLoadNamedField* that = HLoadNamedField::cast(other);
if (!this->access_.Equals(that->access_)) return false;
if (this->maps_ == that->maps_) return true;
access.SetGVNFlags(this, LOAD);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
HObjectAccess access_;
const UniqueSet<Map>* maps_;
};
-class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> {
+class HLoadNamedGeneric final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadNamedGeneric, HValue*,
Handle<Object>, InlineCacheState);
slot_ = slot;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
};
-class HLoadFunctionPrototype FINAL : public HUnaryOperation {
+class HLoadFunctionPrototype final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HLoadFunctionPrototype, HValue*);
HValue* function() { return OperandAt(0); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
explicit HLoadFunctionPrototype(HValue* function)
};
-class HLoadKeyed FINAL
- : public HTemplateInstruction<3>, public ArrayInstructionInterface {
+class HLoadKeyed final : public HTemplateInstruction<3>,
+ public ArrayInstructionInterface {
public:
DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*,
ElementsKind);
}
bool HasDependency() const { return OperandAt(0) != OperandAt(2); }
uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); }
- bool TryIncreaseBaseOffset(uint32_t increase_by_value) OVERRIDE;
- HValue* GetKey() OVERRIDE { return key(); }
- void SetKey(HValue* key) OVERRIDE { SetOperandAt(1, key); }
- bool IsDehoisted() const OVERRIDE {
+ bool TryIncreaseBaseOffset(uint32_t increase_by_value) override;
+ HValue* GetKey() override { return key(); }
+ void SetKey(HValue* key) override { SetOperandAt(1, key); }
+ bool IsDehoisted() const override {
return IsDehoistedField::decode(bit_field_);
}
- void SetDehoisted(bool is_dehoisted) OVERRIDE {
+ void SetDehoisted(bool is_dehoisted) override {
bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
}
- ElementsKind elements_kind() const OVERRIDE {
+ ElementsKind elements_kind() const override {
return ElementsKindField::decode(bit_field_);
}
LoadKeyedHoleMode hole_mode() const {
return HoleModeField::decode(bit_field_);
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// kind_fast: tagged[int32] (none)
// kind_double: tagged[int32] (none)
// kind_fixed_typed_array: tagged[int32] (none)
return Representation::None();
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
return RequiredInputRepresentation(index);
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
bool UsesMustHandleHole() const;
bool AllUsesCanTreatHoleAsNaN() const;
bool RequiresHoleCheck() const;
- Range* InferRange(Zone* zone) OVERRIDE;
+ Range* InferRange(Zone* zone) override;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
if (!other->IsLoadKeyed()) return false;
HLoadKeyed* other_load = HLoadKeyed::cast(other);
SetFlag(kUseGVN);
}
- bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
+ bool IsDeletable() const override { return !RequiresHoleCheck(); }
// Establish some checks around our packed fields
enum LoadKeyedBits {
};
-class HLoadKeyedGeneric FINAL : public HTemplateInstruction<3> {
+class HLoadKeyedGeneric final : public HTemplateInstruction<3> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadKeyedGeneric, HValue*,
HValue*, InlineCacheState);
slot_ = slot;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// tagged[tagged]
return Representation::Tagged();
}
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric)
};
-class HStoreNamedField FINAL : public HTemplateInstruction<3> {
+class HStoreNamedField final : public HTemplateInstruction<3> {
public:
DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*,
HObjectAccess, HValue*);
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField)
- bool HasEscapingOperandAt(int index) OVERRIDE { return index == 1; }
- bool HasOutOfBoundsAccess(int size) OVERRIDE {
+ bool HasEscapingOperandAt(int index) override { return index == 1; }
+ bool HasOutOfBoundsAccess(int size) override {
return !access().IsInobject() || access().offset() >= size;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 0 && access().IsExternalMemory()) {
// object must be external in case of external memory access
return Representation::External();
return Representation::Tagged();
}
virtual bool HandleSideEffectDominator(GVNFlag side_effect,
- HValue* dominator) OVERRIDE {
+ HValue* dominator) override {
DCHECK(side_effect == kNewSpacePromotion);
if (!FLAG_use_write_barrier_elimination) return false;
dominator_ = dominator;
return false;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
HValue* object() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
};
-class HStoreNamedGeneric FINAL : public HTemplateInstruction<3> {
+class HStoreNamedGeneric final : public HTemplateInstruction<3> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HStoreNamedGeneric, HValue*,
Handle<String>, HValue*,
return initialization_state_;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HStoreKeyed FINAL
- : public HTemplateInstruction<3>, public ArrayInstructionInterface {
+class HStoreKeyed final : public HTemplateInstruction<3>,
+ public ArrayInstructionInterface {
public:
DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*,
ElementsKind);
DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*,
ElementsKind, StoreFieldOrKeyedMode, int);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// kind_fast: tagged[int32] = tagged
// kind_double: tagged[int32] = double
// kind_smi : tagged[int32] = smi
return is_external() || is_fixed_typed_array();
}
- Representation observed_input_representation(int index) OVERRIDE {
+ Representation observed_input_representation(int index) override {
if (index < 2) return RequiredInputRepresentation(index);
if (IsUninitialized()) {
return Representation::None();
StoreFieldOrKeyedMode store_mode() const {
return StoreModeField::decode(bit_field_);
}
- ElementsKind elements_kind() const OVERRIDE {
+ ElementsKind elements_kind() const override {
return ElementsKindField::decode(bit_field_);
}
uint32_t base_offset() const { return base_offset_; }
- bool TryIncreaseBaseOffset(uint32_t increase_by_value) OVERRIDE;
- HValue* GetKey() OVERRIDE { return key(); }
- void SetKey(HValue* key) OVERRIDE { SetOperandAt(1, key); }
- bool IsDehoisted() const OVERRIDE {
+ bool TryIncreaseBaseOffset(uint32_t increase_by_value) override;
+ HValue* GetKey() override { return key(); }
+ void SetKey(HValue* key) override { SetOperandAt(1, key); }
+ bool IsDehoisted() const override {
return IsDehoistedField::decode(bit_field_);
}
- void SetDehoisted(bool is_dehoisted) OVERRIDE {
+ void SetDehoisted(bool is_dehoisted) override {
bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
}
bool IsUninitialized() { return IsUninitializedField::decode(bit_field_); }
}
virtual bool HandleSideEffectDominator(GVNFlag side_effect,
- HValue* dominator) OVERRIDE {
+ HValue* dominator) override {
DCHECK(side_effect == kNewSpacePromotion);
dominator_ = dominator;
return false;
bool NeedsCanonicalization();
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed)
};
-class HStoreKeyedGeneric FINAL : public HTemplateInstruction<4> {
+class HStoreKeyedGeneric final : public HTemplateInstruction<4> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HStoreKeyedGeneric, HValue*,
HValue*, HValue*, LanguageMode,
return initialization_state_;
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// tagged[tagged] = tagged
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric)
};
-class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
+class HTransitionElementsKind final : public HTemplateInstruction<2> {
public:
inline static HTransitionElementsKind* New(Isolate* isolate, Zone* zone,
HValue* context, HValue* object,
original_map, transitioned_map);
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
}
bool map_is_stable() const { return MapIsStableField::decode(bit_field_); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
HTransitionElementsKind* instr = HTransitionElementsKind::cast(other);
return original_map_ == instr->original_map_ &&
transitioned_map_ == instr->transitioned_map_;
}
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
private:
HTransitionElementsKind(HValue* context, HValue* object,
};
-class HStringAdd FINAL : public HBinaryOperation {
+class HStringAdd final : public HBinaryOperation {
public:
static HInstruction* New(
Isolate* isolate, Zone* zone, HValue* context, HValue* left,
StringAddFlags flags() const { return flags_; }
PretenureFlag pretenure_flag() const { return pretenure_flag_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(StringAdd)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return flags_ == HStringAdd::cast(other)->flags_ &&
pretenure_flag_ == HStringAdd::cast(other)->pretenure_flag_;
}
}
// No side-effects except possible allocation:
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
const StringAddFlags flags_;
const PretenureFlag pretenure_flag_;
};
-class HStringCharCodeAt FINAL : public HTemplateInstruction<3> {
+class HStringCharCodeAt final : public HTemplateInstruction<3> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HStringCharCodeAt,
HValue*,
HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
// The index is supposed to be Integer32.
return index == 2
? Representation::Integer32()
DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt)
protected:
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
- Range* InferRange(Zone* zone) OVERRIDE {
+ Range* InferRange(Zone* zone) override {
return new(zone) Range(0, String::kMaxUtf16CodeUnit);
}
}
// No side effects: runtime function assumes string + number inputs.
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HStringCharFromCode FINAL : public HTemplateInstruction<2> {
+class HStringCharFromCode final : public HTemplateInstruction<2> {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
HValue* char_code);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return index == 0
? Representation::Tagged()
: Representation::Integer32();
HValue* context() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
SetChangesFlag(kNewSpacePromotion);
}
- bool IsDeletable() const OVERRIDE {
+ bool IsDeletable() const override {
return !value()->ToNumberCanBeObserved();
}
};
}
private:
- bool IsDeletable() const FINAL { return true; }
+ bool IsDeletable() const final { return true; }
int literal_index_;
int depth_;
};
-class HRegExpLiteral FINAL : public HMaterializedLiteral<1> {
+class HRegExpLiteral final : public HMaterializedLiteral<1> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HRegExpLiteral,
Handle<FixedArray>,
Handle<String> pattern() { return pattern_; }
Handle<String> flags() { return flags_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HFunctionLiteral FINAL : public HTemplateInstruction<1> {
+class HFunctionLiteral final : public HTemplateInstruction<1> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HFunctionLiteral,
Handle<SharedFunctionInfo>,
bool);
HValue* context() { return OperandAt(0); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
SetChangesFlag(kNewSpacePromotion);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
class FunctionKindField : public BitField<FunctionKind, 0, 8> {};
class PretenureField : public BitField<bool, 8, 1> {};
};
-class HTypeof FINAL : public HTemplateInstruction<2> {
+class HTypeof final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HTypeof, HValue*);
HValue* context() const { return OperandAt(0); }
HValue* value() const { return OperandAt(1); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
set_representation(Representation::Tagged());
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HTrapAllocationMemento FINAL : public HTemplateInstruction<1> {
+class HTrapAllocationMemento final : public HTemplateInstruction<1> {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HToFastProperties FINAL : public HUnaryOperation {
+class HToFastProperties final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
#endif
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
-class HDateField FINAL : public HUnaryOperation {
+class HDateField final : public HUnaryOperation {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HDateField, HValue*, Smi*);
Smi* index() const { return index_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
};
-class HSeqStringGetChar FINAL : public HTemplateInstruction<2> {
+class HSeqStringGetChar final : public HTemplateInstruction<2> {
public:
static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
String::Encoding encoding, HValue* string,
HValue* index);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return (index == 0) ? Representation::Tagged()
: Representation::Integer32();
}
DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar)
protected:
- bool DataEquals(HValue* other) OVERRIDE {
+ bool DataEquals(HValue* other) override {
return encoding() == HSeqStringGetChar::cast(other)->encoding();
}
- Range* InferRange(Zone* zone) OVERRIDE {
+ Range* InferRange(Zone* zone) override {
if (encoding() == String::ONE_BYTE_ENCODING) {
return new(zone) Range(0, String::kMaxOneByteCharCode);
} else {
SetDependsOnFlag(kStringChars);
}
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
String::Encoding encoding_;
};
-class HSeqStringSetChar FINAL : public HTemplateInstruction<4> {
+class HSeqStringSetChar final : public HTemplateInstruction<4> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(
HSeqStringSetChar, String::Encoding,
HValue* index() { return OperandAt(2); }
HValue* value() { return OperandAt(3); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return (index <= 1) ? Representation::Tagged()
: Representation::Integer32();
}
};
-class HCheckMapValue FINAL : public HTemplateInstruction<2> {
+class HCheckMapValue final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- HType CalculateInferredType() OVERRIDE {
+ HType CalculateInferredType() override {
if (value()->type().IsHeapObject()) return value()->type();
return HType::HeapObject();
}
HValue* value() const { return OperandAt(0); }
HValue* map() const { return OperandAt(1); }
- HValue* Canonicalize() OVERRIDE;
+ HValue* Canonicalize() override;
DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
protected:
- int RedefinedOperandIndex() OVERRIDE { return 0; }
+ int RedefinedOperandIndex() override { return 0; }
- bool DataEquals(HValue* other) OVERRIDE { return true; }
+ bool DataEquals(HValue* other) override { return true; }
private:
HCheckMapValue(HValue* value, HValue* map)
};
-class HForInPrepareMap FINAL : public HTemplateInstruction<2> {
+class HForInPrepareMap final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HForInPrepareMap, HValue*);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
HValue* context() const { return OperandAt(0); }
HValue* enumerable() const { return OperandAt(1); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+ HType CalculateInferredType() override { return HType::Tagged(); }
DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap);
};
-class HForInCacheArray FINAL : public HTemplateInstruction<2> {
+class HForInCacheArray final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int);
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
index_cache_ = index_cache;
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+ HType CalculateInferredType() override { return HType::Tagged(); }
DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray);
};
-class HLoadFieldByIndex FINAL : public HTemplateInstruction<2> {
+class HLoadFieldByIndex final : public HTemplateInstruction<2> {
public:
DECLARE_INSTRUCTION_FACTORY_P2(HLoadFieldByIndex, HValue*, HValue*);
set_representation(Representation::Tagged());
}
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
if (index == 1) {
return Representation::Smi();
} else {
HValue* object() const { return OperandAt(0); }
HValue* index() const { return OperandAt(1); }
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
- HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+ HType CalculateInferredType() override { return HType::Tagged(); }
DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
private:
- bool IsDeletable() const OVERRIDE { return true; }
+ bool IsDeletable() const override { return true; }
};
HValue* context() { return OperandAt(0); }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
HValue* function() const { return OperandAt(1); }
Handle<ScopeInfo> scope_info() const { return scope_info_; }
- Representation RequiredInputRepresentation(int index) OVERRIDE {
+ Representation RequiredInputRepresentation(int index) override {
return Representation::Tagged();
}
- std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE; // NOLINT
+ std::ostream& PrintDataTo(std::ostream& os) const override; // NOLINT
DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext)
V(JSArray, 0xe21) /* 0000 1110 0010 0001 */ \
V(None, 0xfff) /* 0000 1111 1111 1111 */
-class HType FINAL {
+class HType final {
public:
#define DECLARE_CONSTRUCTOR(Name, mask) \
static HType Name() WARN_UNUSED_RESULT { return HType(k##Name); }
class LiveRange;
-class HBasicBlock FINAL : public ZoneObject {
+class HBasicBlock final : public ZoneObject {
public:
explicit HBasicBlock(HGraph* graph);
~HBasicBlock() { }
std::ostream& operator<<(std::ostream& os, const HBasicBlock& b);
-class HPredecessorIterator FINAL BASE_EMBEDDED {
+class HPredecessorIterator final BASE_EMBEDDED {
public:
explicit HPredecessorIterator(HBasicBlock* block)
: predecessor_list_(block->predecessors()), current_(0) { }
};
-class HInstructionIterator FINAL BASE_EMBEDDED {
+class HInstructionIterator final BASE_EMBEDDED {
public:
explicit HInstructionIterator(HBasicBlock* block)
: instr_(block->first()) {
};
-class HLoopInformation FINAL : public ZoneObject {
+class HLoopInformation final : public ZoneObject {
public:
HLoopInformation(HBasicBlock* loop_header, Zone* zone)
: back_edges_(4, zone),
class BoundsCheckTable;
class InductionVariableBlocksTable;
-class HGraph FINAL : public ZoneObject {
+class HGraph final : public ZoneObject {
public:
explicit HGraph(CompilationInfo* info);
};
-class HEnvironment FINAL : public ZoneObject {
+class HEnvironment final : public ZoneObject {
public:
HEnvironment(HEnvironment* outer,
Scope* scope,
};
-class EffectContext FINAL : public AstContext {
+class EffectContext final : public AstContext {
public:
explicit EffectContext(HOptimizedGraphBuilder* owner)
: AstContext(owner, Expression::kEffect) {
}
virtual ~EffectContext();
- void ReturnValue(HValue* value) OVERRIDE;
+ void ReturnValue(HValue* value) override;
virtual void ReturnInstruction(HInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnControl(HControlInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnContinuation(HIfContinuation* continuation,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
};
-class ValueContext FINAL : public AstContext {
+class ValueContext final : public AstContext {
public:
ValueContext(HOptimizedGraphBuilder* owner, ArgumentsAllowedFlag flag)
: AstContext(owner, Expression::kValue), flag_(flag) {
}
virtual ~ValueContext();
- void ReturnValue(HValue* value) OVERRIDE;
+ void ReturnValue(HValue* value) override;
virtual void ReturnInstruction(HInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnControl(HControlInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnContinuation(HIfContinuation* continuation,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
bool arguments_allowed() { return flag_ == ARGUMENTS_ALLOWED; }
};
-class TestContext FINAL : public AstContext {
+class TestContext final : public AstContext {
public:
TestContext(HOptimizedGraphBuilder* owner,
Expression* condition,
if_false_(if_false) {
}
- void ReturnValue(HValue* value) OVERRIDE;
+ void ReturnValue(HValue* value) override;
virtual void ReturnInstruction(HInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnControl(HControlInstruction* instr,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
virtual void ReturnContinuation(HIfContinuation* continuation,
- BailoutId ast_id) OVERRIDE;
+ BailoutId ast_id) override;
static TestContext* cast(AstContext* context) {
DCHECK(context->IsTest());
};
-class FunctionState FINAL {
+class FunctionState final {
public:
FunctionState(HOptimizedGraphBuilder* owner,
CompilationInfo* info,
};
-class HIfContinuation FINAL {
+class HIfContinuation final {
public:
HIfContinuation()
: continuation_captured_(false),
};
-class HAllocationMode FINAL BASE_EMBEDDED {
+class HAllocationMode final BASE_EMBEDDED {
public:
explicit HAllocationMode(Handle<AllocationSite> feedback_site)
: current_site_(NULL), feedback_site_(feedback_site),
void AddIncrementCounter(StatsCounter* counter);
- class IfBuilder FINAL {
+ class IfBuilder final {
public:
// If using this constructor, Initialize() must be called explicitly!
IfBuilder();
int deopt_merge_at_join_block_count_;
};
- class LoopBuilder FINAL {
+ class LoopBuilder final {
public:
enum Direction {
kPreIncrement,
HValue* BuildNewElementsCapacity(HValue* old_capacity);
- class JSArrayBuilder FINAL {
+ class JSArrayBuilder final {
public:
JSArrayBuilder(HGraphBuilder* builder,
ElementsKind kind,
// A class encapsulating (lazily-allocated) break and continue blocks for
// a breakable statement. Separated from BreakAndContinueScope so that it
// can have a separate lifetime.
- class BreakAndContinueInfo FINAL BASE_EMBEDDED {
+ class BreakAndContinueInfo final BASE_EMBEDDED {
public:
explicit BreakAndContinueInfo(BreakableStatement* target,
Scope* scope,
// A helper class to maintain a stack of current BreakAndContinueInfo
// structures mirroring BreakableStatement nesting.
- class BreakAndContinueScope FINAL BASE_EMBEDDED {
+ class BreakAndContinueScope final BASE_EMBEDDED {
public:
BreakAndContinueScope(BreakAndContinueInfo* info,
HOptimizedGraphBuilder* owner)
explicit HOptimizedGraphBuilder(CompilationInfo* info);
- bool BuildGraph() OVERRIDE;
+ bool BuildGraph() override;
// Simple accessors.
BreakAndContinueScope* break_scope() const { return break_scope_; }
void set_break_scope(BreakAndContinueScope* head) { break_scope_ = head; }
- HValue* context() OVERRIDE { return environment()->context(); }
+ HValue* context() override { return environment()->context(); }
HOsrBuilder* osr() const { return osr_; }
FunctionState* function_state() const { return function_state_; }
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
void* operator new(size_t size, Zone* zone) { return zone->New(size); }
void operator delete(void* pointer, Zone* zone) { }
HBasicBlock* false_block);
// Visit a list of expressions from left to right, each in a value context.
- void VisitExpressions(ZoneList<Expression*>* exprs) OVERRIDE;
+ void VisitExpressions(ZoneList<Expression*>* exprs) override;
void VisitExpressions(ZoneList<Expression*>* exprs,
ArgumentsAllowedFlag flag);
void PushArgumentsFromEnvironment(int count);
void SetUpScope(Scope* scope);
- void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
+ void VisitStatements(ZoneList<Statement*>* statements) override;
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
Zone* AstContext::zone() const { return owner_->zone(); }
-class HStatistics FINAL: public Malloced {
+class HStatistics final : public Malloced {
public:
HStatistics()
: times_(5),
};
-class HTracer FINAL : public Malloced {
+class HTracer final : public Malloced {
public:
explicit HTracer(int isolate_id)
: trace_(&string_allocator_), indent_(0) {
void TraceLiveRanges(const char* name, LAllocator* allocator);
private:
- class Tag FINAL BASE_EMBEDDED {
+ class Tag final BASE_EMBEDDED {
public:
Tag(HTracer* tracer, const char* name) {
name_ = name;
};
-class NoObservableSideEffectsScope FINAL {
+class NoObservableSideEffectsScope final {
public:
explicit NoObservableSideEffectsScope(HGraphBuilder* builder) :
builder_(builder) {
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static const byte kTwoByteNopInstruction = 0x3c; // Cmpb al, #imm8.
static const byte kTwoByteJumpInstruction = 0xeb; // Jmp #imm8.
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
// When invoking builtins, we need to record the safepoint in the middle of
// the invoke instruction sequence generated by the macro assembler.
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) {}
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
LInstanceOfKnownGlobal* instr_;
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen,
LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen,
LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen,
LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen,
LNumberTagI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(
instr_, instr_->value(), instr_->temp(), SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(
instr_, instr_->value(), instr_->temp(), UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_, done()); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_, done()); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
- void GenerateBodyInstructionPost(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
+ void GenerateBodyInstructionPost(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
int* offset,
AllocationSiteMode mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const FINAL { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const final { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return false;
}
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 1> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 1> {
public:
LWrapReceiver(LOperand* receiver,
LOperand* function,
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LModByConstI(LOperand* dividend,
int32_t divisor,
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LModI final : public LTemplateInstruction<1, 2, 1> {
public:
LModI(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 3> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> {
public:
LFlooringDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LMulI final : public LTemplateInstruction<1, 2, 1> {
public:
LMulI(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFloor(LOperand* value) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 2> {
+class LMathExp final : public LTemplateInstruction<1, 1, 2> {
public:
LMathExp(LOperand* value,
LOperand* temp1,
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) {
inputs_[0] = value;
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 1> {
public:
LMathPowHalf(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
"string-compare-and-branch")
DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Token::Value op() const { return hydrogen()->token(); }
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 1> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 1> {
public:
LHasInstanceTypeAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
"has-cached-array-index-and-branch")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 1> {
+class LConstantD final : public LTemplateInstruction<1, 0, 1> {
public:
explicit LConstantD(LOperand* temp) {
temps_[0] = temp;
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 1> {
+class LBranch final : public LControlInstruction<1, 1> {
public:
LBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpMapAndBranch(LOperand* value) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index)
: index_(index) {
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
Token::Value op() const { return op_; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* left() { return inputs_[1]; }
LOperand* right() { return inputs_[2]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
Token::Value op() const { return op_; }
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
explicit LReturn(LOperand* value,
LOperand* context,
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 1> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 1> {
public:
LLoadFunctionPrototype(LOperand* function, LOperand* temp) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
bool key_is_smi() {
return hydrogen()->key()->representation().IsTagged();
}
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagI(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagU(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 1> {
public:
LDoubleToI(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 1> {
public:
LTaggedToI(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 1> {
public:
explicit LNumberUntagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 2> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 2> {
public:
LStoreNamedField(LOperand* obj,
LOperand* val,
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* obj, LOperand* key, LOperand* val) {
inputs_[0] = obj;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* object,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 1> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 1> {
public:
LCheckInstanceType(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* value) {
inputs_[0] = value;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* value) {
inputs_[0] = value;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* value, LOperand* temp_xmm) {
inputs_[0] = value;
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 1> {
+class LAllocate final : public LTemplateInstruction<1, 2, 1> {
public:
LAllocate(LOperand* context, LOperand* size, LOperand* temp) {
inputs_[0] = context;
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph),
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
};
-class CallICState FINAL BASE_EMBEDDED {
+class CallICState final BASE_EMBEDDED {
public:
explicit CallICState(ExtraICState extra_ic_state);
std::ostream& operator<<(std::ostream& os, const CallICState& s);
-class BinaryOpICState FINAL BASE_EMBEDDED {
+class BinaryOpICState final BASE_EMBEDDED {
public:
BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state);
};
-class LoadICState FINAL BASE_EMBEDDED {
+class LoadICState final BASE_EMBEDDED {
public:
explicit LoadICState(ExtraICState extra_ic_state) : state_(extra_ic_state) {}
}
}
- Handle<Code> megamorphic_stub() OVERRIDE;
+ Handle<Code> megamorphic_stub() override;
// Update the inline cache and the global stub cache based on the
// lookup result.
virtual Handle<Code> CompileHandler(LookupIterator* lookup,
Handle<Object> unused,
- CacheHolderFlag cache_holder) OVERRIDE;
+ CacheHolderFlag cache_holder) override;
private:
virtual Handle<Code> pre_monomorphic_stub() const;
protected:
// Stub accessors.
- Handle<Code> megamorphic_stub() OVERRIDE;
+ Handle<Code> megamorphic_stub() override;
Handle<Code> slow_stub() const;
virtual Handle<Code> pre_monomorphic_stub() const {
JSReceiver::StoreFromKeyed store_mode);
virtual Handle<Code> CompileHandler(LookupIterator* lookup,
Handle<Object> value,
- CacheHolderFlag cache_holder) OVERRIDE;
+ CacheHolderFlag cache_holder) override;
private:
inline void set_target(Code* code);
};
-class CodeTracer FINAL : public Malloced {
+class CodeTracer final : public Malloced {
public:
explicit CodeTracer(int isolate_id)
: file_(NULL),
#undef FORWARD_DECLARE
-class TextElement FINAL BASE_EMBEDDED {
+class TextElement final BASE_EMBEDDED {
public:
enum TextType {
ATOM,
// v8::Platform implementation.
virtual void CallOnBackgroundThread(
- Task* task, ExpectedRuntime expected_runtime) OVERRIDE;
+ Task* task, ExpectedRuntime expected_runtime) override;
virtual void CallOnForegroundThread(v8::Isolate* isolate,
- Task* task) OVERRIDE;
- double MonotonicallyIncreasingTime() OVERRIDE;
+ Task* task) override;
+ double MonotonicallyIncreasingTime() override;
private:
static const int kMaxThreadPoolSize;
virtual ~WorkerThread();
// Thread implementation.
- void Run() OVERRIDE;
+ void Run() override;
private:
friend class QuitTask;
};
-class LMoveOperands FINAL BASE_EMBEDDED {
+class LMoveOperands final BASE_EMBEDDED {
public:
LMoveOperands(LOperand* source, LOperand* destination)
: source_(source), destination_(destination) {
};
-template<LOperand::Kind kOperandKind, int kNumCachedOperands>
-class LSubKindOperand FINAL : public LOperand {
+template <LOperand::Kind kOperandKind, int kNumCachedOperands>
+class LSubKindOperand final : public LOperand {
public:
static LSubKindOperand* Create(int index, Zone* zone) {
DCHECK(index >= 0);
#undef LITHIUM_TYPEDEF_SUBKIND_OPERAND_CLASS
-class LParallelMove FINAL : public ZoneObject {
+class LParallelMove final : public ZoneObject {
public:
explicit LParallelMove(Zone* zone) : move_operands_(4, zone) { }
};
-class LPointerMap FINAL : public ZoneObject {
+class LPointerMap final : public ZoneObject {
public:
explicit LPointerMap(Zone* zone)
: pointer_operands_(8, zone),
};
-class LEnvironment FINAL : public ZoneObject {
+class LEnvironment final : public ZoneObject {
public:
LEnvironment(Handle<JSFunction> closure,
FrameType frame_type,
// Iterates over the non-null, non-constant operands in an environment.
-class ShallowIterator FINAL BASE_EMBEDDED {
+class ShallowIterator final BASE_EMBEDDED {
public:
explicit ShallowIterator(LEnvironment* env)
: env_(env),
// Iterator for non-null, non-constant operands incl. outer environments.
-class DeepIterator FINAL BASE_EMBEDDED {
+class DeepIterator final BASE_EMBEDDED {
public:
explicit DeepIterator(LEnvironment* env)
: current_iterator_(env) {
namespace v8 {
namespace internal {
-class LookupIterator FINAL BASE_EMBEDDED {
+class LookupIterator final BASE_EMBEDDED {
public:
enum Configuration {
// Configuration bits.
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
const unsigned offset = masm->instr_at(pos) & kImm16Mask;
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
void GenerateCall(MacroAssembler* masm, Register target);
private:
- bool NeedsImmovableCode() OVERRIDE { return true; }
+ bool NeedsImmovableCode() override { return true; }
DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
namespace internal {
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) { }
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_,
instr_->value(),
instr_->temp1(),
instr_->temp2(),
SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_,
instr_->value(),
instr_->temp1(),
instr_->temp2(),
UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
LEnvironment* environment);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const FINAL { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const final { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) { }
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
LOperand* length() { return inputs_[1]; }
LOperand* index() { return inputs_[2]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LModByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 3> {
+class LModI final : public LTemplateInstruction<1, 2, 3> {
public:
LModI(LOperand* left,
LOperand* right) {
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 0> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
// Instruction for computing multiplier * multiplicand + addend.
-class LMultiplyAddD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplyAddD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplyAddD(LOperand* addend, LOperand* multiplier,
LOperand* multiplicand) {
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 1> {
public:
LMathFloor(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 3> {
+class LMathExp final : public LTemplateInstruction<1, 1, 3> {
public:
LMathExp(LOperand* value,
LOperand* double_temp,
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) {
inputs_[0] = value;
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 1> {
public:
LMathPowHalf(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
Token::Value op() const { return hydrogen()->token(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasInstanceTypeAndBranch(LOperand* value) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 1> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 1> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 0> {
+class LBranch final : public LControlInstruction<1, 0> {
public:
explicit LBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 1> {
public:
LCmpMapAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* right() { return inputs_[2]; }
Token::Value op() const { return op_; }
- Opcode opcode() const FINAL { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const final { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
inputs_[0] = value;
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadFunctionPrototype(LOperand* function) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 0> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreContextSlot(LOperand* context, LOperand* value) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagD(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 2> {
public:
LTaggedToI(LOperand* value,
LOperand* temp,
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LNumberUntagD(LOperand* value) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* obj,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 1> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 1> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckInstanceType(LOperand* value) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampDToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 2> {
+class LAllocate final : public LTemplateInstruction<1, 2, 2> {
public:
LAllocate(LOperand* context,
LOperand* size,
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph) { }
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
const unsigned offset = masm->instr_at(pos) & kImm16Mask;
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
void GenerateCall(MacroAssembler* masm, Register target);
private:
- bool NeedsImmovableCode() OVERRIDE { return true; }
+ bool NeedsImmovableCode() override { return true; }
DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
namespace internal {
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) { }
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_,
instr_->value(),
instr_->temp1(),
instr_->temp2(),
UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
LEnvironment* environment);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
V(WrapReceiver)
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const FINAL { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const final { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) { }
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
LOperand* length() { return inputs_[1]; }
LOperand* index() { return inputs_[2]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LModByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 3> {
+class LModI final : public LTemplateInstruction<1, 2, 3> {
public:
LModI(LOperand* left,
LOperand* right) {
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 0> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
// Instruction for computing multiplier * multiplicand + addend.
-class LMultiplyAddD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplyAddD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplyAddD(LOperand* addend, LOperand* multiplier,
LOperand* multiplicand) {
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 1> {
public:
LMathFloor(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 3> {
+class LMathExp final : public LTemplateInstruction<1, 1, 3> {
public:
LMathExp(LOperand* value,
LOperand* double_temp,
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) {
inputs_[0] = value;
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 1> {
public:
LMathPowHalf(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
Token::Value op() const { return hydrogen()->token(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasInstanceTypeAndBranch(LOperand* value) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 1> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 1> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 0> {
+class LBranch final : public LControlInstruction<1, 0> {
public:
explicit LBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 1> {
public:
LCmpMapAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* right() { return inputs_[2]; }
Token::Value op() const { return op_; }
- Opcode opcode() const FINAL { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const final { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
inputs_[0] = value;
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadFunctionPrototype(LOperand* function) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 0> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreContextSlot(LOperand* context, LOperand* value) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagD(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 2> {
public:
LTaggedToI(LOperand* value,
LOperand* temp,
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LNumberUntagD(LOperand* value) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* obj,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 1> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 1> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckInstanceType(LOperand* value) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampDToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 2> {
+class LAllocate final : public LTemplateInstruction<1, 2, 2> {
public:
LAllocate(LOperand* context,
LOperand* size,
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph) { }
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
explicit SequentialStringKey(Vector<const Char> string, uint32_t seed)
: string_(string), hash_field_(0), seed_(seed) { }
- uint32_t Hash() OVERRIDE {
+ uint32_t Hash() override {
hash_field_ = StringHasher::HashSequentialString<Char>(string_.start(),
string_.length(),
seed_);
}
- uint32_t HashForObject(Object* other) OVERRIDE {
+ uint32_t HashForObject(Object* other) override {
return String::cast(other)->Hash();
}
OneByteStringKey(Vector<const uint8_t> str, uint32_t seed)
: SequentialStringKey<uint8_t>(str, seed) { }
- bool IsMatch(Object* string) OVERRIDE {
+ bool IsMatch(Object* string) override {
return String::cast(string)->IsOneByteEqualTo(string_);
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
+ Handle<Object> AsHandle(Isolate* isolate) override;
};
DCHECK(string_->IsSeqOneByteString());
}
- uint32_t Hash() OVERRIDE {
+ uint32_t Hash() override {
DCHECK(length_ >= 0);
DCHECK(from_ + length_ <= string_->length());
const uint8_t* chars = string_->GetChars() + from_;
return result;
}
- uint32_t HashForObject(Object* other) OVERRIDE {
+ uint32_t HashForObject(Object* other) override {
return String::cast(other)->Hash();
}
- bool IsMatch(Object* string) OVERRIDE;
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
+ bool IsMatch(Object* string) override;
+ Handle<Object> AsHandle(Isolate* isolate) override;
private:
Handle<SeqOneByteString> string_;
explicit TwoByteStringKey(Vector<const uc16> str, uint32_t seed)
: SequentialStringKey<uc16>(str, seed) { }
- bool IsMatch(Object* string) OVERRIDE {
+ bool IsMatch(Object* string) override {
return String::cast(string)->IsTwoByteEqualTo(string_);
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
+ Handle<Object> AsHandle(Isolate* isolate) override;
};
explicit Utf8StringKey(Vector<const char> string, uint32_t seed)
: string_(string), hash_field_(0), seed_(seed) { }
- bool IsMatch(Object* string) OVERRIDE {
+ bool IsMatch(Object* string) override {
return String::cast(string)->IsUtf8EqualTo(string_);
}
- uint32_t Hash() OVERRIDE {
+ uint32_t Hash() override {
if (hash_field_ != 0) return hash_field_ >> String::kHashShift;
hash_field_ = StringHasher::ComputeUtf8Hash(string_, seed_, &chars_);
uint32_t result = hash_field_ >> String::kHashShift;
return result;
}
- uint32_t HashForObject(Object* other) OVERRIDE {
+ uint32_t HashForObject(Object* other) override {
return String::cast(other)->Hash();
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
if (hash_field_ == 0) Hash();
return isolate->factory()->NewInternalizedStringFromUtf8(
string_, chars_, hash_field_);
}
-class String::SubStringRange::iterator FINAL {
+class String::SubStringRange::iterator final {
public:
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
CodeCacheHashTableKey(Handle<Name> name, Handle<Code> code)
: name_(name), flags_(code->flags()), code_(code) { }
- bool IsMatch(Object* other) OVERRIDE {
+ bool IsMatch(Object* other) override {
if (!other->IsFixedArray()) return false;
FixedArray* pair = FixedArray::cast(other);
Name* name = Name::cast(pair->get(0));
return name->Hash() ^ flags;
}
- uint32_t Hash() OVERRIDE { return NameFlagsHashHelper(*name_, flags_); }
+ uint32_t Hash() override { return NameFlagsHashHelper(*name_, flags_); }
- uint32_t HashForObject(Object* obj) OVERRIDE {
+ uint32_t HashForObject(Object* obj) override {
FixedArray* pair = FixedArray::cast(obj);
Name* name = Name::cast(pair->get(0));
Code* code = Code::cast(pair->get(1));
return NameFlagsHashHelper(name, code->flags());
}
- MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) override {
Handle<Code> code = code_.ToHandleChecked();
Handle<FixedArray> pair = isolate->factory()->NewFixedArray(2);
pair->set(0, *name_);
: maps_(maps),
code_flags_(code_flags) {}
- bool IsMatch(Object* other) OVERRIDE {
+ bool IsMatch(Object* other) override {
MapHandleList other_maps(kDefaultListAllocationSize);
int other_flags;
FromObject(other, &other_flags, &other_maps);
return hash;
}
- uint32_t Hash() OVERRIDE {
- return MapsHashHelper(maps_, code_flags_);
- }
+ uint32_t Hash() override { return MapsHashHelper(maps_, code_flags_); }
- uint32_t HashForObject(Object* obj) OVERRIDE {
+ uint32_t HashForObject(Object* obj) override {
MapHandleList other_maps(kDefaultListAllocationSize);
int other_flags;
FromObject(obj, &other_flags, &other_maps);
return MapsHashHelper(&other_maps, other_flags);
}
- MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) override {
// The maps in |maps_| must be copied to a newly allocated FixedArray,
// both because the referenced MapList is short-lived, and because C++
// objects can't be stored in the heap anyway.
language_mode_(language_mode),
scope_position_(scope_position) {}
- bool IsMatch(Object* other) OVERRIDE {
+ bool IsMatch(Object* other) override {
DisallowHeapAllocation no_allocation;
if (!other->IsFixedArray()) {
if (!other->IsNumber()) return false;
return hash;
}
- uint32_t Hash() OVERRIDE {
+ uint32_t Hash() override {
return StringSharedHashHelper(*source_, *shared_, language_mode_,
scope_position_);
}
- uint32_t HashForObject(Object* obj) OVERRIDE {
+ uint32_t HashForObject(Object* obj) override {
DisallowHeapAllocation no_allocation;
if (obj->IsNumber()) {
return static_cast<uint32_t>(obj->Number());
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
Handle<FixedArray> array = isolate->factory()->NewFixedArray(4);
array->set(0, *shared_);
array->set(1, *source_);
// stored value is stored where the key should be. IsMatch then
// compares the search key to the found object, rather than comparing
// a key to a key.
- bool IsMatch(Object* obj) OVERRIDE {
+ bool IsMatch(Object* obj) override {
FixedArray* val = FixedArray::cast(obj);
return string_->Equals(String::cast(val->get(JSRegExp::kSourceIndex)))
&& (flags_ == val->get(JSRegExp::kFlagsIndex));
}
- uint32_t Hash() OVERRIDE { return RegExpHash(*string_, flags_); }
+ uint32_t Hash() override { return RegExpHash(*string_, flags_); }
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
// Plain hash maps, which is where regexp keys are used, don't
// use this function.
UNREACHABLE();
return MaybeHandle<Object>().ToHandleChecked();
}
- uint32_t HashForObject(Object* obj) OVERRIDE {
+ uint32_t HashForObject(Object* obj) override {
FixedArray* val = FixedArray::cast(obj);
return RegExpHash(String::cast(val->get(JSRegExp::kSourceIndex)),
Smi::cast(val->get(JSRegExp::kFlagsIndex)));
explicit InternalizedStringKey(Handle<String> string)
: string_(string) { }
- bool IsMatch(Object* string) OVERRIDE {
+ bool IsMatch(Object* string) override {
return String::cast(string)->Equals(*string_);
}
- uint32_t Hash() OVERRIDE { return string_->Hash(); }
+ uint32_t Hash() override { return string_->Hash(); }
- uint32_t HashForObject(Object* other) OVERRIDE {
+ uint32_t HashForObject(Object* other) override {
return String::cast(other)->Hash();
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
// Internalize the string if possible.
MaybeHandle<Map> maybe_map =
isolate->factory()->InternalizedStringMapForString(string_);
#endif
}
- bool IsMatch(Object* o) OVERRIDE {
+ bool IsMatch(Object* o) override {
if (!o->IsString()) return false;
String* other = String::cast(o);
if (other->length() != 2) return false;
return other->Get(1) == c2_;
}
- uint32_t Hash() OVERRIDE { return hash_; }
- uint32_t HashForObject(Object* key) OVERRIDE {
+ uint32_t Hash() override { return hash_; }
+ uint32_t HashForObject(Object* key) override {
if (!key->IsString()) return 0;
return String::cast(key)->Hash();
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
+ Handle<Object> AsHandle(Isolate* isolate) override {
// The TwoCharHashTableKey is only used for looking in the string
// table, not for adding to it.
UNREACHABLE();
public:
explicit StringsKey(Handle<FixedArray> strings) : strings_(strings) { }
- bool IsMatch(Object* strings) OVERRIDE {
+ bool IsMatch(Object* strings) override {
FixedArray* o = FixedArray::cast(strings);
int len = strings_->length();
if (o->length() != len) return false;
return true;
}
- uint32_t Hash() OVERRIDE { return HashForObject(*strings_); }
+ uint32_t Hash() override { return HashForObject(*strings_); }
- uint32_t HashForObject(Object* obj) OVERRIDE {
+ uint32_t HashForObject(Object* obj) override {
FixedArray* strings = FixedArray::cast(obj);
int len = strings->length();
uint32_t hash = 0;
return hash;
}
- Handle<Object> AsHandle(Isolate* isolate) OVERRIDE { return strings_; }
+ Handle<Object> AsHandle(Isolate* isolate) override { return strings_; }
private:
Handle<FixedArray> strings_;
private:
// v8::Task overrides.
- void Run() OVERRIDE {
+ void Run() override {
DisallowHeapAllocation no_allocation;
DisallowHandleAllocation no_handles;
DisallowHandleDereference no_deref;
enum Mode { STORE_BUFFER_ONLY, INCREMENTAL, INCREMENTAL_COMPACTION };
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static void PatchBranchIntoNop(MacroAssembler* masm, int pos) {
// Consider adding DCHECK here to catch bad patching
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm, OnNoNeedToInformIncrementalMarker on_no_need,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
void GenerateCall(MacroAssembler* masm, Register target);
private:
- bool NeedsImmovableCode() OVERRIDE { return true; }
+ bool NeedsImmovableCode() override { return true; }
DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
DEFINE_PLATFORM_CODE_STUB(DirectCEntry, PlatformCodeStub);
Label* done, Register elements,
Register name, Register r0, Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
namespace internal {
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen, LPointerMap* pointers,
Safepoint::DeoptMode mode)
: codegen_(codegen), pointers_(pointers), deopt_mode_(mode) {}
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
instr_->temp2(), SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
instr_->temp2(), UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) {}
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen, LLoadFieldByIndex* instr,
Register result, Register object, Register index)
result_(result),
object_(object),
index_(index) {}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, result_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
void RecordSafepointWithRegisters(LPointerMap* pointers, int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op);
void EmitGoto(int block);
void EmitDeepCopy(Handle<JSObject> object, Register result, Register source,
int* offset, AllocationSiteMode mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const OVERRIDE { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const override { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) {}
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) { inputs_[0] = value; }
DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use")
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block) : LGap(block), replacement_(NULL) {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
virtual bool HasInterestingComment(LCodeGen* gen) const { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) { inputs_[0] = context; }
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) {}
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function, LOperand* receiver, LOperand* length,
LOperand* elements) {
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
LOperand* length() { return inputs_[1]; }
LOperand* index() { return inputs_[2]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) { inputs_[0] = elements; }
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LModByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LModI final : public LTemplateInstruction<1, 2, 0> {
public:
LModI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByConstI(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LDivI final : public LTemplateInstruction<1, 2, 0> {
public:
LDivI(LOperand* dividend, LOperand* divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 1> {
public:
LFlooringDivByConstI(LOperand* dividend, int32_t divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 0> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
// Instruction for computing multiplier * multiplicand + addend.
-class LMultiplyAddD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplyAddD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplyAddD(LOperand* addend, LOperand* multiplier,
LOperand* multiplicand) {
// Instruction for computing minuend - multiplier * multiplicand.
-class LMultiplySubD FINAL : public LTemplateInstruction<1, 3, 0> {
+class LMultiplySubD final : public LTemplateInstruction<1, 3, 0> {
public:
LMultiplySubD(LOperand* minuend, LOperand* multiplier,
LOperand* multiplicand) {
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
Token::Value op() const { return hydrogen()->token(); }
bool is_double() const { return hydrogen()->representation().IsDouble(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFloor(LOperand* value) { inputs_[0] = value; }
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) { inputs_[0] = value; }
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) { inputs_[0] = value; }
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 3> {
+class LMathExp final : public LTemplateInstruction<1, 1, 3> {
public:
LMathExp(LOperand* value, LOperand* double_temp, LOperand* temp1,
LOperand* temp2) {
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) { inputs_[0] = value; }
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathPowHalf(LOperand* value) { inputs_[0] = value; }
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) { inputs_[0] = object; }
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 1> {
public:
LCompareMinusZeroAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) { inputs_[0] = value; }
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
Token::Value op() const { return hydrogen()->token(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasInstanceTypeAndBranch(LOperand* value) { inputs_[0] = value; }
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) { inputs_[0] = value; }
};
-class LHasCachedArrayIndexAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 1> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 1> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch, "class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LRSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LRSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LRSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 0> {
+class LBranch final : public LControlInstruction<1, 0> {
public:
explicit LBranch(LOperand* value) { inputs_[0] = value; }
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 1> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 1> {
public:
LCmpMapAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) { inputs_[0] = value; }
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context, LOperand* string, LOperand* index,
LOperand* value) {
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right) : op_(op) {
inputs_[0] = left;
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op, LOperand* context, LOperand* left,
LOperand* right)
LOperand* right() { return inputs_[2]; }
Token::Value op() const { return op_; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
LReturn(LOperand* value, LOperand* context, LOperand* parameter_count) {
inputs_[0] = value;
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) { inputs_[0] = object; }
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadFunctionPrototype(LOperand* function) { inputs_[0] = function; }
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) { inputs_[0] = context; }
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 0> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreContextSlot(LOperand* context, LOperand* value) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) { inputs_[0] = value; }
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) {}
};
-class LStoreCodeEntry FINAL : public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) { inputs_[0] = context; }
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) { inputs_[0] = function; }
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) { inputs_[0] = context; }
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) { inputs_[0] = value; }
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) { inputs_[0] = value; }
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagD(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) { inputs_[0] = value; }
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) { inputs_[0] = value; }
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 2> {
public:
LTaggedToI(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) { inputs_[0] = value; }
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LNumberUntagD(LOperand* value) { inputs_[0] = value; }
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check) : needs_check_(needs_check) {
inputs_[0] = value;
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
bool NeedsCanonicalization() {
if (hydrogen()->value()->IsAdd() || hydrogen()->value()->IsSub() ||
hydrogen()->value()->IsMul() || hydrogen()->value()->IsDiv()) {
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
LOperand* value) {
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 1> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 1> {
public:
LTransitionElementsKind(LOperand* object, LOperand* context,
LOperand* new_map_temp) {
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object, LOperand* temp) {
inputs_[0] = object;
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) { inputs_[0] = value; }
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckInstanceType(LOperand* value) { inputs_[0] = value; }
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 1> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 1> {
public:
explicit LCheckMaps(LOperand* value = NULL, LOperand* temp = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) { inputs_[0] = value; }
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) { inputs_[0] = value; }
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* unclamped) { inputs_[0] = unclamped; }
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) { inputs_[0] = unclamped; }
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped, LOperand* temp) {
inputs_[0] = unclamped;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) { inputs_[0] = value; }
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 2> {
+class LAllocate final : public LTemplateInstruction<1, 2, 2> {
public:
LAllocate(LOperand* context, LOperand* size, LOperand* temp1,
LOperand* temp2) {
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) { inputs_[0] = context; }
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) { inputs_[0] = context; }
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) { inputs_[0] = value; }
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) { inputs_[0] = value; }
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) { temps_[0] = temp; }
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) { inputs_[0] = context; }
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) { inputs_[0] = map; }
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph) : LChunk(info, graph) {}
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
: ObjectLiteralCheckerBase(parser), has_seen_proto_(false) {}
void CheckProperty(Token::Value property, PropertyKind type, bool is_static,
- bool is_generator, bool* ok) OVERRIDE;
+ bool is_generator, bool* ok) override;
private:
bool IsProto() { return this->scanner()->LiteralMatches("__proto__", 9); }
: ObjectLiteralCheckerBase(parser), has_seen_constructor_(false) {}
void CheckProperty(Token::Value property, PropertyKind type, bool is_static,
- bool is_generator, bool* ok) OVERRIDE;
+ bool is_generator, bool* ok) override;
private:
bool IsConstructor() {
void AstPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
- IndentedScope indent(this, "TRY FINALLY");
+ IndentedScope indent(this, "TRY finalLY");
PrintIndentedVisit("TRY", node->try_block());
PrintIndentedVisit("FINALLY", node->finally_block());
}
void Find(AstNode* node, bool print = false);
// Individual nodes
-#define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
static void PrintOut(Isolate* isolate, Zone* zone, AstNode* node);
// Individual nodes
-#define DECLARE_VISIT(type) void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
std::ostream& operator<<(std::ostream& os, const Descriptor& d);
-class DataDescriptor FINAL : public Descriptor {
+class DataDescriptor final : public Descriptor {
public:
DataDescriptor(Handle<Name> key, int field_index,
PropertyAttributes attributes, Representation representation)
};
-class DataConstantDescriptor FINAL : public Descriptor {
+class DataConstantDescriptor final : public Descriptor {
public:
DataConstantDescriptor(Handle<Name> key, Handle<Object> value,
PropertyAttributes attributes)
};
-class AccessorConstantDescriptor FINAL : public Descriptor {
+class AccessorConstantDescriptor final : public Descriptor {
public:
AccessorConstantDescriptor(Handle<Name> key, Handle<Object> foreign,
PropertyAttributes attributes)
}
// Node visitors.
-#define DEF_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DEF_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DEF_VISIT)
#undef DEF_VISIT
virtual ~ExternalStreamingStream() { delete[] current_data_; }
- size_t BufferSeekForward(size_t delta) OVERRIDE {
+ size_t BufferSeekForward(size_t delta) override {
// We never need to seek forward when streaming scripts. We only seek
// forward when we want to parse a function whose location we already know,
// and when streaming, we don't know the locations of anything we haven't
return 0;
}
- size_t FillBuffer(size_t position) OVERRIDE;
+ size_t FillBuffer(size_t position) override;
private:
void HandleUtf8SplitCharacters(size_t* data_in_buffer);
DCHECK(string->IsInternalizedString());
}
- bool IsMatch(Object* string) OVERRIDE {
+ bool IsMatch(Object* string) override {
// We know that all entries in a hash table had their hash keys created.
// Use that knowledge to have fast failure.
if (hash_ != HashForObject(string)) return false;
return string_->SlowEquals(String::cast(string));
}
- uint32_t Hash() OVERRIDE { return hash_; }
+ uint32_t Hash() override { return hash_; }
- uint32_t HashForObject(Object* key) OVERRIDE {
+ uint32_t HashForObject(Object* key) override {
return String::cast(key)->Hash();
}
- MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate)
- OVERRIDE {
+ MUST_USE_RESULT virtual Handle<Object> AsHandle(Isolate* isolate) override {
return handle(string_, isolate);
}
public:
Serializer(Isolate* isolate, SnapshotByteSink* sink);
~Serializer();
- void VisitPointers(Object** start, Object** end) OVERRIDE;
+ void VisitPointers(Object** start, Object** end) override;
void EncodeReservations(List<SerializedData::Reservation>* out) const;
// Serialize the objects reachable from a single object pointer.
void Serialize(Object** o);
virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
- WhereToPoint where_to_point, int skip) OVERRIDE;
+ WhereToPoint where_to_point, int skip) override;
private:
int PartialSnapshotCacheIndex(HeapObject* o);
// The StartupSerializer has to serialize the root array, which is slightly
// different.
- void VisitPointers(Object** start, Object** end) OVERRIDE;
+ void VisitPointers(Object** start, Object** end) override;
// Serialize the current state of the heap. The order is:
// 1) Strong references.
// 3) Weak references (e.g. the string table).
virtual void SerializeStrongReferences();
virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
- WhereToPoint where_to_point, int skip) OVERRIDE;
+ WhereToPoint where_to_point, int skip) override;
void SerializeWeakReferences();
void Serialize() {
SerializeStrongReferences();
~CodeSerializer() { OutputStatistics("CodeSerializer"); }
virtual void SerializeObject(HeapObject* o, HowToCode how_to_code,
- WhereToPoint where_to_point, int skip) OVERRIDE;
+ WhereToPoint where_to_point, int skip) override;
void SerializeBuiltin(int builtin_index, HowToCode how_to_code,
WhereToPoint where_to_point);
*
* Note: Memory ownership remains with callee.
*/
-class SnapshotByteSource FINAL {
+class SnapshotByteSource final {
public:
SnapshotByteSource(const char* data, int length)
: data_(reinterpret_cast<const byte*>(data)),
// Normal allocator uses new[] and delete[].
-class HeapStringAllocator FINAL : public StringAllocator {
+class HeapStringAllocator final : public StringAllocator {
public:
~HeapStringAllocator() { DeleteArray(space_); }
- char* allocate(unsigned bytes) OVERRIDE;
- char* grow(unsigned* bytes) OVERRIDE;
+ char* allocate(unsigned bytes) override;
+ char* grow(unsigned* bytes) override;
private:
char* space_;
};
-class FmtElm FINAL {
+class FmtElm final {
public:
FmtElm(int value) : type_(INT) { // NOLINT
data_.u_int_ = value;
};
-class StringStream FINAL {
+class StringStream final {
public:
explicit StringStream(StringAllocator* allocator):
allocator_(allocator),
void ConfigureMonomorphicArray();
void ConfigureMonomorphic(Handle<JSFunction> function);
- InlineCacheState StateFromFeedback() const OVERRIDE;
+ InlineCacheState StateFromFeedback() const override;
- int ExtractMaps(MapHandleList* maps) const OVERRIDE {
+ int ExtractMaps(MapHandleList* maps) const override {
// CallICs don't record map feedback.
return 0;
}
- MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const OVERRIDE {
+ MaybeHandle<Code> FindHandlerForMap(Handle<Map> map) const override {
return MaybeHandle<Code>();
}
virtual bool FindHandlers(CodeHandleList* code_list,
- int length = -1) const OVERRIDE {
+ int length = -1) const override {
return length == 0;
}
};
void ConfigurePolymorphic(MapHandleList* maps, CodeHandleList* handlers);
- InlineCacheState StateFromFeedback() const OVERRIDE;
+ InlineCacheState StateFromFeedback() const override;
};
void ConfigurePolymorphic(Handle<Name> name, MapHandleList* maps,
CodeHandleList* handlers);
- InlineCacheState StateFromFeedback() const OVERRIDE;
- Name* FindFirstName() const OVERRIDE;
+ InlineCacheState StateFromFeedback() const override;
+ Name* FindFirstName() const override;
};
}
} // namespace v8::internal
var->IsParameter() ? parameter_index(var->index()) : kNoVar;
}
- void VisitDeclarations(ZoneList<Declaration*>* declarations) OVERRIDE;
- void VisitStatements(ZoneList<Statement*>* statements) OVERRIDE;
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+ void VisitStatements(ZoneList<Statement*>* statements) override;
-#define DECLARE_VISIT(type) virtual void Visit##type(type* node) OVERRIDE;
+#define DECLARE_VISIT(type) virtual void Visit##type(type* node) override;
AST_NODE_LIST(DECLARE_VISIT)
#undef DECLARE_VISIT
template <typename T>
-class UniqueSet FINAL : public ZoneObject {
+class UniqueSet final : public ZoneObject {
public:
// Constructor. A new set will be empty.
UniqueSet() : size_(0), capacity_(0), array_(NULL) { }
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static const byte kTwoByteNopInstruction = 0x3c; // Cmpb al, #imm8.
static const byte kTwoByteJumpInstruction = 0xeb; // Jmp #imm8.
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- Major MajorKey() const FINAL { return RecordWrite; }
+ Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
// When invoking builtins, we need to record the safepoint in the middle of
// the invoke instruction sequence generated by the macro assembler.
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) { }
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
LInstanceOfKnownGlobal* instr_;
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen, LMathAbs* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen, LStringCharCodeAt* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen, LStringCharFromCode* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen, LNumberTagI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
instr_->temp2(), SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen, LNumberTagU* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp1(),
instr_->temp2(), UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen, LNumberTagD* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen, LTaggedToI* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_, done()); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_, done()); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen, LCheckMaps* instr, Register object)
: LDeferredCode(codegen), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen, LAllocate* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen, LStackCheck* instr)
: LDeferredCode(codegen), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
- void GenerateBodyInstructionPost(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
+ void GenerateBodyInstructionPost(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
void RecordSafepointWithRegisters(LPointerMap* pointers,
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
int* offset,
AllocationSiteMode mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
- bool MustSignExtendResult(LPlatformChunk* chunk) const FINAL;
+ bool MustSignExtendResult(LPlatformChunk* chunk) const final;
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const FINAL { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const final { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
LLazyBailout() : gap_instructions_size_(0) { }
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
explicit LTailCallThroughMegamorphicCache(LOperand* context,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 0> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 0> {
public:
LWrapReceiver(LOperand* receiver, LOperand* function) {
inputs_[0] = receiver;
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LModByConstI(LOperand* dividend,
int32_t divisor,
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LModI final : public LTemplateInstruction<1, 2, 1> {
public:
LModI(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 3> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> {
public:
LFlooringDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMulI final : public LTemplateInstruction<1, 2, 0> {
public:
LMulI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFloor(LOperand* value) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 1> {
+class LMathRound final : public LTemplateInstruction<1, 1, 1> {
public:
LMathRound(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 2> {
+class LMathExp final : public LTemplateInstruction<1, 1, 2> {
public:
LMathExp(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathSqrt(LOperand* value) {
inputs_[0] = value;
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathPowHalf(LOperand* value) {
inputs_[0] = value;
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCompareMinusZeroAndBranch(LOperand* value) {
inputs_[0] = value;
};
-
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsObjectAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsObjectAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
explicit LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
explicit LStringCompareAndBranch(LOperand* context,
LOperand* left,
"string-compare-and-branch")
DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Token::Value op() const { return hydrogen()->token(); }
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 0> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasInstanceTypeAndBranch(LOperand* value) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
"has-cached-array-index-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasCachedArrayIndexAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantD final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 0> {
+class LBranch final : public LControlInstruction<1, 0> {
public:
explicit LBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpMapAndBranch(LOperand* value) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDateField final : public LTemplateInstruction<1, 1, 0> {
public:
LDateField(LOperand* date, Smi* index) : index_(index) {
inputs_[0] = date;
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 0> {
public:
LMathMinMax(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
LOperand* left() { return inputs_[0]; }
LOperand* right() { return inputs_[1]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* left() { return inputs_[1]; }
LOperand* right() { return inputs_[2]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
explicit LReturn(LOperand* value,
LOperand* context,
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
explicit LLoadNamedGeneric(LOperand* context, LOperand* object,
LOperand* vector) {
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadFunctionPrototype(LOperand* function) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
}
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
}
LOperand* elements() { return inputs_[0]; }
LOperand* key() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
ElementsKind elements_kind() const {
return hydrogen()->elements_kind();
};
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
explicit LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
LOperand* temp_vector() { return temps_[1]; }
int arity() const { return hydrogen()->argument_count() - 1; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagI(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 2> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 2> {
public:
LNumberTagU(LOperand* value, LOperand* temp1, LOperand* temp2) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 1> {
public:
explicit LNumberTagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 1> {
public:
LTaggedToI(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 0> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LNumberUntagD(LOperand* value) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreNamedField(LOperand* object, LOperand* value, LOperand* temp) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Representation representation() const {
return hydrogen()->field_representation();
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* object, LOperand* key, LOperand* value) {
inputs_[0] = object;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
uint32_t base_offset() const { return hydrogen()->base_offset(); }
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* object,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
explicit LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckInstanceType(LOperand* value) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* unclamped) {
inputs_[0] = unclamped;
};
-class LClampTToUint8 FINAL : public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8 final : public LTemplateInstruction<1, 1, 1> {
public:
LClampTToUint8(LOperand* unclamped,
LOperand* temp_xmm) {
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 1> {
+class LAllocate final : public LTemplateInstruction<1, 2, 1> {
public:
LAllocate(LOperand* context, LOperand* size, LOperand* temp) {
inputs_[0] = context;
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
LOsrEntry() {}
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph),
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
Register r0,
Register r1);
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
private:
static const int kInlinedProbes = 4;
INCREMENTAL_COMPACTION
};
- bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+ bool SometimesSetsUpAFrame() override { return false; }
static const byte kTwoByteNopInstruction = 0x3c; // Cmpb al, #imm8.
static const byte kTwoByteJumpInstruction = 0xeb; // Jmp #imm8.
kUpdateRememberedSetOnNoNeedToInformIncrementalMarker
};
- inline Major MajorKey() const FINAL { return RecordWrite; }
+ inline Major MajorKey() const final { return RecordWrite; }
- void Generate(MacroAssembler* masm) OVERRIDE;
+ void Generate(MacroAssembler* masm) override;
void GenerateIncremental(MacroAssembler* masm, Mode mode);
void CheckNeedsToInformIncrementalMarker(
MacroAssembler* masm,
Mode mode);
void InformIncrementalMarker(MacroAssembler* masm);
- void Activate(Code* code) OVERRIDE {
+ void Activate(Code* code) override {
code->GetHeap()->incremental_marking()->ActivateGeneratedStub(code);
}
// When invoking builtins, we need to record the safepoint in the middle of
// the invoke instruction sequence generated by the macro assembler.
-class SafepointGenerator FINAL : public CallWrapper {
+class SafepointGenerator final : public CallWrapper {
public:
SafepointGenerator(LCodeGen* codegen,
LPointerMap* pointers,
deopt_mode_(mode) {}
virtual ~SafepointGenerator() {}
- void BeforeCall(int call_size) const OVERRIDE {}
+ void BeforeCall(int call_size) const override {}
- void AfterCall() const OVERRIDE {
+ void AfterCall() const override {
codegen_->RecordSafepoint(pointers_, deopt_mode_);
}
void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) {
- class DeferredInstanceOfKnownGlobal FINAL : public LDeferredCode {
+ class DeferredInstanceOfKnownGlobal final : public LDeferredCode {
public:
DeferredInstanceOfKnownGlobal(LCodeGen* codegen,
LInstanceOfKnownGlobal* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceOfKnownGlobal(instr_, &map_check_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
Label* map_check() { return &map_check_; }
private:
LInstanceOfKnownGlobal* instr_;
void LCodeGen::DoMathAbs(LMathAbs* instr) {
// Class for deferred case.
- class DeferredMathAbsTaggedHeapNumber FINAL : public LDeferredCode {
+ class DeferredMathAbsTaggedHeapNumber final : public LDeferredCode {
public:
DeferredMathAbsTaggedHeapNumber(LCodeGen* codegen,
LMathAbs* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredMathAbsTaggedHeapNumber(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LMathAbs* instr_;
void LCodeGen::DoStringCharCodeAt(LStringCharCodeAt* instr) {
- class DeferredStringCharCodeAt FINAL : public LDeferredCode {
+ class DeferredStringCharCodeAt final : public LDeferredCode {
public:
DeferredStringCharCodeAt(LCodeGen* codegen,
LStringCharCodeAt* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStringCharCodeAt(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStringCharCodeAt(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharCodeAt* instr_;
void LCodeGen::DoStringCharFromCode(LStringCharFromCode* instr) {
- class DeferredStringCharFromCode FINAL : public LDeferredCode {
+ class DeferredStringCharFromCode final : public LDeferredCode {
public:
DeferredStringCharFromCode(LCodeGen* codegen,
LStringCharFromCode* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredStringCharFromCode(instr_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LStringCharFromCode* instr_;
void LCodeGen::DoNumberTagI(LNumberTagI* instr) {
- class DeferredNumberTagI FINAL : public LDeferredCode {
+ class DeferredNumberTagI final : public LDeferredCode {
public:
DeferredNumberTagI(LCodeGen* codegen,
LNumberTagI* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp(),
SIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagI* instr_;
void LCodeGen::DoNumberTagU(LNumberTagU* instr) {
- class DeferredNumberTagU FINAL : public LDeferredCode {
+ class DeferredNumberTagU final : public LDeferredCode {
public:
DeferredNumberTagU(LCodeGen* codegen,
LNumberTagU* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredNumberTagIU(instr_, instr_->value(), instr_->temp(),
UNSIGNED_INT32);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagU* instr_;
void LCodeGen::DoNumberTagD(LNumberTagD* instr) {
- class DeferredNumberTagD FINAL : public LDeferredCode {
+ class DeferredNumberTagD final : public LDeferredCode {
public:
DeferredNumberTagD(LCodeGen* codegen,
LNumberTagD* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredNumberTagD(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredNumberTagD(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LNumberTagD* instr_;
void LCodeGen::DoTaggedToI(LTaggedToI* instr) {
- class DeferredTaggedToI FINAL : public LDeferredCode {
+ class DeferredTaggedToI final : public LDeferredCode {
public:
DeferredTaggedToI(LCodeGen* codegen,
LTaggedToI* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredTaggedToI(instr_, done()); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredTaggedToI(instr_, done()); }
+ LInstruction* instr() override { return instr_; }
private:
LTaggedToI* instr_;
void LCodeGen::DoCheckMaps(LCheckMaps* instr) {
- class DeferredCheckMaps FINAL : public LDeferredCode {
+ class DeferredCheckMaps final : public LDeferredCode {
public:
DeferredCheckMaps(LCodeGen* codegen,
LCheckMaps* instr,
: LDeferredCode(codegen, x87_stack), instr_(instr), object_(object) {
SetExit(check_maps());
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredInstanceMigration(instr_, object_);
}
Label* check_maps() { return &check_maps_; }
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LCheckMaps* instr_;
void LCodeGen::DoAllocate(LAllocate* instr) {
- class DeferredAllocate FINAL : public LDeferredCode {
+ class DeferredAllocate final : public LDeferredCode {
public:
DeferredAllocate(LCodeGen* codegen,
LAllocate* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredAllocate(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredAllocate(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LAllocate* instr_;
void LCodeGen::DoStackCheck(LStackCheck* instr) {
- class DeferredStackCheck FINAL : public LDeferredCode {
+ class DeferredStackCheck final : public LDeferredCode {
public:
DeferredStackCheck(LCodeGen* codegen,
LStackCheck* instr,
const X87Stack& x87_stack)
: LDeferredCode(codegen, x87_stack), instr_(instr) { }
- void Generate() OVERRIDE { codegen()->DoDeferredStackCheck(instr_); }
- LInstruction* instr() OVERRIDE { return instr_; }
+ void Generate() override { codegen()->DoDeferredStackCheck(instr_); }
+ LInstruction* instr() override { return instr_; }
private:
LStackCheck* instr_;
void LCodeGen::DoLoadFieldByIndex(LLoadFieldByIndex* instr) {
- class DeferredLoadMutableDouble FINAL : public LDeferredCode {
+ class DeferredLoadMutableDouble final : public LDeferredCode {
public:
DeferredLoadMutableDouble(LCodeGen* codegen,
LLoadFieldByIndex* instr,
object_(object),
index_(index) {
}
- void Generate() OVERRIDE {
+ void Generate() override {
codegen()->DoDeferredLoadMutableDouble(instr_, object_, index_);
}
- LInstruction* instr() OVERRIDE { return instr_; }
+ LInstruction* instr() override { return instr_; }
private:
LLoadFieldByIndex* instr_;
// Code generation passes. Returns true if code generation should
// continue.
- void GenerateBodyInstructionPre(LInstruction* instr) OVERRIDE;
- void GenerateBodyInstructionPost(LInstruction* instr) OVERRIDE;
+ void GenerateBodyInstructionPre(LInstruction* instr) override;
+ void GenerateBodyInstructionPost(LInstruction* instr) override;
bool GeneratePrologue();
bool GenerateDeferredCode();
bool GenerateJumpTable();
int arguments,
Safepoint::DeoptMode mode);
- void RecordAndWritePosition(int position) OVERRIDE;
+ void RecordAndWritePosition(int position) override;
static Condition TokenToCondition(Token::Value op, bool is_unsigned);
void EmitGoto(int block);
int* offset,
AllocationSiteMode mode);
- void EnsureSpaceForLazyDeopt(int space_needed) OVERRIDE;
+ void EnsureSpaceForLazyDeopt(int space_needed) override;
void DoLoadKeyedExternalArray(LLoadKeyed* instr);
void DoLoadKeyedFixedDoubleArray(LLoadKeyed* instr);
void DoLoadKeyedFixedArray(LLoadKeyed* instr);
Safepoint::Kind expected_safepoint_kind_;
- class PushSafepointRegistersScope FINAL BASE_EMBEDDED {
+ class PushSafepointRegistersScope final BASE_EMBEDDED {
public:
explicit PushSafepointRegistersScope(LCodeGen* codegen)
: codegen_(codegen) {
class LCodeGen;
class LGapResolver;
-class LGapResolver FINAL BASE_EMBEDDED {
+class LGapResolver final BASE_EMBEDDED {
public:
explicit LGapResolver(LCodeGen* owner);
#define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \
- Opcode opcode() const FINAL { return LInstruction::k##type; } \
- void CompileToNative(LCodeGen* generator) FINAL; \
- const char* Mnemonic() const FINAL { return mnemonic; } \
+ Opcode opcode() const final { return LInstruction::k##type; } \
+ void CompileToNative(LCodeGen* generator) final; \
+ const char* Mnemonic() const final { return mnemonic; } \
static L##type* cast(LInstruction* instr) { \
DCHECK(instr->Is##type()); \
return reinterpret_cast<L##type*>(instr); \
public:
// Allow 0 or 1 output operands.
STATIC_ASSERT(R == 0 || R == 1);
- bool HasResult() const FINAL { return R != 0 && result() != NULL; }
+ bool HasResult() const final { return R != 0 && result() != NULL; }
void set_result(LOperand* operand) { results_[0] = operand; }
- LOperand* result() const OVERRIDE { return results_[0]; }
+ LOperand* result() const override { return results_[0]; }
protected:
EmbeddedContainer<LOperand*, R> results_;
private:
// Iterator support.
- int InputCount() FINAL { return I; }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return I; }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return T; }
- LOperand* TempAt(int i) FINAL { return temps_[i]; }
+ int TempCount() final { return T; }
+ LOperand* TempAt(int i) final { return temps_[i]; }
};
}
// Can't use the DECLARE-macro here because of sub-classes.
- bool IsGap() const FINAL { return true; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ bool IsGap() const final { return true; }
+ void PrintDataTo(StringStream* stream) override;
static LGap* cast(LInstruction* instr) {
DCHECK(instr->IsGap());
return reinterpret_cast<LGap*>(instr);
};
-class LInstructionGap FINAL : public LGap {
+class LInstructionGap final : public LGap {
public:
explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE {
+ bool HasInterestingComment(LCodeGen* gen) const override {
return !IsRedundant();
}
};
-class LClobberDoubles FINAL : public LTemplateInstruction<0, 0, 0> {
+class LClobberDoubles final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LClobberDoubles(Isolate* isolate) { }
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE { return true; }
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(ClobberDoubles, "clobber-d")
};
-class LGoto FINAL : public LTemplateInstruction<0, 0, 0> {
+class LGoto final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LGoto(HBasicBlock* block) : block_(block) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE;
+ bool HasInterestingComment(LCodeGen* gen) const override;
DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")
- void PrintDataTo(StringStream* stream) OVERRIDE;
- bool IsControl() const OVERRIDE { return true; }
+ void PrintDataTo(StringStream* stream) override;
+ bool IsControl() const override { return true; }
int block_id() const { return block_->block_id(); }
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return false;
}
};
-class LLazyBailout FINAL : public LTemplateInstruction<0, 0, 0> {
+class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")
};
-class LDummy FINAL : public LTemplateInstruction<1, 0, 0> {
+class LDummy final : public LTemplateInstruction<1, 0, 0> {
public:
LDummy() {}
DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")
};
-class LDummyUse FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDummyUse final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDummyUse(LOperand* value) {
inputs_[0] = value;
};
-class LDeoptimize FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {
public:
- bool IsControl() const OVERRIDE { return true; }
+ bool IsControl() const override { return true; }
DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")
DECLARE_HYDROGEN_ACCESSOR(Deoptimize)
};
-class LLabel FINAL : public LGap {
+class LLabel final : public LGap {
public:
explicit LLabel(HBasicBlock* block)
: LGap(block), replacement_(NULL) { }
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Label, "label")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int block_id() const { return block()->block_id(); }
bool is_loop_header() const { return block()->IsLoopHeader(); }
};
-class LParameter FINAL : public LTemplateInstruction<1, 0, 0> {
+class LParameter final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")
};
-class LCallStub FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallStub final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallStub(LOperand* context) {
inputs_[0] = context;
};
-class LTailCallThroughMegamorphicCache FINAL
+class LTailCallThroughMegamorphicCache final
: public LTemplateInstruction<0, 3, 0> {
public:
LTailCallThroughMegamorphicCache(LOperand* context, LOperand* receiver,
};
-class LUnknownOSRValue FINAL : public LTemplateInstruction<1, 0, 0> {
+class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")
};
public:
LControlInstruction() : false_label_(NULL), true_label_(NULL) { }
- bool IsControl() const FINAL { return true; }
+ bool IsControl() const final { return true; }
int SuccessorCount() { return hydrogen()->SuccessorCount(); }
HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }
};
-class LWrapReceiver FINAL : public LTemplateInstruction<1, 2, 1> {
+class LWrapReceiver final : public LTemplateInstruction<1, 2, 1> {
public:
LWrapReceiver(LOperand* receiver,
LOperand* function,
};
-class LApplyArguments FINAL : public LTemplateInstruction<1, 4, 0> {
+class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {
public:
LApplyArguments(LOperand* function,
LOperand* receiver,
};
-class LAccessArgumentsAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {
public:
LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {
inputs_[0] = arguments;
DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LArgumentsLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LArgumentsLength(LOperand* elements) {
inputs_[0] = elements;
};
-class LArgumentsElements FINAL : public LTemplateInstruction<1, 0, 0> {
+class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")
DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)
};
-class LDebugBreak FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")
};
-class LModByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LModByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LModByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LModByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LModByConstI(LOperand* dividend,
int32_t divisor,
};
-class LModI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LModI final : public LTemplateInstruction<1, 2, 1> {
public:
LModI(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LDivByConstI FINAL : public LTemplateInstruction<1, 1, 2> {
+class LDivByConstI final : public LTemplateInstruction<1, 1, 2> {
public:
LDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LFlooringDivByPowerOf2I FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {
public:
LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {
inputs_[0] = dividend;
};
-class LFlooringDivByConstI FINAL : public LTemplateInstruction<1, 1, 3> {
+class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> {
public:
LFlooringDivByConstI(LOperand* dividend,
int32_t divisor,
};
-class LFlooringDivI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {
public:
LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {
inputs_[0] = dividend;
};
-class LMulI FINAL : public LTemplateInstruction<1, 2, 1> {
+class LMulI final : public LTemplateInstruction<1, 2, 1> {
public:
LMulI(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LCompareNumericAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {
public:
LCompareNumericAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
return hydrogen()->representation().IsDouble();
}
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LMathFloor FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFloor final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFloor(LOperand* value) {
inputs_[0] = value;
};
-class LMathRound FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathRound final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathRound(LOperand* value) {
inputs_[0] = value;
};
-class LMathFround FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathFround final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathFround(LOperand* value) { inputs_[0] = value; }
};
-class LMathAbs FINAL : public LTemplateInstruction<1, 2, 0> {
+class LMathAbs final : public LTemplateInstruction<1, 2, 0> {
public:
LMathAbs(LOperand* context, LOperand* value) {
inputs_[1] = context;
};
-class LMathLog FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathLog final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathLog(LOperand* value) {
inputs_[0] = value;
};
-class LMathClz32 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathClz32(LOperand* value) {
inputs_[0] = value;
};
-class LMathExp FINAL : public LTemplateInstruction<1, 1, 2> {
+class LMathExp final : public LTemplateInstruction<1, 1, 2> {
public:
LMathExp(LOperand* value,
LOperand* temp1,
};
-class LMathSqrt FINAL : public LTemplateInstruction<1, 1, 2> {
+class LMathSqrt final : public LTemplateInstruction<1, 1, 2> {
public:
explicit LMathSqrt(LOperand* value,
LOperand* temp1,
};
-class LMathPowHalf FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMathPowHalf(LOperand* value) { inputs_[0] = value; }
};
-class LCmpObjectEqAndBranch FINAL : public LControlInstruction<2, 0> {
+class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {
public:
LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LCmpHoleAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpHoleAndBranch(LOperand* object) {
inputs_[0] = object;
};
-class LCompareMinusZeroAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCompareMinusZeroAndBranch(LOperand* value) { inputs_[0] = value; }
};
-class LIsObjectAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsObjectAndBranch final : public LControlInstruction<1, 1> {
public:
LIsObjectAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch, "is-object-and-branch")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsStringAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsStringAndBranch final : public LControlInstruction<1, 1> {
public:
LIsStringAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsSmiAndBranch FINAL : public LControlInstruction<1, 0> {
+class LIsSmiAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LIsSmiAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsUndetectableAndBranch FINAL : public LControlInstruction<1, 1> {
+class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {
public:
LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"is-undetectable-and-branch")
DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStringCompareAndBranch FINAL : public LControlInstruction<3, 0> {
+class LStringCompareAndBranch final : public LControlInstruction<3, 0> {
public:
LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
"string-compare-and-branch")
DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Token::Value op() const { return hydrogen()->token(); }
};
-class LHasInstanceTypeAndBranch FINAL : public LControlInstruction<1, 1> {
+class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 1> {
public:
LHasInstanceTypeAndBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
"has-instance-type-and-branch")
DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LGetCachedArrayIndex FINAL : public LTemplateInstruction<1, 1, 0> {
+class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LGetCachedArrayIndex(LOperand* value) {
inputs_[0] = value;
};
-class LHasCachedArrayIndexAndBranch FINAL
- : public LControlInstruction<1, 0> {
+class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LHasCachedArrayIndexAndBranch(LOperand* value) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,
"has-cached-array-index-and-branch")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LIsConstructCallAndBranch FINAL : public LControlInstruction<0, 1> {
+class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {
public:
explicit LIsConstructCallAndBranch(LOperand* temp) {
temps_[0] = temp;
};
-class LClassOfTestAndBranch FINAL : public LControlInstruction<1, 2> {
+class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {
public:
LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) {
inputs_[0] = value;
"class-of-test-and-branch")
DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LCmpT final : public LTemplateInstruction<1, 3, 0> {
public:
LCmpT(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOf FINAL : public LTemplateInstruction<1, 3, 0> {
+class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {
public:
LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LInstanceOfKnownGlobal FINAL : public LTemplateInstruction<1, 2, 1> {
+class LInstanceOfKnownGlobal final : public LTemplateInstruction<1, 2, 1> {
public:
LInstanceOfKnownGlobal(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
return lazy_deopt_env_;
}
virtual void SetDeferredLazyDeoptimizationEnvironment(
- LEnvironment* env) OVERRIDE {
+ LEnvironment* env) override {
lazy_deopt_env_ = env;
}
};
-class LBoundsCheck FINAL : public LTemplateInstruction<0, 2, 0> {
+class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {
public:
LBoundsCheck(LOperand* index, LOperand* length) {
inputs_[0] = index;
};
-class LBitI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LBitI final : public LTemplateInstruction<1, 2, 0> {
public:
LBitI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LShiftI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LShiftI final : public LTemplateInstruction<1, 2, 0> {
public:
LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
: op_(op), can_deopt_(can_deopt) {
};
-class LSubI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSubI final : public LTemplateInstruction<1, 2, 0> {
public:
LSubI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LConstantI FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantI final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantS FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantS final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantD FINAL : public LTemplateInstruction<1, 0, 1> {
+class LConstantD final : public LTemplateInstruction<1, 0, 1> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantE FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantE final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LConstantT FINAL : public LTemplateInstruction<1, 0, 0> {
+class LConstantT final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")
DECLARE_HYDROGEN_ACCESSOR(Constant)
};
-class LBranch FINAL : public LControlInstruction<1, 1> {
+class LBranch final : public LControlInstruction<1, 1> {
public:
LBranch(LOperand* value, LOperand* temp) {
inputs_[0] = value;
DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")
DECLARE_HYDROGEN_ACCESSOR(Branch)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LCmpMapAndBranch FINAL : public LControlInstruction<1, 0> {
+class LCmpMapAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LCmpMapAndBranch(LOperand* value) {
inputs_[0] = value;
};
-class LMapEnumLength FINAL : public LTemplateInstruction<1, 1, 0> {
+class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LMapEnumLength(LOperand* value) {
inputs_[0] = value;
};
-class LDateField FINAL : public LTemplateInstruction<1, 1, 1> {
+class LDateField final : public LTemplateInstruction<1, 1, 1> {
public:
LDateField(LOperand* date, LOperand* temp, Smi* index)
: index_(index) {
};
-class LSeqStringGetChar FINAL : public LTemplateInstruction<1, 2, 0> {
+class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {
public:
LSeqStringGetChar(LOperand* string, LOperand* index) {
inputs_[0] = string;
};
-class LSeqStringSetChar FINAL : public LTemplateInstruction<1, 4, 0> {
+class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {
public:
LSeqStringSetChar(LOperand* context,
LOperand* string,
};
-class LAddI FINAL : public LTemplateInstruction<1, 2, 0> {
+class LAddI final : public LTemplateInstruction<1, 2, 0> {
public:
LAddI(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LMathMinMax FINAL : public LTemplateInstruction<1, 2, 1> {
+class LMathMinMax final : public LTemplateInstruction<1, 2, 1> {
public:
LMathMinMax(LOperand* left, LOperand* right, LOperand* temp) {
inputs_[0] = left;
};
-class LPower FINAL : public LTemplateInstruction<1, 2, 0> {
+class LPower final : public LTemplateInstruction<1, 2, 0> {
public:
LPower(LOperand* left, LOperand* right) {
inputs_[0] = left;
};
-class LArithmeticD FINAL : public LTemplateInstruction<1, 2, 0> {
+class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {
public:
LArithmeticD(Token::Value op, LOperand* left, LOperand* right)
: op_(op) {
Token::Value op() const { return op_; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticD; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticD; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
private:
Token::Value op_;
};
-class LArithmeticT FINAL : public LTemplateInstruction<1, 3, 0> {
+class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {
public:
LArithmeticT(Token::Value op,
LOperand* context,
LOperand* left() { return inputs_[1]; }
LOperand* right() { return inputs_[2]; }
- Opcode opcode() const OVERRIDE { return LInstruction::kArithmeticT; }
- void CompileToNative(LCodeGen* generator) OVERRIDE;
- const char* Mnemonic() const OVERRIDE;
+ Opcode opcode() const override { return LInstruction::kArithmeticT; }
+ void CompileToNative(LCodeGen* generator) override;
+ const char* Mnemonic() const override;
Token::Value op() const { return op_; }
};
-class LReturn FINAL : public LTemplateInstruction<0, 3, 0> {
+class LReturn final : public LTemplateInstruction<0, 3, 0> {
public:
explicit LReturn(LOperand* value,
LOperand* context,
};
-class LLoadNamedField FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadNamedField(LOperand* object) {
inputs_[0] = object;
};
-class LLoadNamedGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {
inputs_[0] = context;
};
-class LLoadFunctionPrototype FINAL : public LTemplateInstruction<1, 1, 1> {
+class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 1> {
public:
LLoadFunctionPrototype(LOperand* function, LOperand* temp) {
inputs_[0] = function;
};
-class LLoadRoot FINAL : public LTemplateInstruction<1, 0, 0> {
+class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")
DECLARE_HYDROGEN_ACCESSOR(LoadRoot)
};
-class LLoadKeyed FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadKeyed(LOperand* elements, LOperand* key) {
inputs_[0] = elements;
DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")
DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
bool key_is_smi() {
return hydrogen()->key()->representation().IsTagged();
}
-class LLoadKeyedGeneric FINAL : public LTemplateInstruction<1, 3, 1> {
+class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {
public:
LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,
LOperand* vector) {
};
-class LLoadGlobalGeneric FINAL : public LTemplateInstruction<1, 2, 1> {
+class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {
public:
LLoadGlobalGeneric(LOperand* context, LOperand* global_object,
LOperand* vector) {
};
-class LLoadContextSlot FINAL : public LTemplateInstruction<1, 1, 0> {
+class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LLoadContextSlot(LOperand* context) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreContextSlot FINAL : public LTemplateInstruction<0, 2, 1> {
+class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {
public:
LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {
inputs_[0] = context;
int slot_index() { return hydrogen()->slot_index(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LPushArgument FINAL : public LTemplateInstruction<0, 1, 0> {
+class LPushArgument final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LPushArgument(LOperand* value) {
inputs_[0] = value;
};
-class LDrop FINAL : public LTemplateInstruction<0, 0, 0> {
+class LDrop final : public LTemplateInstruction<0, 0, 0> {
public:
explicit LDrop(int count) : count_(count) { }
};
-class LStoreCodeEntry FINAL: public LTemplateInstruction<0, 2, 0> {
+class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {
public:
LStoreCodeEntry(LOperand* function, LOperand* code_object) {
inputs_[0] = function;
LOperand* function() { return inputs_[0]; }
LOperand* code_object() { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")
DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)
};
-class LInnerAllocatedObject FINAL: public LTemplateInstruction<1, 2, 0> {
+class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {
public:
LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {
inputs_[0] = base_object;
LOperand* base_object() const { return inputs_[0]; }
LOperand* offset() const { return inputs_[1]; }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")
};
-class LThisFunction FINAL : public LTemplateInstruction<1, 0, 0> {
+class LThisFunction final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")
DECLARE_HYDROGEN_ACCESSOR(ThisFunction)
};
-class LContext FINAL : public LTemplateInstruction<1, 0, 0> {
+class LContext final : public LTemplateInstruction<1, 0, 0> {
public:
DECLARE_CONCRETE_INSTRUCTION(Context, "context")
DECLARE_HYDROGEN_ACCESSOR(Context)
};
-class LDeclareGlobals FINAL : public LTemplateInstruction<0, 1, 0> {
+class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LDeclareGlobals(LOperand* context) {
inputs_[0] = context;
};
-class LCallJSFunction FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallJSFunction(LOperand* function) {
inputs_[0] = function;
DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")
DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallWithDescriptor FINAL : public LTemplateResultInstruction<1> {
+class LCallWithDescriptor final : public LTemplateResultInstruction<1> {
public:
LCallWithDescriptor(CallInterfaceDescriptor descriptor,
const ZoneList<LOperand*>& operands, Zone* zone)
private:
DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
ZoneList<LOperand*> inputs_;
// Iterator support.
- int InputCount() FINAL { return inputs_.length(); }
- LOperand* InputAt(int i) FINAL { return inputs_[i]; }
+ int InputCount() final { return inputs_.length(); }
+ LOperand* InputAt(int i) final { return inputs_[i]; }
- int TempCount() FINAL { return 0; }
- LOperand* TempAt(int i) FINAL { return NULL; }
+ int TempCount() final { return 0; }
+ LOperand* TempAt(int i) final { return NULL; }
};
-class LInvokeFunction FINAL : public LTemplateInstruction<1, 2, 0> {
+class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {
public:
LInvokeFunction(LOperand* context, LOperand* function) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")
DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallFunction FINAL : public LTemplateInstruction<1, 2, 2> {
+class LCallFunction final : public LTemplateInstruction<1, 2, 2> {
public:
LCallFunction(LOperand* context, LOperand* function, LOperand* slot,
LOperand* vector) {
DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")
DECLARE_HYDROGEN_ACCESSOR(CallFunction)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNew FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNew final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNew(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")
DECLARE_HYDROGEN_ACCESSOR(CallNew)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallNewArray FINAL : public LTemplateInstruction<1, 2, 0> {
+class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {
public:
LCallNewArray(LOperand* context, LOperand* constructor) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")
DECLARE_HYDROGEN_ACCESSOR(CallNewArray)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
int arity() const { return hydrogen()->argument_count() - 1; }
};
-class LCallRuntime FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCallRuntime(LOperand* context) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")
DECLARE_HYDROGEN_ACCESSOR(CallRuntime)
- bool ClobbersDoubleRegisters(Isolate* isolate) const OVERRIDE {
+ bool ClobbersDoubleRegisters(Isolate* isolate) const override {
return save_doubles() == kDontSaveFPRegs;
}
};
-class LInteger32ToDouble FINAL : public LTemplateInstruction<1, 1, 0> {
+class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LInteger32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LUint32ToDouble FINAL : public LTemplateInstruction<1, 1, 1> {
+class LUint32ToDouble final : public LTemplateInstruction<1, 1, 1> {
public:
explicit LUint32ToDouble(LOperand* value) {
inputs_[0] = value;
};
-class LNumberTagI FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagI final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagI(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LNumberTagU FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagU final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagU(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LNumberTagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberTagD final : public LTemplateInstruction<1, 1, 1> {
public:
LNumberTagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
// Sometimes truncating conversion from a tagged value to an int32.
-class LDoubleToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToI(LOperand* value) {
inputs_[0] = value;
};
-class LDoubleToSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleToSmi(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LTaggedToI FINAL : public LTemplateInstruction<1, 1, 0> {
+class LTaggedToI final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LTaggedToI(LOperand* value) {
inputs_[0] = value;
};
-class LSmiTag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiTag final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LSmiTag(LOperand* value) {
inputs_[0] = value;
};
-class LNumberUntagD FINAL : public LTemplateInstruction<1, 1, 1> {
+class LNumberUntagD final : public LTemplateInstruction<1, 1, 1> {
public:
explicit LNumberUntagD(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LSmiUntag FINAL : public LTemplateInstruction<1, 1, 0> {
+class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {
public:
LSmiUntag(LOperand* value, bool needs_check)
: needs_check_(needs_check) {
};
-class LStoreNamedField FINAL : public LTemplateInstruction<0, 2, 2> {
+class LStoreNamedField final : public LTemplateInstruction<0, 2, 2> {
public:
LStoreNamedField(LOperand* obj,
LOperand* val,
DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LStoreNamedGeneric FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value) {
inputs_[0] = context;
DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Object> name() const { return hydrogen()->name(); }
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LStoreKeyed FINAL : public LTemplateInstruction<0, 3, 0> {
+class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {
public:
LStoreKeyed(LOperand* obj, LOperand* key, LOperand* val) {
inputs_[0] = obj;
DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
uint32_t base_offset() const { return hydrogen()->base_offset(); }
bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }
};
-class LStoreKeyedGeneric FINAL : public LTemplateInstruction<0, 4, 0> {
+class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 0> {
public:
LStoreKeyedGeneric(LOperand* context,
LOperand* object,
DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")
DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
LanguageMode language_mode() { return hydrogen()->language_mode(); }
};
-class LTransitionElementsKind FINAL : public LTemplateInstruction<0, 2, 2> {
+class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {
public:
LTransitionElementsKind(LOperand* object,
LOperand* context,
"transition-elements-kind")
DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
Handle<Map> original_map() { return hydrogen()->original_map().handle(); }
Handle<Map> transitioned_map() {
};
-class LTrapAllocationMemento FINAL : public LTemplateInstruction<0, 1, 1> {
+class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {
public:
LTrapAllocationMemento(LOperand* object,
LOperand* temp) {
};
-class LStringAdd FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringAdd final : public LTemplateInstruction<1, 3, 0> {
public:
LStringAdd(LOperand* context, LOperand* left, LOperand* right) {
inputs_[0] = context;
};
-class LStringCharCodeAt FINAL : public LTemplateInstruction<1, 3, 0> {
+class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {
public:
LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {
inputs_[0] = context;
};
-class LStringCharFromCode FINAL : public LTemplateInstruction<1, 2, 0> {
+class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {
public:
LStringCharFromCode(LOperand* context, LOperand* char_code) {
inputs_[0] = context;
};
-class LCheckValue FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckValue final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckValue(LOperand* value) {
inputs_[0] = value;
};
-class LCheckInstanceType FINAL : public LTemplateInstruction<0, 1, 1> {
+class LCheckInstanceType final : public LTemplateInstruction<0, 1, 1> {
public:
LCheckInstanceType(LOperand* value, LOperand* temp) {
inputs_[0] = value;
};
-class LCheckMaps FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckMaps(LOperand* value = NULL) {
inputs_[0] = value;
};
-class LCheckSmi FINAL : public LTemplateInstruction<1, 1, 0> {
+class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LCheckSmi(LOperand* value) {
inputs_[0] = value;
};
-class LClampDToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampDToUint8(LOperand* value) {
inputs_[0] = value;
};
-class LClampIToUint8 FINAL : public LTemplateInstruction<1, 1, 0> {
+class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LClampIToUint8(LOperand* value) {
inputs_[0] = value;
// Truncating conversion from a tagged value to an int32.
-class LClampTToUint8NoSSE2 FINAL : public LTemplateInstruction<1, 1, 3> {
+class LClampTToUint8NoSSE2 final : public LTemplateInstruction<1, 1, 3> {
public:
LClampTToUint8NoSSE2(LOperand* unclamped,
LOperand* temp1,
};
-class LCheckNonSmi FINAL : public LTemplateInstruction<0, 1, 0> {
+class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LCheckNonSmi(LOperand* value) {
inputs_[0] = value;
};
-class LDoubleBits FINAL : public LTemplateInstruction<1, 1, 0> {
+class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LDoubleBits(LOperand* value) {
inputs_[0] = value;
};
-class LConstructDouble FINAL : public LTemplateInstruction<1, 2, 0> {
+class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {
public:
LConstructDouble(LOperand* hi, LOperand* lo) {
inputs_[0] = hi;
};
-class LAllocate FINAL : public LTemplateInstruction<1, 2, 1> {
+class LAllocate final : public LTemplateInstruction<1, 2, 1> {
public:
LAllocate(LOperand* context, LOperand* size, LOperand* temp) {
inputs_[0] = context;
};
-class LRegExpLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LRegExpLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LFunctionLiteral FINAL : public LTemplateInstruction<1, 1, 0> {
+class LFunctionLiteral final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LFunctionLiteral(LOperand* context) {
inputs_[0] = context;
};
-class LToFastProperties FINAL : public LTemplateInstruction<1, 1, 0> {
+class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LToFastProperties(LOperand* value) {
inputs_[0] = value;
};
-class LTypeof FINAL : public LTemplateInstruction<1, 2, 0> {
+class LTypeof final : public LTemplateInstruction<1, 2, 0> {
public:
LTypeof(LOperand* context, LOperand* value) {
inputs_[0] = context;
};
-class LTypeofIsAndBranch FINAL : public LControlInstruction<1, 0> {
+class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {
public:
explicit LTypeofIsAndBranch(LOperand* value) {
inputs_[0] = value;
Handle<String> type_literal() { return hydrogen()->type_literal(); }
- void PrintDataTo(StringStream* stream) OVERRIDE;
+ void PrintDataTo(StringStream* stream) override;
};
-class LOsrEntry FINAL : public LTemplateInstruction<0, 0, 0> {
+class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {
public:
- bool HasInterestingComment(LCodeGen* gen) const OVERRIDE { return false; }
+ bool HasInterestingComment(LCodeGen* gen) const override { return false; }
DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")
};
-class LStackCheck FINAL : public LTemplateInstruction<0, 1, 0> {
+class LStackCheck final : public LTemplateInstruction<0, 1, 0> {
public:
explicit LStackCheck(LOperand* context) {
inputs_[0] = context;
};
-class LForInPrepareMap FINAL : public LTemplateInstruction<1, 2, 0> {
+class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {
public:
LForInPrepareMap(LOperand* context, LOperand* object) {
inputs_[0] = context;
};
-class LForInCacheArray FINAL : public LTemplateInstruction<1, 1, 0> {
+class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {
public:
explicit LForInCacheArray(LOperand* map) {
inputs_[0] = map;
};
-class LCheckMapValue FINAL : public LTemplateInstruction<0, 2, 0> {
+class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {
public:
LCheckMapValue(LOperand* value, LOperand* map) {
inputs_[0] = value;
};
-class LLoadFieldByIndex FINAL : public LTemplateInstruction<1, 2, 0> {
+class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {
public:
LLoadFieldByIndex(LOperand* object, LOperand* index) {
inputs_[0] = object;
class LChunkBuilder;
-class LPlatformChunk FINAL : public LChunk {
+class LPlatformChunk final : public LChunk {
public:
LPlatformChunk(CompilationInfo* info, HGraph* graph)
: LChunk(info, graph),
};
-class LChunkBuilder FINAL : public LChunkBuilderBase {
+class LChunkBuilder final : public LChunkBuilderBase {
public:
LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)
: LChunkBuilderBase(info, graph),
// An input operand in register, stack slot or a constant operand.
// Will not be moved to a register even if one is freely available.
- MUST_USE_RESULT LOperand* UseAny(HValue* value) OVERRIDE;
+ MUST_USE_RESULT LOperand* UseAny(HValue* value) override;
// Temporary operand that must be in a register.
MUST_USE_RESULT LUnallocated* TempRegister();
//
// Note: The implementation is inherently not thread safe. Do not use
// from multi-threaded code.
-class Zone FINAL {
+class Zone final {
public:
Zone();
~Zone();
// The ZoneScope is used to automatically call DeleteAll() on a
// Zone when the ZoneScope is destroyed (i.e. goes out of scope)
-class ZoneScope FINAL {
+class ZoneScope final {
public:
explicit ZoneScope(Zone* zone) : zone_(zone) { }
~ZoneScope() { zone_->DeleteAll(); }
// The ZoneAllocationPolicy is used to specialize generic data
// structures to allocate themselves and their elements in the Zone.
-class ZoneAllocationPolicy FINAL {
+class ZoneAllocationPolicy final {
public:
explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) { }
void* New(size_t size) { return zone()->New(size); }
// Zone. ZoneLists cannot be deleted individually; you can delete all
// objects in the Zone by calling Zone::DeleteAll().
template <typename T>
-class ZoneList FINAL : public List<T, ZoneAllocationPolicy> {
+class ZoneList final : public List<T, ZoneAllocationPolicy> {
public:
// Construct a new ZoneList with the given capacity; the length is
// always zero. The capacity must be non-negative.
// different configurations of a concrete splay tree (see splay-tree.h).
// The tree itself and all its elements are allocated in the Zone.
template <typename Config>
-class ZoneSplayTree FINAL : public SplayTree<Config, ZoneAllocationPolicy> {
+class ZoneSplayTree final : public SplayTree<Config, ZoneAllocationPolicy> {
public:
explicit ZoneSplayTree(Zone* zone)
: SplayTree<Config, ZoneAllocationPolicy>(ZoneAllocationPolicy(zone)) {}
protected:
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs, bool incomplete) FINAL {
+ Node** value_inputs, bool incomplete) final {
return graph()->NewNode(op, value_input_count, value_inputs, incomplete);
}
};
protected:
virtual Node* MakeNode(const Operator* op, int value_input_count,
- Node** value_inputs, bool incomplete) FINAL;
+ Node** value_inputs, bool incomplete) final;
private:
Node* effect_;
explicit MoveInterpreter(Zone* zone) : zone_(zone) {}
virtual void AssembleMove(InstructionOperand* source,
- InstructionOperand* destination) OVERRIDE {
+ InstructionOperand* destination) override {
ParallelMove* moves = new (zone_) ParallelMove(zone_);
moves->AddMove(*source, *destination);
state_.ExecuteInParallel(moves);
}
virtual void AssembleSwap(InstructionOperand* source,
- InstructionOperand* destination) OVERRIDE {
+ InstructionOperand* destination) override {
ParallelMove* moves = new (zone_) ParallelMove(zone_);
moves->AddMove(*source, *destination);
moves->AddMove(*destination, *source);
StringLengthStubTF(uint32_t key, Isolate* isolate) : CodeStub(key, isolate) {}
- CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+ CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
return LoadDescriptor(isolate());
};
- Handle<Code> GenerateCode() OVERRIDE {
+ Handle<Code> GenerateCode() override {
Zone zone;
// Build a "hybrid" CompilationInfo for a JSFunction/CodeStub pair.
ParseInfo parse_info(&zone, GetFunction(isolate(), "STRING_LENGTH_STUB"));
return Pipeline(&info).GenerateCode();
}
- Major MajorKey() const OVERRIDE { return StringLength; };
- Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
- InlineCacheState GetICState() const OVERRIDE { return MONOMORPHIC; }
- ExtraICState GetExtraICState() const OVERRIDE { return Code::LOAD_IC; }
- Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+ Major MajorKey() const override { return StringLength; };
+ Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+ InlineCacheState GetICState() const override { return MONOMORPHIC; }
+ ExtraICState GetExtraICState() const override { return Code::LOAD_IC; }
+ Code::StubType GetStubType() const override { return Code::FAST; }
private:
DISALLOW_COPY_AND_ASSIGN(StringLengthStubTF);
// The Wait() call blocks a thread until it is called for the Nth time, then all
// calls return. Each ThreadBarrier object can only be used once.
template <int N>
-class ThreadBarrier FINAL {
+class ThreadBarrier final {
public:
ThreadBarrier() : num_blocked_(0) {}
namespace {
-class ThreadWithMutexAndConditionVariable FINAL : public Thread {
+class ThreadWithMutexAndConditionVariable final : public Thread {
public:
ThreadWithMutexAndConditionVariable()
: Thread(Options("ThreadWithMutexAndConditionVariable")),
finished_(false) {}
virtual ~ThreadWithMutexAndConditionVariable() {}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
LockGuard<Mutex> lock_guard(&mutex_);
running_ = true;
cv_.NotifyOne();
namespace {
-class ThreadWithSharedMutexAndConditionVariable FINAL : public Thread {
+class ThreadWithSharedMutexAndConditionVariable final : public Thread {
public:
ThreadWithSharedMutexAndConditionVariable()
: Thread(Options("ThreadWithSharedMutexAndConditionVariable")),
mutex_(NULL) {}
virtual ~ThreadWithSharedMutexAndConditionVariable() {}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
LockGuard<Mutex> lock_guard(mutex_);
running_ = true;
cv_->NotifyAll();
namespace {
-class LoopIncrementThread FINAL : public Thread {
+class LoopIncrementThread final : public Thread {
public:
LoopIncrementThread(int rem, int* counter, int limit, int thread_count,
ConditionVariable* cv, Mutex* mutex)
EXPECT_EQ(0, limit % thread_count);
}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
int last_count = -1;
while (true) {
LockGuard<Mutex> lock_guard(mutex_);
}
}
- void Run() FINAL {
+ void Run() final {
for (size_t i = 0; i < arraysize(keys_); i++) {
CHECK(!Thread::HasThreadLocal(keys_[i]));
}
static const size_t kDataSize = kBufferSize * kAlphabetSize * 10;
-class ProducerThread FINAL : public Thread {
+class ProducerThread final : public Thread {
public:
ProducerThread(char* buffer, Semaphore* free_space, Semaphore* used_space)
: Thread(Options("ProducerThread")),
used_space_(used_space) {}
virtual ~ProducerThread() {}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
for (size_t n = 0; n < kDataSize; ++n) {
free_space_->Wait();
buffer_[n % kBufferSize] = kAlphabet[n % kAlphabetSize];
};
-class ConsumerThread FINAL : public Thread {
+class ConsumerThread final : public Thread {
public:
ConsumerThread(const char* buffer, Semaphore* free_space,
Semaphore* used_space)
used_space_(used_space) {}
virtual ~ConsumerThread() {}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
for (size_t n = 0; n < kDataSize; ++n) {
used_space_->Wait();
EXPECT_EQ(kAlphabet[n % kAlphabetSize], buffer_[n % kBufferSize]);
};
-class WaitAndSignalThread FINAL : public Thread {
+class WaitAndSignalThread final : public Thread {
public:
explicit WaitAndSignalThread(Semaphore* semaphore)
: Thread(Options("WaitAndSignalThread")), semaphore_(semaphore) {}
virtual ~WaitAndSignalThread() {}
- virtual void Run() OVERRIDE {
+ virtual void Run() override {
for (int n = 0; n < 100; ++n) {
semaphore_->Wait();
ASSERT_FALSE(semaphore_->WaitFor(TimeDelta::FromMicroseconds(1)));
: public ChangeLoweringTest,
public ::testing::WithParamInterface<MachineType> {
public:
- ~ChangeLoweringCommonTest() OVERRIDE {}
+ ~ChangeLoweringCommonTest() override {}
- MachineType WordRepresentation() const FINAL { return GetParam(); }
+ MachineType WordRepresentation() const final { return GetParam(); }
};
class ChangeLowering32Test : public ChangeLoweringTest {
public:
- ~ChangeLowering32Test() OVERRIDE {}
- MachineType WordRepresentation() const FINAL { return kRepWord32; }
+ ~ChangeLowering32Test() override {}
+ MachineType WordRepresentation() const final { return kRepWord32; }
};
class ChangeLowering64Test : public ChangeLoweringTest {
public:
- ~ChangeLowering64Test() OVERRIDE {}
- MachineType WordRepresentation() const FINAL { return kRepWord64; }
+ ~ChangeLowering64Test() override {}
+ MachineType WordRepresentation() const final { return kRepWord64; }
};
public:
explicit CommonOperatorReducerTest(int num_parameters = 1)
: GraphTest(num_parameters), machine_(zone()) {}
- ~CommonOperatorReducerTest() OVERRIDE {}
+ ~CommonOperatorReducerTest() override {}
protected:
Reduction Reduce(Node* node, MachineOperatorBuilder::Flags flags =
class CommonOperatorTest : public TestWithZone {
public:
CommonOperatorTest() : common_(zone()) {}
- ~CommonOperatorTest() OVERRIDE {}
+ ~CommonOperatorTest() override {}
CommonOperatorBuilder* common() { return &common_; }
machine_(zone()),
javascript_(zone()),
jsgraph_(isolate(), graph(), common(), javascript(), machine()) {}
- ~ControlFlowOptimizerTest() OVERRIDE {}
+ ~ControlFlowOptimizerTest() override {}
protected:
void Optimize() {
// Wraps all "kOpA0" nodes in "kOpB1" operators by allocating new nodes.
-class A0Wrapper FINAL : public Reducer {
+class A0Wrapper final : public Reducer {
public:
explicit A0Wrapper(Graph* graph) : graph_(graph) {}
- virtual Reduction Reduce(Node* node) OVERRIDE {
+ virtual Reduction Reduce(Node* node) override {
switch (node->op()->opcode()) {
case kOpcodeA0:
EXPECT_EQ(0, node->InputCount());
// Wraps all "kOpB0" nodes in two "kOpC1" operators by allocating new nodes.
-class B0Wrapper FINAL : public Reducer {
+class B0Wrapper final : public Reducer {
public:
explicit B0Wrapper(Graph* graph) : graph_(graph) {}
- virtual Reduction Reduce(Node* node) OVERRIDE {
+ virtual Reduction Reduce(Node* node) override {
switch (node->op()->opcode()) {
case kOpcodeB0:
EXPECT_EQ(0, node->InputCount());
class GraphTest : public TestWithContext, public TestWithIsolateAndZone {
public:
explicit GraphTest(int num_parameters = 1);
- ~GraphTest() OVERRIDE;
+ ~GraphTest() override;
protected:
Node* start() { return graph()->start(); }
class TypedGraphTest : public GraphTest {
public:
explicit TypedGraphTest(int num_parameters = 1);
- ~TypedGraphTest() OVERRIDE;
+ ~TypedGraphTest() override;
protected:
Node* Parameter(int32_t index = 0) { return GraphTest::Parameter(index); }
public TestWithIsolateAndZone {
public:
InstructionSelectorTest();
- ~InstructionSelectorTest() OVERRIDE;
+ ~InstructionSelectorTest() override;
base::RandomNumberGenerator* rng() { return &rng_; }
kAllExceptNopInstructions
};
- class StreamBuilder FINAL : public RawMachineAssembler {
+ class StreamBuilder final : public RawMachineAssembler {
public:
StreamBuilder(InstructionSelectorTest* test, MachineType return_type)
: RawMachineAssembler(test->isolate(),
InstructionSelectorTest* test_;
};
- class Stream FINAL {
+ class Stream final {
public:
size_t size() const { return instructions_.size(); }
const Instruction* operator[](size_t index) const {
class JSIntrinsicLoweringTest : public GraphTest {
public:
JSIntrinsicLoweringTest() : GraphTest(3), javascript_(zone()) {}
- ~JSIntrinsicLoweringTest() OVERRIDE {}
+ ~JSIntrinsicLoweringTest() override {}
protected:
Reduction Reduce(Node* node, MachineOperatorBuilder::Flags flags =
class JSTypedLoweringTest : public TypedGraphTest {
public:
JSTypedLoweringTest() : TypedGraphTest(3), javascript_(zone()) {}
- ~JSTypedLoweringTest() OVERRIDE {}
+ ~JSTypedLoweringTest() override {}
protected:
Reduction Reduce(Node* node) {
locals_count_(locals_count),
replacement_(replacement) {}
- void DescribeTo(std::ostream* os) const OVERRIDE {
+ void DescribeTo(std::ostream* os) const override {
*os << "is a frame state with '" << liveness_
<< "' liveness, empty "
"parameters and empty expression stack";
}
bool MatchAndExplain(Node* frame_state,
- MatchResultListener* listener) const OVERRIDE {
+ MatchResultListener* listener) const override {
if (frame_state == NULL) {
*listener << "which is NULL";
return false;
class LoadEliminationTest : public GraphTest {
public:
LoadEliminationTest() : GraphTest(3), simplified_(zone()) {}
- ~LoadEliminationTest() OVERRIDE {}
+ ~LoadEliminationTest() override {}
protected:
Reduction Reduce(Node* node) {
class LoopPeelingTest : public GraphTest {
public:
LoopPeelingTest() : GraphTest(1), machine_(zone()) {}
- ~LoopPeelingTest() OVERRIDE {}
+ ~LoopPeelingTest() override {}
protected:
MachineOperatorBuilder machine_;
public:
explicit MachineOperatorReducerTestWithParam(int num_parameters = 2)
: MachineOperatorReducerTest(num_parameters) {}
- ~MachineOperatorReducerTestWithParam() OVERRIDE {}
+ ~MachineOperatorReducerTestWithParam() override {}
};
class NodeMatcherTest : public GraphTest {
public:
NodeMatcherTest() : machine_(zone()) {}
- ~NodeMatcherTest() OVERRIDE {}
+ ~NodeMatcherTest() override {}
MachineOperatorBuilder* machine() { return &machine_; }
public:
explicit NodeMatcher(IrOpcode::Value opcode) : opcode_(opcode) {}
- void DescribeTo(std::ostream* os) const OVERRIDE {
+ void DescribeTo(std::ostream* os) const override {
*os << "is a " << IrOpcode::Mnemonic(opcode_) << " node";
}
bool MatchAndExplain(Node* node,
- MatchResultListener* listener) const OVERRIDE {
+ MatchResultListener* listener) const override {
if (node == NULL) {
*listener << "which is NULL";
return false;
};
-class IsBranchMatcher FINAL : public NodeMatcher {
+class IsBranchMatcher final : public NodeMatcher {
public:
IsBranchMatcher(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& control_matcher)
value_matcher_(value_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
};
-class IsSwitchMatcher FINAL : public NodeMatcher {
+class IsSwitchMatcher final : public NodeMatcher {
public:
IsSwitchMatcher(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& control_matcher)
value_matcher_(value_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
};
-class IsIfValueMatcher FINAL : public NodeMatcher {
+class IsIfValueMatcher final : public NodeMatcher {
public:
IsIfValueMatcher(const Matcher<int32_t>& value_matcher,
const Matcher<Node*>& control_matcher)
value_matcher_(value_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<int32_t>(node->op()), "value",
value_matcher_, listener) &&
};
-class IsControl1Matcher FINAL : public NodeMatcher {
+class IsControl1Matcher final : public NodeMatcher {
public:
IsControl1Matcher(IrOpcode::Value opcode,
const Matcher<Node*>& control_matcher)
: NodeMatcher(opcode), control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose control (";
control_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node),
"control", control_matcher_, listener));
};
-class IsControl2Matcher FINAL : public NodeMatcher {
+class IsControl2Matcher final : public NodeMatcher {
public:
IsControl2Matcher(IrOpcode::Value opcode,
const Matcher<Node*>& control0_matcher,
control0_matcher_(control0_matcher),
control1_matcher_(control1_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose control0 (";
control0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
"control0", control0_matcher_, listener) &&
};
-class IsControl3Matcher FINAL : public NodeMatcher {
+class IsControl3Matcher final : public NodeMatcher {
public:
IsControl3Matcher(IrOpcode::Value opcode,
const Matcher<Node*>& control0_matcher,
control1_matcher_(control1_matcher),
control2_matcher_(control2_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose control0 (";
control0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetControlInput(node, 0),
"control0", control0_matcher_, listener) &&
};
-class IsFinishMatcher FINAL : public NodeMatcher {
+class IsFinishMatcher final : public NodeMatcher {
public:
IsFinishMatcher(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& effect_matcher)
value_matcher_(value_matcher),
effect_matcher_(effect_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
};
-class IsReturnMatcher FINAL : public NodeMatcher {
+class IsReturnMatcher final : public NodeMatcher {
public:
IsReturnMatcher(const Matcher<Node*>& value_matcher,
const Matcher<Node*>& effect_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"value", value_matcher_, listener) &&
template <typename T>
-class IsConstantMatcher FINAL : public NodeMatcher {
+class IsConstantMatcher final : public NodeMatcher {
public:
IsConstantMatcher(IrOpcode::Value opcode, const Matcher<T>& value_matcher)
: NodeMatcher(opcode), value_matcher_(value_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value (";
value_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<T>(node), "value", value_matcher_,
listener));
};
-class IsSelectMatcher FINAL : public NodeMatcher {
+class IsSelectMatcher final : public NodeMatcher {
public:
IsSelectMatcher(const Matcher<MachineType>& type_matcher,
const Matcher<Node*>& value0_matcher,
value1_matcher_(value1_matcher),
value2_matcher_(value2_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose type (";
type_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
type_matcher_, listener) &&
};
-class IsPhiMatcher FINAL : public NodeMatcher {
+class IsPhiMatcher final : public NodeMatcher {
public:
IsPhiMatcher(const Matcher<MachineType>& type_matcher,
const Matcher<Node*>& value0_matcher,
value1_matcher_(value1_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose type (";
type_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
type_matcher_, listener) &&
};
-class IsPhi2Matcher FINAL : public NodeMatcher {
+class IsPhi2Matcher final : public NodeMatcher {
public:
IsPhi2Matcher(const Matcher<MachineType>& type_matcher,
const Matcher<Node*>& value0_matcher,
value2_matcher_(value2_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose type (";
type_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<MachineType>(node), "type",
type_matcher_, listener) &&
};
-class IsEffectPhiMatcher FINAL : public NodeMatcher {
+class IsEffectPhiMatcher final : public NodeMatcher {
public:
IsEffectPhiMatcher(const Matcher<Node*>& effect0_matcher,
const Matcher<Node*>& effect1_matcher,
effect1_matcher_(effect1_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << "), effect0 (";
effect0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetEffectInput(node, 0),
"effect0", effect0_matcher_, listener) &&
};
-class IsEffectSetMatcher FINAL : public NodeMatcher {
+class IsEffectSetMatcher final : public NodeMatcher {
public:
IsEffectSetMatcher(const Matcher<Node*>& effect0_matcher,
const Matcher<Node*>& effect1_matcher)
effect0_matcher_(effect0_matcher),
effect1_matcher_(effect1_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << "), effect0 (";
effect0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
if (!NodeMatcher::MatchAndExplain(node, listener)) return false;
Node* effect0 = NodeProperties::GetEffectInput(node, 0);
};
-class IsProjectionMatcher FINAL : public NodeMatcher {
+class IsProjectionMatcher final : public NodeMatcher {
public:
IsProjectionMatcher(const Matcher<size_t>& index_matcher,
const Matcher<Node*>& base_matcher)
index_matcher_(index_matcher),
base_matcher_(base_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose index (";
index_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<size_t>(node), "index",
index_matcher_, listener) &&
};
-class IsCall2Matcher FINAL : public NodeMatcher {
+class IsCall2Matcher final : public NodeMatcher {
public:
IsCall2Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
const Matcher<Node*>& value0_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value0 (";
value0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
"descriptor", descriptor_matcher_, listener) &&
};
-class IsCall4Matcher FINAL : public NodeMatcher {
+class IsCall4Matcher final : public NodeMatcher {
public:
IsCall4Matcher(const Matcher<CallDescriptor*>& descriptor_matcher,
const Matcher<Node*>& value0_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose value0 (";
value0_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
"descriptor", descriptor_matcher_, listener) &&
};
-class IsLoadFieldMatcher FINAL : public NodeMatcher {
+class IsLoadFieldMatcher final : public NodeMatcher {
public:
IsLoadFieldMatcher(const Matcher<FieldAccess>& access_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
access_matcher_, listener) &&
};
-class IsStoreFieldMatcher FINAL : public NodeMatcher {
+class IsStoreFieldMatcher final : public NodeMatcher {
public:
IsStoreFieldMatcher(const Matcher<FieldAccess>& access_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<FieldAccess>(node), "access",
access_matcher_, listener) &&
};
-class IsLoadBufferMatcher FINAL : public NodeMatcher {
+class IsLoadBufferMatcher final : public NodeMatcher {
public:
IsLoadBufferMatcher(const Matcher<BufferAccess>& access_matcher,
const Matcher<Node*>& buffer_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
access_matcher_, listener) &&
};
-class IsStoreBufferMatcher FINAL : public NodeMatcher {
+class IsStoreBufferMatcher final : public NodeMatcher {
public:
IsStoreBufferMatcher(const Matcher<BufferAccess>& access_matcher,
const Matcher<Node*>& buffer_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(BufferAccessOf(node->op()), "access",
access_matcher_, listener) &&
};
-class IsLoadElementMatcher FINAL : public NodeMatcher {
+class IsLoadElementMatcher final : public NodeMatcher {
public:
IsLoadElementMatcher(const Matcher<ElementAccess>& access_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
access_matcher_, listener) &&
};
-class IsStoreElementMatcher FINAL : public NodeMatcher {
+class IsStoreElementMatcher final : public NodeMatcher {
public:
IsStoreElementMatcher(const Matcher<ElementAccess>& access_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose access (";
access_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<ElementAccess>(node), "access",
access_matcher_, listener) &&
};
-class IsLoadMatcher FINAL : public NodeMatcher {
+class IsLoadMatcher final : public NodeMatcher {
public:
IsLoadMatcher(const Matcher<LoadRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose rep (";
rep_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<LoadRepresentation>(node), "rep",
rep_matcher_, listener) &&
};
-class IsToNumberMatcher FINAL : public NodeMatcher {
+class IsToNumberMatcher final : public NodeMatcher {
public:
IsToNumberMatcher(const Matcher<Node*>& base_matcher,
const Matcher<Node*>& context_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose base (";
base_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
base_matcher_, listener) &&
};
-class IsStoreMatcher FINAL : public NodeMatcher {
+class IsStoreMatcher final : public NodeMatcher {
public:
IsStoreMatcher(const Matcher<StoreRepresentation>& rep_matcher,
const Matcher<Node*>& base_matcher,
effect_matcher_(effect_matcher),
control_matcher_(control_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose rep (";
rep_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(OpParameter<StoreRepresentation>(node), "rep",
rep_matcher_, listener) &&
};
-class IsBinopMatcher FINAL : public NodeMatcher {
+class IsBinopMatcher final : public NodeMatcher {
public:
IsBinopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& lhs_matcher,
const Matcher<Node*>& rhs_matcher)
lhs_matcher_(lhs_matcher),
rhs_matcher_(rhs_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose lhs (";
lhs_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "lhs",
lhs_matcher_, listener) &&
};
-class IsUnopMatcher FINAL : public NodeMatcher {
+class IsUnopMatcher final : public NodeMatcher {
public:
IsUnopMatcher(IrOpcode::Value opcode, const Matcher<Node*>& input_matcher)
: NodeMatcher(opcode), input_matcher_(input_matcher) {}
- void DescribeTo(std::ostream* os) const FINAL {
+ void DescribeTo(std::ostream* os) const final {
NodeMatcher::DescribeTo(os);
*os << " whose input (";
input_matcher_.DescribeTo(os);
*os << ")";
}
- bool MatchAndExplain(Node* node, MatchResultListener* listener) const FINAL {
+ bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
return (NodeMatcher::MatchAndExplain(node, listener) &&
PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
"input", input_matcher_, listener));
public:
explicit SimplifiedOperatorReducerTest(int num_parameters = 1)
: TypedGraphTest(num_parameters), simplified_(zone()) {}
- ~SimplifiedOperatorReducerTest() OVERRIDE {}
+ ~SimplifiedOperatorReducerTest() override {}
protected:
Reduction Reduce(Node* node) {
public:
explicit SimplifiedOperatorReducerTestWithParam(int num_parameters = 1)
: SimplifiedOperatorReducerTest(num_parameters) {}
- ~SimplifiedOperatorReducerTestWithParam() OVERRIDE {}
+ ~SimplifiedOperatorReducerTestWithParam() override {}
};
};
-class TaskQueueThread FINAL : public base::Thread {
+class TaskQueueThread final : public base::Thread {
public:
explicit TaskQueueThread(TaskQueue* queue)
: Thread(Options("libplatform TaskQueueThread")), queue_(queue) {}
- virtual void Run() OVERRIDE { EXPECT_THAT(queue_->GetNext(), IsNull()); }
+ virtual void Run() override { EXPECT_THAT(queue_->GetNext(), IsNull()); }
private:
TaskQueue* queue_;
namespace {
-class DefaultPlatformEnvironment FINAL : public ::testing::Environment {
+class DefaultPlatformEnvironment final : public ::testing::Environment {
public:
DefaultPlatformEnvironment() : platform_(NULL) {}
~DefaultPlatformEnvironment() {}
- virtual void SetUp() OVERRIDE {
+ virtual void SetUp() override {
EXPECT_EQ(NULL, platform_);
platform_ = v8::platform::CreateDefaultPlatform();
ASSERT_TRUE(platform_ != NULL);
ASSERT_TRUE(v8::V8::Initialize());
}
- virtual void TearDown() OVERRIDE {
+ virtual void TearDown() override {
ASSERT_TRUE(platform_ != NULL);
v8::V8::Dispose();
v8::V8::ShutdownPlatform();
projects / platform / upstream / v8.git / commitdiff