Changeset 261567 in webkit
- Timestamp:
- May 12, 2020 11:48:02 AM (4 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 68 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/API/JSScriptRef.cpp
r261556 r261567 40 40 using namespace JSC; 41 41 42 struct OpaqueJSScript : public SourceProvider {42 struct OpaqueJSScript final : public SourceProvider { 43 43 public: 44 44 static WTF::Ref<OpaqueJSScript> create(VM& vm, const SourceOrigin& sourceOrigin, URL&& url, int startingLineNumber, const String& source) … … 47 47 } 48 48 49 unsigned hash() const override49 unsigned hash() const final 50 50 { 51 51 return m_source.get().hash(); 52 52 } 53 53 54 StringView source() const override54 StringView source() const final 55 55 { 56 56 return m_source.get(); … … 67 67 } 68 68 69 virtual ~OpaqueJSScript(){ }69 ~OpaqueJSScript() final { } 70 70 71 71 VM& m_vm; -
trunk/Source/JavaScriptCore/ChangeLog
r261564 r261567 1 2020-05-12 Ross Kirsling <ross.kirsling@sony.com> 2 3 [clang-tidy] Run modernize-use-override over JSC, then ensure as much as possible is final 4 https://bugs.webkit.org/show_bug.cgi?id=211743 5 6 Reviewed by Saam Barati. 7 8 * API/JSScriptRef.cpp: 9 * b3/B3ArgumentRegValue.h: 10 * b3/B3AtomicValue.h: 11 * b3/B3CCallValue.h: 12 * b3/B3CheckSpecial.h: 13 * b3/B3CheckValue.h: 14 * b3/B3Const32Value.h: 15 * b3/B3Const64Value.h: 16 * b3/B3ConstDoubleValue.h: 17 * b3/B3ConstFloatValue.h: 18 * b3/B3DataSection.h: 19 * b3/B3ExtractValue.h: 20 * b3/B3FenceValue.h: 21 * b3/B3MemoryValue.h: 22 * b3/B3PatchpointSpecial.h: 23 * b3/B3PatchpointValue.h: 24 * b3/B3SlotBaseValue.h: 25 * b3/B3StackmapSpecial.h: 26 * b3/B3StackmapValue.h: 27 * b3/B3SwitchValue.h: 28 * b3/B3UpsilonValue.h: 29 * b3/B3VariableValue.h: 30 * b3/B3WasmAddressValue.h: 31 * b3/B3WasmBoundsCheckValue.h: 32 * b3/air/AirCCallSpecial.h: 33 * b3/air/AirPrintSpecial.h: 34 * bytecode/BytecodeDumper.h: 35 * bytecode/GetterSetterAccessCase.h: 36 * bytecode/InstanceOfAccessCase.h: 37 * bytecode/IntrinsicGetterAccessCase.h: 38 * bytecode/ModuleNamespaceAccessCase.h: 39 * bytecode/ProxyableAccessCase.h: 40 * bytecode/Watchpoint.h: 41 * dfg/DFGFailedFinalizer.h: 42 * dfg/DFGGraph.h: 43 * dfg/DFGJITCode.h: 44 * dfg/DFGJITFinalizer.h: 45 * dfg/DFGToFTLDeferredCompilationCallback.h: 46 * dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h: 47 * ftl/FTLForOSREntryJITCode.h: 48 * ftl/FTLJITCode.h: 49 * ftl/FTLJITFinalizer.h: 50 * heap/CompleteSubspace.h: 51 * heap/FastMallocAlignedMemoryAllocator.h: 52 * heap/GigacageAlignedMemoryAllocator.h: 53 * heap/HeapSnapshotBuilder.h: 54 * heap/IsoAlignedMemoryAllocator.h: 55 * heap/IsoSubspace.h: 56 * heap/IsoSubspacePerVM.cpp: 57 * heap/IsoSubspacePerVM.h: 58 * heap/MarkStackMergingConstraint.h: 59 * heap/SimpleMarkingConstraint.h: 60 * heap/SpaceTimeMutatorScheduler.h: 61 * heap/StochasticSpaceTimeMutatorScheduler.h: 62 * heap/SynchronousStopTheWorldMutatorScheduler.h: 63 * jit/GCAwareJITStubRoutine.h: 64 * jit/JITCode.h: 65 * jit/JITThunks.h: 66 * jit/JITToDFGDeferredCompilationCallback.h: 67 * jit/PolymorphicCallStubRoutine.h: 68 * jsc.cpp: 69 * parser/Lexer.cpp: Address warning. 70 * runtime/JSDestructibleObjectHeapCellType.h: 71 * runtime/SimpleTypedArrayController.h: 72 * runtime/Structure.h: 73 * runtime/WeakGCMap.h: 74 * wasm/WasmEntryPlan.h: 75 1 76 2020-05-12 Michael Catanzaro <mcatanzaro@gnome.org> 2 77 -
trunk/Source/JavaScriptCore/b3/B3ArgumentRegValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class JS_EXPORT_PRIVATE ArgumentRegValue : public Value {35 class JS_EXPORT_PRIVATE ArgumentRegValue final : public Value { 36 36 public: 37 37 static bool accepts(Kind kind) { return kind == ArgumentReg; } 38 38 39 ~ArgumentRegValue() ;39 ~ArgumentRegValue() final; 40 40 41 41 Reg argumentReg() const { return m_reg; } … … 43 43 B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN 44 44 45 pr otected:46 void dumpMeta(CommaPrinter&, PrintStream&) const override;45 private: 46 void dumpMeta(CommaPrinter&, PrintStream&) const final; 47 47 48 private:49 48 friend class Procedure; 50 49 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3AtomicValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class JS_EXPORT_PRIVATE AtomicValue : public MemoryValue {35 class JS_EXPORT_PRIVATE AtomicValue final : public MemoryValue { 36 36 public: 37 37 static bool accepts(Kind kind) … … 40 40 } 41 41 42 ~AtomicValue() ;42 ~AtomicValue() final; 43 43 44 44 Type accessType() const { return child(0)->type(); } … … 48 48 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 49 49 50 pr otected:51 void dumpMeta(CommaPrinter&, PrintStream&) const override;50 private: 51 void dumpMeta(CommaPrinter&, PrintStream&) const final; 52 52 53 private:54 53 friend class Procedure; 55 54 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3CCallValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class JS_EXPORT_PRIVATE CCallValue : public Value {35 class JS_EXPORT_PRIVATE CCallValue final : public Value { 36 36 public: 37 37 static bool accepts(Kind kind) { return kind == CCall; } 38 38 39 ~CCallValue() ;39 ~CCallValue() final; 40 40 41 41 void appendArgs(const Vector<Value*>&); -
trunk/Source/JavaScriptCore/b3/B3CheckSpecial.h
r261556 r261567 49 49 // - CheckMul(a, b), which turns into Mul32 b, a but we pass Any for a's ValueRep. 50 50 51 class CheckSpecial : public StackmapSpecial {51 class CheckSpecial final : public StackmapSpecial { 52 52 public: 53 53 // Support for hash consing these things. … … 114 114 CheckSpecial(Air::Kind, unsigned numArgs, RoleMode stackmapRole = SameAsRep); 115 115 CheckSpecial(const Key&); 116 ~CheckSpecial() ;116 ~CheckSpecial() final; 117 117 118 pr otected:118 private: 119 119 // Constructs and returns the Inst representing the branch that this will use. 120 120 Air::Inst hiddenBranch(const Air::Inst&) const; … … 134 134 void deepDumpImpl(PrintStream&) const final; 135 135 136 private:137 136 Air::Kind m_checkKind; 138 137 RoleMode m_stackmapRole; -
trunk/Source/JavaScriptCore/b3/B3CheckValue.h
r261556 r261567 32 32 namespace JSC { namespace B3 { 33 33 34 class CheckValue : public StackmapValue {34 class CheckValue final : public StackmapValue { 35 35 public: 36 36 static bool accepts(Kind kind) … … 47 47 } 48 48 49 ~CheckValue() ;49 ~CheckValue() final; 50 50 51 51 void convertToAdd(); -
trunk/Source/JavaScriptCore/b3/B3Const32Value.h
r261556 r261567 36 36 static bool accepts(Kind kind) { return kind == Const32; } 37 37 38 ~Const32Value() ;38 ~Const32Value() override; 39 39 40 40 int32_t value() const { return m_value; } -
trunk/Source/JavaScriptCore/b3/B3Const64Value.h
r261556 r261567 36 36 static bool accepts(Kind kind) { return kind == Const64; } 37 37 38 ~Const64Value() ;38 ~Const64Value() override; 39 39 40 40 int64_t value() const { return m_value; } -
trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h
r261556 r261567 32 32 namespace JSC { namespace B3 { 33 33 34 class JS_EXPORT_PRIVATE ConstDoubleValue : public Value {34 class JS_EXPORT_PRIVATE ConstDoubleValue final : public Value { 35 35 public: 36 36 static bool accepts(Kind kind) { return kind == ConstDouble; } 37 37 38 ~ConstDoubleValue() ;38 ~ConstDoubleValue() final; 39 39 40 40 double value() const { return m_value; } 41 41 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;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; 58 58 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;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; 66 66 67 67 B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN … … 71 71 friend class Value; 72 72 73 void dumpMeta(CommaPrinter&, PrintStream&) const override;73 void dumpMeta(CommaPrinter&, PrintStream&) const final; 74 74 75 75 static Opcode opcodeFromConstructor(Origin, double) { return ConstDouble; } -
trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h
r261556 r261567 32 32 namespace JSC { namespace B3 { 33 33 34 class JS_EXPORT_PRIVATE ConstFloatValue : public Value {34 class JS_EXPORT_PRIVATE ConstFloatValue final : public Value { 35 35 public: 36 36 static bool accepts(Kind kind) { return kind == ConstFloat; } 37 37 38 ~ConstFloatValue() ;38 ~ConstFloatValue() final; 39 39 40 40 float value() const { return m_value; } 41 41 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;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; 57 57 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;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; 65 65 66 66 B3_SPECIALIZE_VALUE_FOR_NO_CHILDREN … … 70 70 friend class Value; 71 71 72 void dumpMeta(CommaPrinter&, PrintStream&) const override;72 void dumpMeta(CommaPrinter&, PrintStream&) const final; 73 73 74 74 static Opcode opcodeFromConstructor(Origin, float) { return ConstFloat; } -
trunk/Source/JavaScriptCore/b3/B3DataSection.h
r261556 r261567 32 32 namespace JSC { namespace B3 { 33 33 34 class DataSection : public OpaqueByproduct {34 class DataSection final : public OpaqueByproduct { 35 35 public: 36 36 DataSection(size_t size); 37 virtual ~DataSection();37 ~DataSection() final; 38 38 39 39 void* data() const { return m_data; } 40 40 size_t size() const { return m_size; } 41 41 42 void dump(PrintStream&) const override;42 void dump(PrintStream&) const final; 43 43 44 44 private: -
trunk/Source/JavaScriptCore/b3/B3ExtractValue.h
r261556 r261567 36 36 static bool accepts(Kind kind) { return kind == Extract; } 37 37 38 ~ExtractValue() ;38 ~ExtractValue() final; 39 39 40 40 int32_t index() const { return m_index; } … … 44 44 45 45 private: 46 void dumpMeta(CommaPrinter&, PrintStream&) const override;46 void dumpMeta(CommaPrinter&, PrintStream&) const final; 47 47 48 48 static Opcode opcodeFromConstructor(Origin, Type, Value*, int32_t) { return Extract; } -
trunk/Source/JavaScriptCore/b3/B3FenceValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class JS_EXPORT_PRIVATE FenceValue : public Value {35 class JS_EXPORT_PRIVATE FenceValue final : public Value { 36 36 public: 37 37 static bool accepts(Kind kind) { return kind == Fence; } 38 38 39 ~FenceValue() ;39 ~FenceValue() final; 40 40 41 41 // The read/write heaps are reflected in the effects() of this value. The compiler may change -
trunk/Source/JavaScriptCore/b3/B3MemoryValue.h
r261556 r261567 42 42 } 43 43 44 ~MemoryValue() ;44 ~MemoryValue() override; 45 45 46 46 OffsetType offset() const { return m_offset; } -
trunk/Source/JavaScriptCore/b3/B3PatchpointSpecial.h
r261556 r261567 42 42 // Patch &patchpoint, result, args... 43 43 44 class PatchpointSpecial : public StackmapSpecial {44 class PatchpointSpecial final : public StackmapSpecial { 45 45 public: 46 46 JS_EXPORT_PRIVATE PatchpointSpecial(); 47 virtual ~PatchpointSpecial();47 JS_EXPORT_PRIVATE ~PatchpointSpecial() final; 48 48 49 pr otected:49 private: 50 50 void forEachArg(Air::Inst&, const ScopedLambda<Air::Inst::EachArgCallback>&) final; 51 51 bool isValid(Air::Inst&) final; -
trunk/Source/JavaScriptCore/b3/B3PatchpointValue.h
r261556 r261567 34 34 namespace JSC { namespace B3 { 35 35 36 class PatchpointValue : public StackmapValue {36 class PatchpointValue final : public StackmapValue { 37 37 public: 38 38 typedef StackmapValue Base; … … 40 40 static bool accepts(Kind kind) { return kind == Patchpoint; } 41 41 42 ~PatchpointValue() ;42 ~PatchpointValue() final; 43 43 44 44 // The effects of the patchpoint. This defaults to Effects::forCall(), but you can set it to anything. … … 65 65 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_VARARGS_CHILDREN 66 66 67 pr otected:68 void dumpMeta(CommaPrinter&, PrintStream&) const override;67 private: 68 void dumpMeta(CommaPrinter&, PrintStream&) const final; 69 69 70 private:71 70 friend class Procedure; 72 71 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3SlotBaseValue.h
r261556 r261567 34 34 class StackSlot; 35 35 36 class JS_EXPORT_PRIVATE SlotBaseValue : public Value {36 class JS_EXPORT_PRIVATE SlotBaseValue final : public Value { 37 37 public: 38 38 static bool accepts(Kind kind) { return kind == SlotBase; } 39 39 40 ~SlotBaseValue() ;40 ~SlotBaseValue() final; 41 41 42 42 StackSlot* slot() const { return m_slot; } … … 48 48 friend class Value; 49 49 50 void dumpMeta(CommaPrinter&, PrintStream&) const override;50 void dumpMeta(CommaPrinter&, PrintStream&) const final; 51 51 52 52 static Opcode opcodeFromConstructor(Origin, StackSlot*) { return SlotBase; } -
trunk/Source/JavaScriptCore/b3/B3StackmapSpecial.h
r261556 r261567 43 43 public: 44 44 StackmapSpecial(); 45 virtual ~StackmapSpecial();45 ~StackmapSpecial() override; 46 46 47 47 enum RoleMode : int8_t { -
trunk/Source/JavaScriptCore/b3/B3StackmapValue.h
r261556 r261567 62 62 } 63 63 64 ~StackmapValue() ;64 ~StackmapValue() override; 65 65 66 66 // Use this to add children. -
trunk/Source/JavaScriptCore/b3/B3SwitchValue.h
r261556 r261567 34 34 namespace JSC { namespace B3 { 35 35 36 class SwitchValue : public Value {36 class SwitchValue final : public Value { 37 37 public: 38 38 static bool accepts(Kind kind) { return kind == Switch; } 39 39 40 ~SwitchValue() ;40 ~SwitchValue() final; 41 41 42 42 // numCaseValues() + 1 == numSuccessors(). … … 63 63 JS_EXPORT_PRIVATE void appendCase(const SwitchCase&); 64 64 65 void dumpSuccessors(const BasicBlock*, PrintStream&) const override;65 void dumpSuccessors(const BasicBlock*, PrintStream&) const final; 66 66 67 67 B3_SPECIALIZE_VALUE_FOR_FIXED_CHILDREN(1) 68 68 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 69 69 70 pr otected:71 void dumpMeta(CommaPrinter&, PrintStream&) const override;70 private: 71 void dumpMeta(CommaPrinter&, PrintStream&) const final; 72 72 73 private:74 73 friend class Procedure; 75 74 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3UpsilonValue.h
r261556 r261567 32 32 namespace JSC { namespace B3 { 33 33 34 class JS_EXPORT_PRIVATE UpsilonValue : public Value {34 class JS_EXPORT_PRIVATE UpsilonValue final : public Value { 35 35 public: 36 36 static bool accepts(Kind kind) { return kind == Upsilon; } 37 37 38 ~UpsilonValue() ;38 ~UpsilonValue() final; 39 39 40 40 Value* phi() const { return m_phi; } … … 49 49 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 50 50 51 pr otected:52 void dumpMeta(CommaPrinter&, PrintStream&) const override;51 private: 52 void dumpMeta(CommaPrinter&, PrintStream&) const final; 53 53 54 private:55 54 friend class Procedure; 56 55 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3VariableValue.h
r261556 r261567 34 34 class Variable; 35 35 36 class JS_EXPORT_PRIVATE VariableValue : public Value {36 class JS_EXPORT_PRIVATE VariableValue final : public Value { 37 37 public: 38 38 static bool accepts(Kind kind) { return kind == Get || kind == Set; } 39 39 40 ~VariableValue() ;40 ~VariableValue() final; 41 41 42 42 Variable* variable() const { return m_variable; } … … 45 45 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 46 46 47 pr otected:48 void dumpMeta(CommaPrinter&, PrintStream&) const override;47 private: 48 void dumpMeta(CommaPrinter&, PrintStream&) const final; 49 49 50 private:51 50 friend class Procedure; 52 51 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3WasmAddressValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class JS_EXPORT_PRIVATE WasmAddressValue : public Value {35 class JS_EXPORT_PRIVATE WasmAddressValue final : public Value { 36 36 public: 37 37 static bool accepts(Kind kind) { return kind == WasmAddress; } 38 38 39 ~WasmAddressValue() ;39 ~WasmAddressValue() final; 40 40 41 41 GPRReg pinnedGPR() const { return m_pinnedGPR; } … … 44 44 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 45 45 46 pr otected:47 void dumpMeta(CommaPrinter&, PrintStream&) const override;46 private: 47 void dumpMeta(CommaPrinter&, PrintStream&) const final; 48 48 49 private:50 49 friend class Procedure; 51 50 friend class Value; -
trunk/Source/JavaScriptCore/b3/B3WasmBoundsCheckValue.h
r261556 r261567 33 33 namespace JSC { namespace B3 { 34 34 35 class WasmBoundsCheckValue : public Value {35 class WasmBoundsCheckValue final : public Value { 36 36 public: 37 37 static bool accepts(Kind kind) { return kind == WasmBoundsCheck; } 38 38 39 ~WasmBoundsCheckValue() ;39 ~WasmBoundsCheckValue() final; 40 40 41 41 enum class Type { … … 56 56 B3_SPECIALIZE_VALUE_FOR_FINAL_SIZE_FIXED_CHILDREN 57 57 58 pr otected:59 void dumpMeta(CommaPrinter&, PrintStream&) const override;58 private: 59 void dumpMeta(CommaPrinter&, PrintStream&) const final; 60 60 61 private:62 61 friend class Procedure; 63 62 friend class Value; -
trunk/Source/JavaScriptCore/b3/air/AirCCallSpecial.h
r261556 r261567 43 43 // the prologue, whichever happened sooner. 44 44 45 class CCallSpecial : public Special {45 class CCallSpecial final : public Special { 46 46 public: 47 47 CCallSpecial(); 48 ~CCallSpecial() ;48 ~CCallSpecial() final; 49 49 50 50 // You cannot use this register to pass arguments. It just so happens that this register is not … … 53 53 static constexpr GPRReg scratchRegister = GPRInfo::nonPreservedNonArgumentGPR0; 54 54 55 pr otected:55 private: 56 56 void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final; 57 57 bool isValid(Inst&) final; … … 66 66 void deepDumpImpl(PrintStream&) const final; 67 67 68 private:69 68 static constexpr unsigned specialArgOffset = 0; 70 69 static constexpr unsigned numSpecialArgs = 1; -
trunk/Source/JavaScriptCore/b3/air/AirPrintSpecial.h
r261556 r261567 93 93 namespace B3 { namespace Air { 94 94 95 class PrintSpecial : public Special {95 class PrintSpecial final : public Special { 96 96 public: 97 97 PrintSpecial(Printer::PrintRecordList*); 98 ~PrintSpecial() ;98 ~PrintSpecial() final; 99 99 100 100 // You cannot use this register to pass arguments. It just so happens that this register is not … … 103 103 static constexpr GPRReg scratchRegister = GPRInfo::nonArgGPR0; 104 104 105 pr otected:105 private: 106 106 void forEachArg(Inst&, const ScopedLambda<Inst::EachArgCallback>&) final; 107 107 bool isValid(Inst&) final; … … 116 116 void deepDumpImpl(PrintStream&) const final; 117 117 118 private:119 118 static constexpr unsigned specialArgOffset = 0; 120 119 static constexpr unsigned numSpecialArgs = 1; -
trunk/Source/JavaScriptCore/bytecode/BytecodeDumper.h
r261556 r261567 85 85 } 86 86 87 virtual ~BytecodeDumper(){ }87 ~BytecodeDumper() override { } 88 88 89 89 protected: … … 102 102 103 103 template<class Block> 104 class CodeBlockBytecodeDumper : public BytecodeDumper<Block> {104 class CodeBlockBytecodeDumper final : public BytecodeDumper<Block> { 105 105 public: 106 106 static void dumpBlock(Block*, const InstructionStream&, PrintStream& out, const ICStatusMap& = ICStatusMap()); … … 128 128 enum Type : int8_t; 129 129 130 class BytecodeDumper : public JSC::BytecodeDumper<FunctionCodeBlock> {130 class BytecodeDumper final : public JSC::BytecodeDumper<FunctionCodeBlock> { 131 131 public: 132 132 static void dumpBlock(FunctionCodeBlock*, const ModuleInformation&, PrintStream& out); … … 136 136 137 137 void dumpConstants(); 138 CString constantName(VirtualRegister index) const override;138 CString constantName(VirtualRegister index) const final; 139 139 CString formatConstant(Type, uint64_t) const; 140 140 }; -
trunk/Source/JavaScriptCore/bytecode/GetterSetterAccessCase.h
r261556 r261567 33 33 namespace JSC { 34 34 35 class GetterSetterAccessCase : public ProxyableAccessCase {35 class GetterSetterAccessCase final : public ProxyableAccessCase { 36 36 public: 37 37 typedef ProxyableAccessCase Base; … … 49 49 Optional<DOMAttributeAnnotation> domAttribute() const { return m_domAttribute; } 50 50 51 bool hasAlternateBase() const override;52 JSObject* alternateBase() const override;51 bool hasAlternateBase() const final; 52 JSObject* alternateBase() const final; 53 53 54 54 void emitDOMJITGetter(AccessGenerationState&, const DOMJIT::GetterSetter*, GPRReg baseForGetGPR); … … 63 63 FunctionPtr<OperationPtrTag> customSetter = nullptr, JSObject* customSlotBase = nullptr); 64 64 65 void dumpImpl(PrintStream&, CommaPrinter&) const override;66 std::unique_ptr<AccessCase> clone() const override;65 void dumpImpl(PrintStream&, CommaPrinter&) const final; 66 std::unique_ptr<AccessCase> clone() const final; 67 67 68 ~GetterSetterAccessCase() ;68 ~GetterSetterAccessCase() final; 69 69 70 70 FunctionPtr<OperationPtrTag> customAccessor() const { return m_customAccessor; } -
trunk/Source/JavaScriptCore/bytecode/InstanceOfAccessCase.h
r261556 r261567 32 32 namespace JSC { 33 33 34 class InstanceOfAccessCase : public AccessCase {34 class InstanceOfAccessCase final : public AccessCase { 35 35 public: 36 36 using Base = AccessCase; … … 42 42 JSObject* prototype() const { return m_prototype.get(); } 43 43 44 void dumpImpl(PrintStream&, CommaPrinter&) const override;45 std::unique_ptr<AccessCase> clone() const override;44 void dumpImpl(PrintStream&, CommaPrinter&) const final; 45 std::unique_ptr<AccessCase> clone() const final; 46 46 47 ~InstanceOfAccessCase() ;47 ~InstanceOfAccessCase() final; 48 48 49 pr otected:49 private: 50 50 InstanceOfAccessCase( 51 51 VM&, JSCell*, AccessType, Structure*, const ObjectPropertyConditionSet&, 52 52 JSObject* prototype); 53 53 54 private:55 54 WriteBarrier<JSObject> m_prototype; 56 55 }; -
trunk/Source/JavaScriptCore/bytecode/IntrinsicGetterAccessCase.h
r261556 r261567 32 32 namespace JSC { 33 33 34 class IntrinsicGetterAccessCase : public AccessCase {34 class IntrinsicGetterAccessCase final : public AccessCase { 35 35 public: 36 36 typedef AccessCase Base; … … 45 45 static std::unique_ptr<AccessCase> create(VM&, JSCell*, CacheableIdentifier, PropertyOffset, Structure*, const ObjectPropertyConditionSet&, JSFunction* intrinsicFunction, std::unique_ptr<PolyProtoAccessChain>); 46 46 47 std::unique_ptr<AccessCase> clone() const override;47 std::unique_ptr<AccessCase> clone() const final; 48 48 49 ~IntrinsicGetterAccessCase() ;49 ~IntrinsicGetterAccessCase() final; 50 50 51 51 private: -
trunk/Source/JavaScriptCore/bytecode/ModuleNamespaceAccessCase.h
r261556 r261567 36 36 class JSModuleNamespaceObject; 37 37 38 class ModuleNamespaceAccessCase : public AccessCase {38 class ModuleNamespaceAccessCase final : public AccessCase { 39 39 public: 40 40 using Base = AccessCase; … … 47 47 static std::unique_ptr<AccessCase> create(VM&, JSCell* owner, CacheableIdentifier, JSModuleNamespaceObject*, JSModuleEnvironment*, ScopeOffset); 48 48 49 std::unique_ptr<AccessCase> clone() const override;49 std::unique_ptr<AccessCase> clone() const final; 50 50 51 51 void emit(AccessGenerationState&, MacroAssembler::JumpList& fallThrough); 52 52 53 ~ModuleNamespaceAccessCase() ;53 ~ModuleNamespaceAccessCase() final; 54 54 55 55 private: -
trunk/Source/JavaScriptCore/bytecode/ProxyableAccessCase.h
r261556 r261567 44 44 std::unique_ptr<AccessCase> clone() const override; 45 45 46 ~ProxyableAccessCase() ;46 ~ProxyableAccessCase() override; 47 47 48 48 protected: -
trunk/Source/JavaScriptCore/bytecode/Watchpoint.h
r261556 r261567 534 534 public: 535 535 JS_EXPORT_PRIVATE DeferredWatchpointFire(VM&); 536 JS_EXPORT_PRIVATE ~DeferredWatchpointFire() ;536 JS_EXPORT_PRIVATE ~DeferredWatchpointFire() override; 537 537 538 538 JS_EXPORT_PRIVATE void takeWatchpointsToFire(WatchpointSet*); -
trunk/Source/JavaScriptCore/dfg/DFGFailedFinalizer.h
r261556 r261567 32 32 namespace JSC { namespace DFG { 33 33 34 class FailedFinalizer : public Finalizer {34 class FailedFinalizer final : public Finalizer { 35 35 public: 36 36 FailedFinalizer(Plan&); 37 virtual ~FailedFinalizer();37 ~FailedFinalizer() final; 38 38 39 size_t codeSize() override;40 bool finalize() override;41 bool finalizeFunction() override;39 size_t codeSize() final; 40 bool finalize() final; 41 bool finalizeFunction() final; 42 42 }; 43 43 -
trunk/Source/JavaScriptCore/dfg/DFGGraph.h
r261556 r261567 160 160 // The order may be significant for nodes with side-effects (property accesses, value conversions). 161 161 // Nodes that are 'dead' remain in the vector with refCount 0. 162 class Graph : public virtual Scannable {162 class Graph final : public virtual Scannable { 163 163 public: 164 164 Graph(VM&, Plan&); 165 ~Graph() ;165 ~Graph() final; 166 166 167 167 void changeChild(Edge& edge, Node* newNode) … … 1002 1002 void registerFrozenValues(); 1003 1003 1004 void visitChildren(SlotVisitor&) override;1004 void visitChildren(SlotVisitor&) final; 1005 1005 1006 1006 void logAssertionFailure( -
trunk/Source/JavaScriptCore/dfg/DFGJITCode.h
r261556 r261567 47 47 class JITCompiler; 48 48 49 class JITCode : public DirectJITCode {49 class JITCode final : public DirectJITCode { 50 50 public: 51 51 JITCode(); 52 virtual ~JITCode();52 ~JITCode() final; 53 53 54 CommonData* dfgCommon() override;55 JITCode* dfg() override;54 CommonData* dfgCommon() final; 55 JITCode* dfg() final; 56 56 57 57 OSREntryData* appendOSREntryData(BytecodeIndex bytecodeIndex, CodeLocationLabel<OSREntryPtrTag> machineCode) … … 114 114 #endif // ENABLE(FTL_JIT) 115 115 116 void validateReferences(const TrackedReferences&) override;116 void validateReferences(const TrackedReferences&) final; 117 117 118 void shrinkToFit(const ConcurrentJSLocker&) override;118 void shrinkToFit(const ConcurrentJSLocker&) final; 119 119 120 RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) override;120 RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) final; 121 121 #if ENABLE(FTL_JIT) 122 122 CodeBlock* osrEntryBlock() { return m_osrEntryBlock.get(); } … … 127 127 static ptrdiff_t commonDataOffset() { return OBJECT_OFFSETOF(JITCode, common); } 128 128 129 Optional<CodeOrigin> findPC(CodeBlock*, void* pc) override;129 Optional<CodeOrigin> findPC(CodeBlock*, void* pc) final; 130 130 131 131 using DirectJITCode::initializeCodeRefForDFG; -
trunk/Source/JavaScriptCore/dfg/DFGJITFinalizer.h
r261556 r261567 34 34 namespace JSC { namespace DFG { 35 35 36 class JITFinalizer : public Finalizer {36 class JITFinalizer final : public Finalizer { 37 37 public: 38 38 JITFinalizer(Plan&, Ref<JITCode>&&, std::unique_ptr<LinkBuffer>, MacroAssemblerCodePtr<JSEntryPtrTag> withArityCheck = MacroAssemblerCodePtr<JSEntryPtrTag>(MacroAssemblerCodePtr<JSEntryPtrTag>::EmptyValue)); 39 virtual ~JITFinalizer();39 ~JITFinalizer() final; 40 40 41 size_t codeSize() override;42 bool finalize() override;43 bool finalizeFunction() override;41 size_t codeSize() final; 42 bool finalize() final; 43 bool finalizeFunction() final; 44 44 45 45 private: -
trunk/Source/JavaScriptCore/dfg/DFGToFTLDeferredCompilationCallback.h
r261556 r261567 37 37 namespace DFG { 38 38 39 class ToFTLDeferredCompilationCallback : public DeferredCompilationCallback { 40 protected: 41 ToFTLDeferredCompilationCallback(); 42 39 class ToFTLDeferredCompilationCallback final : public DeferredCompilationCallback { 43 40 public: 44 virtual ~ToFTLDeferredCompilationCallback();41 ~ToFTLDeferredCompilationCallback() final; 45 42 46 43 static Ref<ToFTLDeferredCompilationCallback> create(); 47 44 48 virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock); 49 virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult); 45 void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final; 46 void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final; 47 48 private: 49 ToFTLDeferredCompilationCallback(); 50 50 }; 51 51 -
trunk/Source/JavaScriptCore/dfg/DFGToFTLForOSREntryDeferredCompilationCallback.h
r261556 r261567 38 38 namespace DFG { 39 39 40 class ToFTLForOSREntryDeferredCompilationCallback : public DeferredCompilationCallback { 41 protected: 40 class ToFTLForOSREntryDeferredCompilationCallback final : public DeferredCompilationCallback { 41 public: 42 ~ToFTLForOSREntryDeferredCompilationCallback() final; 43 44 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 private: 42 50 ToFTLForOSREntryDeferredCompilationCallback(JITCode::TriggerReason* forcedOSREntryTrigger); 43 51 44 public:45 virtual ~ToFTLForOSREntryDeferredCompilationCallback();46 47 static Ref<ToFTLForOSREntryDeferredCompilationCallback> create(JITCode::TriggerReason* forcedOSREntryTrigger);48 49 virtual void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock);50 virtual void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult);51 52 private:53 52 JITCode::TriggerReason* m_forcedOSREntryTrigger; 54 53 }; -
trunk/Source/JavaScriptCore/ftl/FTLForOSREntryJITCode.h
r261556 r261567 41 41 // - Each OSR entry compilation allows entry through only one bytecode index. 42 42 43 class ForOSREntryJITCode : public FTL::JITCode {43 class ForOSREntryJITCode final : public FTL::JITCode { 44 44 public: 45 45 ForOSREntryJITCode(); 46 ~ForOSREntryJITCode() ;46 ~ForOSREntryJITCode() final; 47 47 48 48 void initializeEntryBuffer(VM&, unsigned numCalleeLocals); … … 55 55 unsigned entryFailureCount() const { return m_entryFailureCount; } 56 56 57 ForOSREntryJITCode* ftlForOSREntry() ;57 ForOSREntryJITCode* ftlForOSREntry() final; 58 58 59 59 private: -
trunk/Source/JavaScriptCore/ftl/FTLJITCode.h
r261556 r261567 43 43 public: 44 44 JITCode(); 45 ~JITCode() ;45 ~JITCode() override; 46 46 47 47 CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override; -
trunk/Source/JavaScriptCore/ftl/FTLJITFinalizer.h
r261556 r261567 48 48 }; 49 49 50 class JITFinalizer : public DFG::Finalizer {50 class JITFinalizer final : public DFG::Finalizer { 51 51 public: 52 52 JITFinalizer(DFG::Plan&); 53 virtual ~JITFinalizer();53 ~JITFinalizer() final; 54 54 55 size_t codeSize() override;56 bool finalize() override;57 bool finalizeFunction() override;55 size_t codeSize() final; 56 bool finalize() final; 57 bool finalizeFunction() final; 58 58 59 59 bool finalizeCommon(); -
trunk/Source/JavaScriptCore/heap/CompleteSubspace.h
r261556 r261567 30 30 namespace JSC { 31 31 32 class CompleteSubspace : public Subspace {32 class CompleteSubspace final : public Subspace { 33 33 public: 34 34 JS_EXPORT_PRIVATE CompleteSubspace(CString name, Heap&, HeapCellType*, AlignedMemoryAllocator*); 35 JS_EXPORT_PRIVATE ~CompleteSubspace() ;35 JS_EXPORT_PRIVATE ~CompleteSubspace() final; 36 36 37 37 // In some code paths, we need it to be a compile error to call the virtual version of one of … … 40 40 // FIXME: Currently subspaces speak of BlockDirectories as "allocators", but that's temporary. 41 41 // https://bugs.webkit.org/show_bug.cgi?id=181559 42 Allocator allocatorFor(size_t, AllocatorForMode) override;42 Allocator allocatorFor(size_t, AllocatorForMode) final; 43 43 Allocator allocatorForNonVirtual(size_t, AllocatorForMode); 44 44 45 void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) override;45 void* allocate(VM&, size_t, GCDeferralContext*, AllocationFailureMode) final; 46 46 void* allocateNonVirtual(VM&, size_t, GCDeferralContext*, AllocationFailureMode); 47 47 void* reallocatePreciseAllocationNonVirtual(VM&, HeapCell*, size_t, GCDeferralContext*, AllocationFailureMode); -
trunk/Source/JavaScriptCore/heap/FastMallocAlignedMemoryAllocator.h
r261556 r261567 34 34 namespace JSC { 35 35 36 class FastMallocAlignedMemoryAllocator : public AlignedMemoryAllocator {36 class FastMallocAlignedMemoryAllocator final : public AlignedMemoryAllocator { 37 37 public: 38 38 FastMallocAlignedMemoryAllocator(); 39 ~FastMallocAlignedMemoryAllocator() ;39 ~FastMallocAlignedMemoryAllocator() final; 40 40 41 void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;42 void freeAlignedMemory(void*) override;41 void* tryAllocateAlignedMemory(size_t alignment, size_t size) final; 42 void freeAlignedMemory(void*) final; 43 43 44 void dump(PrintStream&) const override;44 void dump(PrintStream&) const final; 45 45 46 void* tryAllocateMemory(size_t) override;47 void freeMemory(void*) override;48 void* tryReallocateMemory(void*, size_t) override;46 void* tryAllocateMemory(size_t) final; 47 void freeMemory(void*) final; 48 void* tryReallocateMemory(void*, size_t) final; 49 49 50 50 #if ENABLE(MALLOC_HEAP_BREAKDOWN) -
trunk/Source/JavaScriptCore/heap/GigacageAlignedMemoryAllocator.h
r261556 r261567 35 35 namespace JSC { 36 36 37 class GigacageAlignedMemoryAllocator : public AlignedMemoryAllocator {37 class GigacageAlignedMemoryAllocator final : public AlignedMemoryAllocator { 38 38 public: 39 39 GigacageAlignedMemoryAllocator(Gigacage::Kind); 40 ~GigacageAlignedMemoryAllocator() ;40 ~GigacageAlignedMemoryAllocator() final; 41 41 42 void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;43 void freeAlignedMemory(void*) override;42 void* tryAllocateAlignedMemory(size_t alignment, size_t size) final; 43 void freeAlignedMemory(void*) final; 44 44 45 void dump(PrintStream&) const override;45 void dump(PrintStream&) const final; 46 46 47 void* tryAllocateMemory(size_t) override;48 void freeMemory(void*) override;49 void* tryReallocateMemory(void*, size_t) override;47 void* tryAllocateMemory(size_t) final; 48 void freeMemory(void*) final; 49 void* tryReallocateMemory(void*, size_t) final; 50 50 51 51 private: -
trunk/Source/JavaScriptCore/heap/HeapSnapshotBuilder.h
r261556 r261567 109 109 110 110 HeapSnapshotBuilder(HeapProfiler&, SnapshotType = SnapshotType::InspectorSnapshot); 111 ~HeapSnapshotBuilder() ;111 ~HeapSnapshotBuilder() final; 112 112 113 113 static void resetNextAvailableObjectIdentifier(); … … 117 117 118 118 // A root or marked cell. 119 void analyzeNode(JSCell*) ;119 void analyzeNode(JSCell*) final; 120 120 121 121 // A reference from one cell to another. 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) ;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; 126 126 127 void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*) ;128 void setWrappedObjectForCell(JSCell*, void*) ;129 void setLabelForCell(JSCell*, const String&) ;127 void setOpaqueRootReachabilityReasonForCell(JSCell*, const char*) final; 128 void setWrappedObjectForCell(JSCell*, void*) final; 129 void setLabelForCell(JSCell*, const String&) final; 130 130 131 131 String json(); -
trunk/Source/JavaScriptCore/heap/IsoAlignedMemoryAllocator.h
r261556 r261567 35 35 namespace JSC { 36 36 37 class IsoAlignedMemoryAllocator : public AlignedMemoryAllocator {37 class IsoAlignedMemoryAllocator final : public AlignedMemoryAllocator { 38 38 public: 39 39 IsoAlignedMemoryAllocator(CString); 40 ~IsoAlignedMemoryAllocator() ;40 ~IsoAlignedMemoryAllocator() final; 41 41 42 void* tryAllocateAlignedMemory(size_t alignment, size_t size) override;43 void freeAlignedMemory(void*) override;42 void* tryAllocateAlignedMemory(size_t alignment, size_t size) final; 43 void freeAlignedMemory(void*) final; 44 44 45 void dump(PrintStream&) const override;45 void dump(PrintStream&) const final; 46 46 47 void* tryAllocateMemory(size_t) override;48 void freeMemory(void*) override;49 void* tryReallocateMemory(void*, size_t) override;47 void* tryAllocateMemory(size_t) final; 48 void freeMemory(void*) final; 49 void* tryReallocateMemory(void*, size_t) final; 50 50 51 51 private: -
trunk/Source/JavaScriptCore/heap/IsoSubspace.h
r261556 r261567 39 39 public: 40 40 JS_EXPORT_PRIVATE IsoSubspace(CString name, Heap&, HeapCellType*, size_t size, uint8_t numberOfLowerTierCells); 41 JS_EXPORT_PRIVATE ~IsoSubspace() ;41 JS_EXPORT_PRIVATE ~IsoSubspace() override; 42 42 43 43 size_t cellSize() { return m_directory.cellSize(); } -
trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.cpp
r261556 r261567 32 32 namespace JSC { 33 33 34 class IsoSubspacePerVM::AutoremovingIsoSubspace : public IsoSubspace {34 class IsoSubspacePerVM::AutoremovingIsoSubspace final : public IsoSubspace { 35 35 public: 36 36 AutoremovingIsoSubspace(IsoSubspacePerVM& perVM, CString name, Heap& heap, HeapCellType* heapCellType, size_t size) … … 40 40 } 41 41 42 ~AutoremovingIsoSubspace() 42 ~AutoremovingIsoSubspace() final 43 43 { 44 44 auto locker = holdLock(m_perVM.m_lock); -
trunk/Source/JavaScriptCore/heap/IsoSubspacePerVM.h
r261556 r261567 37 37 // once, then this is not great, because concurrent allocations will probably contend on this thing's 38 38 // lock. 39 class IsoSubspacePerVM {39 class IsoSubspacePerVM final { 40 40 public: 41 41 struct SubspaceParameters { -
trunk/Source/JavaScriptCore/heap/MarkStackMergingConstraint.h
r261556 r261567 33 33 class SlotVisitor; 34 34 35 class MarkStackMergingConstraint : public MarkingConstraint {35 class MarkStackMergingConstraint final : public MarkingConstraint { 36 36 public: 37 37 MarkStackMergingConstraint(Heap&); 38 ~MarkStackMergingConstraint() ;38 ~MarkStackMergingConstraint() final; 39 39 40 double quickWorkEstimate(SlotVisitor&) override; 41 42 protected: 43 void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) override; 44 void executeImpl(SlotVisitor&) override; 40 double quickWorkEstimate(SlotVisitor&) final; 45 41 46 42 private: 43 void prepareToExecuteImpl(const AbstractLocker& constraintSolvingLocker, SlotVisitor&) final; 44 void executeImpl(SlotVisitor&) final; 45 47 46 Heap& m_heap; 48 47 }; -
trunk/Source/JavaScriptCore/heap/SimpleMarkingConstraint.h
r261556 r261567 34 34 // downside is that this makes it hard for constraints to override any functions in MarkingConstraint 35 35 // other than executeImpl. In those cases, just subclass MarkingConstraint. 36 class SimpleMarkingConstraint : public MarkingConstraint {36 class SimpleMarkingConstraint final : public MarkingConstraint { 37 37 public: 38 38 JS_EXPORT_PRIVATE SimpleMarkingConstraint( … … 52 52 } 53 53 54 JS_EXPORT_PRIVATE ~SimpleMarkingConstraint() ;54 JS_EXPORT_PRIVATE ~SimpleMarkingConstraint() final; 55 55 56 56 private: 57 void executeImpl(SlotVisitor&) override;57 void executeImpl(SlotVisitor&) final; 58 58 59 59 ::Function<void(SlotVisitor&)> m_executeFunction; -
trunk/Source/JavaScriptCore/heap/SpaceTimeMutatorScheduler.h
r261556 r261567 39 39 // began. 40 40 41 class SpaceTimeMutatorScheduler : public MutatorScheduler {41 class SpaceTimeMutatorScheduler final : public MutatorScheduler { 42 42 public: 43 43 SpaceTimeMutatorScheduler(Heap&); 44 ~SpaceTimeMutatorScheduler() ;44 ~SpaceTimeMutatorScheduler() final; 45 45 46 State state() const override;46 State state() const final; 47 47 48 void beginCollection() override;48 void beginCollection() final; 49 49 50 void didStop() override;51 void willResume() override;52 void didExecuteConstraints() override;50 void didStop() final; 51 void willResume() final; 52 void didExecuteConstraints() final; 53 53 54 MonotonicTime timeToStop() override;55 MonotonicTime timeToResume() override;54 MonotonicTime timeToStop() final; 55 MonotonicTime timeToResume() final; 56 56 57 void log() override;57 void log() final; 58 58 59 void endCollection() override;59 void endCollection() final; 60 60 61 61 private: -
trunk/Source/JavaScriptCore/heap/StochasticSpaceTimeMutatorScheduler.h
r261556 r261567 40 40 // began. 41 41 42 class StochasticSpaceTimeMutatorScheduler : public MutatorScheduler {42 class StochasticSpaceTimeMutatorScheduler final : public MutatorScheduler { 43 43 public: 44 44 StochasticSpaceTimeMutatorScheduler(Heap&); 45 ~StochasticSpaceTimeMutatorScheduler() ;45 ~StochasticSpaceTimeMutatorScheduler() final; 46 46 47 State state() const override;47 State state() const final; 48 48 49 void beginCollection() override;49 void beginCollection() final; 50 50 51 void didStop() override;52 void willResume() override;53 void didReachTermination() override;54 void didExecuteConstraints() override;55 void synchronousDrainingDidStall() override;51 void didStop() final; 52 void willResume() final; 53 void didReachTermination() final; 54 void didExecuteConstraints() final; 55 void synchronousDrainingDidStall() final; 56 56 57 MonotonicTime timeToStop() override;58 MonotonicTime timeToResume() override;57 MonotonicTime timeToStop() final; 58 MonotonicTime timeToResume() final; 59 59 60 void log() override;60 void log() final; 61 61 62 void endCollection() override;62 void endCollection() final; 63 63 64 64 private: -
trunk/Source/JavaScriptCore/heap/SynchronousStopTheWorldMutatorScheduler.h
r261556 r261567 36 36 // SpaceTimeMutatorScheduler. It tells the GC to never resume the world once the GC cycle begins. 37 37 38 class SynchronousStopTheWorldMutatorScheduler : public MutatorScheduler {38 class SynchronousStopTheWorldMutatorScheduler final : public MutatorScheduler { 39 39 public: 40 40 SynchronousStopTheWorldMutatorScheduler(); 41 ~SynchronousStopTheWorldMutatorScheduler() ;41 ~SynchronousStopTheWorldMutatorScheduler() final; 42 42 43 State state() const override;43 State state() const final; 44 44 45 void beginCollection() override;45 void beginCollection() final; 46 46 47 MonotonicTime timeToStop() override;48 MonotonicTime timeToResume() override;47 MonotonicTime timeToStop() final; 48 MonotonicTime timeToResume() final; 49 49 50 void endCollection() override;50 void endCollection() final; 51 51 52 52 private: -
trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.h
r261556 r261567 52 52 public: 53 53 GCAwareJITStubRoutine(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&); 54 virtual ~GCAwareJITStubRoutine();54 ~GCAwareJITStubRoutine() override; 55 55 56 56 static Ref<JITStubRoutine> create(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>& code, VM& vm) … … 84 84 MarkingGCAwareJITStubRoutine( 85 85 const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&); 86 virtual ~MarkingGCAwareJITStubRoutine();86 ~MarkingGCAwareJITStubRoutine() override; 87 87 88 88 protected: … … 98 98 // handling table when it dies. It also frees space in CodeOrigin table 99 99 // for new exception handlers to use the same DisposableCallSiteIndex. 100 class GCAwareJITStubRoutineWithExceptionHandler : public MarkingGCAwareJITStubRoutine {100 class GCAwareJITStubRoutineWithExceptionHandler final : public MarkingGCAwareJITStubRoutine { 101 101 public: 102 102 typedef GCAwareJITStubRoutine Base; … … 104 104 GCAwareJITStubRoutineWithExceptionHandler(const MacroAssemblerCodeRef<JITStubRoutinePtrTag>&, VM&, const JSCell* owner, const Vector<JSCell*>&, Bag<CallLinkInfo>&&, CodeBlock*, DisposableCallSiteIndex); 105 105 106 void aboutToDie() override;107 void observeZeroRefCount() override;106 void aboutToDie() final; 107 void observeZeroRefCount() final; 108 108 109 109 private: -
trunk/Source/JavaScriptCore/jit/JITCode.h
r261556 r261567 227 227 228 228 public: 229 virtual ~JITCodeWithCodeRef();229 ~JITCodeWithCodeRef() override; 230 230 231 231 void* executableAddressAtOffset(size_t offset) override; … … 246 246 DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared); 247 247 DirectJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared); // For generated thunk. 248 virtual ~DirectJITCode();248 ~DirectJITCode() override; 249 249 250 250 CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override; … … 261 261 NativeJITCode(JITType); 262 262 NativeJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, JITCode::ShareAttribute = JITCode::ShareAttribute::NotShared); 263 virtual ~NativeJITCode();263 ~NativeJITCode() override; 264 264 265 265 CodePtr<JSEntryPtrTag> addressForCall(ArityCheckMode) override; … … 269 269 public: 270 270 NativeDOMJITCode(CodeRef<JSEntryPtrTag>, JITType, Intrinsic, const DOMJIT::Signature*); 271 virtual ~NativeDOMJITCode()= default;272 273 const DOMJIT::Signature* signature() const override{ return m_signature; }271 ~NativeDOMJITCode() final = default; 272 273 const DOMJIT::Signature* signature() const final { return m_signature; } 274 274 275 275 private: -
trunk/Source/JavaScriptCore/jit/JITThunks.h
r261556 r261567 51 51 public: 52 52 JITThunks(); 53 virtual ~JITThunks();53 ~JITThunks() final; 54 54 55 55 MacroAssemblerCodePtr<JITThunkPtrTag> ctiNativeCall(VM&); … … 68 68 69 69 private: 70 void finalize(Handle<Unknown>, void* context) override;70 void finalize(Handle<Unknown>, void* context) final; 71 71 72 72 typedef HashMap<ThunkGenerator, MacroAssemblerCodeRef<JITThunkPtrTag>> CTIStubMap; -
trunk/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.h
r261556 r261567 34 34 class ScriptExecutable; 35 35 36 class JITToDFGDeferredCompilationCallback : public DeferredCompilationCallback { 37 protected: 38 JITToDFGDeferredCompilationCallback(); 39 36 class JITToDFGDeferredCompilationCallback final : public DeferredCompilationCallback { 40 37 public: 41 virtual ~JITToDFGDeferredCompilationCallback();38 ~JITToDFGDeferredCompilationCallback() final; 42 39 43 40 static Ref<JITToDFGDeferredCompilationCallback> create(); 44 41 45 void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) override; 46 void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) override; 42 void compilationDidBecomeReadyAsynchronously(CodeBlock*, CodeBlock* profiledDFGCodeBlock) final; 43 void compilationDidComplete(CodeBlock*, CodeBlock* profiledDFGCodeBlock, CompilationResult) final; 44 45 private: 46 JITToDFGDeferredCompilationCallback(); 47 47 }; 48 48 -
trunk/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.h
r261556 r261567 81 81 }; 82 82 83 class PolymorphicCallStubRoutine : public GCAwareJITStubRoutine {83 class PolymorphicCallStubRoutine final : public GCAwareJITStubRoutine { 84 84 public: 85 85 PolymorphicCallStubRoutine( … … 88 88 UniqueArray<uint32_t>&& fastCounts); 89 89 90 virtual ~PolymorphicCallStubRoutine();90 ~PolymorphicCallStubRoutine() final; 91 91 92 92 CallVariantList variants() const; … … 103 103 } 104 104 105 bool visitWeak(VM&) override; 106 107 protected: 108 void markRequiredObjectsInternal(SlotVisitor&) override; 105 bool visitWeak(VM&) final; 109 106 110 107 private: 108 void markRequiredObjectsInternal(SlotVisitor&) final; 109 111 110 Vector<WriteBarrier<JSCell>, 2> m_variants; 112 111 UniqueArray<uint32_t> m_fastCounts; -
trunk/Source/JavaScriptCore/jsc.cpp
r261556 r261567 973 973 } 974 974 975 class ShellSourceProvider : public StringSourceProvider {975 class ShellSourceProvider final : public StringSourceProvider { 976 976 public: 977 977 static Ref<ShellSourceProvider> create(const String& source, const SourceOrigin& sourceOrigin, URL&& url, const TextPosition& startPosition, SourceProviderSourceType sourceType) … … 980 980 } 981 981 982 ~ShellSourceProvider() 982 ~ShellSourceProvider() final 983 983 { 984 984 commitCachedBytecode(); 985 985 } 986 986 987 RefPtr<CachedBytecode> cachedBytecode() const override987 RefPtr<CachedBytecode> cachedBytecode() const final 988 988 { 989 989 if (!m_cachedBytecode) … … 992 992 } 993 993 994 void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const override994 void updateCache(const UnlinkedFunctionExecutable* executable, const SourceCode&, CodeSpecializationKind kind, const UnlinkedFunctionCodeBlock* codeBlock) const final 995 995 { 996 996 if (!cacheEnabled() || !m_cachedBytecode) … … 1002 1002 } 1003 1003 1004 void cacheBytecode(const BytecodeCacheGenerator& generator) const override1004 void cacheBytecode(const BytecodeCacheGenerator& generator) const final 1005 1005 { 1006 1006 if (!cacheEnabled()) … … 1013 1013 } 1014 1014 1015 void commitCachedBytecode() const override1015 void commitCachedBytecode() const final 1016 1016 { 1017 1017 if (!cacheEnabled() || !m_cachedBytecode || !m_cachedBytecode->hasUpdates()) -
trunk/Source/JavaScriptCore/parser/Lexer.cpp
r261556 r261567 747 747 } 748 748 749 static ALWAYS_INLINE bool isSingleCharacterIdentStart(UChar c)749 static ALWAYS_INLINE UNUSED_FUNCTION bool isSingleCharacterIdentStart(UChar c) 750 750 { 751 751 if (LIKELY(isLatin1(c))) -
trunk/Source/JavaScriptCore/runtime/JSDestructibleObjectHeapCellType.h
r261556 r261567 30 30 namespace JSC { 31 31 32 class JSDestructibleObjectHeapCellType : public HeapCellType {32 class JSDestructibleObjectHeapCellType final : public HeapCellType { 33 33 public: 34 34 JS_EXPORT_PRIVATE JSDestructibleObjectHeapCellType(); 35 JS_EXPORT_PRIVATE virtual ~JSDestructibleObjectHeapCellType();35 JS_EXPORT_PRIVATE ~JSDestructibleObjectHeapCellType() final; 36 36 37 void finishSweep(MarkedBlock::Handle&, FreeList*) override;38 void destroy(VM&, JSCell*) override;37 void finishSweep(MarkedBlock::Handle&, FreeList*) final; 38 void destroy(VM&, JSCell*) final; 39 39 }; 40 40 -
trunk/Source/JavaScriptCore/runtime/SimpleTypedArrayController.h
r261556 r261567 47 47 // one. 48 48 49 class SimpleTypedArrayController : public TypedArrayController {49 class SimpleTypedArrayController final : public TypedArrayController { 50 50 public: 51 51 SimpleTypedArrayController(); 52 virtual ~SimpleTypedArrayController();52 ~SimpleTypedArrayController() final; 53 53 54 JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) override;55 void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) override;56 bool isAtomicsWaitAllowedOnCurrentThread() override;54 JSArrayBuffer* toJS(JSGlobalObject*, JSGlobalObject*, ArrayBuffer*) final; 55 void registerWrapper(JSGlobalObject*, ArrayBuffer*, JSArrayBuffer*) final; 56 bool isAtomicsWaitAllowedOnCurrentThread() final; 57 57 58 58 private: 59 class JSArrayBufferOwner : public WeakHandleOwner {59 class JSArrayBufferOwner final : public WeakHandleOwner { 60 60 public: 61 bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) override;62 void finalize(JSC::Handle<JSC::Unknown>, void* context) override;61 bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, SlotVisitor&, const char** reason) final; 62 void finalize(JSC::Handle<JSC::Unknown>, void* context) final; 63 63 }; 64 64 -
trunk/Source/JavaScriptCore/runtime/Structure.h
r261556 r261567 97 97 }; 98 98 99 class StructureFireDetail : public FireDetail {99 class StructureFireDetail final : public FireDetail { 100 100 public: 101 101 StructureFireDetail(const Structure* structure) … … 104 104 } 105 105 106 void dump(PrintStream& out) const override;106 void dump(PrintStream& out) const final; 107 107 108 108 private: … … 110 110 }; 111 111 112 class DeferredStructureTransitionWatchpointFire : public DeferredWatchpointFire {112 class DeferredStructureTransitionWatchpointFire final : public DeferredWatchpointFire { 113 113 WTF_MAKE_NONCOPYABLE(DeferredStructureTransitionWatchpointFire); 114 114 public: 115 115 JS_EXPORT_PRIVATE DeferredStructureTransitionWatchpointFire(VM&, Structure*); 116 JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire() ;117 118 void dump(PrintStream& out) const override;116 JS_EXPORT_PRIVATE ~DeferredStructureTransitionWatchpointFire() final; 117 118 void dump(PrintStream& out) const final; 119 119 120 120 const Structure* structure() const { return m_structure; } -
trunk/Source/JavaScriptCore/runtime/WeakGCMap.h
r261556 r261567 41 41 template<typename KeyArg, typename ValueArg, typename HashArg = typename DefaultHash<KeyArg>::Hash, 42 42 typename KeyTraitsArg = HashTraits<KeyArg>> 43 class WeakGCMap : public WeakGCMapBase {43 class WeakGCMap final : public WeakGCMapBase { 44 44 WTF_MAKE_FAST_ALLOCATED; 45 45 typedef Weak<ValueArg> ValueType; … … 53 53 54 54 explicit WeakGCMap(VM&); 55 ~WeakGCMap() ;55 ~WeakGCMap() final; 56 56 57 57 ValueArg* get(const KeyType& key) const … … 92 92 inline bool contains(const KeyType& key) const; 93 93 94 void pruneStaleEntries() override;94 void pruneStaleEntries() final; 95 95 96 96 private: -
trunk/Source/JavaScriptCore/wasm/WasmEntryPlan.h
r261556 r261567 51 51 JS_EXPORT_PRIVATE EntryPlan(Context*, Vector<uint8_t>&&, AsyncWork, CompletionTask&&); 52 52 53 virtual ~EntryPlan()= default;53 ~EntryPlan() override = default; 54 54 55 55 void prepare();
Note: See TracChangeset
for help on using the changeset viewer.