Internals: Use and enforce class final for ~5% performance boost.

include/verilated.h

@@ -129,7 +129,7 @@ extern vluint32_t VL_THREAD_ID() VL_MT_SAFE;
 #define VL_LOCK_SPINS 50000  /// Number of times to spin for a mutex before relaxing
 
 /// Mutex, wrapped to allow -fthread_safety checks
-class VL_CAPABILITY("mutex") VerilatedMutex {
+class VL_CAPABILITY("mutex") VerilatedMutex final {
 private:
     std::mutex m_mutex;  // Mutex
 public:
@@ -155,7 +155,7 @@ public:
 };
 
 /// Lock guard for mutex (ala std::unique_lock), wrapped to allow -fthread_safety checks
-class VL_SCOPED_CAPABILITY VerilatedLockGuard {
+class VL_SCOPED_CAPABILITY VerilatedLockGuard final {
     VL_UNCOPYABLE(VerilatedLockGuard);
 
 private:
@@ -174,14 +174,14 @@ public:
 #else  // !VL_THREADED
 
 /// Empty non-threaded mutex to avoid #ifdefs in consuming code
-class VerilatedMutex {
+class VerilatedMutex final {
 public:
     void lock() {}
     void unlock() {}
 };
 
 /// Empty non-threaded lock guard to avoid #ifdefs in consuming code
-class VerilatedLockGuard {
+class VerilatedLockGuard final {
     VL_UNCOPYABLE(VerilatedLockGuard);
 
 public:
@@ -194,7 +194,7 @@ public:
 #endif  // VL_THREADED
 
 /// Remember the calling thread at construction time, and make sure later calls use same thread
-class VerilatedAssertOneThread {
+class VerilatedAssertOneThread final {
     // MEMBERS
 #if defined(VL_THREADED) && defined(VL_DEBUG)
     vluint32_t m_threadid;  /// Thread that is legal
@@ -230,7 +230,7 @@ public:
 
 class VerilatedScope;
 
-class VerilatedModule {
+class VerilatedModule VL_NOT_FINAL {
     VL_UNCOPYABLE(VerilatedModule);
 
 private:
@@ -269,7 +269,8 @@ public:
 #define VL_CELL(instname, type)  ///< Declare a cell, ala SP_CELL
 
 /// Declare a module, ala SC_MODULE
-#define VL_MODULE(modname) class modname : public VerilatedModule
+#define VL_MODULE(modname) class modname VL_NOT_FINAL : public VerilatedModule
+// Not class final in VL_MODULE, as users might be abstracting our models (--hierarchical)
 
 /// Constructor, ala SC_CTOR
 #define VL_CTOR(modname) modname(const char* __VCname = "")
@@ -298,7 +299,7 @@ public:
 //===========================================================================
 /// Verilator symbol table base class
 
-class VerilatedSyms {
+class VerilatedSyms VL_NOT_FINAL {
 public:  // But for internal use only
 #ifdef VL_THREADED
     VerilatedEvalMsgQueue* __Vm_evalMsgQp;
@@ -311,7 +312,7 @@ public:  // But for internal use only
 /// Verilator global class information class
 /// This class is initialized by main thread only. Reading post-init is thread safe.
 
-class VerilatedScope {
+class VerilatedScope final {
 public:
     typedef enum : vluint8_t {
         SCOPE_MODULE,
@@ -359,7 +360,7 @@ public:  // But internals only - called from VerilatedModule's
     Type type() const { return m_type; }
 };
 
-class VerilatedHierarchy {
+class VerilatedHierarchy final {
 public:
     static void add(VerilatedScope* fromp, VerilatedScope* top);
 };
@@ -367,7 +368,7 @@ public:
 //===========================================================================
 /// Verilator global static information class
 
-class Verilated {
+class Verilated final {
     // MEMBERS
     // Slow path variables
     static VerilatedMutex m_mutex;  ///< Mutex for s_s/s_ns members, when VL_THREADED

include/verilated_cov.cpp

@@ -29,7 +29,7 @@
 // VerilatedCovImpBase
 /// Implementation base class for constants
 
-struct VerilatedCovImpBase {
+struct VerilatedCovImpBase VL_NOT_FINAL {
     // TYPES
     enum { MAX_KEYS = 33 };  /// Maximum user arguments + filename+lineno
     enum { KEY_UNDEF = 0 };  /// Magic key # for unspecified values
@@ -39,7 +39,7 @@ struct VerilatedCovImpBase {
 // VerilatedCovImpItem
 /// Implementation class for a VerilatedCov item
 
-class VerilatedCovImpItem : VerilatedCovImpBase {
+class VerilatedCovImpItem VL_NOT_FINAL : VerilatedCovImpBase {
 public:  // But only local to this file
     // MEMBERS
     int m_keys[MAX_KEYS];  ///< Key
@@ -63,7 +63,7 @@ public:  // But only local to this file
 /// This isn't in the header file for auto-magic conversion because it
 /// inlines to too much code and makes compilation too slow.
 
-template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
+template <class T> class VerilatedCoverItemSpec final : public VerilatedCovImpItem {
 private:
     // MEMBERS
     T* m_countp;  ///< Count value
@@ -87,7 +87,7 @@ public:
 /// All value and keys are indexed into a unique number.  Thus we can greatly reduce
 /// the storage requirements for otherwise identical keys.
 
-class VerilatedCovImp : VerilatedCovImpBase {
+class VerilatedCovImp final : VerilatedCovImpBase {
 private:
     // TYPES
     typedef std::map<const std::string, int> ValueIndexMap;

include/verilated_cov.h

@@ -88,7 +88,7 @@ template <class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
 /// Global class with methods affecting all coverage data.
 /// All public methods in this class are thread safe.
 
-class VerilatedCov {
+class VerilatedCov final {
     VL_UNCOPYABLE(VerilatedCov);
 
 public:

include/verilated_cov_key.h

@@ -102,7 +102,7 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 /// Verilator coverage global class.
 /// This class is thread safe.
 
-class VerilatedCovKey {
+class VerilatedCovKey final {
 public:
     static std::string shortKey(const std::string& key) VL_PURE {
         // VLCOVGEN_SHORT_AUTO_EDIT_BEGIN

include/verilated_fst_c.h

@@ -35,7 +35,7 @@
 /// Base class to create a Verilator FST dump
 /// This is an internally used class - see VerilatedFstC for what to call from applications
 
-class VerilatedFst : public VerilatedTrace<VerilatedFst> {
+class VerilatedFst final : public VerilatedTrace<VerilatedFst> {
 private:
     // Give the superclass access to private bits (to avoid virtual functions)
     friend class VerilatedTrace<VerilatedFst>;
@@ -128,7 +128,7 @@ template <> void VerilatedTrace<VerilatedFst>::set_time_resolution(const std::st
 /// Also derived for use in SystemC simulations.
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
 
-class VerilatedFstC {
+class VerilatedFstC final {
     VerilatedFst m_sptrace;  ///< Trace file being created
 
     // CONSTRUCTORS

include/verilated_heavy.h

@@ -46,7 +46,7 @@ extern std::string VL_TO_STRING_W(int words, WDataInP obj);
 //===================================================================
 // Shuffle RNG
 
-class VlURNG {
+class VlURNG final {
 public:
     typedef size_t result_type;
     static constexpr size_t min() { return 0; }
@@ -57,7 +57,7 @@ public:
 //===================================================================
 // Readmem/Writemem operation classes
 
-class VlReadMem {
+class VlReadMem final {
     bool m_hex;  // Hex format
     int m_bits;  // Bit width of values
     const std::string& m_filename;  // Filename
@@ -74,7 +74,7 @@ public:
     void setData(void* valuep, const std::string& rhs);
 };
 
-class VlWriteMem {
+class VlWriteMem final {
     bool m_hex;  // Hex format
     int m_bits;  // Bit width of values
     FILE* m_fp;  // File handle for filename
@@ -93,7 +93,7 @@ public:
 //
 // Bound here is the maximum size() allowed, e.g. 1 + SystemVerilog bound
 // For dynamic arrays it is always zero
-template <class T_Value, size_t T_MaxSize = 0> class VlQueue {
+template <class T_Value, size_t T_MaxSize = 0> class VlQueue final {
 private:
     // TYPES
     typedef std::deque<T_Value> Deque;
@@ -424,7 +424,7 @@ template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
 // This is only used when we need an upper-level container and so can't
 // simply use a C style array (which is just a pointer).
 
-template <std::size_t T_Words> class VlWide {
+template <std::size_t T_Words> class VlWide final {
     WData m_storage[T_Words];
 
 public:
@@ -460,7 +460,7 @@ template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& o
 // There are no multithreaded locks on this; the base variable must
 // be protected by other means
 //
-template <class T_Key, class T_Value> class VlAssocArray {
+template <class T_Key, class T_Value> class VlAssocArray final {
 private:
     // TYPES
     typedef std::map<T_Key, T_Value> Map;

include/verilated_imp.h

@@ -46,7 +46,7 @@ class VerilatedScope;
 
 #ifdef VL_THREADED
 /// Message, enqueued on an mtask, and consumed on the main eval thread
-class VerilatedMsg {
+class VerilatedMsg final {
 public:
     // TYPES
     struct Cmp {
@@ -78,7 +78,7 @@ public:
 /// Each thread has a queue it pushes to
 /// This assumes no thread starts pushing the next tick until the previous has drained.
 /// If more aggressiveness is needed, a double-buffered scheme might work well.
-class VerilatedEvalMsgQueue {
+class VerilatedEvalMsgQueue final {
     typedef std::multiset<VerilatedMsg, VerilatedMsg::Cmp> VerilatedThreadQueue;
 
     std::atomic<vluint64_t> m_depth;  ///< Current depth of queue (see comments below)
@@ -130,7 +130,7 @@ public:
 };
 
 /// Each thread has a local queue to build up messages until the end of the eval() call
-class VerilatedThreadMsgQueue {
+class VerilatedThreadMsgQueue final {
     std::queue<VerilatedMsg> m_queue;
 
 public:
@@ -174,7 +174,7 @@ public:
 #endif  // VL_THREADED
 
 // FILE* list constructed from a file-descriptor
-class VerilatedFpList {
+class VerilatedFpList final {
     FILE* m_fp[31];
     std::size_t m_sz = 0;
 
@@ -193,7 +193,7 @@ public:
 //======================================================================
 // VerilatedImp
 
-class VerilatedImpData {
+class VerilatedImpData final {
     // Whole class is internal use only - Global information shared between verilated*.cpp files.
 protected:
     friend class Verilated;
@@ -264,7 +264,7 @@ protected:
     }
 };
 
-class VerilatedImp {
+class VerilatedImp final {
     // Whole class is internal use only - Global information shared between verilated*.cpp files.
 protected:
     friend class Verilated;

include/verilated_save.h

@@ -28,7 +28,7 @@
 // VerilatedSerialize - convert structures to a stream representation
 // This class is not thread safe, it must be called by a single thread
 
-class VerilatedSerialize {
+class VerilatedSerialize VL_NOT_FINAL {
 protected:
     // MEMBERS
     // For speed, keep m_cp as the first member of this structure
@@ -87,7 +87,7 @@ private:
 // VerilatedDeserial - load structures from a stream representation
 // This class is not thread safe, it must be called by a single thread
 
-class VerilatedDeserialize {
+class VerilatedDeserialize VL_NOT_FINAL {
 protected:
     // MEMBERS
     // For speed, keep m_cp as the first member of this structure
@@ -154,7 +154,7 @@ private:
 // VerilatedSave - serialize to a file
 // This class is not thread safe, it must be called by a single thread
 
-class VerilatedSave : public VerilatedSerialize {
+class VerilatedSave final : public VerilatedSerialize {
 private:
     int m_fd = -1;  ///< File descriptor we're writing to
 
@@ -174,7 +174,7 @@ public:
 // VerilatedRestore - deserialize from a file
 // This class is not thread safe, it must be called by a single thread
 
-class VerilatedRestore : public VerilatedDeserialize {
+class VerilatedRestore final : public VerilatedDeserialize {
 private:
     int m_fd = -1;  ///< File descriptor we're writing to
 

include/verilated_sc.h

@@ -34,7 +34,7 @@
 // This class is thread safe (though most of SystemC is not).
 
 #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
-class VlScBvExposer : public sc_bv_base {
+class VlScBvExposer final : public sc_bv_base {
 public:
     static const vluint32_t* sp_datap(const sc_bv_base& base) VL_MT_SAFE {
         return static_cast<const VlScBvExposer*>(&base)->sp_datatp();

include/verilated_sym_props.h

@@ -36,7 +36,7 @@
 /// Thread safety: Assume is constructed only with model, then any number of readers
 
 // See also V3Ast::VNumRange
-class VerilatedRange {
+class VerilatedRange final {
     int m_left = 0;
     int m_right = 0;
 
@@ -68,7 +68,7 @@ public:
 /// Verilator variable
 /// Thread safety: Assume is constructed only with model, then any number of readers
 
-class VerilatedVarProps {
+class VerilatedVarProps VL_NOT_FINAL {
     // TYPES
     enum { MAGIC = 0xddc4f829 };
     // MEMBERS
@@ -187,7 +187,7 @@ public:
 //===========================================================================
 /// Verilator DPI open array variable
 
-class VerilatedDpiOpenVar {
+class VerilatedDpiOpenVar final {
     // MEMBERS
     const VerilatedVarProps* m_propsp;  // Variable properties
     void* m_datap;  // Location of data (local to thread always, so safe)
@@ -225,7 +225,7 @@ public:
 /// Verilator variable
 /// Thread safety: Assume is constructed only with model, then any number of readers
 
-class VerilatedVar : public VerilatedVarProps {
+class VerilatedVar final : public VerilatedVarProps {
     // MEMBERS
     void* m_datap;  // Location of data
     const char* m_namep;  // Name - slowpath

include/verilated_syms.h

@@ -42,7 +42,7 @@ struct VerilatedCStrCmp {
 };
 
 /// Map of sorted scope names to find associated scope class
-class VerilatedScopeNameMap
+class VerilatedScopeNameMap final
     : public std::map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
 public:
     VerilatedScopeNameMap() = default;
@@ -50,7 +50,7 @@ public:
 };
 
 /// Map of sorted variable names to find associated variable class
-class VerilatedVarNameMap : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
+class VerilatedVarNameMap final : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
 public:
     VerilatedVarNameMap() = default;
     ~VerilatedVarNameMap() = default;
@@ -58,7 +58,7 @@ public:
 
 typedef std::vector<const VerilatedScope*> VerilatedScopeVector;
 
-class VerilatedHierarchyMap : public std::map<const VerilatedScope*, VerilatedScopeVector> {
+class VerilatedHierarchyMap final : public std::map<const VerilatedScope*, VerilatedScopeVector> {
 public:
     VerilatedHierarchyMap() = default;
     ~VerilatedHierarchyMap() = default;

include/verilated_threads.h

@@ -52,7 +52,7 @@ typedef void* VlThrSymTab;
 typedef void (*VlExecFnp)(bool, VlThrSymTab);
 
 /// Track dependencies for a single MTask.
-class VlMTaskVertex {
+class VlMTaskVertex final {
     // MEMBERS
     static std::atomic<vluint64_t> s_yields;  // Statistics
 
@@ -124,7 +124,7 @@ public:
 };
 
 // Profiling support
-class VlProfileRec {
+class VlProfileRec final {
 protected:
     friend class VlThreadPool;
     enum VlProfileE { TYPE_MTASK_RUN, TYPE_BARRIER };
@@ -168,7 +168,7 @@ public:
 
 class VlThreadPool;
 
-class VlWorkerThread {
+class VlWorkerThread final {
 private:
     // TYPES
     struct ExecRec {
@@ -247,7 +247,7 @@ public:
     static void startWorker(VlWorkerThread* workerp);
 };
 
-class VlThreadPool {
+class VlThreadPool final {
     // TYPES
     typedef std::vector<VlProfileRec> ProfileTrace;
     typedef std::set<ProfileTrace*> ProfileSet;

include/verilated_trace.h

@@ -40,7 +40,7 @@
 // Threaded tracing
 
 // A simple synchronized first in first out queue
-template <class T> class VerilatedThreadQueue {  // LCOV_EXCL_LINE  // lcov bug
+template <class T> class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
 private:
     VerilatedMutex m_mutex;  // Protects m_queue
     std::condition_variable_any m_cv;
@@ -83,7 +83,7 @@ public:
 
 // Commands used by thread tracing. Anonymous enum in class, as we want
 // it scoped, but we also want the automatic conversion to integer types.
-class VerilatedTraceCommand {
+class VerilatedTraceCommand final {
 public:
     // These must all fit in 4 bit at the moment, as the tracing routines
     // pack parameters in the top bits.
@@ -110,7 +110,7 @@ public:
 // VerilatedTrace uses F-bounded polymorphism to access duck-typed
 // implementations in the format specific derived class, which must be passed
 // as the type parameter T_Derived
-template <class T_Derived> class VerilatedTrace {
+template <class T_Derived> class VerilatedTrace VL_NOT_FINAL {
 public:
     //=========================================================================
     // Generic tracing internals

include/verilated_vcd_c.h

@@ -34,7 +34,7 @@ class VerilatedVcd;
 // VerilatedFile
 /// File handling routines, which can be overrode for e.g. socket I/O
 
-class VerilatedVcdFile {
+class VerilatedVcdFile final {
 private:
     int m_fd = 0;  ///< File descriptor we're writing to
 public:
@@ -51,7 +51,7 @@ public:
 /// Base class to create a Verilator VCD dump
 /// This is an internally used class - see VerilatedVcdC for what to call from applications
 
-class VerilatedVcd : public VerilatedTrace<VerilatedVcd> {
+class VerilatedVcd VL_NOT_FINAL : public VerilatedTrace<VerilatedVcd> {
 private:
     // Give the superclass access to private bits (to avoid virtual functions)
     friend class VerilatedTrace<VerilatedVcd>;
@@ -329,7 +329,7 @@ template <> void VerilatedTrace<VerilatedVcd>::set_time_resolution(const std::st
 /// Also derived for use in SystemC simulations.
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
 
-class VerilatedVcdC {
+class VerilatedVcdC VL_NOT_FINAL {
     VerilatedVcd m_sptrace;  ///< Trace file being created
 
     // CONSTRUCTORS

include/verilated_vcd_sc.h

@@ -31,7 +31,7 @@
 /// This class is passed to the SystemC simulation kernel, just like a
 /// documented SystemC trace format.
 
-class VerilatedVcdSc : sc_trace_file, public VerilatedVcdC {
+class VerilatedVcdSc final : sc_trace_file, public VerilatedVcdC {
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedVcdSc);
 

include/verilated_vpi.cpp

@@ -55,7 +55,7 @@ constexpr unsigned VL_VPI_LINE_SIZE = 8192;
 // Implementation
 
 // Base VPI handled object
-class VerilatedVpio {
+class VerilatedVpio VL_NOT_FINAL {
     // MEM MANGLEMENT
     static VL_THREAD_LOCAL vluint8_t* t_freeHead;
 
@@ -101,7 +101,7 @@ public:
 
 typedef PLI_INT32 (*VerilatedPliCb)(struct t_cb_data*);
 
-class VerilatedVpioCb : public VerilatedVpio {
+class VerilatedVpioCb final : public VerilatedVpio {
     t_cb_data m_cbData;
     s_vpi_value m_value;
     QData m_time;
@@ -125,7 +125,7 @@ public:
     QData time() const { return m_time; }
 };
 
-class VerilatedVpioConst : public VerilatedVpio {
+class VerilatedVpioConst final : public VerilatedVpio {
     vlsint32_t m_num;
 
 public:
@@ -139,7 +139,7 @@ public:
     vlsint32_t num() const { return m_num; }
 };
 
-class VerilatedVpioParam : public VerilatedVpio {
+class VerilatedVpioParam final : public VerilatedVpio {
     const VerilatedVar* m_varp;
     const VerilatedScope* m_scopep;
 
@@ -165,7 +165,7 @@ public:
     }
 };
 
-class VerilatedVpioRange : public VerilatedVpio {
+class VerilatedVpioRange final : public VerilatedVpio {
     const VerilatedRange* m_range;
     vlsint32_t m_iteration = 0;
 
@@ -191,7 +191,7 @@ public:
     }
 };
 
-class VerilatedVpioScope : public VerilatedVpio {
+class VerilatedVpioScope VL_NOT_FINAL : public VerilatedVpio {
 protected:
     const VerilatedScope* m_scopep;
 
@@ -208,7 +208,7 @@ public:
     virtual const char* fullname() const override { return m_scopep->name(); }
 };
 
-class VerilatedVpioVar : public VerilatedVpio {
+class VerilatedVpioVar VL_NOT_FINAL : public VerilatedVpio {
     const VerilatedVar* m_varp;
     const VerilatedScope* m_scopep;
     vluint8_t* m_prevDatap = nullptr;  // Previous value of data, for cbValueChange
@@ -266,7 +266,7 @@ public:
     }
 };
 
-class VerilatedVpioMemoryWord : public VerilatedVpioVar {
+class VerilatedVpioMemoryWord final : public VerilatedVpioVar {
 public:
     VerilatedVpioMemoryWord(const VerilatedVar* varp, const VerilatedScope* scopep,
                             vlsint32_t index, int offset)
@@ -290,7 +290,7 @@ public:
     }
 };
 
-class VerilatedVpioVarIter : public VerilatedVpio {
+class VerilatedVpioVarIter final : public VerilatedVpio {
     const VerilatedScope* m_scopep;
     VerilatedVarNameMap::const_iterator m_it;
     bool m_started = false;
@@ -321,7 +321,7 @@ public:
     }
 };
 
-class VerilatedVpioMemoryWordIter : public VerilatedVpio {
+class VerilatedVpioMemoryWordIter final : public VerilatedVpio {
     const vpiHandle m_handle;
     const VerilatedVar* m_varp;
     vlsint32_t m_iteration;
@@ -351,7 +351,7 @@ public:
     }
 };
 
-class VerilatedVpioModule : public VerilatedVpioScope {
+class VerilatedVpioModule final : public VerilatedVpioScope {
     const char* m_name;
     const char* m_fullname;
 
@@ -370,7 +370,7 @@ public:
     virtual const char* fullname() const override { return m_fullname; }
 };
 
-class VerilatedVpioModuleIter : public VerilatedVpio {
+class VerilatedVpioModuleIter final : public VerilatedVpio {
     const std::vector<const VerilatedScope*>* m_vec;
     std::vector<const VerilatedScope*>::const_iterator m_it;
 
@@ -405,7 +405,7 @@ struct VerilatedVpiTimedCbsCmp {
 
 class VerilatedVpiError;
 
-class VerilatedVpiImp {
+class VerilatedVpiImp final {
     enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime + 1 };  // Maxium callback reason
     typedef std::list<VerilatedVpioCb*> VpioCbList;
     typedef std::set<std::pair<QData, VerilatedVpioCb*>, VerilatedVpiTimedCbsCmp> VpioTimedCbs;
@@ -534,7 +534,7 @@ public:
     static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE;  // getter for vpi error info
 };
 
-class VerilatedVpiError {
+class VerilatedVpiError final {
     //// Container for vpi error info
 
     t_vpi_error_info m_errorInfo;

include/verilated_vpi.h

@@ -33,7 +33,7 @@
 
 //======================================================================
 
-class VerilatedVpi {
+class VerilatedVpi final {
 public:
     /// Call timed callbacks
     /// Users should call this from their main loops

include/verilatedos.h

@@ -374,7 +374,10 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 //=========================================================================
 // Class definition helpers
 
-// Used to declare a class as uncopyable; put after a private:
+/// Used to indicate a base class, e.g. cannot label "class final"
+#define VL_NOT_FINAL
+
+/// Used to declare a class as uncopyable; put after a private:
 #define VL_UNCOPYABLE(Type) \
     Type(const Type& other) = delete; \
     Type& operator=(const Type&) = delete

src/V3Active.cpp

@@ -43,12 +43,12 @@
 //######################################################################
 // Collect existing active names
 
-class ActiveBaseVisitor : public AstNVisitor {
+class ActiveBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 protected:
     VL_DEBUG_FUNC;  // Declare debug()
 };
 
-class ActiveNamer : public ActiveBaseVisitor {
+class ActiveNamer final : public ActiveBaseVisitor {
 private:
     // STATE
     AstScope* m_scopep = nullptr;  // Current scope to add statement to
@@ -138,7 +138,7 @@ public:
 //######################################################################
 // Active AssignDly replacement functions
 
-class ActiveDlyVisitor : public ActiveBaseVisitor {
+class ActiveDlyVisitor final : public ActiveBaseVisitor {
 public:
     enum CheckType : uint8_t { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 
@@ -211,7 +211,7 @@ public:
 //######################################################################
 // Active class functions
 
-class ActiveVisitor : public ActiveBaseVisitor {
+class ActiveVisitor final : public ActiveBaseVisitor {
 private:
     // NODE STATE
     //  Each call to V3Const::constify

src/V3Active.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Active {
+class V3Active final {
 public:
     static void activeAll(AstNetlist* nodep);
 };

src/V3ActiveTop.cpp

@@ -35,7 +35,7 @@
 //######################################################################
 // Active class functions
 
-class ActiveTopVisitor : public AstNVisitor {
+class ActiveTopVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     //  Entire netlist

src/V3ActiveTop.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3ActiveTop {
+class V3ActiveTop final {
 public:
     static void activeTopAll(AstNetlist* nodep);
 };

src/V3Assert.cpp

@@ -26,7 +26,7 @@
 //######################################################################
 // Assert class functions
 
-class AssertVisitor : public AstNVisitor {
+class AssertVisitor final : public AstNVisitor {
 private:
     // NODE STATE/TYPES
     // Cleared on netlist

src/V3Assert.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Assert {
+class V3Assert final {
 public:
     static void assertAll(AstNetlist* nodep);
 };

src/V3AssertPre.cpp

@@ -26,7 +26,7 @@
 //######################################################################
 // Assert class functions
 
-class AssertPreVisitor : public AstNVisitor {
+class AssertPreVisitor final : public AstNVisitor {
     // Removes clocks and other pre-optimizations
     // Eventually inlines calls to sequences, properties, etc.
     // We're not parsing the tree, or anything more complicated.

src/V3AssertPre.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3AssertPre {
+class V3AssertPre final {
 public:
     static void assertPreAll(AstNetlist* nodep);
 };

src/V3Ast.h

@@ -71,7 +71,7 @@ typedef std::set<int> MTaskIdSet;  // Set of mtaskIds for Var sorting
 
 //######################################################################
 
-class AstType {
+class AstType final {
 public:
 #include "V3Ast__gen_types.h"  // From ./astgen
     // Above include has:
@@ -94,7 +94,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstType& rhs) { return o
 
 //######################################################################
 
-class VLifetime {
+class VLifetime final {
 public:
     enum en : uint8_t { NONE, AUTOMATIC, STATIC };
     enum en m_e;
@@ -123,7 +123,7 @@ inline std::ostream& operator<<(std::ostream& os, const VLifetime& rhs) {
 
 //######################################################################
 
-class VAccess {
+class VAccess final {
 public:
     enum en : uint8_t {
         READ,  // Read/Consumed, variable not changed
@@ -166,7 +166,7 @@ inline std::ostream& operator<<(std::ostream& os, const VAccess& rhs) { return o
 
 //######################################################################
 
-class VSigning {
+class VSigning final {
 public:
     enum en : uint8_t {
         UNSIGNED,
@@ -203,7 +203,7 @@ inline std::ostream& operator<<(std::ostream& os, const VSigning& rhs) {
 
 //######################################################################
 
-class AstPragmaType {
+class AstPragmaType final {
 public:
     enum en : uint8_t {
         ILLEGAL,
@@ -236,7 +236,7 @@ inline bool operator==(AstPragmaType::en lhs, const AstPragmaType& rhs) { return
 
 //######################################################################
 
-class AstCFuncType {
+class AstCFuncType final {
 public:
     enum en : uint8_t {
         FT_NORMAL,
@@ -269,7 +269,7 @@ inline bool operator==(AstCFuncType::en lhs, const AstCFuncType& rhs) { return l
 
 //######################################################################
 
-class VEdgeType {
+class VEdgeType final {
 public:
     // REMEMBER to edit the strings below too
     enum en : uint8_t {
@@ -355,7 +355,7 @@ inline bool operator==(VEdgeType::en lhs, const VEdgeType& rhs) { return lhs ==
 
 //######################################################################
 
-class AstAttrType {
+class AstAttrType final {
 public:
     // clang-format off
     enum en: uint8_t  {
@@ -436,7 +436,7 @@ inline bool operator==(AstAttrType::en lhs, const AstAttrType& rhs) { return lhs
 
 //######################################################################
 
-class AstBasicDTypeKwd {
+class AstBasicDTypeKwd final {
 public:
     enum en : uint8_t {
         UNKNOWN,
@@ -572,7 +572,7 @@ inline bool operator==(AstBasicDTypeKwd::en lhs, const AstBasicDTypeKwd& rhs) {
 
 //######################################################################
 
-class VDirection {
+class VDirection final {
 public:
     enum en : uint8_t { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF };
     enum en m_e;
@@ -617,7 +617,7 @@ inline std::ostream& operator<<(std::ostream& os, const VDirection& rhs) {
 //######################################################################
 
 /// Boolean or unknown
-class VBoolOrUnknown {
+class VBoolOrUnknown final {
 public:
     enum en : uint8_t { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END };
     enum en m_e;
@@ -656,7 +656,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBoolOrUnknown& rhs) {
 //######################################################################
 
 /// Join type
-class VJoinType {
+class VJoinType final {
 public:
     enum en : uint8_t { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 };
     enum en m_e;
@@ -689,7 +689,7 @@ inline std::ostream& operator<<(std::ostream& os, const VJoinType& rhs) {
 
 //######################################################################
 
-class AstVarType {
+class AstVarType final {
 public:
     enum en : uint8_t {
         UNKNOWN,
@@ -757,7 +757,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstVarType& rhs) {
 
 //######################################################################
 
-class VBranchPred {
+class VBranchPred final {
 public:
     enum en : uint8_t { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END };
     enum en m_e;
@@ -798,7 +798,7 @@ inline std::ostream& operator<<(std::ostream& os, const VBranchPred& rhs) {
 
 //######################################################################
 
-class VVarAttrClocker {
+class VVarAttrClocker final {
 public:
     enum en : uint8_t { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END };
     enum en m_e;
@@ -841,7 +841,7 @@ inline std::ostream& operator<<(std::ostream& os, const VVarAttrClocker& rhs) {
 
 //######################################################################
 
-class VAlwaysKwd {
+class VAlwaysKwd final {
 public:
     enum en : uint8_t { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB };
     enum en m_e;
@@ -864,7 +864,7 @@ inline bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lhs =
 
 //######################################################################
 
-class VCaseType {
+class VCaseType final {
 public:
     enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
     enum en m_e;
@@ -883,7 +883,7 @@ inline bool operator==(VCaseType::en lhs, const VCaseType& rhs) { return lhs ==
 
 //######################################################################
 
-class AstDisplayType {
+class AstDisplayType final {
 public:
     enum en : uint8_t { DT_DISPLAY, DT_WRITE, DT_INFO, DT_ERROR, DT_WARNING, DT_FATAL };
     enum en m_e;
@@ -915,7 +915,7 @@ inline bool operator==(AstDisplayType::en lhs, const AstDisplayType& rhs) {
 
 //######################################################################
 
-class VDumpCtlType {
+class VDumpCtlType final {
 public:
     enum en : uint8_t { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON };
     enum en m_e;
@@ -941,7 +941,7 @@ inline bool operator==(VDumpCtlType::en lhs, const VDumpCtlType& rhs) { return l
 
 //######################################################################
 
-class VParseRefExp {
+class VParseRefExp final {
 public:
     enum en : uint8_t {
         PX_NONE,  // Used in V3LinkParse only
@@ -975,7 +975,7 @@ inline std::ostream& operator<<(std::ostream& os, const VParseRefExp& rhs) {
 // VNumRange - Structure containing numeric range information
 // See also AstRange, which is a symbolic version of this
 
-class VNumRange {
+class VNumRange final {
 public:
     int m_hi = 0;  // HI part, HI always >= LO
     int m_lo = 0;  // LO
@@ -1048,7 +1048,7 @@ inline std::ostream& operator<<(std::ostream& os, const VNumRange& rhs) {
 
 //######################################################################
 
-class VUseType {
+class VUseType final {
 public:
     enum en : uint8_t {
         IMP_INCLUDE,  // Implementation (.cpp) needs an include
@@ -1081,7 +1081,7 @@ inline std::ostream& operator<<(std::ostream& os, const VUseType& rhs) {
 
 //######################################################################
 
-class VBasicTypeKey {
+class VBasicTypeKey final {
 public:
     int m_width;  // From AstNodeDType: Bit width of operation
     int m_widthMin;  // From AstNodeDType: If unsized, bitwidth of minimum implementation
@@ -1123,7 +1123,7 @@ class WidthVP;
 class V3GraphVertex;
 class VSymEnt;
 
-class VNUser {
+class VNUser final {
     union {
         void* up;
         int ui;
@@ -1159,7 +1159,7 @@ public:
 //  user2.  When the member goes out of scope it will be automagically
 //  freed up.
 
-class AstUserInUseBase {
+class AstUserInUseBase VL_NOT_FINAL {
 protected:
     static void allocate(int id, uint32_t& cntGblRef, bool& userBusyRef) {
         // Perhaps there's still a AstUserInUse in scope for this?
@@ -1190,7 +1190,7 @@ protected:
 // We let AstNode peek into here, because when under low optimization even
 // an accessor would be way too slow.
 // clang-format off
-class AstUser1InUse : AstUserInUseBase {
+class AstUser1InUse final : AstUserInUseBase {
 protected:
     friend class AstNode;
     static uint32_t     s_userCntGbl;   // Count of which usage of userp() this is
@@ -1201,7 +1201,7 @@ public:
     static void clear() { clearcnt(1, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
     static void check() { checkcnt(1, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
 };
-class AstUser2InUse : AstUserInUseBase {
+class AstUser2InUse final : AstUserInUseBase {
 protected:
     friend class AstNode;
     static uint32_t     s_userCntGbl;   // Count of which usage of userp() this is
@@ -1212,7 +1212,7 @@ public:
     static void clear() { clearcnt(2, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
     static void check() { checkcnt(2, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
 };
-class AstUser3InUse : AstUserInUseBase {
+class AstUser3InUse final : AstUserInUseBase {
 protected:
     friend class AstNode;
     static uint32_t     s_userCntGbl;   // Count of which usage of userp() this is
@@ -1223,7 +1223,7 @@ public:
     static void clear() { clearcnt(3, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
     static void check() { checkcnt(3, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
 };
-class AstUser4InUse : AstUserInUseBase {
+class AstUser4InUse final : AstUserInUseBase {
 protected:
     friend class AstNode;
     static uint32_t     s_userCntGbl;   // Count of which usage of userp() this is
@@ -1234,7 +1234,7 @@ public:
     static void clear() { clearcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
     static void check() { checkcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
 };
-class AstUser5InUse : AstUserInUseBase {
+class AstUser5InUse final : AstUserInUseBase {
 protected:
     friend class AstNode;
     static uint32_t     s_userCntGbl;   // Count of which usage of userp() this is
@@ -1251,7 +1251,7 @@ public:
 // AstNVisitor -- Allows new functions to be called on each node
 // type without changing the base classes.  See "Modern C++ Design".
 
-class AstNVisitor {
+class AstNVisitor VL_NOT_FINAL {
 private:
     // MEMBERS
     std::vector<AstNode*> m_deleteps;  // Nodes to delete when doDeletes() called
@@ -1298,7 +1298,7 @@ public:
 // AstNRelinker -- Holds the state of a unlink so a new node can be
 // added at the same point.
 
-class AstNRelinker {
+class AstNRelinker final {
 protected:
     friend class AstNode;
     enum RelinkWhatEn : uint8_t {
@@ -1328,7 +1328,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstNRelinker& rhs) {
 //######################################################################
 // V3Hash -- Node hashing for V3Combine
 
-class V3Hash {
+class V3Hash final {
     // A hash of a tree of nodes, consisting of 8 bits with the number of nodes in the hash
     // and 24 bit value hash of relevant information about the node.
     // A value of 0 is illegal
@@ -1381,7 +1381,7 @@ std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);
 //######################################################################
 // Callback base class to determine if node matches some formula
 
-class VNodeMatcher {
+class VNodeMatcher VL_NOT_FINAL {
 public:
     virtual bool nodeMatch(const AstNode* nodep) const { return true; }
 };
@@ -1399,7 +1399,7 @@ public:
         } \
     } while (false)
 
-class AstNode {
+class AstNode VL_NOT_FINAL {
     // v ASTNODE_PREFETCH depends on below ordering of members
     AstNode* m_nextp;  // Next peer in the parent's list
     AstNode* m_backp;  // Node that points to this one (via next/op1/op2/...)
@@ -1914,7 +1914,7 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
     } \
     Ast##name* clonep() const { return static_cast<Ast##name*>(AstNode::clonep()); }
 
-class AstNodeMath : public AstNode {
+class AstNodeMath VL_NOT_FINAL : public AstNode {
     // Math -- anything that's part of an expression tree
 public:
     AstNodeMath(AstType t, FileLine* fl)
@@ -1934,7 +1934,7 @@ public:
     bool isOpaque() { return VN_IS(this, CvtPackString); }
 };
 
-class AstNodeTermop : public AstNodeMath {
+class AstNodeTermop VL_NOT_FINAL : public AstNodeMath {
     // Terminal operator -- a operator with no "inputs"
 public:
     AstNodeTermop(AstType t, FileLine* fl)
@@ -1947,7 +1947,7 @@ public:
     virtual void dump(std::ostream& str) const override;
 };
 
-class AstNodeUniop : public AstNodeMath {
+class AstNodeUniop VL_NOT_FINAL : public AstNodeMath {
     // Unary math
 public:
     AstNodeUniop(AstType t, FileLine* fl, AstNode* lhsp)
@@ -1973,7 +1973,7 @@ public:
     virtual bool same(const AstNode*) const override { return true; }
 };
 
-class AstNodeBiop : public AstNodeMath {
+class AstNodeBiop VL_NOT_FINAL : public AstNodeMath {
     // Binary math
 public:
     AstNodeBiop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs)
@@ -2005,7 +2005,7 @@ public:
     virtual bool same(const AstNode*) const override { return true; }
 };
 
-class AstNodeTriop : public AstNodeMath {
+class AstNodeTriop VL_NOT_FINAL : public AstNodeMath {
     // Trinary math
 public:
     AstNodeTriop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
@@ -2038,7 +2038,7 @@ public:
     virtual bool same(const AstNode*) const override { return true; }
 };
 
-class AstNodeQuadop : public AstNodeMath {
+class AstNodeQuadop VL_NOT_FINAL : public AstNodeMath {
     // Quaternary math
 public:
     AstNodeQuadop(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths, AstNode* fhs)
@@ -2075,7 +2075,7 @@ public:
     virtual bool same(const AstNode*) const override { return true; }
 };
 
-class AstNodeBiCom : public AstNodeBiop {
+class AstNodeBiCom VL_NOT_FINAL : public AstNodeBiop {
     // Binary math with commutative properties
 public:
     AstNodeBiCom(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs)
@@ -2083,14 +2083,14 @@ public:
     ASTNODE_BASE_FUNCS(NodeBiCom)
 };
 
-class AstNodeBiComAsv : public AstNodeBiCom {
+class AstNodeBiComAsv VL_NOT_FINAL : public AstNodeBiCom {
     // Binary math with commutative & associative properties
 public:
     AstNodeBiComAsv(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs)
         : AstNodeBiCom{t, fl, lhs, rhs} {}
     ASTNODE_BASE_FUNCS(NodeBiComAsv)
 };
-class AstNodeCond : public AstNodeTriop {
+class AstNodeCond VL_NOT_FINAL : public AstNodeTriop {
 public:
     AstNodeCond(AstType t, FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
         : AstNodeTriop{t, fl, condp, expr1p, expr2p} {
@@ -2121,7 +2121,7 @@ public:
     virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) = 0;
 };
 
-class AstNodeBlock : public AstNode {
+class AstNodeBlock VL_NOT_FINAL : public AstNode {
     // A Begin/fork block
     // Parents: statement
     // Children: statements
@@ -2145,7 +2145,7 @@ public:
     bool unnamed() const { return m_unnamed; }
 };
 
-class AstNodePreSel : public AstNode {
+class AstNodePreSel VL_NOT_FINAL : public AstNode {
     // Something that becomes an AstSel
 public:
     AstNodePreSel(AstType t, FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
@@ -2169,7 +2169,7 @@ public:
     virtual bool same(const AstNode*) const override { return true; }
 };
 
-class AstNodeProcedure : public AstNode {
+class AstNodeProcedure VL_NOT_FINAL : public AstNode {
     // IEEE procedure: initial, final, always
 public:
     AstNodeProcedure(AstType t, FileLine* fl, AstNode* bodysp)
@@ -2184,7 +2184,7 @@ public:
     bool isJustOneBodyStmt() const { return bodysp() && !bodysp()->nextp(); }
 };
 
-class AstNodeStmt : public AstNode {
+class AstNodeStmt VL_NOT_FINAL : public AstNode {
     // Statement -- anything that's directly under a function
     bool m_statement;  // Really a statement (e.g. not a function with return)
 public:
@@ -2202,7 +2202,7 @@ public:
     virtual void dump(std::ostream& str = std::cout) const override;
 };
 
-class AstNodeAssign : public AstNodeStmt {
+class AstNodeAssign VL_NOT_FINAL : public AstNodeStmt {
 public:
     AstNodeAssign(AstType t, FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : AstNodeStmt{t, fl} {
@@ -2227,7 +2227,7 @@ public:
     virtual bool brokeLhsMustBeLvalue() const = 0;
 };
 
-class AstNodeFor : public AstNodeStmt {
+class AstNodeFor VL_NOT_FINAL : public AstNodeStmt {
 public:
     AstNodeFor(AstType t, FileLine* fl, AstNode* initsp, AstNode* condp, AstNode* incsp,
                AstNode* bodysp)
@@ -2248,7 +2248,7 @@ public:
     virtual bool same(const AstNode* samep) const override { return true; }
 };
 
-class AstNodeIf : public AstNodeStmt {
+class AstNodeIf VL_NOT_FINAL : public AstNodeStmt {
 private:
     VBranchPred m_branchPred;  // Branch prediction as taken/untaken?
 public:
@@ -2274,7 +2274,7 @@ public:
     VBranchPred branchPred() const { return m_branchPred; }
 };
 
-class AstNodeCase : public AstNodeStmt {
+class AstNodeCase VL_NOT_FINAL : public AstNodeStmt {
 public:
     AstNodeCase(AstType t, FileLine* fl, AstNode* exprp, AstNode* casesp)
         : AstNodeStmt{t, fl} {
@@ -2292,7 +2292,7 @@ public:
     void addNotParallelp(AstNode* nodep) { setOp3p(nodep); }
 };
 
-class AstNodeVarRef : public AstNodeMath {
+class AstNodeVarRef VL_NOT_FINAL : public AstNodeMath {
     // An AstVarRef or AstVarXRef
 private:
     VAccess m_access;  // Left hand side assignment
@@ -2344,7 +2344,7 @@ public:
     void iterateChildren(AstNVisitor& v) {}
 };
 
-class AstNodeText : public AstNode {
+class AstNodeText VL_NOT_FINAL : public AstNode {
 private:
     string m_text;
 
@@ -2364,7 +2364,7 @@ public:
     const string& text() const { return m_text; }
 };
 
-class AstNodeDType : public AstNode {
+class AstNodeDType VL_NOT_FINAL : public AstNode {
     // Ideally width() would migrate to BasicDType as that's where it makes sense,
     // but it's currently so prevalent in the code we leave it here.
     // Note the below members are included in AstTypeTable::Key lookups
@@ -2460,7 +2460,7 @@ private:
     CTypeRecursed cTypeRecurse(bool compound) const;
 };
 
-class AstNodeUOrStructDType : public AstNodeDType {
+class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
     // A struct or union; common handling
 private:
     // TYPES
@@ -2524,7 +2524,7 @@ public:
     VNumRange declRange() const { return VNumRange(msb(), lsb(), false); }
 };
 
-class AstNodeArrayDType : public AstNodeDType {
+class AstNodeArrayDType VL_NOT_FINAL : public AstNodeDType {
     // Array data type, ie "some_dtype var_name [2:0]"
     // Children: DTYPE (moved to refDTypep() in V3Width)
     // Children: RANGE (array bounds)
@@ -2587,7 +2587,7 @@ public:
     VNumRange declRange() const;
 };
 
-class AstNodeSel : public AstNodeBiop {
+class AstNodeSel VL_NOT_FINAL : public AstNodeBiop {
     // Single bit range extraction, perhaps with non-constant selection or array selection
 public:
     AstNodeSel(AstType t, FileLine* fl, AstNode* fromp, AstNode* bitp)
@@ -2603,7 +2603,7 @@ public:
     virtual bool hasDType() const override { return true; }
 };
 
-class AstNodeStream : public AstNodeBiop {
+class AstNodeStream VL_NOT_FINAL : public AstNodeBiop {
     // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp()
 public:
     AstNodeStream(AstType t, FileLine* fl, AstNode* lhsp, AstNode* rhsp)
@@ -2616,7 +2616,7 @@ public:
 //######################################################################
 // Tasks/functions common handling
 
-class AstNodeCCall : public AstNodeStmt {
+class AstNodeCCall VL_NOT_FINAL : public AstNodeStmt {
     // A call of a C++ function, perhaps a AstCFunc or perhaps globally named
     // Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal.
     AstCFunc* m_funcp;
@@ -2664,7 +2664,7 @@ public:
     void addArgsp(AstNode* nodep) { addOp2p(nodep); }
 };
 
-class AstNodeFTask : public AstNode {
+class AstNodeFTask VL_NOT_FINAL : public AstNode {
 private:
     string m_name;  // Name of task
     string m_cname;  // Name of task if DPI import
@@ -2769,7 +2769,7 @@ public:
     VLifetime lifetime() const { return m_lifetime; }
 };
 
-class AstNodeFTaskRef : public AstNodeStmt {
+class AstNodeFTaskRef VL_NOT_FINAL : public AstNodeStmt {
     // A reference to a task (or function)
     // Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal.
 private:
@@ -2823,7 +2823,7 @@ public:
     void scopeNamep(AstNode* nodep) { setNOp4p(nodep); }
 };
 
-class AstNodeModule : public AstNode {
+class AstNodeModule VL_NOT_FINAL : public AstNode {
     // A module, package, program or interface declaration;
     // something that can live directly under the TOP,
     // excluding $unit package stuff
@@ -2902,7 +2902,7 @@ public:
     VOptionBool unconnectedDrive() const { return m_unconnectedDrive; }
 };
 
-class AstNodeRange : public AstNode {
+class AstNodeRange VL_NOT_FINAL : public AstNode {
     // A range, sized or unsized
 public:
     AstNodeRange(AstType t, FileLine* fl)

src/V3AstNodes.cpp

@@ -553,7 +553,7 @@ string AstVar::mtasksString() const {
     return os.str();
 }
 
-class AstNodeDType::CTypeRecursed {
+class AstNodeDType::CTypeRecursed final {
 public:
     string m_type;  // The base type, e.g.: "Foo_t"s
     string m_dims;  // Array dimensions, e.g.: "[3][2][1]"

src/V3Begin.cpp

@@ -36,7 +36,7 @@
 
 //######################################################################
 
-class BeginState {
+class BeginState final {
 private:
     // NODE STATE
     // Entire netlist:
@@ -56,7 +56,7 @@ public:
 
 //######################################################################
 
-class BeginVisitor : public AstNVisitor {
+class BeginVisitor final : public AstNVisitor {
 private:
     // STATE
     BeginState* m_statep;  // Current global state
@@ -247,7 +247,7 @@ public:
 
 //######################################################################
 
-class BeginRelinkVisitor : public AstNVisitor {
+class BeginRelinkVisitor final : public AstNVisitor {
     // Replace tasks with new pointer
 private:
     // NODE STATE

src/V3Begin.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Begin {
+class V3Begin final {
 public:
     static void debeginAll(AstNetlist* nodep);
 };

src/V3Branch.cpp

@@ -35,7 +35,7 @@
 //######################################################################
 // Branch state, as a visitor of each AstNode
 
-class BranchVisitor : public AstNVisitor {
+class BranchVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Branch.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Branch {
+class V3Branch final {
 public:
     // CONSTRUCTORS
     static void branchAll(AstNetlist* nodep);

src/V3Broken.cpp

@@ -36,7 +36,7 @@
 
 //######################################################################
 
-class BrokenTable : public AstNVisitor {
+class BrokenTable final : public AstNVisitor {
     // Table of brokenExists node pointers
 private:
     // MEMBERS
@@ -211,7 +211,7 @@ bool AstNode::brokeExistsBelow() const {
 
 //######################################################################
 
-class BrokenMarkVisitor : public AstNVisitor {
+class BrokenMarkVisitor final : public AstNVisitor {
     // Mark every node in the tree
 private:
     // NODE STATE
@@ -237,7 +237,7 @@ public:
 //######################################################################
 // Broken state, as a visitor of each AstNode
 
-class BrokenCheckVisitor : public AstNVisitor {
+class BrokenCheckVisitor final : public AstNVisitor {
     bool m_inScope = false;  // Under AstScope
 
 private:

src/V3Broken.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Broken {
+class V3Broken final {
 public:
     static void brokenAll(AstNetlist* nodep);
     static void addNewed(AstNode* nodep);

src/V3CCtors.cpp

@@ -34,7 +34,7 @@
 #include <algorithm>
 #include <map>
 
-class V3CCtorsVisitor {
+class V3CCtorsVisitor final {
 private:
     string m_basename;
     string m_argsp;

src/V3CCtors.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3CCtors {
+class V3CCtors final {
 public:
     static void cctorsAll();
 

src/V3CUse.cpp

@@ -36,7 +36,7 @@
 
 //######################################################################
 
-class CUseState {
+class CUseState final {
 private:
     // MEMBERS
     AstNodeModule* m_modInsertp;  // Current module to insert AstCUse under
@@ -75,7 +75,7 @@ public:
 // Visit within a module all nodes and data types they reference, finding
 // any classes so we can make sure they are defined when Verilated code
 // compiles
-class CUseDTypeVisitor : public AstNVisitor {
+class CUseDTypeVisitor final : public AstNVisitor {
     // MEMBERS
     CUseState& m_stater;  // State for inserter
     bool m_impOnly = false;  // In details needed only for implementation
@@ -113,7 +113,7 @@ public:
     VL_UNCOPYABLE(CUseDTypeVisitor);
 };
 
-class CUseVisitor : public AstNVisitor {
+class CUseVisitor final : public AstNVisitor {
     // MEMBERS
     CUseState m_state;  // Inserter state
 

src/V3CUse.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3CUse {
+class V3CUse final {
 public:
     static void cUseAll();
 };

src/V3Case.cpp

@@ -50,7 +50,7 @@
 
 //######################################################################
 
-class CaseLintVisitor : public AstNVisitor {
+class CaseLintVisitor final : public AstNVisitor {
 private:
     AstNodeCase* m_caseExprp
         = nullptr;  // Under a CASE value node, if so the relevant case statement
@@ -117,7 +117,7 @@ public:
 //######################################################################
 // Case state, as a visitor of each AstNode
 
-class CaseVisitor : public AstNVisitor {
+class CaseVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Cleared each Case

src/V3Case.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Case {
+class V3Case final {
 public:
     static void caseAll(AstNetlist* nodep);
     static void caseLint(AstNodeCase* nodep);

src/V3Cast.cpp

@@ -49,7 +49,7 @@
 //######################################################################
 // Cast state, as a visitor of each AstNode
 
-class CastVisitor : public AstNVisitor {
+class CastVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Cast.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Cast {
+class V3Cast final {
 public:
     static void castAll(AstNetlist* nodep);
 };

src/V3Cdc.cpp

@@ -41,7 +41,7 @@ constexpr int CDC_WEIGHT_ASYNC = 0x1000;  // Weight for edges that feed async lo
 
 //######################################################################
 
-class CdcBaseVisitor : public AstNVisitor {
+class CdcBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 public:
     VL_DEBUG_FUNC;  // Declare debug()
 };
@@ -49,7 +49,7 @@ public:
 //######################################################################
 // Graph support classes
 
-class CdcEitherVertex : public V3GraphVertex {
+class CdcEitherVertex VL_NOT_FINAL : public V3GraphVertex {
     AstScope* m_scopep;
     AstNode* m_nodep;
     AstSenTree* m_srcDomainp = nullptr;
@@ -83,7 +83,7 @@ public:
     void asyncPath(bool flag) { m_asyncPath = flag; }
 };
 
-class CdcVarVertex : public CdcEitherVertex {
+class CdcVarVertex final : public CdcEitherVertex {
     AstVarScope* m_varScp;
     int m_cntAsyncRst = 0;
     bool m_fromFlop = false;
@@ -105,7 +105,7 @@ public:
     void fromFlop(bool flag) { m_fromFlop = flag; }
 };
 
-class CdcLogicVertex : public CdcEitherVertex {
+class CdcLogicVertex final : public CdcEitherVertex {
     bool m_hazard : 1;
     bool m_isFlop : 1;
 
@@ -135,7 +135,7 @@ public:
 
 //######################################################################
 
-class CdcDumpVisitor : public CdcBaseVisitor {
+class CdcDumpVisitor final : public CdcBaseVisitor {
 private:
     // NODE STATE
     // Entire netlist:
@@ -175,7 +175,7 @@ public:
 
 //######################################################################
 
-class CdcWidthVisitor : public CdcBaseVisitor {
+class CdcWidthVisitor final : public CdcBaseVisitor {
 private:
     int m_maxLineno = 0;
     size_t m_maxFilenameLen = 0;
@@ -209,7 +209,7 @@ public:
 //######################################################################
 // Cdc class functions
 
-class CdcVisitor : public CdcBaseVisitor {
+class CdcVisitor final : public CdcBaseVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Cdc.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Cdc {
+class V3Cdc final {
 public:
     static void cdcAll(AstNetlist* nodep);
 };

src/V3Changed.cpp

@@ -38,7 +38,7 @@
 
 //######################################################################
 
-class ChangedState {
+class ChangedState final {
 public:
     // STATE
     AstNodeModule* m_topModp = nullptr;  // Top module
@@ -94,7 +94,7 @@ public:
 //######################################################################
 // Utility visitor to find elements to be compared
 
-class ChangedInsertVisitor : public AstNVisitor {
+class ChangedInsertVisitor final : public AstNVisitor {
 private:
     // STATE
     ChangedState* m_statep;  // Shared state across visitors
@@ -214,7 +214,7 @@ public:
 //######################################################################
 // Changed state, as a visitor of each AstNode
 
-class ChangedVisitor : public AstNVisitor {
+class ChangedVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Changed.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Changed {
+class V3Changed final {
 public:
     static void changedAll(AstNetlist* nodep);
 };

src/V3Class.cpp

@@ -29,7 +29,7 @@
 
 //######################################################################
 
-class ClassVisitor : public AstNVisitor {
+class ClassVisitor final : public AstNVisitor {
 private:
     // MEMBERS
     AstUser1InUse m_inuser1;

src/V3Class.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Class {
+class V3Class final {
 public:
     static void classAll(AstNetlist* nodep);
 };

src/V3Clean.cpp

@@ -35,7 +35,7 @@
 //######################################################################
 // Clean state, as a visitor of each AstNode
 
-class CleanVisitor : public AstNVisitor {
+class CleanVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Clean.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Clean {
+class V3Clean final {
 public:
     static void cleanAll(AstNetlist* nodep);
 };

src/V3Clock.cpp

@@ -40,7 +40,7 @@
 //######################################################################
 // Clock state, as a visitor of each AstNode
 
-class ClockVisitor : public AstNVisitor {
+class ClockVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Cleared each Module:

src/V3Clock.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Clock {
+class V3Clock final {
 public:
     static void clockAll(AstNetlist* nodep);
 };

src/V3Combine.cpp

@@ -51,7 +51,7 @@ constexpr int COMBINE_MIN_STATEMENTS = 50;  // Min # of statements to be worth m
 
 //######################################################################
 
-class CombBaseVisitor : public AstNVisitor {
+class CombBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 protected:
     // STATE
 
@@ -63,7 +63,7 @@ protected:
 //######################################################################
 // Combine replacement function
 
-class CombCallVisitor : CombBaseVisitor {
+class CombCallVisitor final : CombBaseVisitor {
     // Find all CCALLS of each CFUNC, so that we can later rename them
 private:
     // NODE STATE
@@ -139,7 +139,7 @@ public:
 //######################################################################
 // Combine marking function
 
-class CombMarkVisitor : CombBaseVisitor {
+class CombMarkVisitor final : CombBaseVisitor {
     // Mark all nodes under specified one.
 private:
     // OUTPUT:
@@ -159,7 +159,7 @@ public:
 //######################################################################
 // Combine state, as a visitor of each AstNode
 
-class CombineVisitor : CombBaseVisitor {
+class CombineVisitor final : CombBaseVisitor {
 private:
     // NODE STATE
     // Entire netlist:

src/V3Combine.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Combine {
+class V3Combine final {
 public:
     static void combineAll(AstNetlist* nodep);
 };

src/V3Config.cpp

@@ -82,7 +82,7 @@ public:
 };
 
 // Only public_flat_rw has the sensitity tree
-class V3ConfigVarAttr {
+class V3ConfigVarAttr final {
 public:
     AstAttrType m_type;  // Type of attribute
     AstSenTree* m_sentreep;  // Sensitivity tree for public_flat_rw
@@ -92,7 +92,7 @@ public:
 };
 
 // Overload vector with the required update function and to apply all entries
-class V3ConfigVar : public std::vector<V3ConfigVarAttr> {
+class V3ConfigVar final : public std::vector<V3ConfigVarAttr> {
 public:
     // Update from other by copying all attributes
     void update(const V3ConfigVar& node) {
@@ -116,7 +116,7 @@ typedef V3ConfigWildcardResolver<V3ConfigVar> V3ConfigVarResolver;
 //######################################################################
 // Function or task: Have variables and properties
 
-class V3ConfigFTask {
+class V3ConfigFTask final {
     V3ConfigVarResolver m_vars;  // Variables in function/task
     bool m_isolate = false;  // Isolate function return
     bool m_noinline = false;  // Don't inline function/task
@@ -153,7 +153,7 @@ typedef V3ConfigWildcardResolver<V3ConfigFTask> V3ConfigFTaskResolver;
 //######################################################################
 // Modules have tasks, variables, named blocks and properties
 
-class V3ConfigModule {
+class V3ConfigModule final {
     typedef std::unordered_set<string> StringSet;
     typedef std::set<AstPragmaType> PragmaSet;
 
@@ -224,7 +224,7 @@ typedef V3ConfigWildcardResolver<V3ConfigModule> V3ConfigModuleResolver;
 //  - Line attributes: Attributes attached to lines
 
 // lint/coverage/tracing on/off
-class V3ConfigIgnoresLine {
+class V3ConfigIgnoresLine final {
 public:
     int m_lineno;  // Line number to make change at
     V3ErrorCode m_code;  // Error code
@@ -253,7 +253,7 @@ std::ostream& operator<<(std::ostream& os, const V3ConfigIgnoresLine& rhs) {
 typedef std::bitset<AstPragmaType::ENUM_SIZE> V3ConfigLineAttribute;
 
 // File entity
-class V3ConfigFile {
+class V3ConfigFile final {
     typedef std::map<int, V3ConfigLineAttribute> LineAttrMap;  // Map line->bitset of attributes
     typedef std::multiset<V3ConfigIgnoresLine> IgnLines;  // list of {line,code,on}
     typedef std::pair<V3ErrorCode, string> WaiverSetting;  // Waive code if string matches
@@ -347,7 +347,7 @@ typedef V3ConfigWildcardResolver<V3ConfigFile> V3ConfigFileResolver;
 //######################################################################
 // Resolve modules and files in the design
 
-class V3ConfigResolver {
+class V3ConfigResolver final {
     V3ConfigModuleResolver m_modules;  // Access to module names (with wildcards)
     V3ConfigFileResolver m_files;  // Access to file names (with wildcards)
 

src/V3Config.h

@@ -26,7 +26,7 @@
 
 //######################################################################
 
-class V3Config {
+class V3Config final {
 public:
     static void addCaseFull(const string& file, int lineno);
     static void addCaseParallel(const string& file, int lineno);

src/V3Const.cpp

@@ -36,7 +36,7 @@
 //######################################################################
 // Utilities
 
-class ConstVarMarkVisitor : public AstNVisitor {
+class ConstVarMarkVisitor final : public AstNVisitor {
     // NODE STATE
     // AstVar::user4p           -> bool, Var marked, 0=not set yet
 private:
@@ -55,7 +55,7 @@ public:
     virtual ~ConstVarMarkVisitor() override = default;
 };
 
-class ConstVarFindVisitor : public AstNVisitor {
+class ConstVarFindVisitor final : public AstNVisitor {
     // NODE STATE
     // AstVar::user4p           -> bool, input from ConstVarMarkVisitor
     // MEMBERS
@@ -79,7 +79,7 @@ public:
 //######################################################################
 // Const state, as a visitor of each AstNode
 
-class ConstVisitor : public AstNVisitor {
+class ConstVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // ** only when m_warn/m_doExpensive is set.  If state is needed other times,

src/V3Const.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Const {
+class V3Const final {
 public:
     static AstNode* constifyParamsEdit(AstNode* nodep);
     static AstNode* constifyGenerateParamsEdit(AstNode* nodep);

src/V3Coverage.cpp

@@ -37,7 +37,7 @@
 //######################################################################
 // Coverage state, as a visitor of each AstNode
 
-class CoverageVisitor : public AstNVisitor {
+class CoverageVisitor final : public AstNVisitor {
 private:
     // TYPES
     typedef std::unordered_map<string, int> VarNameMap;

src/V3Coverage.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Coverage {
+class V3Coverage final {
 public:
     // CONSTRUCTORS
     static void coverage(AstNetlist* rootp);

src/V3CoverageJoin.cpp

@@ -30,7 +30,7 @@
 //######################################################################
 // CoverageJoin state, as a visitor of each AstNode
 
-class CoverageJoinVisitor : public AstNVisitor {
+class CoverageJoinVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // V3Hashed

src/V3CoverageJoin.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3CoverageJoin {
+class V3CoverageJoin final {
 public:
     // CONSTRUCTORS
     static void coverageJoin(AstNetlist* rootp);

src/V3Dead.cpp

@@ -46,7 +46,7 @@
 
 //######################################################################
 
-class DeadModVisitor : public AstNVisitor {
+class DeadModVisitor final : public AstNVisitor {
     // In a module that is dead, cleanup the in-use counts of the modules
 private:
     // NODE STATE
@@ -69,7 +69,7 @@ public:
 //######################################################################
 // Dead state, as a visitor of each AstNode
 
-class DeadVisitor : public AstNVisitor {
+class DeadVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Entire Netlist:

src/V3Dead.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Dead {
+class V3Dead final {
 public:
     // Modules, no vars/dtypes
     static void deadifyModules(AstNetlist* nodep);

src/V3Delayed.cpp

@@ -63,7 +63,7 @@
 //######################################################################
 // Delayed state, as a visitor of each AstNode
 
-class DelayedVisitor : public AstNVisitor {
+class DelayedVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     // Cleared each module:

src/V3Delayed.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Delayed {
+class V3Delayed final {
 public:
     static void delayedAll(AstNetlist* nodep);
 };

src/V3Depth.cpp

@@ -34,7 +34,7 @@
 
 //######################################################################
 
-class DepthVisitor : public AstNVisitor {
+class DepthVisitor final : public AstNVisitor {
 private:
     // NODE STATE
 

src/V3Depth.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Depth {
+class V3Depth final {
 public:
     static void depthAll(AstNetlist* nodep);
 };

src/V3DepthBlock.cpp

@@ -32,7 +32,7 @@
 
 //######################################################################
 
-class DepthBlockVisitor : public AstNVisitor {
+class DepthBlockVisitor final : public AstNVisitor {
 private:
     // NODE STATE
 

src/V3DepthBlock.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3DepthBlock {
+class V3DepthBlock final {
 public:
     static void depthBlockAll(AstNetlist* nodep);
 };

src/V3Descope.cpp

@@ -34,7 +34,7 @@
 
 //######################################################################
 
-class DescopeVisitor : public AstNVisitor {
+class DescopeVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     //  Cleared entire netlist

src/V3Descope.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Descope {
+class V3Descope final {
 public:
     static void descopeAll(AstNetlist* nodep);
 };

src/V3EmitC.cpp

@@ -39,7 +39,7 @@ constexpr int EMITC_NUM_CONSTW
 //######################################################################
 // Emit statements and math operators
 
-class EmitCStmts : public EmitCBaseVisitor {
+class EmitCStmts VL_NOT_FINAL : public EmitCBaseVisitor {
 private:
     typedef std::vector<const AstVar*> VarVec;
     typedef std::map<int, VarVec> VarSortMap;  // Map size class to VarVec
@@ -1264,7 +1264,7 @@ public:
 //######################################################################
 // Establish mtask variable sort order in mtasks mode
 
-class EmitVarTspSorter : public V3TSP::TspStateBase {
+class EmitVarTspSorter final : public V3TSP::TspStateBase {
 private:
     // MEMBERS
     const MTaskIdSet& m_mtaskIds;  // Mtask we're ordering
@@ -1306,7 +1306,7 @@ unsigned EmitVarTspSorter::m_serialNext = 0;
 //######################################################################
 // Internal EmitC implementation
 
-class EmitCImp : EmitCStmts {
+class EmitCImp final : EmitCStmts {
     // MEMBERS
     AstNodeModule* m_modp = nullptr;
     std::vector<AstChangeDet*> m_blkChangeDetVec;  // All encountered changes in block
@@ -3401,7 +3401,7 @@ void EmitCImp::mainImp(AstNodeModule* modp, bool slow) {
 //######################################################################
 // Tracing routines
 
-class EmitCTrace : EmitCStmts {
+class EmitCTrace final : EmitCStmts {
     // NODE STATE/TYPES
     // Cleared on netlist
     //  AstNode::user1()        -> int.  Enum number

src/V3EmitC.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3EmitC {
+class V3EmitC final {
 public:
     static void emitc();
     static void emitcInlines();

src/V3EmitCBase.h

@@ -30,7 +30,7 @@
 //######################################################################
 // Base Visitor class -- holds output file pointer
 
-class EmitCBaseVisitor : public AstNVisitor {
+class EmitCBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 public:
     // STATE
     V3OutCFile* m_ofp = nullptr;
@@ -113,7 +113,7 @@ public:
 //######################################################################
 // Count operations under the given node, as a visitor of each AstNode
 
-class EmitCBaseCounterVisitor : public AstNVisitor {
+class EmitCBaseCounterVisitor final : public AstNVisitor {
 private:
     // MEMBERS
     int m_count = 0;  // Number of statements

src/V3EmitCInlines.cpp

@@ -26,7 +26,7 @@
 
 //######################################################################
 
-class EmitCInlines : EmitCBaseVisitor {
+class EmitCInlines final : EmitCBaseVisitor {
     // STATE
 
     // METHODS

src/V3EmitCMain.cpp

@@ -26,7 +26,7 @@
 
 //######################################################################
 
-class EmitCMain : EmitCBaseVisitor {
+class EmitCMain final : EmitCBaseVisitor {
     // METHODS
 
     // VISITORS

src/V3EmitCMain.h

@@ -22,7 +22,7 @@
 
 //============================================================================
 
-class V3EmitCMain {
+class V3EmitCMain final {
 public:
     static void emit();
 };

src/V3EmitCMake.cpp

@@ -28,7 +28,7 @@
 //######################################################################
 // Emit statements
 
-class CMakeEmitter {
+class CMakeEmitter final {
 
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()

src/V3EmitCMake.h

@@ -22,7 +22,7 @@
 
 //============================================================================
 
-class V3EmitCMake {
+class V3EmitCMake final {
 public:
     static void emit();
 };

src/V3EmitCSyms.cpp

@@ -29,7 +29,7 @@
 //######################################################################
 // Symbol table emitting
 
-class EmitCSyms : EmitCBaseVisitor {
+class EmitCSyms final : EmitCBaseVisitor {
     // NODE STATE
     // Cleared on Netlist
     //  AstNodeModule::user1()  -> bool.  Set true __Vconfigure called

src/V3EmitMk.cpp

@@ -26,7 +26,7 @@
 //######################################################################
 // Emit statements and math operators
 
-class EmitMk {
+class EmitMk final {
 public:
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()
@@ -289,7 +289,7 @@ public:
 };
 
 //######################################################################
-class EmitMkHierVerilation {
+class EmitMkHierVerilation final {
     const V3HierBlockPlan* const m_planp;
     const string m_makefile;  // path of this makefile
     void emitCommonOpts(V3OutMkFile& of) const {

src/V3EmitMk.h

@@ -24,7 +24,7 @@ class V3HierBlockPlan;
 
 //============================================================================
 
-class V3EmitMk {
+class V3EmitMk final {
 public:
     static void emitmk();
     static void emitHierVerilation(const V3HierBlockPlan* planp);

src/V3EmitV.cpp

@@ -28,7 +28,7 @@
 //######################################################################
 // Emit statements and math operators
 
-class EmitVBaseVisitor : public EmitCBaseVisitor {
+class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
     // MEMBERS
     bool m_suppressSemi = false;
     bool m_suppressUnknown = false;
@@ -673,7 +673,7 @@ public:
 //######################################################################
 // Emit to an output file
 
-class EmitVFileVisitor : public EmitVBaseVisitor {
+class EmitVFileVisitor final : public EmitVBaseVisitor {
     // MEMBERS
     V3OutFile* m_ofp;
     // METHODS
@@ -699,7 +699,7 @@ public:
 //######################################################################
 // Emit to a stream (perhaps stringstream)
 
-class EmitVStreamVisitor : public EmitVBaseVisitor {
+class EmitVStreamVisitor final : public EmitVBaseVisitor {
     // MEMBERS
     std::ostream& m_os;
     // METHODS
@@ -721,7 +721,7 @@ public:
 //######################################################################
 // Emit to a stream (perhaps stringstream)
 
-class EmitVPrefixedFormatter : public V3OutFormatter {
+class EmitVPrefixedFormatter final : public V3OutFormatter {
     std::ostream& m_os;
     string m_prefix;  // What to print at beginning of each line
     int m_flWidth;  // Padding of fileline
@@ -763,7 +763,7 @@ public:
     }
 };
 
-class EmitVPrefixedVisitor : public EmitVBaseVisitor {
+class EmitVPrefixedVisitor final : public EmitVBaseVisitor {
     // MEMBERS
     EmitVPrefixedFormatter m_formatter;  // Special verilog formatter (Way down the
                                          // inheritance is another unused V3OutFormatter)

src/V3EmitV.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3EmitV {
+class V3EmitV final {
 public:
     static void verilogForTree(AstNode* nodep, std::ostream& os = std::cout);
     static void verilogPrefixedTree(AstNode* nodep, std::ostream& os, const string& prefix,

src/V3EmitXml.cpp

@@ -28,7 +28,7 @@
 //######################################################################
 // Emit statements and math operators
 
-class EmitXmlFileVisitor : public AstNVisitor {
+class EmitXmlFileVisitor final : public AstNVisitor {
     // NODE STATE
     // Entire netlist:
     // AstNode::user1           -> uint64_t, number to connect crossrefs
@@ -256,7 +256,7 @@ public:
 //######################################################################
 // List of module files xml visitor
 
-class ModuleFilesXmlVisitor : public AstNVisitor {
+class ModuleFilesXmlVisitor final : public AstNVisitor {
 private:
     // MEMBERS
     std::ostream& m_os;
@@ -304,7 +304,7 @@ public:
 //######################################################################
 // Hierarchy of Cells visitor
 
-class HierCellsXmlVisitor : public AstNVisitor {
+class HierCellsXmlVisitor final : public AstNVisitor {
 private:
     // MEMBERS
     std::ostream& m_os;

src/V3EmitXml.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3EmitXml {
+class V3EmitXml final {
 public:
     static void emitxml();
 };

src/V3Error.h

@@ -33,7 +33,7 @@
 
 //######################################################################
 
-class V3ErrorCode {
+class V3ErrorCode final {
 public:
     // clang-format off
     enum en: uint8_t  {
@@ -217,7 +217,7 @@ inline std::ostream& operator<<(std::ostream& os, const V3ErrorCode& rhs) {
 
 //######################################################################
 
-class V3Error {
+class V3Error final {
     // Base class for any object that wants debugging and error reporting
 
     typedef std::set<string> MessagesSet;

src/V3Expand.cpp

@@ -37,7 +37,7 @@
 //######################################################################
 // Expand state, as a visitor of each AstNode
 
-class ExpandVisitor : public AstNVisitor {
+class ExpandVisitor final : public AstNVisitor {
 private:
     // NODE STATE
     //  AstNode::user1()        -> bool.  Processed

src/V3Expand.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Expand {
+class V3Expand final {
 public:
     static void expandAll(AstNetlist* nodep);
 };

src/V3File.cpp

@@ -62,9 +62,9 @@ constexpr int INFILTER_CACHE_MAX = (64 * 1024);  // Maximum bytes to cache if sa
 //######################################################################
 // V3File Internal state
 
-class V3FileDependImp {
+class V3FileDependImp final {
     // TYPES
-    class DependFile {
+    class DependFile final {
         // A single file
         bool m_target;  // True if write, else read
         bool m_exists = true;
@@ -327,7 +327,7 @@ void V3File::createMakeDir() {
 //######################################################################
 // VInFilterImp
 
-class VInFilterImp {
+class VInFilterImp final {
     typedef std::map<const string, string> FileContentsMap;
     typedef VInFilter::StrList StrList;
 
@@ -949,7 +949,7 @@ void V3OutCFile::putsGuard() {
 //######################################################################
 // VIdProtect
 
-class VIdProtectImp {
+class VIdProtectImp final {
     // MEMBERS
     typedef std::map<const string, string> IdMap;
     IdMap m_nameMap;  // Map of old name into new name

src/V3File.h

@@ -31,7 +31,7 @@
 //============================================================================
 // V3File: Create streams, recording dependency information
 
-class V3File {
+class V3File final {
 public:
     static std::ifstream* new_ifstream(const string& filename) {
         addSrcDepend(filename);
@@ -76,7 +76,7 @@ public:
 
 class VInFilterImp;
 
-class VInFilter {
+class VInFilter final {
 public:
     // TYPES
     typedef std::list<string> StrList;
@@ -99,7 +99,7 @@ public:
 //============================================================================
 // V3OutFormatter: A class for automatic indentation of C++ or Verilog code.
 
-class V3OutFormatter {
+class V3OutFormatter VL_NOT_FINAL {
     // TYPES
     static constexpr int MAXSPACE = 80;  // After this indent, stop indenting more
 public:
@@ -176,7 +176,7 @@ public:
 //============================================================================
 // V3OutFile: A class for printing to a file, with automatic indentation of C++ code.
 
-class V3OutFile : public V3OutFormatter {
+class V3OutFile VL_NOT_FINAL : public V3OutFormatter {
     // MEMBERS
     FILE* m_fp;
 
@@ -190,7 +190,7 @@ private:
     virtual void putcOutput(char chr) override { fputc(chr, m_fp); }
 };
 
-class V3OutCFile : public V3OutFile {
+class V3OutCFile VL_NOT_FINAL : public V3OutFile {
     int m_guard = false;  // Created header guard
     int m_private;  // 1 = Most recently emitted private:, 2 = public:
 public:
@@ -218,7 +218,7 @@ public:
     }
 };
 
-class V3OutScFile : public V3OutCFile {
+class V3OutScFile final : public V3OutCFile {
 public:
     explicit V3OutScFile(const string& filename)
         : V3OutCFile{filename} {}
@@ -231,7 +231,7 @@ public:
     }
 };
 
-class V3OutVFile : public V3OutFile {
+class V3OutVFile final : public V3OutFile {
 public:
     explicit V3OutVFile(const string& filename)
         : V3OutFile{filename, V3OutFormatter::LA_VERILOG} {}
@@ -239,7 +239,7 @@ public:
     virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); }
 };
 
-class V3OutXmlFile : public V3OutFile {
+class V3OutXmlFile final : public V3OutFile {
 public:
     explicit V3OutXmlFile(const string& filename)
         : V3OutFile{filename, V3OutFormatter::LA_XML} {
@@ -249,7 +249,7 @@ public:
     virtual void putsHeader() { puts("<?xml version=\"1.0\" ?>\n"); }
 };
 
-class V3OutMkFile : public V3OutFile {
+class V3OutMkFile final : public V3OutFile {
 public:
     explicit V3OutMkFile(const string& filename)
         : V3OutFile{filename, V3OutFormatter::LA_MK} {}
@@ -265,7 +265,7 @@ public:
 
 class VIdProtectImp;
 
-class VIdProtect {
+class VIdProtect final {
 public:
     // METHODS
     // Rename to a new encoded string (unless earlier passthru'ed)

src/V3FileLine.h

@@ -37,7 +37,7 @@ class FileLine;
 
 //! This singleton class contains tables of data that are unchanging in each
 //! source file (each with its own unique filename number).
-class FileLineSingleton {
+class FileLineSingleton final {
     // TYPES
     typedef std::map<const string, int> FileNameNumMap;
     // MEMBERS
@@ -64,7 +64,7 @@ protected:
 };
 
 //! All source lines from a file/stream, to enable errors to show sources
-class VFileContent {
+class VFileContent final {
     // MEMBERS
     int m_id;  // Content ID number
     std::deque<string> m_lines;  // Source text lines
@@ -87,7 +87,7 @@ std::ostream& operator<<(std::ostream& os, VFileContent* contentp);
 //! This class is instantiated for every source code line (potentially
 //! millions). To save space, per-file information (e.g. filename, source
 //! language is held in tables in the FileLineSingleton class.
-class FileLine {
+class FileLine final {
     // CONSTANTS
     static constexpr unsigned SHOW_SOURCE_MAX_LENGTH = 400;  // Don't show source lines > this long
 

src/V3Gate.cpp

@@ -43,7 +43,7 @@ constexpr int GATE_DEDUP_MAX_DEPTH = 20;
 
 //######################################################################
 
-class GateBaseVisitor : public AstNVisitor {
+class GateBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 public:
     VL_DEBUG_FUNC;  // Declare debug()
 };
@@ -52,7 +52,7 @@ public:
 
 class GateLogicVertex;
 class GateVarVertex;
-class GateGraphBaseVisitor {
+class GateGraphBaseVisitor VL_NOT_FINAL {
 public:
     V3Graph* m_graphp;  // Graph this class is visiting
     explicit GateGraphBaseVisitor(V3Graph* graphp)
@@ -66,7 +66,7 @@ public:
 //######################################################################
 // Support classes
 
-class GateEitherVertex : public V3GraphVertex {
+class GateEitherVertex VL_NOT_FINAL : public V3GraphVertex {
     AstScope* m_scopep;  // Scope vertex refers to
     bool m_reducible = true;  // True if this node should be able to be eliminated
     bool m_dedupable = true;  // True if this node should be able to be deduped
@@ -123,7 +123,7 @@ public:
     }
 };
 
-class GateVarVertex : public GateEitherVertex {
+class GateVarVertex final : public GateEitherVertex {
     AstVarScope* m_varScp;
     bool m_isTop = false;
     bool m_isClock = false;
@@ -163,7 +163,7 @@ public:
     }
 };
 
-class GateLogicVertex : public GateEitherVertex {
+class GateLogicVertex final : public GateEitherVertex {
     AstNode* m_nodep;
     AstActive* m_activep;  // Under what active; nullptr is ok (under cfunc or such)
     bool m_slow;  // In slow block
@@ -192,7 +192,7 @@ public:
 //######################################################################
 // Is this a simple math expression with a single input and single output?
 
-class GateOkVisitor : public GateBaseVisitor {
+class GateOkVisitor final : public GateBaseVisitor {
 private:
     // RETURN STATE
     bool m_isSimple = true;  // Set false when we know it isn't simple
@@ -301,7 +301,7 @@ public:
 //######################################################################
 // Gate class functions
 
-class GateVisitor : public GateBaseVisitor {
+class GateVisitor final : public GateBaseVisitor {
 private:
     // NODE STATE
     // Entire netlist:
@@ -826,7 +826,7 @@ void GateVisitor::warnSignals() {
 
 class GateDedupeVarVisitor;
 
-class GateElimVisitor : public GateBaseVisitor {
+class GateElimVisitor final : public GateBaseVisitor {
 private:
     // NODE STATE
     // STATE
@@ -903,7 +903,7 @@ void GateVisitor::optimizeElimVar(AstVarScope* varscp, AstNode* substp, AstNode*
 //######################################################################
 // Auxiliary hash class for GateDedupeVarVisitor
 
-class GateDedupeHash : public V3HashedUserSame {
+class GateDedupeHash final : public V3HashedUserSame {
 public:
     // TYPES
     typedef std::set<AstNode*> NodeSet;
@@ -1021,7 +1021,7 @@ public:
 //######################################################################
 // Have we seen the rhs of this assign before?
 
-class GateDedupeVarVisitor : public GateBaseVisitor {
+class GateDedupeVarVisitor final : public GateBaseVisitor {
     // Given a node, it is visited to try to find the AstNodeAssign under
     // it that can used for dedupe.
     // Right now, only the following node trees are supported for dedupe.
@@ -1121,7 +1121,7 @@ void GateElimVisitor::hashReplace(AstNode* oldp, AstNode* newp) {
 //######################################################################
 // Recurse through the graph, looking for duplicate expressions on the rhs of an assign
 
-class GateDedupeGraphVisitor : public GateGraphBaseVisitor {
+class GateDedupeGraphVisitor final : public GateGraphBaseVisitor {
 private:
     // NODE STATE
     // AstVarScope::user2p      -> bool: already visited
@@ -1248,7 +1248,7 @@ void GateVisitor::dedupe() {
 //######################################################################
 // Recurse through the graph, try to merge assigns
 
-class GateMergeAssignsGraphVisitor : public GateGraphBaseVisitor {
+class GateMergeAssignsGraphVisitor final : public GateGraphBaseVisitor {
 private:
     // NODE STATE
     AstNodeAssign* m_assignp = nullptr;
@@ -1378,7 +1378,7 @@ void GateVisitor::mergeAssigns() {
 //######################################################################
 // Find a var's offset in a concatenation
 
-class GateConcatVisitor : public GateBaseVisitor {
+class GateConcatVisitor final : public GateBaseVisitor {
 private:
     // STATE
     AstVarScope* m_vscp = nullptr;  // Varscope we're trying to find
@@ -1429,7 +1429,7 @@ public:
 //######################################################################
 // Recurse through the graph, looking for clock vectors to bypass
 
-class GateClkDecompState {
+class GateClkDecompState final {
 public:
     int m_offset;
     AstVarScope* m_last_vsp;
@@ -1439,7 +1439,7 @@ public:
     virtual ~GateClkDecompState() = default;
 };
 
-class GateClkDecompGraphVisitor : public GateGraphBaseVisitor {
+class GateClkDecompGraphVisitor final : public GateGraphBaseVisitor {
 private:
     // NODE STATE
     // AstVarScope::user2p      -> bool: already visited
@@ -1571,7 +1571,7 @@ void GateVisitor::decomposeClkVectors() {
 //######################################################################
 // Convert VARSCOPE(ASSIGN(default, VARREF)) to just VARSCOPE(default)
 
-class GateDeassignVisitor : public GateBaseVisitor {
+class GateDeassignVisitor final : public GateBaseVisitor {
 private:
     // VISITORS
     virtual void visit(AstVarScope* nodep) override {

src/V3Gate.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3Gate {
+class V3Gate final {
 public:
     static void gateAll(AstNetlist* nodep);
 };

src/V3GenClk.cpp

@@ -29,7 +29,7 @@
 //######################################################################
 // GenClk state, as a visitor of each AstNode
 
-class GenClkBaseVisitor : public AstNVisitor {
+class GenClkBaseVisitor VL_NOT_FINAL : public AstNVisitor {
 protected:
     VL_DEBUG_FUNC;  // Declare debug()
 };
@@ -37,7 +37,7 @@ protected:
 //######################################################################
 // GenClk Read
 
-class GenClkRenameVisitor : public GenClkBaseVisitor {
+class GenClkRenameVisitor final : public GenClkBaseVisitor {
 private:
     // NODE STATE
     // Cleared on top scope
@@ -127,7 +127,7 @@ public:
 //######################################################################
 // GenClk Read
 
-class GenClkReadVisitor : public GenClkBaseVisitor {
+class GenClkReadVisitor final : public GenClkBaseVisitor {
 private:
     // NODE STATE
     // Cleared on top scope

src/V3GenClk.h

@@ -25,7 +25,7 @@
 
 //============================================================================
 
-class V3GenClk {
+class V3GenClk final {
 public:
     static void genClkAll(AstNetlist* nodep);
 };

src/V3Global.h

@@ -61,7 +61,7 @@ public:
 
 //######################################################################
 
-class VWidthMinUsage {
+class VWidthMinUsage final {
 public:
     enum en : uint8_t { LINT_WIDTH, MATCHES_WIDTH, VERILOG_WIDTH };
     enum en m_e;
@@ -87,7 +87,7 @@ inline bool operator==(VWidthMinUsage::en lhs, const VWidthMinUsage& rhs) {
 //######################################################################
 // V3Global - The top level class for the entire program
 
-class V3Global {
+class V3Global final {
     // Globals
     AstNetlist* m_rootp;  // Root of entire netlist
     V3HierBlockPlan* m_hierPlanp;  // Hierarchical verilation plan, nullptr unless hier_block

src/V3Graph.h

@@ -45,7 +45,7 @@ typedef bool (*V3EdgeFuncP)(const V3GraphEdge* edgep);
 // it's useful to have algorithms that can walk in either direction, hence
 // some methods take GraphWay to programmatically select the direction.
 
-class GraphWay {
+class GraphWay final {
 public:
     enum en : uint8_t {
         FORWARD = 0,
@@ -77,7 +77,7 @@ inline bool operator==(GraphWay::en lhs, const GraphWay& rhs) { return lhs == rh
 
 //============================================================================
 
-class V3Graph {
+class V3Graph VL_NOT_FINAL {
 private:
     // MEMBERS
     V3List<V3GraphVertex*> m_vertices;  // All vertices
@@ -185,7 +185,7 @@ public:
 
 //============================================================================
 
-class V3GraphVertex {
+class V3GraphVertex VL_NOT_FINAL {
     // Vertices may be a 'gate'/wire statement OR a variable
 protected:
     friend class V3Graph;
@@ -273,7 +273,7 @@ std::ostream& operator<<(std::ostream& os, V3GraphVertex* vertexp);
 
 //============================================================================
 
-class V3GraphEdge {
+class V3GraphEdge VL_NOT_FINAL {
     // Wires/variables aren't edges.  Edges have only a single to/from vertex
 public:
     // ENUMS