Changeset 261556 in webkit


Ignore:
Timestamp:
May 12, 2020 9:12:21 AM (4 years ago)
Author:
Truitt Savell
Message:

Unreviewed, reverting r261542.

Broke internal builds

Reverted changeset:

"[clang-tidy] Run modernize-use-override over JSC, then ensure
as much as possible is final"
​https://bugs.webkit.org/show_bug.cgi?id=211743
​https://trac.webkit.org/changeset/261542

Location:
trunk/Source/JavaScriptCore
Files:
68 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/JSScriptRef.cpp

    r261542 r261556  
    4040using namespace JSC;
    4141
    42 struct OpaqueJSScript final : public SourceProvider {
     42struct OpaqueJSScript : public SourceProvider {
    4343public:
    4444    static WTF::Ref<OpaqueJSScript> create(VM& vm, const SourceOrigin& sourceOrigin, URL&& url, int startingLineNumber, const String& source)
    … …  
    4747    }
    4848
    49     unsigned hash() const final
     49    unsigned hash() const override
    5050    {
    5151        return m_source.get().hash();
    5252    }
    5353
    54     StringView source() const final
     54    StringView source() const override
    5555    {
    5656        return m_source.get();
    … …  
    6767    }
    6868
    69     ~OpaqueJSScript() final { }
     69    virtual ~OpaqueJSScript() { }
    7070
    7171    VM& m_vm;

  • trunk/Source/JavaScriptCore/ChangeLog

    r261549 r261556  
     12020-05-12  Truitt Savell  <tsavell@apple.com>
     2
     3        Unreviewed, reverting r261542.
     4
     5        Broke internal builds
     6
     7        Reverted changeset:
     8
     9        "[clang-tidy] Run modernize-use-override over JSC, then ensure
     10        as much as possible is final"
     11        https://bugs.webkit.org/show_bug.cgi?id=211743
     12        https://trac.webkit.org/changeset/261542
     13
    1142020-05-12  Mark Lam  <mark.lam@apple.com>
    215

  • trunk/Source/JavaScriptCore/b3/B3ArgumentRegValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE ArgumentRegValue final : public Value {
     35class JS_EXPORT_PRIVATE ArgumentRegValue : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == ArgumentReg; }
    3838   
    39     ~ArgumentRegValue() final;
     39    ~ArgumentRegValue();
    4040
    4141    Reg argumentReg() const { return m_reg; }
    … …  
    4343    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
    4444
     45protected:
     46    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     47
    4548private:
    46     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    47 
    4849    friend class Procedure;
    4950    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3AtomicValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE AtomicValue final : public MemoryValue {
     35class JS_EXPORT_PRIVATE AtomicValue : public MemoryValue {
    3636public:
    3737    static bool accepts(Kind kind)
    … …  
    4040    }
    4141   
    42     ~AtomicValue() final;
     42    ~AtomicValue();
    4343   
    4444    Type accessType() const { return child(0)->type(); }
    … …  
    4848    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4949   
     50protected:
     51    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     52
    5053private:
    51     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    52 
    5354    friend class Procedure;
    5455    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3CCallValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE CCallValue final : public Value {
     35class JS_EXPORT_PRIVATE CCallValue : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == CCall; }
    3838
    39     ~CCallValue() final;
     39    ~CCallValue();
    4040
    4141    void appendArgs(const Vector<Value*>&);

  • trunk/Source/JavaScriptCore/b3/B3CheckSpecial.h

    r261542 r261556  
    4949// - CheckMul(a, b), which turns into Mul32 b, a but we pass Any for a's ValueRep.
    5050
    51 class CheckSpecial final : public StackmapSpecial {
     51class CheckSpecial : public StackmapSpecial {
    5252public:
    5353    // Support for hash consing these things.
    … …  
    114114    CheckSpecial(Air::Kind, unsigned numArgs, RoleMode stackmapRole = SameAsRep);
    115115    CheckSpecial(const Key&);
    116     ~CheckSpecial() final;
     116    ~CheckSpecial();
    117117
    118 private:
     118protected:
    119119    // Constructs and returns the Inst representing the branch that this will use.
    120120    Air::Inst hiddenBranch(const Air::Inst&) const;
    … …  
    134134    void deepDumpImpl(PrintStream&) const final;
    135135
     136private:
    136137    Air::Kind m_checkKind;
    137138    RoleMode m_stackmapRole;

  • trunk/Source/JavaScriptCore/b3/B3CheckValue.h

    r261542 r261556  
    3232namespace JSC { namespace B3 {
    3333
    34 class CheckValue final : public StackmapValue {
     34class CheckValue : public StackmapValue {
    3535public:
    3636    static bool accepts(Kind kind)
    … …  
    4747    }
    4848
    49     ~CheckValue() final;
     49    ~CheckValue();
    5050
    5151    void convertToAdd();

  • trunk/Source/JavaScriptCore/b3/B3Const32Value.h

    r261542 r261556  
    3636    static bool accepts(Kind kind) { return kind == Const32; }
    3737   
    38     ~Const32Value() override;
     38    ~Const32Value();
    3939   
    4040    int32_t value() const { return m_value; }

  • trunk/Source/JavaScriptCore/b3/B3Const64Value.h

    r261542 r261556  
    3636    static bool accepts(Kind kind) { return kind == Const64; }
    3737   
    38     ~Const64Value() override;
     38    ~Const64Value();
    3939   
    4040    int64_t value() const { return m_value; }

  • trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h

    r261542 r261556  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE ConstDoubleValue final : public Value {
     34class JS_EXPORT_PRIVATE ConstDoubleValue : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == ConstDouble; }
    3737   
    38     ~ConstDoubleValue() final;
     38    ~ConstDoubleValue();
    3939   
    4040    double value() const { return m_value; }
    4141
    42     Value* negConstant(Procedure&) const final;
    43     Value* addConstant(Procedure&, int32_t other) const final;
    44     Value* addConstant(Procedure&, const Value* other) const final;
    45     Value* subConstant(Procedure&, const Value* other) const final;
    46     Value* divConstant(Procedure&, const Value* other) const final;
    47     Value* modConstant(Procedure&, const Value* other) const final;
    48     Value* mulConstant(Procedure&, const Value* other) const final;
    49     Value* bitAndConstant(Procedure&, const Value* other) const final;
    50     Value* bitOrConstant(Procedure&, const Value* other) const final;
    51     Value* bitXorConstant(Procedure&, const Value* other) const final;
    52     Value* bitwiseCastConstant(Procedure&) const final;
    53     Value* doubleToFloatConstant(Procedure&) const final;
    54     Value* absConstant(Procedure&) const final;
    55     Value* ceilConstant(Procedure&) const final;
    56     Value* floorConstant(Procedure&) const final;
    57     Value* sqrtConstant(Procedure&) const final;
     42    Value* negConstant(Procedure&) const override;
     43    Value* addConstant(Procedure&, int32_t other) const override;
     44    Value* addConstant(Procedure&, const Value* other) const override;
     45    Value* subConstant(Procedure&, const Value* other) const override;
     46    Value* divConstant(Procedure&, const Value* other) const override;
     47    Value* modConstant(Procedure&, const Value* other) const override;
     48    Value* mulConstant(Procedure&, const Value* other) const override;
     49    Value* bitAndConstant(Procedure&, const Value* other) const override;
     50    Value* bitOrConstant(Procedure&, const Value* other) const override;
     51    Value* bitXorConstant(Procedure&, const Value* other) const override;
     52    Value* bitwiseCastConstant(Procedure&) const override;
     53    Value* doubleToFloatConstant(Procedure&) const override;
     54    Value* absConstant(Procedure&) const override;
     55    Value* ceilConstant(Procedure&) const override;
     56    Value* floorConstant(Procedure&) const override;
     57    Value* sqrtConstant(Procedure&) const override;
    5858
    59     TriState equalConstant(const Value* other) const final;
    60     TriState notEqualConstant(const Value* other) const final;
    61     TriState lessThanConstant(const Value* other) const final;
    62     TriState greaterThanConstant(const Value* other) const final;
    63     TriState lessEqualConstant(const Value* other) const final;
    64     TriState greaterEqualConstant(const Value* other) const final;
    65     TriState equalOrUnorderedConstant(const Value* other) const final;
     59    TriState equalConstant(const Value* other) const override;
     60    TriState notEqualConstant(const Value* other) const override;
     61    TriState lessThanConstant(const Value* other) const override;
     62    TriState greaterThanConstant(const Value* other) const override;
     63    TriState lessEqualConstant(const Value* other) const override;
     64    TriState greaterEqualConstant(const Value* other) const override;
     65    TriState equalOrUnorderedConstant(const Value* other) const override;
    6666
    6767    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
    … …  
    7171    friend class Value;
    7272
    73     void dumpMeta(CommaPrinter&, PrintStream&) const final;
     73    void dumpMeta(CommaPrinter&, PrintStream&) const override;
    7474
    7575    static Opcode opcodeFromConstructor(Origin, double) { return ConstDouble; }

  • trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h

    r261542 r261556  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE ConstFloatValue final : public Value {
     34class JS_EXPORT_PRIVATE ConstFloatValue : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == ConstFloat; }
    3737
    38     ~ConstFloatValue() final;
     38    ~ConstFloatValue();
    3939
    4040    float value() const { return m_value; }
    4141
    42     Value* negConstant(Procedure&) const final;
    43     Value* addConstant(Procedure&, int32_t other) const final;
    44     Value* addConstant(Procedure&, const Value* other) const final;
    45     Value* subConstant(Procedure&, const Value* other) const final;
    46     Value* divConstant(Procedure&, const Value* other) const final;
    47     Value* mulConstant(Procedure&, const Value* other) const final;
    48     Value* bitAndConstant(Procedure&, const Value* other) const final;
    49     Value* bitOrConstant(Procedure&, const Value* other) const final;
    50     Value* bitXorConstant(Procedure&, const Value* other) const final;
    51     Value* bitwiseCastConstant(Procedure&) const final;
    52     Value* floatToDoubleConstant(Procedure&) const final;
    53     Value* absConstant(Procedure&) const final;
    54     Value* ceilConstant(Procedure&) const final;
    55     Value* floorConstant(Procedure&) const final;
    56     Value* sqrtConstant(Procedure&) const final;
     42    Value* negConstant(Procedure&) const override;
     43    Value* addConstant(Procedure&, int32_t other) const override;
     44    Value* addConstant(Procedure&, const Value* other) const override;
     45    Value* subConstant(Procedure&, const Value* other) const override;
     46    Value* divConstant(Procedure&, const Value* other) const override;
     47    Value* mulConstant(Procedure&, const Value* other) const override;
     48    Value* bitAndConstant(Procedure&, const Value* other) const override;
     49    Value* bitOrConstant(Procedure&, const Value* other) const override;
     50    Value* bitXorConstant(Procedure&, const Value* other) const override;
     51    Value* bitwiseCastConstant(Procedure&) const override;
     52    Value* floatToDoubleConstant(Procedure&) const override;
     53    Value* absConstant(Procedure&) const override;
     54    Value* ceilConstant(Procedure&) const override;
     55    Value* floorConstant(Procedure&) const override;
     56    Value* sqrtConstant(Procedure&) const override;
    5757
    58     TriState equalConstant(const Value* other) const final;
    59     TriState notEqualConstant(const Value* other) const final;
    60     TriState lessThanConstant(const Value* other) const final;
    61     TriState greaterThanConstant(const Value* other) const final;
    62     TriState lessEqualConstant(const Value* other) const final;
    63     TriState greaterEqualConstant(const Value* other) const final;
    64     TriState equalOrUnorderedConstant(const Value* other) const final;
     58    TriState equalConstant(const Value* other) const override;
     59    TriState notEqualConstant(const Value* other) const override;
     60    TriState lessThanConstant(const Value* other) const override;
     61    TriState greaterThanConstant(const Value* other) const override;
     62    TriState lessEqualConstant(const Value* other) const override;
     63    TriState greaterEqualConstant(const Value* other) const override;
     64    TriState equalOrUnorderedConstant(const Value* other) const override;
    6565
    6666    B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN
    … …  
    7070    friend class Value;
    7171
    72     void dumpMeta(CommaPrinter&, PrintStream&) const final;
     72    void dumpMeta(CommaPrinter&, PrintStream&) const override;
    7373
    7474    static Opcode opcodeFromConstructor(Origin, float) { return ConstFloat; }

  • trunk/Source/JavaScriptCore/b3/B3DataSection.h

    r261542 r261556  
    3232namespace JSC { namespace B3 {
    3333
    34 class DataSection final : public OpaqueByproduct {
     34class DataSection : public OpaqueByproduct {
    3535public:
    3636    DataSection(size_t size);
    37     ~DataSection() final;
     37    virtual ~DataSection();
    3838
    3939    void* data() const { return m_data; }
    4040    size_t size() const { return m_size; }
    4141
    42     void dump(PrintStream&) const final;
     42    void dump(PrintStream&) const override;
    4343
    4444private:

  • trunk/Source/JavaScriptCore/b3/B3ExtractValue.h

    r261542 r261556  
    3636    static bool accepts(Kind kind) { return kind == Extract; }
    3737
    38     ~ExtractValue() final;
     38    ~ExtractValue();
    3939
    4040    int32_t index() const { return m_index; }
    … …  
    4444
    4545private:
    46     void dumpMeta(CommaPrinter&, PrintStream&) const final;
     46    void dumpMeta(CommaPrinter&, PrintStream&) const override;
    4747
    4848    static Opcode opcodeFromConstructor(Origin, Type, Value*, int32_t) { return Extract; }

  • trunk/Source/JavaScriptCore/b3/B3FenceValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE FenceValue final : public Value {
     35class JS_EXPORT_PRIVATE FenceValue : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == Fence; }
    3838   
    39     ~FenceValue() final;
     39    ~FenceValue();
    4040   
    4141    // The read/write heaps are reflected in the effects() of this value. The compiler may change

  • trunk/Source/JavaScriptCore/b3/B3MemoryValue.h

    r261542 r261556  
    4242    }
    4343
    44     ~MemoryValue() override;
     44    ~MemoryValue();
    4545
    4646    OffsetType offset() const { return m_offset; }

  • trunk/Source/JavaScriptCore/b3/B3PatchpointSpecial.h

    r261542 r261556  
    4242//     Patch &patchpoint, result, args...
    4343
    44 class PatchpointSpecial final : public StackmapSpecial {
     44class PatchpointSpecial : public StackmapSpecial {
    4545public:
    4646    JS_EXPORT_PRIVATE PatchpointSpecial();
    47     ~PatchpointSpecial() final;
     47    virtual ~PatchpointSpecial();
    4848
    49 private:
     49protected:
    5050    void forEachArg(Air::Inst&, const ScopedLambda<Air::Inst::EachArgCallback>&) final;
    5151    bool isValid(Air::Inst&) final;

  • trunk/Source/JavaScriptCore/b3/B3PatchpointValue.h

    r261542 r261556  
    3434namespace JSC { namespace B3 {
    3535
    36 class PatchpointValue final : public StackmapValue {
     36class PatchpointValue : public StackmapValue {
    3737public:
    3838    typedef StackmapValue Base;
    … …  
    4040    static bool accepts(Kind kind) { return kind == Patchpoint; }
    4141
    42     ~PatchpointValue() final;
     42    ~PatchpointValue();
    4343
    4444    // The effects of the patchpoint. This defaults to Effects::forCall(), but you can set it to anything.
    … …  
    6565    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_VARARGS_CHILDREN
    6666
     67protected:
     68    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     69
    6770private:
    68     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    69 
    7071    friend class Procedure;
    7172    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3SlotBaseValue.h

    r261542 r261556  
    3434class StackSlot;
    3535
    36 class JS_EXPORT_PRIVATE SlotBaseValue final : public Value {
     36class JS_EXPORT_PRIVATE SlotBaseValue : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == SlotBase; }
    3939
    40     ~SlotBaseValue() final;
     40    ~SlotBaseValue();
    4141
    4242    StackSlot* slot() const { return m_slot; }
    … …  
    4848    friend class Value;
    4949
    50     void dumpMeta(CommaPrinter&, PrintStream&) const final;
     50    void dumpMeta(CommaPrinter&, PrintStream&) const override;
    5151
    5252    static Opcode opcodeFromConstructor(Origin, StackSlot*) { return SlotBase; }

  • trunk/Source/JavaScriptCore/b3/B3StackmapSpecial.h

    r261542 r261556  
    4343public:
    4444    StackmapSpecial();
    45     ~StackmapSpecial() override;
     45    virtual ~StackmapSpecial();
    4646
    4747    enum RoleMode : int8_t {

  • trunk/Source/JavaScriptCore/b3/B3StackmapValue.h

    r261542 r261556  
    6262    }
    6363
    64     ~StackmapValue() override;
     64    ~StackmapValue();
    6565
    6666    // Use this to add children.

  • trunk/Source/JavaScriptCore/b3/B3SwitchValue.h

    r261542 r261556  
    3434namespace JSC { namespace B3 {
    3535
    36 class SwitchValue final : public Value {
     36class SwitchValue : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == Switch; }
    3939
    40     ~SwitchValue() final;
     40    ~SwitchValue();
    4141
    4242    // numCaseValues() + 1 == numSuccessors().
    … …  
    6363    JS_EXPORT_PRIVATE void appendCase(const SwitchCase&);
    6464
    65     void dumpSuccessors(const BasicBlock*, PrintStream&) const final;
     65    void dumpSuccessors(const BasicBlock*, PrintStream&) const override;
    6666
    6767    B3_SPECIALIZE_VALUE_FOR_FIXED_CHILDREN(1)
    6868    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    6969
     70protected:
     71    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     72
    7073private:
    71     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    72 
    7374    friend class Procedure;
    7475    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3UpsilonValue.h

    r261542 r261556  
    3232namespace JSC { namespace B3 {
    3333
    34 class JS_EXPORT_PRIVATE UpsilonValue final : public Value {
     34class JS_EXPORT_PRIVATE UpsilonValue : public Value {
    3535public:
    3636    static bool accepts(Kind kind) { return kind == Upsilon; }
    3737
    38     ~UpsilonValue() final;
     38    ~UpsilonValue();
    3939
    4040    Value* phi() const { return m_phi; }
    … …  
    4949    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    5050
     51protected:
     52    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     53
    5154private:
    52     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    53 
    5455    friend class Procedure;
    5556    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3VariableValue.h

    r261542 r261556  
    3434class Variable;
    3535
    36 class JS_EXPORT_PRIVATE VariableValue final : public Value {
     36class JS_EXPORT_PRIVATE VariableValue : public Value {
    3737public:
    3838    static bool accepts(Kind kind) { return kind == Get || kind == Set; }
    3939
    40     ~VariableValue() final;
     40    ~VariableValue();
    4141
    4242    Variable* variable() const { return m_variable; }
    … …  
    4545    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4646
     47protected:
     48    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     49
    4750private:
    48     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    49 
    5051    friend class Procedure;
    5152    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3WasmAddressValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class JS_EXPORT_PRIVATE WasmAddressValue final : public Value {
     35class JS_EXPORT_PRIVATE WasmAddressValue : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == WasmAddress; }
    3838
    39     ~WasmAddressValue() final;
     39    ~WasmAddressValue();
    4040
    4141    GPRReg pinnedGPR() const { return m_pinnedGPR; }
    … …  
    4444    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    4545
     46protected:
     47    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     48
    4649private:
    47     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    48 
    4950    friend class Procedure;
    5051    friend class Value;

  • trunk/Source/JavaScriptCore/b3/B3WasmBoundsCheckValue.h

    r261542 r261556  
    3333namespace JSC { namespace B3 {
    3434
    35 class WasmBoundsCheckValue final : public Value {
     35class WasmBoundsCheckValue : public Value {
    3636public:
    3737    static bool accepts(Kind kind) { return kind == WasmBoundsCheck; }
    3838   
    39     ~WasmBoundsCheckValue() final;
     39    ~WasmBoundsCheckValue();
    4040
    4141    enum class Type {
    … …  
    5656    B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN
    5757
     58protected:
     59    void dumpMeta(CommaPrinter&, PrintStream&) const override;
     60
    5861private:
    59     void dumpMeta(CommaPrinter&, PrintStream&) const final;
    60 
    6162    friend class Procedure;
    6263    friend class Value;

  • trunk/Source/JavaScriptCore/b3/air/AirCCallSpecial.h

    r261542 r261556  
    4343// the prologue, whichever happened sooner.
    4444
    45 class CCallSpecial final : public Special {
     45class CCallSpecial : public Special {
    4646public:
    4747    CCallSpecial();
    48     ~CCallSpecial() final;
     48    ~CCallSpecial();
    4949
    5050    // You cannot use this register to pass arguments. It just so happens that this register is not
    … …  
    5353    static constexpr GPRReg scratchRegister = GPRInfo::nonPreservedNonArgumentGPR0;
    5454
    55 private:
     55protected:
    5656    void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final;
    5757    bool isValid(Inst&) final;
    … …  
    6666    void deepDumpImpl(PrintStream&) const final;
    6767
     68private:
    6869    static constexpr unsigned specialArgOffset = 0;
    6970    static constexpr unsigned numSpecialArgs = 1;

  • trunk/Source/JavaScriptCore/b3/air/AirPrintSpecial.h

    r261542 r261556  
    9393namespace B3 { namespace Air {
    9494
    95 class PrintSpecial final : public Special {
     95class PrintSpecial : public Special {
    9696public:
    9797    PrintSpecial(Printer::PrintRecordList*);
    98     ~PrintSpecial() final;
     98    ~PrintSpecial();
    9999   
    100100    // You cannot use this register to pass arguments. It just so happens that this register is not
    … …  
    103103    static constexpr GPRReg scratchRegister = GPRInfo::nonArgGPR0;
    104104   
    105 private:
     105protected:
    106106    void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final;
    107107    bool isValid(Inst&) final;
    … …  
    116116    void deepDumpImpl(PrintStream&) const final;
    117117   
     118private:
    118119    static constexpr unsigned specialArgOffset = 0;
    119120    static constexpr unsigned numSpecialArgs = 1;

  • trunk/Source/JavaScriptCore/bytecode/BytecodeDumper.h

    r261542 r261556  
    8585    }
    8686
    87     ~BytecodeDumper() override { }
     87    virtual ~BytecodeDumper() { }
    8888
    8989protected:
    … …  
    102102
    103103template<class Block>
    104 class CodeBlockBytecodeDumper final : public BytecodeDumper<Block> {
     104class CodeBlockBytecodeDumper : public BytecodeDumper<Block> {
    105105public:
    106106    static void dumpBlock(Block*, const InstructionStream&, PrintStream& out, const ICStatusMap& = ICStatusMap());
    … …  
    128128enum Type : int8_t;
    129129
    130 class BytecodeDumper final : public JSC::BytecodeDumper<FunctionCodeBlock> {
     130class BytecodeDumper : public JSC::BytecodeDumper<FunctionCodeBlock> {
    131131public:
    132132    static void dumpBlock(FunctionCodeBlock*, const ModuleInformation&, PrintStream& out);
    … …  
    136136
    137137    void dumpConstants();
    138     CString constantName(VirtualRegister index) const final;
     138    CString constantName(VirtualRegister index) const override;
    139139    CString formatConstant(Type, uint64_t) const;
    140140};

  • trunk/Source/JavaScriptCore/bytecode/GetterSetterAccessCase.h

    r261542 r261556  
    3333namespace JSC {
    3434
    35 class GetterSetterAccessCase final : public ProxyableAccessCase {
     35class GetterSetterAccessCase : public ProxyableAccessCase {
    3636public:
    3737    typedef ProxyableAccessCase Base;
    … …  
    4949    Optional<DOMAttributeAnnotation> domAttribute() const { return m_domAttribute; }
    5050
    51     bool hasAlternateBase() const final;
    52     JSObject* alternateBase() const final;
     51    bool hasAlternateBase() const override;
     52    JSObject* alternateBase() const override;
    5353
    5454    void emitDOMJITGetter(AccessGenerationState&, const DOMJIT::GetterSetter*, GPRReg baseForGetGPR);
    … …  
    6363        FunctionPtr<OperationPtrTag> customSetter = nullptr, JSObject* customSlotBase = nullptr);
    6464
    65     void dumpImpl(PrintStream&, CommaPrinter&) const final;
    66     std::unique_ptr<AccessCase> clone() const final;
     65    void dumpImpl(PrintStream&, CommaPrinter&) const override;
     66    std::unique_ptr<AccessCase> clone() const override;
    6767
    68     ~GetterSetterAccessCase() final;
     68    ~GetterSetterAccessCase();
    6969
    7070    FunctionPtr<OperationPtrTag> customAccessor() const { return m_customAccessor; }

  • trunk/Source/JavaScriptCore/bytecode/InstanceOfAccessCase.h

    r261542 r261556  
    3232namespace JSC {
    3333
    34 class InstanceOfAccessCase final : public AccessCase {
     34class InstanceOfAccessCase : public AccessCase {
    3535public:
    3636    using Base = AccessCase;
    … …  
    4242    JSObject* prototype() const { return m_prototype.get(); }
    4343   
    44     void dumpImpl(PrintStream&, CommaPrinter&) const final;
    45     std::unique_ptr<AccessCase> clone() const final;
     44    void dumpImpl(PrintStream&, CommaPrinter&) const override;
     45    std::unique_ptr<AccessCase> clone() const override;
    4646   
    47     ~InstanceOfAccessCase() final;
     47    ~InstanceOfAccessCase();
    4848
    49 private:
     49protected:
    5050    InstanceOfAccessCase(
    5151        VM&, JSCell*, AccessType, Structure*, const ObjectPropertyConditionSet&,
    5252        JSObject* prototype);
    5353
     54private:
    5455    WriteBarrier<JSObject> m_prototype;
    5556};

  • trunk/Source/JavaScriptCore/bytecode/IntrinsicGetterAccessCase.h

    r261542 r261556  
    3232namespace JSC {
    3333
    34 class IntrinsicGetterAccessCase final : public AccessCase {
     34class IntrinsicGetterAccessCase : public AccessCase {
    3535public:
    3636    typedef AccessCase Base;
    … …  
    4545    static std::unique_ptr<AccessCase> create(VM&, JSCell*, CacheableIdentifier, PropertyOffset, Structure*, const ObjectPropertyConditionSet&, JSFunction* intrinsicFunction, std::unique_ptr<PolyProtoAccessChain>);
    4646
    47     std::unique_ptr<AccessCase> clone() const final;
     47    std::unique_ptr<AccessCase> clone() const override;
    4848
    49     ~IntrinsicGetterAccessCase() final;
     49    ~IntrinsicGetterAccessCase();
    5050
    5151private:

  • trunk/Source/JavaScriptCore/bytecode/ModuleNamespaceAccessCase.h

    r261542 r261556  
    3636class JSModuleNamespaceObject;
    3737
    38 class ModuleNamespaceAccessCase final : public AccessCase {
     38class ModuleNamespaceAccessCase : public AccessCase {
    3939public:
    4040    using Base = AccessCase;
    … …  
    4747    static std::unique_ptr<AccessCase> create(VM&, JSCell* owner, CacheableIdentifier, JSModuleNamespaceObject*, JSModuleEnvironment*, ScopeOffset);
    4848
    49     std::unique_ptr<AccessCase> clone() const final;
     49    std::unique_ptr<AccessCase> clone() const override;
    5050
    5151    void emit(AccessGenerationState&, MacroAssembler::JumpList& fallThrough);
    5252
    53     ~ModuleNamespaceAccessCase() final;
     53    ~ModuleNamespaceAccessCase();
    5454
    5555private:

  • trunk/Source/JavaScriptCore/bytecode/ProxyableAccessCase.h

    r261542 r261556  
    4444    std::unique_ptr<AccessCase> clone() const override;
    4545
    46     ~ProxyableAccessCase() override;
     46    ~ProxyableAccessCase();
    4747
    4848protected:

  • trunk/Source/JavaScriptCore/bytecode/Watchpoint.h

    r261542 r261556  
    534534public:
    535535    JS_EXPORT_PRIVATE DeferredWatchpointFire(VM&);
    536     JS_EXPORT_PRIVATE ~DeferredWatchpointFire() override;
     536    JS_EXPORT_PRIVATE ~DeferredWatchpointFire();
    537537
    538538    JS_EXPORT_PRIVATE void takeWatchpointsToFire(WatchpointSet*);

  • trunk/Source/JavaScriptCore/dfg/DFGFailedFinalizer.h

    r261542 r261556  
    3232namespace JSC { namespace DFG {
    3333
    34 class FailedFinalizer final : public Finalizer {
     34class FailedFinalizer : public Finalizer {
    3535public:
    3636    FailedFinalizer(Plan&);
    37     ~FailedFinalizer() final;
     37    virtual ~FailedFinalizer();
    3838   
    39     size_t codeSize() final;
    40     bool finalize() final;
    41     bool finalizeFunction() final;
     39    size_t codeSize() override;
     40    bool finalize() override;
     41    bool finalizeFunction() override;
    4242};
    4343

  • trunk/Source/JavaScriptCore/dfg/DFGGraph.h

    r261542 r261556  
    160160// The order may be significant for nodes with side-effects (property accesses, value conversions).
    161161// Nodes that are 'dead' remain in the vector with refCount 0.
    162 class Graph final : public virtual Scannable {
     162class Graph : public virtual Scannable {
    163163public:
    164164    Graph(VM&, Plan&);
    165     ~Graph() final;
     165    ~Graph();
    166166   
    167167    void changeChild(Edge& edge, Node* newNode)
    … …  
    10021002    void registerFrozenValues();
    10031003   
    1004     void visitChildren(SlotVisitor&) final;
     1004    void visitChildren(SlotVisitor&) override;
    10051005   
    10061006    void logAssertionFailure(

  • trunk/Source/JavaScriptCore/dfg/DFGJITCode.h

    r261542 r261556  
    4747class JITCompiler;
    4848
    49 class JITCode final : public DirectJITCode {
     49class JITCode : public DirectJITCode {
    5050public:
    5151    JITCode();
    52     ~JITCode() final;
     52    virtual ~JITCode();
    5353   
    54     CommonData* dfgCommon() final;
    55     JITCode* dfg() final;
     54    CommonData* dfgCommon() override;
     55    JITCode* dfg() override;
    5656   
    5757    OSREntryData* appendOSREntryData(BytecodeIndex bytecodeIndex, CodeLocationLabel<OSREntryPtrTag> machineCode)
    … …  
    114114#endif // ENABLE(FTL_JIT)
    115115   
    116     void validateReferences(const TrackedReferences&) final;
     116    void validateReferences(const TrackedReferences&) override;
    117117   
    118     void shrinkToFit(const ConcurrentJSLocker&) final;
     118    void shrinkToFit(const ConcurrentJSLocker&) override;
    119119
    120     RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) final;
     120    RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) override;
    121121#if ENABLE(FTL_JIT)
    122122    CodeBlock* osrEntryBlock() { return m_osrEntryBlock.get(); }
    … …  
    127127    static ptrdiff_t commonDataOffset() { return OBJECT_OFFSETOF(JITCode, common); }
    128128
    129     Optional<CodeOrigin> findPC(CodeBlock*, void* pc) final;
     129    Optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;
    130130
    131131    using DirectJITCode::initializeCodeRefForDFG;

  • trunk/Source/JavaScriptCore/dfg/DFGJITFinalizer.h

    r261542 r261556  
    3434namespace JSC { namespace DFG {
    3535
    36 class JITFinalizer final : public Finalizer {
     36class JITFinalizer : public Finalizer {
    3737public:
    3838    JITFinalizer(Plan&, Ref<JITCode>&&, std::unique_ptr<LinkBuffer>, MacroAssemblerCodePtr<JSEntryPtrTag> withArityCheck = MacroAssemblerCodePtr<JSEntryPtrTag>(MacroAssemblerCodePtr<JSEntryPtrTag>::EmptyValue));
    39     ~JITFinalizer() final;
     39    virtual ~JITFinalizer();
    4040   
    41     size_t codeSize() final;
    42     bool finalize() final;
    43     bool finalizeFunction() final;
     41    size_t codeSize() override;
     42    bool finalize() override;
     43    bool finalizeFunction() override;
    4444
    4545private:

  • trunk/Source/JavaScriptCore/dfg/DFGToFTLDeferredCompilationCallback.h

    r261542 r261556  
    3737namespace DFG {
    3838
    39 class ToFTLDeferredCompilationCallback final : public DeferredCompilationCallback {
     39class ToFTLDeferredCompilationCallback : public DeferredCompilationCallback {
     40protected:
     41    ToFTLDeferredCompilationCallback();
     42
    4043public:
    41     ~ToFTLDeferredCompilationCallback() final;
     44    virtual ~ToFTLDeferredCompilationCallback();
    4245
    4346    static Ref<ToFTLDeferredCompilationCallback> create();
    4447   
    45     void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
    46     void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
    47 
    48 private:
    49     ToFTLDeferredCompilationCallback();
     48    virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock);
     49    virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult);
    5050};
    5151

  • trunk/Source/JavaScriptCore/dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h

    r261542 r261556  
    3838namespace DFG {
    3939
    40 class ToFTLForOSREntryDeferredCompilationCallback final : public DeferredCompilationCallback {
     40class ToFTLForOSREntryDeferredCompilationCallback : public DeferredCompilationCallback {
     41protected:
     42    ToFTLForOSREntryDeferredCompilationCallback(JITCode::TriggerReason* forcedOSREntryTrigger);
     43
    4144public:
    42     ~ToFTLForOSREntryDeferredCompilationCallback() final;
     45    virtual ~ToFTLForOSREntryDeferredCompilationCallback();
    4346
    4447    static Ref<ToFTLForOSREntryDeferredCompilationCallback> create(JITCode::TriggerReason* forcedOSREntryTrigger);
    45 
    46     void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
    47     void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
     48   
     49    virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock);
     50    virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult);
    4851
    4952private:
    50     ToFTLForOSREntryDeferredCompilationCallback(JITCode::TriggerReason* forcedOSREntryTrigger);
    51 
    5253    JITCode::TriggerReason* m_forcedOSREntryTrigger;
    5354};

  • trunk/Source/JavaScriptCore/ftl/FTLForOSREntryJITCode.h

    r261542 r261556  
    4141// - Each OSR entry compilation allows entry through only one bytecode index.
    4242
    43 class ForOSREntryJITCode final : public FTL::JITCode {
     43class ForOSREntryJITCode : public FTL::JITCode {
    4444public:
    4545    ForOSREntryJITCode();
    46     ~ForOSREntryJITCode() final;
     46    ~ForOSREntryJITCode();
    4747   
    4848    void initializeEntryBuffer(VM&, unsigned numCalleeLocals);
    … …  
    5555    unsigned entryFailureCount() const { return m_entryFailureCount; }
    5656   
    57     ForOSREntryJITCode* ftlForOSREntry() final;
     57    ForOSREntryJITCode* ftlForOSREntry();
    5858   
    5959private:

  • trunk/Source/JavaScriptCore/ftl/FTLJITCode.h

    r261542 r261556  
    4343public:
    4444    JITCode();
    45     ~JITCode() override;
     45    ~JITCode();
    4646
    4747    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;

  • trunk/Source/JavaScriptCore/ftl/FTLJITFinalizer.h

    r261542 r261556  
    4848};
    4949
    50 class JITFinalizer final : public DFG::Finalizer {
     50class JITFinalizer : public DFG::Finalizer {
    5151public:
    5252    JITFinalizer(DFG::Plan&);
    53     ~JITFinalizer() final;
     53    virtual ~JITFinalizer();
    5454
    55     size_t codeSize() final;
    56     bool finalize() final;
    57     bool finalizeFunction() final;
     55    size_t codeSize() override;
     56    bool finalize() override;
     57    bool finalizeFunction() override;
    5858   
    5959    bool finalizeCommon();

  • trunk/Source/JavaScriptCore/heap/CompleteSubspace.h

    r261542 r261556  
    3030namespace JSC {
    3131
    32 class CompleteSubspace final : public Subspace {
     32class CompleteSubspace : public Subspace {
    3333public:
    3434    JS_EXPORT_PRIVATE CompleteSubspace(CString name, Heap&, HeapCellType*, AlignedMemoryAllocator*);
    35     JS_EXPORT_PRIVATE ~CompleteSubspace() final;
     35    JS_EXPORT_PRIVATE ~CompleteSubspace();
    3636
    3737    // In some code paths, we need it to be a compile error to call the virtual version of one of
    … …  
    4040    // FIXME: Currently subspaces speak of BlockDirectories as "allocators", but that's temporary.
    4141    // https://bugs.webkit.org/show_bug.cgi?id=181559
    42     Allocator allocatorFor(size_t, AllocatorForMode) final;
     42    Allocator allocatorFor(size_t, AllocatorForMode) override;
    4343    Allocator allocatorForNonVirtual(size_t, AllocatorForMode);
    4444   
    45     void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) final;
     45    void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) override;
    4646    void* allocateNonVirtual(VM&, size_t, GCDeferralContext*, AllocationFailureMode);
    4747    void* reallocatePreciseAllocationNonVirtual(VM&, HeapCell*, size_t, GCDeferralContext*, AllocationFailureMode);

  • trunk/Source/JavaScriptCore/heap/FastMallocAlignedMemoryAllocator.h

    r261542 r261556  
    3434namespace JSC {
    3535
    36 class FastMallocAlignedMemoryAllocator final : public AlignedMemoryAllocator {
     36class FastMallocAlignedMemoryAllocator : public AlignedMemoryAllocator {
    3737public:
    3838    FastMallocAlignedMemoryAllocator();
    39     ~FastMallocAlignedMemoryAllocator() final;
     39    ~FastMallocAlignedMemoryAllocator();
    4040   
    41     void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
    42     void freeAlignedMemory(void*) final;
     41    void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
     42    void freeAlignedMemory(void*) override;
    4343   
    44     void dump(PrintStream&) const final;
     44    void dump(PrintStream&) const override;
    4545
    46     void* tryAllocateMemory(size_t) final;
    47     void freeMemory(void*) final;
    48     void* tryReallocateMemory(void*, size_t) final;
     46    void* tryAllocateMemory(size_t) override;
     47    void freeMemory(void*) override;
     48    void* tryReallocateMemory(void*, size_t) override;
    4949
    5050#if ENABLE(MALLOC_HEAP_BREAKDOWN)

  • trunk/Source/JavaScriptCore/heap/GigacageAlignedMemoryAllocator.h

    r261542 r261556  
    3535namespace JSC {
    3636
    37 class GigacageAlignedMemoryAllocator final : public AlignedMemoryAllocator {
     37class GigacageAlignedMemoryAllocator : public AlignedMemoryAllocator {
    3838public:
    3939    GigacageAlignedMemoryAllocator(Gigacage::Kind);
    40     ~GigacageAlignedMemoryAllocator() final;
     40    ~GigacageAlignedMemoryAllocator();
    4141   
    42     void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
    43     void freeAlignedMemory(void*) final;
     42    void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
     43    void freeAlignedMemory(void*) override;
    4444   
    45     void dump(PrintStream&) const final;
     45    void dump(PrintStream&) const override;
    4646
    47     void* tryAllocateMemory(size_t) final;
    48     void freeMemory(void*) final;
    49     void* tryReallocateMemory(void*, size_t) final;
     47    void* tryAllocateMemory(size_t) override;
     48    void freeMemory(void*) override;
     49    void* tryReallocateMemory(void*, size_t) override;
    5050
    5151private:

  • trunk/Source/JavaScriptCore/heap/HeapSnapshotBuilder.h

    r261542 r261556  
    109109
    110110    HeapSnapshotBuilder(HeapProfiler&, SnapshotType = SnapshotType::InspectorSnapshot);
    111     ~HeapSnapshotBuilder() final;
     111    ~HeapSnapshotBuilder();
    112112
    113113    static void resetNextAvailableObjectIdentifier();
    … …  
    117117
    118118    // A root or marked cell.
    119     void analyzeNode(JSCell*) final;
     119    void analyzeNode(JSCell*);
    120120
    121121    // A reference from one cell to another.
    122     void analyzeEdge(JSCell* from, JSCell* to, SlotVisitor::RootMarkReason) final;
    123     void analyzePropertyNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* propertyName) final;
    124     void analyzeVariableNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* variableName) final;
    125     void analyzeIndexEdge(JSCell* from, JSCell* to, uint32_t index) final;
     122    void analyzeEdge(JSCell* from, JSCell* to, SlotVisitor::RootMarkReason);
     123    void analyzePropertyNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* propertyName);
     124    void analyzeVariableNameEdge(JSCell* from, JSCell* to, UniquedStringImpl* variableName);
     125    void analyzeIndexEdge(JSCell* from, JSCell* to, uint32_t index);
    126126
    127     void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*) final;
    128     void setWrappedObjectForCell(JSCell*, void*) final;
    129     void setLabelForCell(JSCell*, const String&) final;
     127    void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*);
     128    void setWrappedObjectForCell(JSCell*, void*);
     129    void setLabelForCell(JSCell*, const String&);
    130130
    131131    String json();

  • trunk/Source/JavaScriptCore/heap/IsoAlignedMemoryAllocator.h

    r261542 r261556  
    3535namespace JSC {
    3636
    37 class IsoAlignedMemoryAllocator final : public AlignedMemoryAllocator {
     37class IsoAlignedMemoryAllocator : public AlignedMemoryAllocator {
    3838public:
    3939    IsoAlignedMemoryAllocator(CString);
    40     ~IsoAlignedMemoryAllocator() final;
     40    ~IsoAlignedMemoryAllocator();
    4141
    42     void* tryAllocateAlignedMemory(size_t alignment, size_t size) final;
    43     void freeAlignedMemory(void*) final;
     42    void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;
     43    void freeAlignedMemory(void*) override;
    4444
    45     void dump(PrintStream&) const final;
     45    void dump(PrintStream&) const override;
    4646
    47     void* tryAllocateMemory(size_t) final;
    48     void freeMemory(void*) final;
    49     void* tryReallocateMemory(void*, size_t) final;
     47    void* tryAllocateMemory(size_t) override;
     48    void freeMemory(void*) override;
     49    void* tryReallocateMemory(void*, size_t) override;
    5050
    5151private:

  • trunk/Source/JavaScriptCore/heap/IsoSubspace.h

    r261542 r261556  
    3939public:
    4040    JS_EXPORT_PRIVATE IsoSubspace(CString name, Heap&, HeapCellType*, size_t size, uint8_t numberOfLowerTierCells);
    41     JS_EXPORT_PRIVATE ~IsoSubspace() override;
     41    JS_EXPORT_PRIVATE ~IsoSubspace();
    4242
    4343    size_t cellSize() { return m_directory.cellSize(); }

  • trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.cpp

    r261542 r261556  
    3232namespace JSC {
    3333
    34 class IsoSubspacePerVM::AutoremovingIsoSubspace final : public IsoSubspace {
     34class IsoSubspacePerVM::AutoremovingIsoSubspace : public IsoSubspace {
    3535public:
    3636    AutoremovingIsoSubspace(IsoSubspacePerVM& perVM, CString name, Heap& heap, HeapCellType* heapCellType, size_t size)
    … …  
    4040    }
    4141   
    42     ~AutoremovingIsoSubspace() final
     42    ~AutoremovingIsoSubspace()
    4343    {
    4444        auto locker = holdLock(m_perVM.m_lock);

  • trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.h

    r261542 r261556  
    3737// once, then this is not great, because concurrent allocations will probably contend on this thing's
    3838// lock.
    39 class IsoSubspacePerVM final {
     39class IsoSubspacePerVM {
    4040public:
    4141    struct SubspaceParameters {

  • trunk/Source/JavaScriptCore/heap/MarkStackMergingConstraint.h

    r261542 r261556  
    3333class SlotVisitor;
    3434
    35 class MarkStackMergingConstraint final : public MarkingConstraint {
     35class MarkStackMergingConstraint : public MarkingConstraint {
    3636public:
    3737    MarkStackMergingConstraint(Heap&);
    38     ~MarkStackMergingConstraint() final;
     38    ~MarkStackMergingConstraint();
    3939   
    40     double quickWorkEstimate(SlotVisitor&) final;
     40    double quickWorkEstimate(SlotVisitor&) override;
     41   
     42protected:
     43    void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) override;
     44    void executeImpl(SlotVisitor&) override;
    4145   
    4246private:
    43     void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) final;
    44     void executeImpl(SlotVisitor&) final;
    45    
    4647    Heap& m_heap;
    4748};

  • trunk/Source/JavaScriptCore/heap/SimpleMarkingConstraint.h

    r261542 r261556  
    3434// downside is that this makes it hard for constraints to override any functions in MarkingConstraint
    3535// other than executeImpl. In those cases, just subclass MarkingConstraint.
    36 class SimpleMarkingConstraint final : public MarkingConstraint {
     36class SimpleMarkingConstraint : public MarkingConstraint {
    3737public:
    3838    JS_EXPORT_PRIVATE SimpleMarkingConstraint(
    … …  
    5252    }
    5353   
    54     JS_EXPORT_PRIVATE ~SimpleMarkingConstraint() final;
     54    JS_EXPORT_PRIVATE ~SimpleMarkingConstraint();
    5555   
    5656private:
    57     void executeImpl(SlotVisitor&) final;
     57    void executeImpl(SlotVisitor&) override;
    5858
    5959    ::Function<void(SlotVisitor&)> m_executeFunction;

  • trunk/Source/JavaScriptCore/heap/SpaceTimeMutatorScheduler.h

    r261542 r261556  
    3939// began.
    4040
    41 class SpaceTimeMutatorScheduler final : public MutatorScheduler {
     41class SpaceTimeMutatorScheduler : public MutatorScheduler {
    4242public:
    4343    SpaceTimeMutatorScheduler(Heap&);
    44     ~SpaceTimeMutatorScheduler() final;
     44    ~SpaceTimeMutatorScheduler();
    4545   
    46     State state() const final;
     46    State state() const override;
    4747   
    48     void beginCollection() final;
     48    void beginCollection() override;
    4949   
    50     void didStop() final;
    51     void willResume() final;
    52     void didExecuteConstraints() final;
     50    void didStop() override;
     51    void willResume() override;
     52    void didExecuteConstraints() override;
    5353   
    54     MonotonicTime timeToStop() final;
    55     MonotonicTime timeToResume() final;
     54    MonotonicTime timeToStop() override;
     55    MonotonicTime timeToResume() override;
    5656   
    57     void log() final;
     57    void log() override;
    5858   
    59     void endCollection() final;
     59    void endCollection() override;
    6060   
    6161private:

  • trunk/Source/JavaScriptCore/heap/StochasticSpaceTimeMutatorScheduler.h

    r261542 r261556  
    4040// began.
    4141
    42 class StochasticSpaceTimeMutatorScheduler final : public MutatorScheduler {
     42class StochasticSpaceTimeMutatorScheduler : public MutatorScheduler {
    4343public:
    4444    StochasticSpaceTimeMutatorScheduler(Heap&);
    45     ~StochasticSpaceTimeMutatorScheduler() final;
     45    ~StochasticSpaceTimeMutatorScheduler();
    4646   
    47     State state() const final;
     47    State state() const override;
    4848   
    49     void beginCollection() final;
     49    void beginCollection() override;
    5050   
    51     void didStop() final;
    52     void willResume() final;
    53     void didReachTermination() final;
    54     void didExecuteConstraints() final;
    55     void synchronousDrainingDidStall() final;
     51    void didStop() override;
     52    void willResume() override;
     53    void didReachTermination() override;
     54    void didExecuteConstraints() override;
     55    void synchronousDrainingDidStall() override;
    5656   
    57     MonotonicTime timeToStop() final;
    58     MonotonicTime timeToResume() final;
     57    MonotonicTime timeToStop() override;
     58    MonotonicTime timeToResume() override;
    5959   
    60     void log() final;
     60    void log() override;
    6161   
    62     void endCollection() final;
     62    void endCollection() override;
    6363   
    6464private:

  • trunk/Source/JavaScriptCore/heap/SynchronousStopTheWorldMutatorScheduler.h

    r261542 r261556  
    3636// SpaceTimeMutatorScheduler. It tells the GC to never resume the world once the GC cycle begins.
    3737
    38 class SynchronousStopTheWorldMutatorScheduler final : public MutatorScheduler {
     38class SynchronousStopTheWorldMutatorScheduler : public MutatorScheduler {
    3939public:
    4040    SynchronousStopTheWorldMutatorScheduler();
    41     ~SynchronousStopTheWorldMutatorScheduler() final;
     41    ~SynchronousStopTheWorldMutatorScheduler();
    4242   
    43     State state() const final;
     43    State state() const override;
    4444   
    45     void beginCollection() final;
     45    void beginCollection() override;
    4646   
    47     MonotonicTime timeToStop() final;
    48     MonotonicTime timeToResume() final;
     47    MonotonicTime timeToStop() override;
     48    MonotonicTime timeToResume() override;
    4949   
    50     void endCollection() final;
     50    void endCollection() override;
    5151
    5252private:

  • trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.h

    r261542 r261556  
    5252public:
    5353    GCAwareJITStubRoutine(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&);
    54     ~GCAwareJITStubRoutine() override;
     54    virtual ~GCAwareJITStubRoutine();
    5555
    5656    static Ref<JITStubRoutine> create(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>& code, VM& vm)
    … …  
    8484    MarkingGCAwareJITStubRoutine(
    8585        const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&);
    86     ~MarkingGCAwareJITStubRoutine() override;
     86    virtual ~MarkingGCAwareJITStubRoutine();
    8787   
    8888protected:
    … …  
    9898// handling table when it dies. It also frees space in CodeOrigin table
    9999// for new exception handlers to use the same DisposableCallSiteIndex.
    100 class GCAwareJITStubRoutineWithExceptionHandler final : public MarkingGCAwareJITStubRoutine {
     100class GCAwareJITStubRoutineWithExceptionHandler : public MarkingGCAwareJITStubRoutine {
    101101public:
    102102    typedef GCAwareJITStubRoutine Base;
    … …  
    104104    GCAwareJITStubRoutineWithExceptionHandler(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&, CodeBlock*, DisposableCallSiteIndex);
    105105
    106     void aboutToDie() final;
    107     void observeZeroRefCount() final;
     106    void aboutToDie() override;
     107    void observeZeroRefCount() override;
    108108
    109109private:

  • trunk/Source/JavaScriptCore/jit/JITCode.h

    r261542 r261556  
    227227
    228228public:
    229     ~JITCodeWithCodeRef() override;
     229    virtual ~JITCodeWithCodeRef();
    230230
    231231    void* executableAddressAtOffset(size_t offset) override;
    … …  
    246246    DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared);
    247247    DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared); // For generated thunk.
    248     ~DirectJITCode() override;
     248    virtual ~DirectJITCode();
    249249   
    250250    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;
    … …  
    261261    NativeJITCode(JITType);
    262262    NativeJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared);
    263     ~NativeJITCode() override;
     263    virtual ~NativeJITCode();
    264264
    265265    CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override;
    … …  
    269269public:
    270270    NativeDOMJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, const DOMJIT::Signature*);
    271     ~NativeDOMJITCode() final = default;
    272 
    273     const DOMJIT::Signature* signature() const final { return m_signature; }
     271    virtual ~NativeDOMJITCode() = default;
     272
     273    const DOMJIT::Signature* signature() const override { return m_signature; }
    274274
    275275private:

  • trunk/Source/JavaScriptCore/jit/JITThunks.h

    r261542 r261556  
    5151public:
    5252    JITThunks();
    53     ~JITThunks() final;
     53    virtual ~JITThunks();
    5454
    5555    MacroAssemblerCodePtr<JITThunkPtrTag> ctiNativeCall(VM&);
    … …  
    6868
    6969private:
    70     void finalize(Handle<Unknown>, void* context) final;
     70    void finalize(Handle<Unknown>, void* context) override;
    7171   
    7272    typedef HashMap<ThunkGenerator, MacroAssemblerCodeRef<JITThunkPtrTag>> CTIStubMap;

  • trunk/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.h

    r261542 r261556  
    3434class ScriptExecutable;
    3535
    36 class JITToDFGDeferredCompilationCallback final : public DeferredCompilationCallback {
     36class JITToDFGDeferredCompilationCallback : public DeferredCompilationCallback {
     37protected:
     38    JITToDFGDeferredCompilationCallback();
     39
    3740public:
    38     ~JITToDFGDeferredCompilationCallback() final;
     41    virtual ~JITToDFGDeferredCompilationCallback();
    3942
    4043    static Ref<JITToDFGDeferredCompilationCallback> create();
    4144   
    42     void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final;
    43     void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final;
    44 
    45 private:
    46     JITToDFGDeferredCompilationCallback();
     45    void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) override;
     46    void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) override;
    4747};
    4848

  • trunk/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.h

    r261542 r261556  
    8181};
    8282
    83 class PolymorphicCallStubRoutine final : public GCAwareJITStubRoutine {
     83class PolymorphicCallStubRoutine : public GCAwareJITStubRoutine {
    8484public:
    8585    PolymorphicCallStubRoutine(
    … …  
    8888        UniqueArray<uint32_t>&& fastCounts);
    8989   
    90     ~PolymorphicCallStubRoutine() final;
     90    virtual ~PolymorphicCallStubRoutine();
    9191   
    9292    CallVariantList variants() const;
    … …  
    103103    }
    104104
    105     bool visitWeak(VM&) final;
     105    bool visitWeak(VM&) override;
     106
     107protected:
     108    void markRequiredObjectsInternal(SlotVisitor&) override;
    106109
    107110private:
    108     void markRequiredObjectsInternal(SlotVisitor&) final;
    109 
    110111    Vector<WriteBarrier<JSCell>, 2> m_variants;
    111112    UniqueArray<uint32_t> m_fastCounts;

  • trunk/Source/JavaScriptCore/jsc.cpp

    r261549 r261556  
    973973}
    974974
    975 class ShellSourceProvider final : public StringSourceProvider {
     975class ShellSourceProvider : public StringSourceProvider {
    976976public:
    977977    static Ref<ShellSourceProvider> create(const String& source, const SourceOrigin& sourceOrigin, URL&& url, const TextPosition& startPosition, SourceProviderSourceType sourceType)
    … …  
    980980    }
    981981
    982     ~ShellSourceProvider() final
     982    ~ShellSourceProvider()
    983983    {
    984984        commitCachedBytecode();
    985985    }
    986986
    987     RefPtr<CachedBytecode> cachedBytecode() const final
     987    RefPtr<CachedBytecode> cachedBytecode() const override
    988988    {
    989989        if (!m_cachedBytecode)
    … …  
    992992    }
    993993
    994     void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const final
     994    void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const override
    995995    {
    996996        if (!cacheEnabled() || !m_cachedBytecode)
    … …  
    10021002    }
    10031003
    1004     void cacheBytecode(const BytecodeCacheGenerator& generator) const final
     1004    void cacheBytecode(const BytecodeCacheGenerator& generator) const override
    10051005    {
    10061006        if (!cacheEnabled())
    … …  
    10131013    }
    10141014
    1015     void commitCachedBytecode() const final
     1015    void commitCachedBytecode() const override
    10161016    {
    10171017        if (!cacheEnabled() || !m_cachedBytecode || !m_cachedBytecode->hasUpdates())

  • trunk/Source/JavaScriptCore/parser/Lexer.cpp

    r261542 r261556  
    747747}
    748748
    749 static ALWAYS_INLINE UNUSED_FUNCTION bool isSingleCharacterIdentStart(UChar c)
     749static ALWAYS_INLINE bool isSingleCharacterIdentStart(UChar c)
    750750{
    751751    if (LIKELY(isLatin1(c)))

  • trunk/Source/JavaScriptCore/runtime/JSDestructibleObjectHeapCellType.h

    r261542 r261556  
    3030namespace JSC {
    3131
    32 class JSDestructibleObjectHeapCellType final : public HeapCellType {
     32class JSDestructibleObjectHeapCellType : public HeapCellType {
    3333public:
    3434    JS_EXPORT_PRIVATE JSDestructibleObjectHeapCellType();
    35     JS_EXPORT_PRIVATE ~JSDestructibleObjectHeapCellType() final;
     35    JS_EXPORT_PRIVATE virtual ~JSDestructibleObjectHeapCellType();
    3636   
    37     void finishSweep(MarkedBlock::Handle&, FreeList*) final;
    38     void destroy(VM&, JSCell*) final;
     37    void finishSweep(MarkedBlock::Handle&, FreeList*) override;
     38    void destroy(VM&, JSCell*) override;
    3939};
    4040

  • trunk/Source/JavaScriptCore/runtime/SimpleTypedArrayController.h

    r261542 r261556  
    4747//   one.
    4848
    49 class SimpleTypedArrayController final : public TypedArrayController {
     49class SimpleTypedArrayController : public TypedArrayController {
    5050public:
    5151    SimpleTypedArrayController();
    52     ~SimpleTypedArrayController() final;
     52    virtual ~SimpleTypedArrayController();
    5353   
    54     JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) final;
    55     void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) final;
    56     bool isAtomicsWaitAllowedOnCurrentThread() final;
     54    JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) override;
     55    void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) override;
     56    bool isAtomicsWaitAllowedOnCurrentThread() override;
    5757
    5858private:
    59     class JSArrayBufferOwner final : public WeakHandleOwner {
     59    class JSArrayBufferOwner : public WeakHandleOwner {
    6060    public:
    61         bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) final;
    62         void finalize(JSC::Handle<JSC::Unknown>, void* context) final;
     61        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) override;
     62        void finalize(JSC::Handle<JSC::Unknown>, void* context) override;
    6363    };
    6464

  • trunk/Source/JavaScriptCore/runtime/Structure.h

    r261542 r261556  
    9797};
    9898
    99 class StructureFireDetail final : public FireDetail {
     99class StructureFireDetail : public FireDetail {
    100100public:
    101101    StructureFireDetail(const Structure* structure)
    … …  
    104104    }
    105105   
    106     void dump(PrintStream& out) const final;
     106    void dump(PrintStream& out) const override;
    107107
    108108private:
    … …  
    110110};
    111111
    112 class DeferredStructureTransitionWatchpointFire final : public DeferredWatchpointFire {
     112class DeferredStructureTransitionWatchpointFire : public DeferredWatchpointFire {
    113113    WTF_MAKE_NONCOPYABLE(DeferredStructureTransitionWatchpointFire);
    114114public:
    115115    JS_EXPORT_PRIVATE DeferredStructureTransitionWatchpointFire(VM&, Structure*);
    116     JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire() final;
    117    
    118     void dump(PrintStream& out) const final;
     116    JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire();
     117   
     118    void dump(PrintStream& out) const override;
    119119
    120120    const Structure* structure() const { return m_structure; }

  • trunk/Source/JavaScriptCore/runtime/WeakGCMap.h

    r261542 r261556  
    4141template<typename KeyArg, typename ValueArg, typename HashArg = typename DefaultHash<KeyArg>::Hash,
    4242    typename KeyTraitsArg = HashTraits<KeyArg>>
    43 class WeakGCMap final : public WeakGCMapBase {
     43class WeakGCMap : public WeakGCMapBase {
    4444    WTF_MAKE_FAST_ALLOCATED;
    4545    typedef Weak<ValueArg> ValueType;
    … …  
    5353
    5454    explicit WeakGCMap(VM&);
    55     ~WeakGCMap() final;
     55    ~WeakGCMap();
    5656
    5757    ValueArg* get(const KeyType& key) const
    … …  
    9292    inline bool contains(const KeyType& key) const;
    9393
    94     void pruneStaleEntries() final;
     94    void pruneStaleEntries() override;
    9595
    9696private:

  • trunk/Source/JavaScriptCore/wasm/WasmEntryPlan.h

    r261542 r261556  
    5151    JS_EXPORT_PRIVATE EntryPlan(Context*, Vector<uint8_t>&&, AsyncWork, CompletionTask&&);
    5252
    53     ~EntryPlan() override = default;
     53    virtual ~EntryPlan() = default;
    5454
    5555    void prepare();
Note: See TracChangeset for help on using the changeset viewer.