Internals: Mark structs final/VL_NOT_FINAL. No functional change intended.

include/verilated.h

@@ -349,7 +349,7 @@ protected:
     // Slow path variables
     mutable VerilatedMutex m_mutex;  // Mutex for most s_s/s_ns members
 
-    struct Serialized {  // All these members serialized/deserialized
+    struct Serialized final {  // All these members serialized/deserialized
         // No std::strings or pointers or will serialize badly!
         // Fast path
         bool m_assertOn = true;  // Assertions are enabled
@@ -379,7 +379,7 @@ protected:
     std::string m_timeFormatSuffix VL_GUARDED_BY(m_timeDumpMutex);  // $timeformat printf format
     std::string m_dumpfile VL_GUARDED_BY(m_timeDumpMutex);  // $dumpfile setting
 
-    struct NonSerialized {  // Non-serialized information
+    struct NonSerialized final {  // Non-serialized information
         // These are reloaded from on command-line settings, so do not need to persist
         // Fast path
         uint64_t m_profExecStart = 1;  // +prof+exec+start time
@@ -393,7 +393,7 @@ protected:
     mutable VerilatedMutex m_argMutex;  // Protect m_argVec, m_argVecLoaded
     // no need to be save-restored (serialized) the
     // assumption is that the restore is allowed to pass different arguments
-    struct NonSerializedCommandArgs {
+    struct NonSerializedCommandArgs final {
         // Medium speed
         std::vector<std::string> m_argVec;  // Argument list
         bool m_argVecLoaded = false;  // Ever loaded argument list

include/verilated_imp.h

@@ -54,7 +54,7 @@ class VerilatedScope;
 class VerilatedMsg final {
 public:
     // TYPES
-    struct Cmp {
+    struct Cmp final {
         bool operator()(const VerilatedMsg& a, const VerilatedMsg& b) const {
             return a.mtaskId() < b.mtaskId();
         }
@@ -221,7 +221,7 @@ class VerilatedContextImp final : VerilatedContext {
     // Internal note: Globals may multi-construct, see verilated.cpp top.
 
     // Medium speed, so uses singleton accessing
-    struct Statics {
+    struct Statics final {
         VerilatedMutex s_randMutex;  // Mutex protecting s_randSeedEpoch
         // Number incrementing on each reseed, 0=illegal
         int s_randSeedEpoch = 1;  // Reads ok, wish had a VL_WRITE_GUARDED_BY(s_randMutex)

include/verilated_profiler.cpp

@@ -106,7 +106,7 @@ VerilatedVirtualBase* VlExecutionProfiler::construct(VerilatedContext& context)
     if (VlThreadPool* const threadPoolp = static_cast<VlThreadPool*>(context.threadPoolp())) {
         for (int i = 0; i < threadPoolp->numThreads(); ++i) {
             // Data to pass to worker thread initialization
-            struct Data {
+            struct Data final {
                 VlExecutionProfiler* const selfp;
                 const uint32_t threadId;
             } data{selfp, static_cast<uint32_t>(i + 1)};

include/verilated_syms.h

@@ -42,7 +42,7 @@
 // Types
 
 // Class to sort maps keyed by const char*'s
-struct VerilatedCStrCmp {
+struct VerilatedCStrCmp final {
     bool operator()(const char* a, const char* b) const { return std::strcmp(a, b) < 0; }
 };
 

include/verilated_threads.h

@@ -127,7 +127,7 @@ public:
 class VlWorkerThread final {
 private:
     // TYPES
-    struct ExecRec {
+    struct ExecRec final {
         VlExecFnp m_fnp = nullptr;  // Function to execute
         VlSelfP m_selfp = nullptr;  // Symbol table to execute
         bool m_evenCycle = false;  // Even/odd for flag alternation

include/verilated_timing.h

@@ -189,7 +189,7 @@ public:
     // Used by coroutines for co_awaiting a certain simulation time
     auto delay(uint64_t delay, VlProcessRef process, const char* filename = VL_UNKNOWN,
                int lineno = 0) {
-        struct Awaitable {
+        struct Awaitable final {
             VlProcessRef process;  // Data of the suspended process, null if not needed
             VlDelayedCoroutineQueue& queue;
             std::vector<VlCoroutineHandle>& queueZeroDelay;
@@ -260,7 +260,7 @@ public:
                  const char* filename = VL_UNKNOWN, int lineno = 0) {
         VL_DEBUG_IF(VL_DBG_MSGF("         Suspending process waiting for %s at %s:%d\n",
                                 eventDescription, filename, lineno););
-        struct Awaitable {
+        struct Awaitable final {
             VlCoroutineVec& suspended;  // Coros waiting on trigger
             VlProcessRef process;  // Data of the suspended process, null if not needed
             VlFileLineDebug fileline;
@@ -308,7 +308,7 @@ class VlDynamicTriggerScheduler final {
 
     // METHODS
     auto awaitable(VlProcessRef process, VlCoroutineVec& queue, const char* filename, int lineno) {
-        struct Awaitable {
+        struct Awaitable final {
             VlProcessRef process;  // Data of the suspended process, null if not needed
             VlCoroutineVec& suspended;  // Coros waiting on trigger
             VlFileLineDebug fileline;
@@ -362,7 +362,7 @@ public:
 // VlForever is a helper awaitable type for suspending coroutines forever. Used for constant
 // wait statements.
 
-struct VlForever {
+struct VlForever final {
     bool await_ready() const { return false; }  // Always suspend
     void await_suspend(std::coroutine_handle<> coro) const { coro.destroy(); }
     void await_resume() const {}
@@ -374,7 +374,7 @@ struct VlForever {
 class VlForkSync final {
     // VlJoin stores the handle of a suspended coroutine that did a fork..join or fork..join_any.
     // If the counter reaches 0, the suspended coroutine shall be resumed.
-    struct VlJoin {
+    struct VlJoin final {
         size_t m_counter = 0;  // When reaches 0, resume suspended coroutine
         VlCoroutineHandle m_susp;  // Coroutine to resume
     };
@@ -393,7 +393,7 @@ public:
         assert(m_join);
         VL_DEBUG_IF(
             VL_DBG_MSGF("             Awaiting join of fork at: %s:%d\n", filename, lineno););
-        struct Awaitable {
+        struct Awaitable final {
             VlProcessRef process;  // Data of the suspended process, null if not needed
             const std::shared_ptr<VlJoin> join;  // Join to await on
             VlFileLineDebug fileline;
@@ -415,7 +415,7 @@ public:
 class VlCoroutine final {
 private:
     // TYPES
-    struct VlPromise {
+    struct VlPromise final {
         std::coroutine_handle<> m_continuation;  // Coroutine to resume after this one finishes
         VlCoroutine* m_corop = nullptr;  // Pointer to the coroutine return object
 

include/verilated_trace.h

@@ -204,7 +204,7 @@ private:
     friend Buffer;
     friend OffloadBuffer;
 
-    struct CallbackRecord {
+    struct CallbackRecord final {
         // Note: would make these fields const, but some old STL implementations
         // (the one in Ubuntu 14.04 with GCC 4.8.4 in particular) use the
         // assignment operator on inserting into collections, so they don't work
@@ -238,7 +238,7 @@ private:
     bool m_offload = false;  // Use the offload thread
     bool m_parallel = false;  // Use parallel tracing
 
-    struct ParallelWorkerData {
+    struct ParallelWorkerData final {
         const dumpCb_t m_cb;  // The callback
         void* const m_userp;  // The use pointer to pass to the callback
         Buffer* const m_bufp;  // The buffer pointer to pass to the callback

include/verilated_types.h

@@ -1592,7 +1592,7 @@ public:
 // Represents the null pointer. Used for setting VlClassRef to null instead of
 // via nullptr_t, to prevent the implicit conversion of 0 to nullptr.
 
-struct VlNull {
+struct VlNull final {
     operator bool() const { return false; }
 };
 
@@ -1751,7 +1751,7 @@ template <typename T_Sampled>
 class VlSampleQueue final {
     // TYPES
     // Type representing a single value sample at a point in time
-    struct VlSample {
+    struct VlSample final {
         uint64_t m_timestamp;  // Timestamp at which the value was sampled
         T_Sampled m_value;  // The sampled value
     };

include/verilated_vpi.cpp

@@ -604,7 +604,7 @@ public:
     void invalidate() { m_id = 0; }
 };
 
-struct VerilatedVpiTimedCbsCmp {
+struct VerilatedVpiTimedCbsCmp final {
     // Ordering sets keyed by time, then callback unique id
     bool operator()(const std::pair<QData, uint64_t>& a,
                     const std::pair<QData, uint64_t>& b) const {

include/verilatedos.h

@@ -612,7 +612,7 @@ static inline double VL_ROUND(double n) {
 namespace vlstd {
 
 template <typename T>
-struct reverse_wrapper {
+struct reverse_wrapper final {
     const T& m_v;
 
     explicit reverse_wrapper(const T& a_v)

src/V3Ast.h

@@ -98,7 +98,7 @@ using MTaskIdSet = std::set<int>;  // Set of mtaskIds for Var sorting
 
 //######################################################################
 
-struct VNTypeInfo {
+struct VNTypeInfo final {
     const char* m_namep;
     enum uint8_t {
         OP_UNUSED,

src/V3AstNodeDType.h

@@ -339,7 +339,7 @@ public:
 class AstBasicDType final : public AstNodeDType {
     // Builtin atomic/vectored data type
     // @astgen op1 := rangep : Optional[AstRange] // Range of variable
-    struct Members {
+    struct Members final {
         VBasicDTypeKwd m_keyword;  // (also in VBasicTypeKey) What keyword created basic type
         VNumRange m_nrange;  // (also in VBasicTypeKey) Numeric msb/lsb (if non-opaque keyword)
         bool operator==(const Members& rhs) const {

src/V3Combine.cpp

@@ -43,7 +43,7 @@ class CombineVisitor final : VNVisitor {
 
     // TYPES
     using funcit_t = std::list<AstCFunc*>::iterator;
-    struct CFuncs {
+    struct CFuncs final {
         std::list<AstCFunc*> m_fast;
         std::list<AstCFunc*> m_slow;
     };

src/V3Coverage.cpp

@@ -39,7 +39,7 @@ class CoverageVisitor final : public VNVisitor {
     // TYPES
     using LinenoSet = std::set<int>;
 
-    struct ToggleEnt {
+    struct ToggleEnt final {
         const string m_comment;  // Comment for coverage dump
         AstNodeExpr* m_varRefp;  // How to get to this element
         AstNodeExpr* m_chgRefp;  // How to get to this element
@@ -54,7 +54,7 @@ class CoverageVisitor final : public VNVisitor {
         }
     };
 
-    struct CheckState {  // State save-restored on each new coverage scope/block
+    struct CheckState final {  // State save-restored on each new coverage scope/block
         bool m_on = false;  // Should this block get covered?
         bool m_inModOff = false;  // In module with no coverage
         int m_handle = 0;  // Opaque handle for index into line tracking

src/V3DfgAstToDfg.cpp

@@ -77,7 +77,7 @@ class AstToDfgVisitor final : public VNVisitor {
 
     // TYPES
     // Represents a driver during canonicalization
-    struct Driver {
+    struct Driver final {
         FileLine* m_fileline;
         DfgVertex* m_vtxp;
         uint32_t m_lsb;

src/V3DfgDecomposition.cpp

@@ -122,7 +122,7 @@ class ExtractCyclicComponents final {
     static constexpr size_t UNASSIGNED = std::numeric_limits<size_t>::max();
 
     // TYPES
-    struct VertexState {
+    struct VertexState final {
         size_t index = UNASSIGNED;  // Used by Pearce's algorithm for detecting SCCs
         size_t component = UNASSIGNED;  // Result component number (0 stays in input graph)
         bool merged = false;  // Visited in the merging pass

src/V3DupFinder.h

@@ -33,7 +33,7 @@
 
 //============================================================================
 
-struct V3DupFinderUserSame {
+struct V3DupFinderUserSame VL_NOT_FINAL {
     // Functor for V3DupFinder::findDuplicate
     virtual bool isSame(AstNode*, AstNode*) = 0;
     V3DupFinderUserSame() = default;

src/V3EmitCFunc.h

@@ -124,7 +124,7 @@ class EmitCFunc VL_NOT_FINAL : public EmitCConstInit {
     bool m_emitConstInit = false;  // Emitting constant initializer
 
     // State associated with processing $display style string formatting
-    struct EmitDispState {
+    struct EmitDispState final {
         string m_format;  // "%s" and text from user
         std::vector<char> m_argsChar;  // Format of each argument to be printed
         std::vector<AstNode*> m_argsp;  // Each argument to be printed

src/V3EmitCSyms.cpp

@@ -39,7 +39,7 @@ class EmitCSyms final : EmitCBaseVisitorConst {
     const VNUser1InUse m_inuser1;
 
     // TYPES
-    struct ScopeData {
+    struct ScopeData final {
         const string m_symName;
         const string m_prettyName;
         const int m_timeunit;
@@ -51,7 +51,7 @@ class EmitCSyms final : EmitCBaseVisitorConst {
             , m_timeunit{timeunit}
             , m_type{type} {}
     };
-    struct ScopeFuncData {
+    struct ScopeFuncData final {
         AstScopeName* const m_scopep;
         AstCFunc* const m_cfuncp;
         AstNodeModule* const m_modp;
@@ -60,7 +60,7 @@ class EmitCSyms final : EmitCBaseVisitorConst {
             , m_cfuncp{funcp}
             , m_modp{modp} {}
     };
-    struct ScopeVarData {
+    struct ScopeVarData final {
         const string m_scopeName;
         const string m_varBasePretty;
         AstVar* const m_varp;
@@ -79,12 +79,12 @@ class EmitCSyms final : EmitCBaseVisitorConst {
     using ModVarPair = std::pair<AstNodeModule*, AstVar*>;
     using ScopeNameList = std::vector<std::string>;
     using ScopeNameHierarchy = std::map<const std::string, ScopeNameList>;
-    struct CmpName {
+    struct CmpName final {
         bool operator()(const ScopeModPair& lhsp, const ScopeModPair& rhsp) const {
             return lhsp.first->name() < rhsp.first->name();
         }
     };
-    struct CmpDpi {
+    struct CmpDpi final {
         bool operator()(const AstCFunc* lhsp, const AstCFunc* rhsp) const {
             if (lhsp->dpiImportPrototype() != rhsp->dpiImportPrototype()) {
                 // cppcheck-suppress comparisonOfFuncReturningBoolError

src/V3Error.cpp

@@ -27,7 +27,7 @@ VL_DEFINE_DEBUG_FUNCTIONS;
 
 //======================================================================
 
-struct v3errorIniter {
+struct v3errorIniter final {
     v3errorIniter() { V3Error::init(); }
 };
 v3errorIniter v3errorInit;

src/V3Force.cpp

@@ -50,7 +50,7 @@ VL_DEFINE_DEBUG_FUNCTIONS;
 
 class ForceConvertVisitor final : public VNVisitor {
     // TYPES
-    struct ForceComponentsVar {
+    struct ForceComponentsVar final {
         AstVar* const m_rdVarp;  // New variable to replace read references with
         AstVar* const m_valVarp;  // Forced value
         AstVar* const m_enVarp;  // Force enabled signal
@@ -76,7 +76,7 @@ class ForceConvertVisitor final : public VNVisitor {
         }
     };
 
-    struct ForceComponentsVarScope {
+    struct ForceComponentsVarScope final {
         AstVarScope* const m_rdVscp;  // New variable to replace read references with
         AstVarScope* const m_enVscp;  // Force enabled signal
         AstVarScope* const m_valVscp;  // Forced value

src/V3FunctionTraits.h

@@ -42,7 +42,7 @@ struct FunctionTraits<ReturnType (ClassType::*)(Args...) const> VL_NOT_FINAL {
 
     // Type of arguments
     template <std::size_t I>
-    struct arg {
+    struct arg final {
         using type = typename std::tuple_element<I, std::tuple<Args...>>::type;
     };
 };

src/V3GraphAcyc.cpp

@@ -80,7 +80,7 @@ public:
 
 //--------------------------------------------------------------------
 
-struct GraphAcycEdgeCmp {
+struct GraphAcycEdgeCmp final {
     bool operator()(const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
         if (lhsp->weight() > rhsp->weight()) return true;  // LHS goes first
         if (lhsp->weight() < rhsp->weight()) return false;  // RHS goes first

src/V3GraphAlg.cpp

@@ -422,12 +422,12 @@ void V3Graph::subtreeLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp, V3Grap
 //######################################################################
 // Algorithms - sorting
 
-struct GraphSortVertexCmp {
+struct GraphSortVertexCmp final {
     bool operator()(const V3GraphVertex* lhsp, const V3GraphVertex* rhsp) const {
         return lhsp->sortCmp(rhsp) < 0;
     }
 };
-struct GraphSortEdgeCmp {
+struct GraphSortEdgeCmp final {
     bool operator()(const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
         return lhsp->sortCmp(rhsp) < 0;
     }

src/V3GraphPathChecker.cpp

@@ -27,7 +27,7 @@
 //######################################################################
 // GraphPCNode
 
-struct GraphPCNode {
+struct GraphPCNode final {
     // User data for each node in GraphPathChecker.
     //
     // Like the LogicMTasks's, store before and after CPs for the nodes in

src/V3Inline.cpp

@@ -45,7 +45,7 @@ static const int INLINE_MODS_SMALLER = 100;  // If a mod is < this # nodes, can
 
 namespace {
 
-struct ModuleState {
+struct ModuleState final {
     bool m_inlined = false;  // Whether to inline this module
     unsigned m_cellRefs = 0;  // Number of AstCells instantiating this module
     std::vector<AstCell*> m_childCells;  // AstCells under this module (to speed up traversal)

src/V3LanguageWords.h

@@ -28,7 +28,7 @@ class V3LanguageWords final {
     // List of common reserved keywords
 private:
     using KeywordMap = std::map<const string, std::string>;
-    struct Singleton {
+    struct Singleton final {
         KeywordMap s_kwdMap;  // List of keywords, and what language applies
         Singleton() { init(); }
         void addKwd(const string& kwd, const string& why) { s_kwdMap.emplace(kwd, why); }

src/V3LifePost.cpp

@@ -95,7 +95,7 @@ public:
 // Location within the execution graph, identified by an mtask
 // and a sequence number within the mtask:
 
-struct LifeLocation {
+struct LifeLocation final {
     const ExecMTask* mtaskp = nullptr;
     uint32_t sequence = 0;
 
@@ -113,7 +113,7 @@ public:
     }
 };
 
-struct LifePostLocation {
+struct LifePostLocation final {
     LifeLocation loc;
     AstAssignPost* nodep = nullptr;
     LifePostLocation() = default;

src/V3LinkDot.cpp

@@ -2038,7 +2038,7 @@ class LinkDotResolveVisitor final : public VNVisitor {
     bool m_explicitSuperNew = false;  // Hit a "super.new" call inside a "new" function
     std::map<AstNode*, AstPin*> m_usedPins;  // Pin used in this cell, map to duplicate
 
-    struct DotStates {
+    struct DotStates final {
         DotPosition m_dotPos;  // Scope part of dotted resolution
         VSymEnt* m_dotSymp;  // SymEnt for dotted AstParse lookup
         const AstDot* m_dotp;  // Current dot

src/V3LinkLevel.cpp

@@ -30,7 +30,7 @@ VL_DEFINE_DEBUG_FUNCTIONS;
 //######################################################################
 // Levelizing class functions
 
-struct CmpLevel {
+struct CmpLevel final {
     bool operator()(const AstNodeModule* lhsp, const AstNodeModule* rhsp) const {
         return lhsp->level() < rhsp->level();
     }

src/V3MergeCond.cpp

@@ -132,7 +132,7 @@ bool areDisjoint(const std::set<const AstVar*>& a, const std::set<const AstVar*>
 //######################################################################
 // Structure containing information required for code motion/merging
 
-struct StmtProperties {
+struct StmtProperties final {
     AstNodeExpr* m_condp = nullptr;  // The condition expression, if a conditional node
     std::set<const AstVar*> m_rdVars;  // Variables read by this statement
     std::set<const AstVar*> m_wrVars;  // Variables written by this statement

src/V3OptionParser.cpp

@@ -26,7 +26,7 @@
 
 //######################################################################
 // V3OptionParser::Impl
-struct V3OptionParser::Impl {
+struct V3OptionParser::Impl final {
     // TYPES
 
     // Setting for isOnOffAllowed() and isPartialMatchAllowed()

src/V3Order.cpp

@@ -838,7 +838,7 @@ class OrderProcess final {
                                    int& newStmtsr);
 
     // processMTask* routines schedule threaded execution
-    struct MTaskState {
+    struct MTaskState final {
         AstMTaskBody* m_mtaskBodyp = nullptr;
         std::list<const OrderLogicVertex*> m_logics;
         ExecMTask* m_execMTaskp = nullptr;

src/V3PairingHeap.h

@@ -41,7 +41,7 @@ public:
 
     // Just a pointer to a heap Node, but with special accessors to help keep back pointers
     // consistent.
-    struct Link {
+    struct Link final {
         Node* m_ptr = nullptr;  // The managed pointer
 
         Link() = default;
@@ -89,7 +89,7 @@ public:
     };
 
     // A single node in the pairing heap tree
-    struct Node {
+    struct Node VL_NOT_FINAL {
         Link m_next;  // Next in list of sibling heaps
         Link m_kids;  // Head of list of child heaps
         Node** m_ownerpp = nullptr;  // Pointer to the Link pointer pointing to this heap

src/V3Param.cpp

@@ -248,7 +248,7 @@ class ParamProcessor final {
 
     // STATE
     using CloneMap = std::unordered_map<const AstNode*, AstNode*>;
-    struct ModInfo {
+    struct ModInfo final {
         AstNodeModule* const m_modp;  // Module with specified name
         CloneMap m_cloneMap;  // Map of old-varp -> new cloned varp
         explicit ModInfo(AstNodeModule* modp)

src/V3ParseImp.h

@@ -45,7 +45,7 @@ enum V3ImportProperty : uint8_t { iprop_NONE, iprop_CONTEXT, iprop_PURE };
 //============================================================================
 // Member qualifiers
 
-struct VMemberQualifiers {
+struct VMemberQualifiers final {
     union {
         uint32_t m_flags;
         struct {
@@ -99,7 +99,7 @@ struct VMemberQualifiers {
 // Parser YYSType, e.g. for parser's yylval
 // We can't use bison's %union as we want to pass the fileline with all tokens
 
-struct V3ParseBisonYYSType {
+struct V3ParseBisonYYSType final {
     FileLine* fl;
     AstNode* scp;  // Symbol table scope for future lookups
     int token;  // Read token, aka tok

src/V3Partition.cpp

@@ -154,7 +154,7 @@ static void partCheckCachedScoreVsActual(uint32_t cached, uint32_t actual) {
 //=============================================================================
 // We keep MTaskEdge graph edges in a PairingHeap, sorted by score and id
 
-struct EdgeKey {
+struct EdgeKey final {
     // Node: Structure layout chosen to minimize padding in PairingHeao<*>::Node
     uint64_t m_id;  // Unique ID part of edge score
     uint32_t m_score;  // Score part of ID
@@ -183,7 +183,7 @@ public:
     // TYPES
     using VxList = std::list<MTaskMoveVertex*>;
 
-    struct CmpLogicMTask {
+    struct CmpLogicMTask final {
         bool operator()(const LogicMTask* ap, const LogicMTask* bp) const {
             return ap->id() < bp->id();
         }
@@ -404,7 +404,7 @@ struct MTaskIdLessThan final {
     }
 };
 
-struct MergeCandidateKey {
+struct MergeCandidateKey final {
     // Note: Structure layout chosen to minimize padding in PairingHeao<*>::Node
     uint64_t m_id;  // Unique ID part of edge score
     uint32_t m_score;  // Score part of ID
@@ -895,7 +895,7 @@ class PartPropagateCp final {
     // TYPES
 
     // We keep pending vertices in a heap during critical path propagation
-    struct PendingKey {
+    struct PendingKey final {
         LogicMTask* m_mtaskp;  // The vertex in the heap
         uint32_t m_score;  // The score of this entry
         void increase(uint32_t score) {
@@ -1236,7 +1236,7 @@ static void partRedirectEdgesFrom(V3Graph* graphp, LogicMTask* recipientp, Logic
 class PartContraction final {
     // TYPES
     // New CP information for mtaskp reflecting an upcoming merge
-    struct NewCp {
+    struct NewCp final {
         uint32_t cp;
         uint32_t propagateCp;
         bool propagate;
@@ -1673,7 +1673,7 @@ private:
         // and swap these sorting records very efficiently. With this the standard library sorting
         // functions are efficient enough and using more optimized methods (e.g.: sorting networks)
         // has no measurable benefit.
-        struct alignas(16) SortingRecord {
+        struct alignas(16) SortingRecord final {
             uint64_t m_id;
             uint32_t m_cp;
             uint8_t m_idx;
@@ -2170,7 +2170,7 @@ public:
     static constexpr uint32_t UNASSIGNED = 0xffffffff;
 
     // TYPES
-    struct MTaskState {
+    struct MTaskState final {
         uint32_t completionTime = 0;  // Estimated time this mtask will complete
         uint32_t threadId = UNASSIGNED;  // Thread id this MTask is assigned to
         const ExecMTask* nextp = nullptr;  // Next MTask on same thread after this
@@ -2320,7 +2320,7 @@ void ThreadSchedule::dumpDotFile(const V3Graph& graph, const string& filename) c
 // "padding" avoids tight "layovers" at cross-thread dependencies.
 class PartPackMTasks final {
     // TYPES
-    struct MTaskCmp {
+    struct MTaskCmp final {
         bool operator()(const ExecMTask* ap, const ExecMTask* bp) const {
             return ap->id() < bp->id();
         }

src/V3Rtti.h

@@ -25,7 +25,7 @@
 // Holds list of types as template parameter pack.
 // Useful in compile-time code generation.
 template <typename... TN>
-struct VTypeList {
+struct VTypeList final {
     template <typename... UN>
     constexpr VTypeList<TN..., UN...> operator+(VTypeList<UN...>) const {
         return {};
@@ -36,7 +36,7 @@ struct VTypeList {
 // Can be safely used as a return or argument type, and even instantiated, without triggering any
 // potential limitations or effects of the held type.
 template <typename T>
-struct VTypeWrapper {
+struct VTypeWrapper final {
     using type_t = T;
 };
 

src/V3Sched.cpp

@@ -167,7 +167,7 @@ AstNodeStmt* profExecSectionPop(FileLine* flp) {
     return new AstCStmt{flp, "VL_EXEC_TRACE_ADD_RECORD(vlSymsp).sectionPop();\n"};
 }
 
-struct EvalLoop {
+struct EvalLoop final {
     // Flag set to true during the first iteration of the loop
     AstVarScope* firstIterp;
     // The loop itself and statements around it
@@ -491,7 +491,7 @@ void createFinal(AstNetlist* netlistp, const LogicClasses& logicClasses) {
 //============================================================================
 // A TriggerKit holds all the components related to a TRIGGERVEC variable
 
-struct TriggerKit {
+struct TriggerKit final {
     // The TRIGGERVEC AstVarScope representing these trigger flags
     AstVarScope* const m_vscp;
     // The AstCFunc that computes the current active triggers
@@ -532,7 +532,7 @@ struct TriggerKit {
 //============================================================================
 // EvalKit groups items that have to be passed to createEval() for a given eval region
 
-struct EvalKit {
+struct EvalKit final {
     // The TRIGGERVEC AstVarScope representing the region's trigger flags
     AstVarScope* const m_vscp = nullptr;
     // The AstCFunc that computes the region's active triggers

src/V3Scoreboard.cpp

@@ -20,7 +20,7 @@
 
 class ScoreboardTestElem;
 
-struct Key {
+struct Key final {
     // Node: Structure layout chosen to minimize padding in PairingHeao<*>::Node
     uint64_t m_id;  // Unique ID part of edge score
     uint32_t m_score;  // Score part of ID

src/V3SplitVar.cpp

@@ -122,7 +122,7 @@
 
 VL_DEFINE_DEBUG_FUNCTIONS;
 
-struct SplitVarImpl {
+struct SplitVarImpl VL_NOT_FINAL {
     // NODE STATE
     //  AstNodeModule::user1()  -> Block number counter for generating unique names
     const VNUser1InUse m_user1InUse;  // Only used in SplitUnpackedVarVisitor
@@ -239,7 +239,7 @@ static void warnNoSplit(const AstVar* varp, const AstNode* wherep, const char* r
 // AstSliceSel  -> Create a temporary variable and refer the variable
 
 // Compare AstNode* to get deterministic ordering when showing messages.
-struct AstNodeComparator {
+struct AstNodeComparator final {
     bool operator()(const AstNode* ap, const AstNode* bp) const {
         const int lineComp = ap->fileline()->operatorCompare(*bp->fileline());
         if (lineComp != 0) return lineComp < 0;
@@ -346,7 +346,7 @@ public:
 };
 
 // Found nodes for SplitPackedVarVisitor
-struct RefsInModule {
+struct RefsInModule final {
     std::set<AstVar*, AstNodeComparator> m_vars;
     std::set<AstVarRef*, AstNodeComparator> m_refs;
     std::set<AstSel*, AstNodeComparator> m_sels;
@@ -356,7 +356,7 @@ public:
     void add(AstVarRef* nodep) { m_refs.insert(nodep); }
     void add(AstSel* nodep) { m_sels.insert(nodep); }
     void remove(AstNode* nodep) {
-        struct Visitor : public VNVisitor {
+        struct Visitor final : public VNVisitor {
             RefsInModule& m_parent;
             void visit(AstNode* nodep) override { iterateChildren(nodep); }
             void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
@@ -812,7 +812,7 @@ public:
     }
     AstVar* varp() const { return m_varp; }
 
-    struct Match {
+    struct Match final {
         bool operator()(int bit, const SplitNewVar& a) const {
             return bit < a.m_lsb + a.m_bitwidth;
         }
@@ -854,7 +854,7 @@ public:
 
 // How a variable is used
 class PackedVarRef final {
-    struct SortByFirst {
+    struct SortByFirst final {
         bool operator()(const std::pair<int, bool>& a, const std::pair<int, bool>& b) const {
             if (a.first == b.first) return a.second < b.second;
             return a.first < b.first;

src/V3Task.cpp

@@ -284,7 +284,7 @@ public:
 //######################################################################
 // DPI related utility functions
 
-struct TaskDpiUtils {
+struct TaskDpiUtils final {
     static std::vector<std::pair<AstUnpackArrayDType*, int>>
     unpackDimsAndStrides(AstNodeDType* dtypep) {
         std::vector<std::pair<AstUnpackArrayDType*, int>> dimStrides;

src/V3ThreadPool.h

@@ -38,7 +38,7 @@
 // Callable, type-erased wrapper for std::packaged_task<Signature> with any Signature.
 class VAnyPackagedTask final {
     // TYPES
-    struct PTWrapperBase {
+    struct PTWrapperBase VL_NOT_FINAL {
         virtual ~PTWrapperBase() {}
         virtual void operator()() = 0;
     };

src/V3Tristate.cpp

@@ -408,7 +408,7 @@ class TristateVisitor final : public TristateBaseVisitor {
     AstUser3Allocator<AstVar, AuxAstVar> m_varAux;
 
     // TYPES
-    struct RefStrength {
+    struct RefStrength final {
         AstVarRef* m_varrefp;
         VStrength m_strength;
         RefStrength(AstVarRef* varrefp, VStrength strength)

src/V3VariableOrder.cpp

@@ -78,7 +78,7 @@ class VariableOrder final {
     //  AstVar::user1()    -> attributes, via m_attributes
     const VNUser1InUse m_user1InUse;  // AstVar
 
-    struct VarAttributes {
+    struct VarAttributes final {
         uint32_t stratum;  // Roughly equivalent to alignment requirement, to avoid padding
         bool anonOk;  // Can be emitted as part of anonymous structure
     };

src/V3WidthSel.cpp

@@ -57,7 +57,7 @@ class WidthSelVisitor final : public VNVisitor {
     }
 
     // RETURN TYPE
-    struct FromData {
+    struct FromData final {
         AstNodeDType* const m_errp;  // Node that was found, for error reporting if not known type
         AstNodeDType* const m_dtypep;  // Data type for the 'from' slice
         VNumRange m_fromRange;  // Numeric range bounds for the 'from' slice

src/VlcTop.cpp

@@ -126,7 +126,7 @@ void VlcTop::writeInfo(const string& filename) {
 
 //********************************************************************
 
-struct CmpComputrons {
+struct CmpComputrons final {
     bool operator()(const VlcTest* lhsp, const VlcTest* rhsp) const {
         if (lhsp->computrons() != rhsp->computrons()) {
             return lhsp->computrons() < rhsp->computrons();

test_regress/t/t_dist_portability.pl

@@ -87,15 +87,18 @@ sub vsnprintf {
 sub final {
     # Note do not do test_regress, as VPI files need to compile without verilatedos.h
     my $files = "src/*.c* src/*.h include/*.c* include/*.h";
-    my $cmd = "cd $root && grep -n -P '(class)' $files | sort";
+    my $cmd = "cd $root && grep -n -P '(class|struct)' $files | sort";
     print "C $cmd\n";
     my $grep = `$cmd`;
     my %names;
     foreach my $line (split /\n/, $grep) {
-        if ($line =~ /:\s*class /) {
+        if ($line =~ /:\s*(class|struct) /) {
             next if $line =~ /final|VL_NOT_FINAL/;
             next if $line =~ /{}/;  # e.g. 'class Foo {};'
             next if $line =~ /;/;  # e.g. 'class Foo;'
+            next if $line =~ /(class|struct)\s+{/;  # e.g. anon 'class {'
+            next if $line =~ /struct std::/;
+            next if $line !~ /{/;
             print "$line\n";
             $names{$1} = 1;
         }