luke
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Internals: Remove unneeded private's. No functional change

This commit is contained in:
Wilson Snyder 2023-11-13 21:37:45 -05:00
parent c8063e5732
commit 9fd5634778
79 changed files with 0 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/V3Active.cpp
View File

@ -195,7 +195,6 @@ public:
// Collect existing active names
class ActiveNamer final : public VNVisitor {
private:
// STATE
AstScope* m_scopep = nullptr; // Current scope to add statement to
AstActive* m_sActivep = nullptr; // For current scope, the Static active we're building
@ -306,7 +305,6 @@ AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Combo>() {
// Latch checking visitor
class ActiveLatchCheckVisitor final : public VNVisitorConst {
private:
// NODE STATE
// Input:
// AstVar::user1p // V2LatchGraphVertex* The vertex handling this node
@ -423,7 +421,6 @@ public:
// Active class functions
class ActiveVisitor final : public VNVisitor {
private:
// NODE STATE
// Each call to V3Const::constify
// AstVarScope::user1() bool: This VarScope is referenced in the sensitivity list

1
src/V3Assert.cpp
View File

@ -26,7 +26,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Assert class functions
class AssertVisitor final : public VNVisitor {
private:
// NODE STATE/TYPES
// Cleared on netlist
// AstNode::user() -> bool. True if processed

1
src/V3Ast.h
View File

@ -1461,7 +1461,6 @@ public:
// string 'this', or 'vlSymsp->...'
class VSelfPointerText final {
private:
// STATIC MEMBERS
// Keep these in shared pointers to avoid branching for special cases
static const std::shared_ptr<const string> s_emptyp; // Holds ""

17
src/V3AstNodeDType.h
View File

@ -34,7 +34,6 @@ 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
private:
int m_width = 0; // (also in AstTypeTable::Key) Bit width of operation
int m_widthMin
= 0; // (also in AstTypeTable::Key) If unsized, bitwidth of minimum implementation
@ -138,7 +137,6 @@ class AstNodeArrayDType VL_NOT_FINAL : public AstNodeDType {
// Array data type, ie "some_dtype var_name [2:0]"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
// @astgen op2 := rangep : Optional[AstRange] // array bounds
private:
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
AstNode* rangenp() const { return reinterpret_cast<AstNode*>(rangep()); }
@ -198,7 +196,6 @@ public:
class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
// A struct or union; common handling
// @astgen op1 := membersp : List[AstMemberDType]
private:
// MEMBERS
string m_name; // Name from upper typedef, if any
AstNodeModule* m_classOrPackagep = nullptr; // Package it will be emitted with
@ -260,7 +257,6 @@ public:
class AstEnumItem final : public AstNode {
// @astgen op1 := rangep : Optional[AstRange] // Range for name appending
// @astgen op2 := valuep : Optional[AstNodeExpr]
private:
string m_name;
public:
@ -283,7 +279,6 @@ class AstAssocArrayDType final : public AstNodeDType {
// Associative array data type, ie "[some_dtype]"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
// @astgen op2 := keyChildDTypep : Optional[AstNodeDType]
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
AstNodeDType* m_keyDTypep; // Keys of this type (after widthing)
public:
@ -354,7 +349,6 @@ public:
class AstBasicDType final : public AstNodeDType {
// Builtin atomic/vectored data type
// @astgen op1 := rangep : Optional[AstRange] // Range of variable
private:
struct Members {
VBasicDTypeKwd m_keyword; // (also in VBasicTypeKey) What keyword created basic type
VNumRange m_nrange; // (also in VBasicTypeKey) Numeric msb/lsb (if non-opaque keyword)
@ -533,7 +527,6 @@ public:
class AstClassRefDType final : public AstNodeDType {
// Reference to a class
// @astgen op1 := paramsp: List[AstPin]
private:
AstClass* m_classp; // data type pointed to, BELOW the AstTypedef
AstNodeModule* m_classOrPackagep = nullptr; // Package hierarchy
public:
@ -577,7 +570,6 @@ class AstConstDType final : public AstNodeDType {
// ConstDType are removed in V3LinkLValue and become AstVar::isConst.
// When more generic types are supported AstConstDType will be propagated further.
// @astgen op1 := childDTypep : Optional[AstNodeDType]
private:
AstNodeDType* m_refDTypep = nullptr; // Inherit from this base data type
public:
AstConstDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)
@ -653,7 +645,6 @@ class AstDefImplicitDType final : public AstNodeDType {
// This allows "var enum {...} a,b" to share the enum definition for both variables
// After link, these become typedefs
// @astgen op1 := childDTypep : Optional[AstNodeDType]
private:
string m_name;
void* m_containerp; // In what scope is the name unique, so we can know what are duplicate
// definitions (arbitrary value)
@ -699,7 +690,6 @@ public:
class AstDynArrayDType final : public AstNodeDType {
// Dynamic array data type, ie "[]"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
private:
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
public:
AstDynArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)
@ -844,7 +834,6 @@ public:
class AstIfaceRefDType final : public AstNodeDType {
// Reference to an interface, either for a port, or inside parent cell
// @astgen op1 := paramsp : List[AstPin]
private:
FileLine* m_modportFileline; // Where modport token was
string m_cellName; // "" = no cell, such as when connects to 'input' iface
string m_ifaceName; // Interface name
@ -908,7 +897,6 @@ class AstMemberDType final : public AstNodeDType {
// PARENT: AstNodeUOrStructDType
// @astgen op1 := childDTypep : Optional[AstNodeDType]
// @astgen op3 := valuep : Optional[AstNode]
private:
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
string m_name; // Name of variable
string m_tag; // Holds the string of the verilator tag -- used in XML output.
@ -981,7 +969,6 @@ class AstParamTypeDType final : public AstNodeDType {
// Parents: MODULE
// A parameter type statement; much like a var or typedef
// @astgen op1 := childDTypep : Optional[AstNodeDType]
private:
const VVarType m_varType; // Type of variable (for localparam vs. param)
string m_name; // Name of variable
public:
@ -1051,7 +1038,6 @@ class AstQueueDType final : public AstNodeDType {
// Queue array data type, ie "[ $ ]"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
// @astgen op2 := boundp : Optional[AstNodeExpr]
private:
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
public:
AstQueueDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp, AstNodeExpr* boundp)
@ -1113,7 +1099,6 @@ class AstRefDType final : public AstNodeDType {
// @astgen op1 := typeofp : Optional[AstNode]
// @astgen op2 := classOrPackageOpp : Optional[AstNodeExpr]
// @astgen op3 := paramsp : List[AstPin]
private:
// Pre-Width must reference the Typeref, not what it points to, as some child
// types like AstBracketArrayType will disappear and can't lose the handle
AstTypedef* m_typedefp = nullptr; // referenced type
@ -1279,7 +1264,6 @@ public:
class AstUnsizedArrayDType final : public AstNodeDType {
// Unsized/open-range Array data type, ie "some_dtype var_name []"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
public:
AstUnsizedArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)
@ -1346,7 +1330,6 @@ public:
class AstWildcardArrayDType final : public AstNodeDType {
// Wildcard index type associative array data type, ie "some_dtype var_name [*]"
// @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
public:
AstWildcardArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)

3
src/V3AstNodeExpr.h
View File

@ -732,7 +732,6 @@ class AstCellRef final : public AstNodeExpr {
// As-of-yet unlinkable reference into a cell
// @astgen op1 := cellp : AstNode
// @astgen op2 := exprp : AstNodeExpr
private:
string m_name; // Cell name
public:
AstCellRef(FileLine* fl, const string& name, AstNode* cellp, AstNodeExpr* exprp)
@ -751,7 +750,6 @@ public:
};
class AstClassOrPackageRef final : public AstNodeExpr {
// @astgen op1 := paramsp : List[AstPin]
private:
string m_name;
// Node not NodeModule to appease some early parser usage
AstNode* m_classOrPackageNodep; // Pointer to class/package referenced
@ -2012,7 +2010,6 @@ class AstStructSel final : public AstNodeExpr {
// Parents: math|stmt
// Children: varref, math
// @astgen op1 := fromp : AstNodeExpr
private:
string m_name; // Name of the member
public:
AstStructSel(FileLine* fl, AstNodeExpr* fromp, const string& name)

33
src/V3AstNodeOther.h
View File

@ -34,7 +34,6 @@ class AstNodeBlock VL_NOT_FINAL : public AstNode {
// A Begin/fork block
// @astgen op2 := stmtsp : List[AstNode]
// Parents: statement
private:
string m_name; // Name of block
bool m_unnamed; // Originally unnamed (name change does not affect this)
protected:
@ -62,7 +61,6 @@ class AstNodeFTask VL_NOT_FINAL : public AstNode {
// @astgen op3 := stmtsp : List[AstNode]
// Scope name
// @astgen op4 := scopeNamep : Optional[AstScopeName]
private:
string m_name; // Name of task
string m_cname; // Name of task if DPI import
uint64_t m_dpiOpenParent = 0; // DPI import open array, if !=0, how many callees
@ -205,7 +203,6 @@ class AstNodeFile VL_NOT_FINAL : public AstNode {
// Emitted Output file
// Parents: NETLIST
// @astgen op1 := tblockp : Optional[AstTextBlock]
private:
string m_name; ///< Filename
public:
AstNodeFile(VNType t, FileLine* fl, const string& name)
@ -223,7 +220,6 @@ class AstNodeModule VL_NOT_FINAL : public AstNode {
// @astgen op1 := inlinesp : List[AstNode]
// @astgen op2 := stmtsp : List[AstNode]
// @astgen op3 := activesp : List[AstActive]
private:
string m_name; // Name of the module
const string m_origName; // Name of the module, ignoring name() changes, for dot lookup
string m_someInstanceName; // Hierarchical name of some arbitrary instance of this module.
@ -453,7 +449,6 @@ class AstNodeIf VL_NOT_FINAL : public AstNodeStmt {
// @astgen op1 := condp : AstNodeExpr
// @astgen op2 := thensp : List[AstNode]
// @astgen op3 := elsesp : List[AstNode]
private:
VBranchPred m_branchPred; // Branch prediction as taken/untaken?
bool m_isBoundsCheck; // True if this if node is for assertion/bounds checking
protected:
@ -509,7 +504,6 @@ public:
virtual const char* cFuncPrefixp() const = 0;
};
class AstNodeText VL_NOT_FINAL : public AstNode {
private:
string m_text;
protected:
@ -529,7 +523,6 @@ public:
void text(const string& value) { m_text = value; }
};
class AstNodeSimpleText VL_NOT_FINAL : public AstNodeText {
private:
bool m_tracking; // When emit, it's ok to parse the string to do indentation
public:
AstNodeSimpleText(VNType t, FileLine* fl, const string& textp, bool tracking = false)
@ -548,7 +541,6 @@ class AstActive final : public AstNode {
// Parents: MODULE | CFUNC
// @astgen op1 := sensesStorep : Optional[AstSenTree] // Moved into m_sensesp in V3Active
// @astgen op2 := stmtsp : List[AstNode] // Logic
private:
string m_name;
AstSenTree* m_sensesp;
@ -575,7 +567,6 @@ class AstBind final : public AstNode {
// Parents: MODULE
// Children: CELL
// @astgen op1 := cellsp : List[AstNode]
private:
string m_name; // Binding to name
public:
AstBind(FileLine* fl, const string& name, AstNode* cellsp)
@ -597,7 +588,6 @@ class AstCFunc final : public AstNode {
// @astgen op2 := initsp : List[AstNode]
// @astgen op3 := stmtsp : List[AstNode]
// @astgen op4 := finalsp : List[AstNode]
private:
AstScope* m_scopep;
string m_name;
string m_cname; // C name, for dpiExports
@ -758,7 +748,6 @@ public:
class AstCUse final : public AstNode {
// C++ use of a class or #include; indicates need of forward declaration
// Parents: NODEMODULE
private:
const string m_name;
const VUseType m_useType; // What sort of use this is
@ -848,7 +837,6 @@ class AstCellInline final : public AstNode {
// except for VPI runs where it exists until the end.
// It is augmented with the scope in V3Scope for VPI.
// Children: When 2 levels inlined, other CellInline under this
private:
string m_name; // Cell name, possibly {a}__DOT__{b}...
const string
m_origModName; // Original name of the module, ignoring name() changes, for dot lookup
@ -1054,7 +1042,6 @@ class AstDpiExport final : public AstNode {
// We could put an AstNodeFTaskRef instead of the verilog function name,
// however we're not *calling* it, so that seems somehow wrong.
// (Probably AstNodeFTaskRef should be renamed AstNodeFTaskCall and have-a AstNodeFTaskRef)
private:
string m_name; // Name of function
string m_cname; // Name of function on c side
public:
@ -1071,7 +1058,6 @@ public:
class AstElabDisplay final : public AstNode {
// Parents: stmtlist
// @astgen op1 := fmtp : List[AstSFormatF]
private:
VDisplayType m_displayType;
public:
@ -1156,7 +1142,6 @@ public:
};
class AstIntfRef final : public AstNode {
// An interface reference
private:
string m_name; // Name of the reference
public:
AstIntfRef(FileLine* fl, const string& name)
@ -1208,7 +1193,6 @@ class AstModportFTaskRef final : public AstNode {
// The storage for the function itself is inside the
// interface/instantiator, thus this is a reference
// PARENT: AstModport
private:
string m_name; // Name of the variable referenced
AstNodeFTask* m_ftaskp = nullptr; // Link to the function
bool m_export; // Type of the function (import/export)
@ -1231,7 +1215,6 @@ class AstModportVarRef final : public AstNode {
// A input/output/etc variable referenced under a modport
// The storage for the variable itself is inside the interface, thus this is a reference
// PARENT: AstModport
private:
string m_name; // Name of the variable referenced
AstVar* m_varp = nullptr; // Link to the actual Var
VDirection m_direction; // Direction of the variable (in/out)
@ -1320,7 +1303,6 @@ public:
uint32_t usedMTaskProfilingIDs() const { return m_nextFreeMTaskProfilingID; }
};
class AstPackageExport final : public AstNode {
private:
// A package export declaration
string m_name;
AstPackage* m_packagep; // Package hierarchy
@ -1346,7 +1328,6 @@ public:
ASTGEN_MEMBERS_AstPackageExportStarStar;
};
class AstPackageImport final : public AstNode {
private:
// A package import declaration
string m_name;
AstPackage* m_packagep; // Package hierarchy
@ -1366,7 +1347,6 @@ public:
class AstPin final : public AstNode {
// A port or parameter assignment on an instantiation
// @astgen op1 := exprp : Optional[AstNode] // NodeExpr or NodeDType (nullptr if unconnected)
private:
int m_pinNum; // Pin number
string m_name; // Pin name, or "" for number based interconnect
AstVar* m_modVarp = nullptr; // Input/output this pin connects to on submodule.
@ -1591,7 +1571,6 @@ public:
ASTGEN_MEMBERS_AstSplitPlaceholder;
};
class AstStrengthSpec final : public AstNode {
private:
VStrength m_s0; // Drive 0 strength
VStrength m_s1; // Drive 1 strength
@ -1698,7 +1677,6 @@ public:
};
class AstTypedefFwd final : public AstNode {
// Forward declaration of a type; stripped after netlist parsing is complete
private:
string m_name;
public:
@ -2115,7 +2093,6 @@ class AstVarScope final : public AstNode {
// varscope for each var in the module
// Parents: MODULE
// Children: none
private:
AstScope* m_scopep; // Scope variable is underneath
AstVar* m_varp; // [AfterLink] Pointer to variable itself
bool m_trace : 1; // Tracing is turned on for this scope
@ -2184,7 +2161,6 @@ class AstFork final : public AstNodeBlock {
// @astgen op1 := initsp : List[AstNode]
// Parents: statement
// Children: statements
private:
VJoinType m_joinType; // Join keyword type
public:
// Node that puts name into the output stream
@ -2252,7 +2228,6 @@ public:
class AstCFile final : public AstNodeFile {
// C++ output file
// Parents: NETLIST
private:
bool m_slow : 1; ///< Compile w/o optimization
bool m_source : 1; ///< Source file (vs header file)
bool m_support : 1; ///< Support file (non systemc)
@ -2351,7 +2326,6 @@ public:
};
class AstModule final : public AstNodeModule {
// A module declaration
private:
const bool m_isProgram; // Module represents a program
public:
AstModule(FileLine* fl, const string& name, bool program = false)
@ -2813,7 +2787,6 @@ class AstDisplay final : public AstNodeStmt {
// Parents: stmtlist
// @astgen op1 := fmtp : AstSFormatF
// @astgen op2 := filep : Optional[AstNodeExpr] // file (must resolve to a VarRef)
private:
VDisplayType m_displayType;
public:
@ -2972,7 +2945,6 @@ class AstJumpBlock final : public AstNodeStmt {
// Children: {statement list, with JumpGo and JumpLabel below}
// @astgen op1 := stmtsp : List[AstNode]
// @astgen op2 := endStmtsp : List[AstNode]
private:
AstJumpLabel* m_labelp = nullptr; // [After V3Jump] Pointer to declaration
int m_labelNum = 0; // Set by V3EmitCSyms to tell final V3Emit what to increment
public:
@ -2997,7 +2969,6 @@ class AstJumpGo final : public AstNodeStmt {
// No support for backward jumps at present
// Parents: {statement list with JumpBlock above}
// Children: none
private:
AstJumpLabel* m_labelp; // [After V3Jump] Pointer to declaration
public:
AstJumpGo(FileLine* fl, AstJumpLabel* labelp)
@ -3021,7 +2992,6 @@ class AstJumpLabel final : public AstNodeStmt {
// Jump point declaration
// Parents: {statement list with JumpBlock above}
// Children: none
private:
AstJumpBlock* m_blockp; // [After V3Jump] Pointer to declaration
public:
AstJumpLabel(FileLine* fl, AstJumpBlock* blockp)
@ -3262,7 +3232,6 @@ class AstTraceDecl final : public AstNodeStmt {
// Parents: {statement list}
// Expression being traced - Moved to AstTraceInc by V3Trace
// @astgen op1 := valuep : Optional[AstNodeExpr]
private:
uint32_t m_code{0}; // Trace identifier code
uint32_t m_fidx{0}; // Trace function index
const string m_showname; // Name of variable
@ -3311,7 +3280,6 @@ class AstTraceInc final : public AstNodeStmt {
// @astgen op1 := precondsp : List[AstNode] // Statements to emit before this node
// @astgen op2 := valuep : AstNodeExpr // Expression being traced (from decl)
private:
AstTraceDecl* m_declp; // Pointer to declaration
const uint32_t m_baseCode; // Trace code base value in function containing this AstTraceInc
const VTraceType m_traceType; // Is this a const/full/incremental dump
@ -3650,7 +3618,6 @@ public:
ASTGEN_MEMBERS_AstGenIf;
};
class AstIf final : public AstNodeIf {
private:
bool m_uniquePragma = false; // unique case
bool m_unique0Pragma = false; // unique0 case
bool m_priorityPragma = false; // priority case

2
src/V3Begin.cpp
View File

@ -35,7 +35,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class BeginState final {
private:
// NODE STATE
// Entire netlist:
// AstNodeFTask::user1 -> bool, 1=processed
@ -55,7 +54,6 @@ public:
//######################################################################
class BeginVisitor final : public VNVisitor {
private:
// STATE
BeginState* const m_statep; // Current global state
AstNodeModule* m_modp = nullptr; // Current module

1
src/V3Branch.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Branch state, as a visitor of each AstNode
class BranchVisitor final : public VNVisitorConst {
private:
// NODE STATE
// Entire netlist:
// AstFTask::user1() -> int. Number of references

2
src/V3Broken.cpp
View File

@ -60,7 +60,6 @@ static bool s_brokenAllowMidvisitorCheck = false;
// Table of allocated AstNode pointers
static class AllocTable final {
private:
// MEMBERS
std::unordered_set<const AstNode*> m_allocated; // Set of all nodes allocated but not freed
@ -122,7 +121,6 @@ void V3Broken::deleted(const AstNode* nodep) { s_allocTable.deleted(nodep); }
// Table of AstNode pointers that can be linked to via member pointers
static class LinkableTable final {
private:
// MEMBERS
std::unordered_set<const AstNode*> m_linkable; // Set of all nodes allocated but not freed

2
src/V3CCtors.cpp
View File

@ -50,7 +50,6 @@ public:
};
class V3CCtorsBuilder final {
private:
AstNodeModule* const m_modp; // Current module/class
const string m_basename;
const VCtorType m_type; // What kind of constructor are we creating
@ -130,7 +129,6 @@ private:
// Link state, as a visitor of each AstNode
class CCtorsVisitor final : public VNVisitor {
private:
// NODE STATE
// STATE

2
src/V3Case.cpp
View File

@ -49,7 +49,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class CaseLintVisitor final : public VNVisitorConst {
private:
const AstNodeCase* m_caseExprp
= nullptr; // Under a CASE value node, if so the relevant case statement
@ -115,7 +114,6 @@ public:
// Case state, as a visitor of each AstNode
class CaseVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared each Case
// AstIf::user3() -> bool. Set true to indicate clone not needed

1
src/V3Cast.cpp
View File

@ -47,7 +47,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Cast state, as a visitor of each AstNode
class CastVisitor final : public VNVisitor {
private:
// NODE STATE
// Entire netlist:
// AstNode::user1() // bool. Indicates node is of known size

1
src/V3Class.cpp
View File

@ -31,7 +31,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class ClassVisitor final : public VNVisitor {
private:
// NODE STATE
// AstClass::user1() -> bool. True if iterated already
// AstVar::user1p() -> AstVarScope* Scope used with this var

1
src/V3Clean.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Clean state, as a visitor of each AstNode
class CleanVisitor final : public VNVisitor {
private:
// NODE STATE
// Entire netlist:
// AstNode::user() -> CleanState. For this node, 0==UNKNOWN

2
src/V3Clock.cpp
View File

@ -39,7 +39,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Convert every WRITE AstVarRef to a READ ref
class ConvertWriteRefsToRead final : public VNVisitor {
private:
// MEMBERS
AstNodeExpr* m_result = nullptr;
@ -67,7 +66,6 @@ public:
// Clock state, as a visitor of each AstNode
class ClockVisitor final : public VNVisitor {
private:
// STATE
AstCFunc* m_evalp = nullptr; // The '_eval' function
AstScope* m_scopep = nullptr; // Current scope

1
src/V3Const.cpp
View File

@ -878,7 +878,6 @@ public:
// Const state, as a visitor of each AstNode
class ConstVisitor final : public VNVisitor {
private:
// CONSTANTS
static constexpr unsigned CONCAT_MERGABLE_MAX_DEPTH = 10; // Limit alg recursion

1
src/V3Coverage.cpp
View File

@ -36,7 +36,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Coverage state, as a visitor of each AstNode
class CoverageVisitor final : public VNVisitor {
private:
// TYPES
using LinenoSet = std::set<int>;

1
src/V3CoverageJoin.cpp
View File

@ -32,7 +32,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// CoverageJoin state, as a visitor of each AstNode
class CoverageJoinVisitor final : public VNVisitor {
private:
// NODE STATE
// VNUser4InUse In V3Hasher via V3DupFinder

1
src/V3Dead.cpp
View File

@ -45,7 +45,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Dead state, as a visitor of each AstNode
class DeadVisitor final : public VNVisitor {
private:
// NODE STATE
// Entire Netlist:
// AstNodeModule::user1() -> int. Count of number of cells referencing this module.

1
src/V3Delayed.cpp
View File

@ -63,7 +63,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Delayed state, as a visitor of each AstNode
class DelayedVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared each module:
// AstVarScope::user1p() -> aux

1
src/V3Depth.cpp
View File

@ -34,7 +34,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class DepthVisitor final : public VNVisitor {
private:
// NODE STATE
// STATE

1
src/V3DepthBlock.cpp
View File

@ -31,7 +31,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class DepthBlockVisitor final : public VNVisitor {
private:
// NODE STATE
// STATE

1
src/V3Descope.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class DescopeVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared entire netlist
// AstCFunc::user() // bool. Indicates processing completed

1
src/V3EmitCFunc.h
View File

@ -116,7 +116,6 @@ public:
// Emit statements and expressions
class EmitCFunc VL_NOT_FINAL : public EmitCConstInit {
private:
VMemberMap m_memberMap;
AstVarRef* m_wideTempRefp = nullptr; // Variable that _WW macros should be setting
int m_labelNum = 0; // Next label number

2
src/V3EmitXml.cpp
View File

@ -320,7 +320,6 @@ public:
// List of module files xml visitor
class ModuleFilesXmlVisitor final : public VNVisitorConst {
private:
// MEMBERS
std::ostream& m_os;
std::set<std::string> m_modulesCovered;
@ -367,7 +366,6 @@ public:
// Hierarchy of Cells visitor
class HierCellsXmlVisitor final : public VNVisitorConst {
private:
// MEMBERS
std::ostream& m_os;
std::string m_hier;

1
src/V3Error.h
View File

@ -405,7 +405,6 @@ public:
// ######################################################################
class V3Error final {
// Base class for any object that wants debugging and error reporting
private:
// CONSTRUCTORS
V3Error() {
std::cerr << ("Static class");

2
src/V3Expand.cpp
View File

@ -38,7 +38,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Find nodes with side effects, to mark as non-expandable
class ExpandOkVisitor final : public VNVisitorConst {
private:
// NODE STATE
// AstNode::user2() -> bool. Is pure (along with all children)
const VNUser2InUse m_inuser2;
@ -70,7 +69,6 @@ public:
// Expand state, as a visitor of each AstNode
class ExpandVisitor final : public VNVisitor {
private:
// NODE STATE
// AstNode::user1() -> bool. Processed
const VNUser1InUse m_inuser1;

3
src/V3Fork.cpp
View File

@ -61,7 +61,6 @@ public:
};
class ForkDynScopeFrame final {
private:
// MEMBERS
AstNodeModule* const m_modp; // Module to insert the scope into
AstNode* const m_procp; // Procedure/block associated with that dynscope
@ -253,7 +252,6 @@ private:
// members
class DynScopeVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVar::user1() -> int, timing-control fork nesting level of that variable
// AstVarRef::user2() -> bool, 1 = Node is a class handle reference. The handle gets
@ -456,7 +454,6 @@ public:
// Fork visitor, transforms asynchronous blocks into separate tasks
class ForkVisitor final : public VNVisitor {
private:
// NODE STATE
// AstNode::user1() -> bool, 1 = Node was created as a call to an asynchronous task
// AstVarRef::user2() -> bool, 1 = Node is a class handle reference. The handle gets

1
src/V3Graph.h
View File

@ -80,7 +80,6 @@ constexpr bool operator==(GraphWay::en lhs, const GraphWay& rhs) { return lhs ==
//============================================================================
class V3Graph VL_NOT_FINAL {
private:
// MEMBERS
V3List<V3GraphVertex*> m_vertices; // All vertices

1
src/V3GraphAcyc.cpp
View File

@ -92,7 +92,6 @@ struct GraphAcycEdgeCmp {
// CLASSES
class GraphAcyc final {
private:
using OrigEdgeList
= std::list<V3GraphEdge*>; // List of orig edges, see also GraphAcycEdge's decl
// GRAPH USERS

5
src/V3GraphAlg.cpp
View File

@ -136,7 +136,6 @@ void V3Graph::removeTransitiveEdges() { GraphAlgRemoveTransitiveEdges{this}.go()
// Changes color()
class GraphAlgWeakly final : GraphAlg<> {
private:
void main() {
// Initialize state
m_graphp->clearColors();
@ -178,7 +177,6 @@ void V3Graph::weaklyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgWeakly{this, edge
// Changes user() and color()
class GraphAlgStrongly final : GraphAlg<> {
private:
uint32_t m_currentDfs = 0; // DFS count
std::vector<V3GraphVertex*> m_callTrace; // List of everything we hit processing so far
@ -269,7 +267,6 @@ void V3Graph::stronglyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgStrongly{this,
// Changes user() and rank()
class GraphAlgRank final : GraphAlg<> {
private:
void main() {
// Rank each vertex, ignoring cutable edges
// Vertex::m_user begin: 1 indicates processing, 2 indicates completed
@ -325,7 +322,6 @@ void V3Graph::rank(V3EdgeFuncP edgeFuncp) { GraphAlgRank{this, edgeFuncp}; }
// Changes user()
class GraphAlgRLoops final : GraphAlg<> {
private:
std::vector<V3GraphVertex*> m_callTrace; // List of everything we hit processing so far
bool m_done = false; // Exit algorithm
@ -379,7 +375,6 @@ void V3Graph::reportLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp) {
// Changes user()
class GraphAlgSubtrees final : GraphAlg<> {
private:
V3Graph* const m_loopGraphp;
//! Iterate through all connected nodes of a graph with a loop or loops.

1
src/V3GraphStream.h
View File

@ -42,7 +42,6 @@
template <class T_Compare>
class GraphStream final {
private:
// TYPES
class VxHolder final {
public:

1
src/V3Hasher.cpp
View File

@ -26,7 +26,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Visitor that computes node hashes
class HasherVisitor final : public VNVisitorConst {
private:
// NODE STATE
// AstNode::user4() -> V3Hash. Hash value of this node (hash of 0 is illegal)
// VNUser4InUse in V3Hasher.h

3
src/V3Inline.cpp
View File

@ -59,7 +59,6 @@ using ModuleStateUser1Allocator = AstUser1Allocator<AstNodeModule, ModuleState>;
// Visitor that determines which modules will be inlined
class InlineMarkVisitor final : public VNVisitor {
private:
// NODE STATE
// Output
// AstNodeModule::user1() // OUTPUT: ModuleState instance (via m_moduleState)
@ -245,7 +244,6 @@ public:
// After cell is cloned, relink the new module's contents
class InlineRelinkVisitor final : public VNVisitor {
private:
// NODE STATE
// Input:
// See InlineVisitor
@ -451,7 +449,6 @@ public:
// Inline state, as a visitor of each AstNode
class InlineVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared entire netlist
// AstIfaceRefDType::user1() // Whether the cell pointed to by this

2
src/V3Inst.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Inst state, as a visitor of each AstNode
class InstVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared each Cell:
// AstPin::user1p() -> bool. True if created assignment already
@ -482,7 +481,6 @@ public:
// Inst static function
class InstStatic final {
private:
InstStatic() = default; // Static class
static AstNodeExpr* extendOrSel(FileLine* fl, AstNodeExpr* rhsp, AstNode* cmpWidthp) {

3
src/V3InstrCount.cpp
View File

@ -30,7 +30,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
/// whichever is larger. We know we won't run both.
class InstrCountVisitor final : public VNVisitorConst {
private:
// NODE STATE
// AstNode::user1() -> bool. Processed if assertNoDups
// AstNode::user2() -> int. Path cost + 1, 0 means don't dump
@ -48,7 +47,6 @@ private:
// TYPES
// Little class to cleanly call startVisitBase/endVisitBase
class VisitBase final {
private:
// MEMBERS
uint32_t m_savedCount;
AstNode* const m_nodep;
@ -287,7 +285,6 @@ private:
// Iterate the graph printing the critical path marked by previous visitation
class InstrCountDumpVisitor final : public VNVisitorConst {
private:
// NODE STATE
// AstNode::user2() -> int. Path cost, 0 means don't dump

1
src/V3Interface.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Track interface references under the Cell they reference
class InlineIntfRefVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVar::user1p() // AstCell which this Var points to
const VNUser1InUse m_inuser1;

1
src/V3Life.cpp
View File

@ -258,7 +258,6 @@ public:
// Life state, as a visitor of each AstNode
class LifeVisitor final : public VNVisitor {
private:
// STATE
LifeState* const m_statep; // Current state
bool m_sideEffect = false; // Side effects discovered in assign RHS

2
src/V3LifePost.cpp
View File

@ -41,7 +41,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// LifePost class functions
class LifePostElimVisitor final : public VNVisitor {
private:
bool m_tracingCall = false; // Iterating into a CCall to a CFunc
// NODE STATE
@ -127,7 +126,6 @@ struct LifePostLocation {
// LifePost delay elimination
class LifePostDlyVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVarScope::user1() -> bool: referenced outside _eval__nba
// AstVarScope::user4() -> AstVarScope*: Passed to LifePostElim to substitute this var

1
src/V3LinkCells.cpp
View File

@ -92,7 +92,6 @@ void LinkCellsGraph::loopsMessageCb(V3GraphVertex* vertexp) {
// Link state, as a visitor of each AstNode
class LinkCellsVisitor final : public VNVisitor {
private:
// NODE STATE
// Entire netlist:
// AstNodeModule::user1p() // V3GraphVertex* Vertex describing this module

3
src/V3LinkDot.cpp
View File

@ -116,7 +116,6 @@ public:
// LinkDot state, as a visitor of each AstNode
class LinkDotState final {
private:
// NODE STATE
// Cleared on Netlist
// AstNodeModule::user1p() // VSymEnt*. Last symbol created for this node
@ -1547,7 +1546,6 @@ public:
//======================================================================
class LinkDotParamVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on global
// *::user1p() -> See LinkDotState
@ -2004,7 +2002,6 @@ void LinkDotState::computeIfaceModSyms() {
//======================================================================
class LinkDotResolveVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on global
// *::user1p() -> See LinkDotState

1
src/V3LinkInc.cpp
View File

@ -47,7 +47,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class LinkIncVisitor final : public VNVisitor {
private:
// TYPES
enum InsertMode : uint8_t {
IM_BEFORE, // Pointing at statement ref is in, insert before this

1
src/V3LinkJump.cpp
View File

@ -42,7 +42,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class LinkJumpVisitor final : public VNVisitor {
private:
// NODE STATE
// AstNode::user1() -> AstJumpLabel*, for this block if endOfIter
// AstNode::user2() -> AstJumpLabel*, for this block if !endOfIter

1
src/V3LinkLValue.cpp
View File

@ -28,7 +28,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Link state, as a visitor of each AstNode
class LinkLValueVisitor final : public VNVisitor {
private:
// NODE STATE
// STATE

1
src/V3LinkLevel.h
View File

@ -29,7 +29,6 @@
//============================================================================
class V3LinkLevel final {
private:
using ModVec = std::vector<AstNodeModule*>;
static void timescaling(const ModVec& mods) VL_MT_DISABLED;

1
src/V3LinkParse.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Link state, as a visitor of each AstNode
class LinkParseVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on netlist
// AstNode::user1() -> bool. True if processed

2
src/V3LinkResolve.cpp
View File

@ -37,7 +37,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Link state, as a visitor of each AstNode
class LinkResolveVisitor final : public VNVisitor {
private:
// NODE STATE
// Entire netlist:
// AstCaseItem::user2() // bool Moved default caseitems
@ -493,7 +492,6 @@ public:
// from child cells up to the top module.
class LinkBotupVisitor final : public VNVisitorConst {
private:
// STATE
AstNodeModule* m_modp = nullptr; // Current module

1
src/V3Localize.cpp
View File

@ -37,7 +37,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// LocalizeVisitor
class LocalizeVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVarScope::user1() -> Bool indicating VarScope is not optimizable.
// AstCFunc::user1() -> Bool indicating CFunc is not a leaf function.

1
src/V3MergeCond.cpp
View File

@ -425,7 +425,6 @@ public:
// Conditional merging
class MergeCondVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVar::user1 -> bool: Set for variables referenced by m_mgCondp
// (Only below MergeCondVisitor::process).

2
src/V3Mutex.h
View File

@ -43,7 +43,6 @@
// once configured and locked, it cannot be changed. Configuration and lock needs to be
// done before starting any additional threads.
class V3MutexConfig final {
private:
// Allows to disable mutexes and lockguards.
// Use carefully as it can cause undefined behavior when used inappropriately.
// All mutexes needs to be unlocked.
@ -78,7 +77,6 @@ public:
/// Mutex, wrapped to allow -fthread_safety checks
template <typename T>
class VL_CAPABILITY("mutex") V3MutexImp final {
private:
T m_mutex; // Mutex
public:

1
src/V3Name.cpp
View File

@ -31,7 +31,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Name state, as a visitor of each AstNode
class NameVisitor final : public VNVisitorConst {
private:
// NODE STATE
// Cleared on Netlist
// AstCell::user1() -> bool. Set true if already processed

1
src/V3Parse.h
View File

@ -32,7 +32,6 @@ class V3ParseSym;
//============================================================================
class V3Parse final {
private:
V3ParseImp* m_impp;
// CONSTRUCTORS

5
src/V3Partition.cpp
View File

@ -418,7 +418,6 @@ using MergeCandidateScoreboard = V3Scoreboard<MergeCandidate, MergeCandidateKey>
// Information associated with scoreboarding a merge candidate
class MergeCandidate VL_NOT_FINAL : public MergeCandidateScoreboard::Node {
private:
// Only the known subclasses can create or delete one of these
friend class SiblingMC;
friend class MTaskEdge;
@ -1056,7 +1055,6 @@ private:
};
class PartPropagateCpSelfTest final {
private:
// MEMBERS
V3Graph m_graph; // A graph
std::array<LogicMTask*, 50> m_vx; // All vertices within the graph
@ -1236,7 +1234,6 @@ static void partRedirectEdgesFrom(V3Graph* graphp, LogicMTask* recipientp, Logic
// Perform edge or sibling contraction on the partition graph
class PartContraction final {
private:
// TYPES
// New CP information for mtaskp reflecting an upcoming merge
struct NewCp {
@ -1846,7 +1843,6 @@ private:
// Scan node, indicate whether it contains a call to a DPI imported
// routine.
class DpiImportCallVisitor final : public VNVisitor {
private:
bool m_hasDpiHazard = false; // Found a DPI import call.
bool m_tracingCall = false; // Iterating into a CCall to a CFunc
// METHODS
@ -1964,7 +1960,6 @@ private:
// parallel mode.
//
class PartFixDataHazards final {
private:
// TYPES
using TasksByRank = std::map<uint32_t /*rank*/, std::set<LogicMTask*, MTaskIdLessThan>>;

1
src/V3Partition.h
View File

@ -82,7 +82,6 @@ private:
// Map a pointer into a id, for e.g. nodep to mtask mappings
class PartPtrIdMap final {
private:
// TYPES
// MEMBERS
mutable uint64_t m_nextId = 0;

1
src/V3Premit.cpp
View File

@ -39,7 +39,6 @@ constexpr int STATIC_CONST_MIN_WIDTH = 256; // Minimum size to extract to stati
// Premit state, as a visitor of each AstNode
class PremitVisitor final : public VNVisitor {
private:
// NODE STATE
// AstNodeExpr::user() -> bool. True if iterated already
// *::user3() -> Used when visiting AstNodeAssign

1
src/V3ProtectLib.cpp
View File

@ -30,7 +30,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// ProtectLib top-level visitor
class ProtectVisitor final : public VNVisitor {
private:
AstVFile* m_vfilep = nullptr; // DPI-enabled Verilog wrapper
AstCFile* m_cfilep = nullptr; // C implementation of DPI functions
// Verilog text blocks

2
src/V3Randomize.cpp
View File

@ -36,7 +36,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Visitor that marks classes needing a randomize() method
class RandomizeMarkVisitor final : public VNVisitorConst {
private:
// NODE STATE
// Cleared on Netlist
// AstClass::user1() -> bool. Set true to indicate needs randomize processing
@ -128,7 +127,6 @@ public:
// Visitor that defines a randomize method where needed
class RandomizeVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on Netlist
// AstClass::user1() -> bool. Set true to indicate needs randomize processing

1
src/V3Reloop.cpp
View File

@ -40,7 +40,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class ReloopVisitor final : public VNVisitor {
private:
// NODE STATE
// AstCFunc::user1p -> Var* for temp var, 0=not set yet
const VNUser1InUse m_inuser1;

2
src/V3SchedTiming.cpp
View File

@ -135,7 +135,6 @@ AstCCall* TimingKit::createCommit(AstNetlist* const netlistp) {
TimingKit prepareTiming(AstNetlist* const netlistp) {
if (!v3Global.usesTiming()) return {};
class AwaitVisitor final : public VNVisitor {
private:
// NODE STATE
// AstSenTree::user1() -> bool. Set true if the sentree has been visited.
const VNUser1InUse m_inuser1;
@ -266,7 +265,6 @@ void transformForks(AstNetlist* const netlistp) {
if (!v3Global.usesTiming()) return;
// Transform all forked processes into functions
class ForkVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVar::user1() -> bool. Set true if the variable was declared before the current
// fork.

2
src/V3Scope.cpp
View File

@ -34,7 +34,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Scope class functions
class ScopeVisitor final : public VNVisitor {
private:
// NODE STATE
// AstVar::user1p -> AstVarScope replacement for this variable
// AstCell::user2p -> AstScope*. The scope created inside the cell
@ -335,7 +334,6 @@ public:
// Scope cleanup -- remove unused activates
class ScopeCleanupVisitor final : public VNVisitor {
private:
// STATE
AstScope* m_scopep = nullptr; // Current scope we are building

1
src/V3SenTree.h
View File

@ -32,7 +32,6 @@
// And provide functions to find/add a new one
class SenTreeFinder final {
private:
// STATE
AstTopScope* const m_topScopep; // Top scope to add global SenTrees to
std::unordered_set<VNRef<AstSenTree>> m_trees; // Set of global SenTrees

2
src/V3Split.cpp
View File

@ -241,7 +241,6 @@ public:
// Split class functions
class SplitReorderBaseVisitor VL_NOT_FINAL : public VNVisitor {
private:
// NODE STATE
// AstVarScope::user1p -> Var SplitNodeVertex* for usage var, 0=not set yet
// AstVarScope::user2p -> Var SplitNodeVertex* for delayed assignment var, 0=not set yet
@ -845,7 +844,6 @@ public:
};
class SplitVisitor final : public SplitReorderBaseVisitor {
private:
// Keys are original always blocks pending delete,
// values are newly split always blocks pending insertion
// at the same position as the originals:

3
src/V3SplitAs.cpp
View File

@ -33,7 +33,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Find all split variables in a block
class SplitAsFindVisitor final : public VNVisitorConst {
private:
// STATE - across all visitors
AstVarScope* m_splitVscp = nullptr; // Variable we want to split
@ -63,7 +62,6 @@ public:
// Remove nodes not containing proper references
class SplitAsCleanVisitor final : public VNVisitor {
private:
// STATE - across all visitors
const AstVarScope* const m_splitVscp; // Variable we want to split
const bool m_modeMatch; // Remove matching Vscp, else non-matching
@ -125,7 +123,6 @@ public:
// SplitAs class functions
class SplitAsVisitor final : public VNVisitor {
private:
// NODE STATE
// AstAlways::user() -> bool. True if already processed
const VNUser1InUse m_inuser1;

2
src/V3Subst.cpp
View File

@ -166,7 +166,6 @@ public:
// as a visitor of each AstNode
class SubstUseVisitor final : public VNVisitorConst {
private:
// NODE STATE
// See SubstVisitor
//
@ -216,7 +215,6 @@ public:
// Subst state, as a visitor of each AstNode
class SubstVisitor final : public VNVisitor {
private:
// NODE STATE
// Passed to SubstUseVisitor
// AstVar::user1p -> SubstVar* for usage var, 0=not set yet. Only under CFunc.

1
src/V3Table.cpp
View File

@ -145,7 +145,6 @@ public:
// Table class functions
class TableVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on each always/assignw

2
src/V3Task.cpp
View File

@ -92,7 +92,6 @@ public:
//######################################################################
class TaskStateVisitor final : public VNVisitor {
private:
// NODE STATE
// Output:
// AstNodeFTask::user3p // AstScope* this FTask is under
@ -331,7 +330,6 @@ struct TaskDpiUtils {
// Task state, as a visitor of each AstNode
class TaskVisitor final : public VNVisitor {
private:
// NODE STATE
// Each module:
// AstNodeFTask::user1 // True if its been expanded

2
src/V3Timing.cpp
View File

@ -108,7 +108,6 @@ static bool hasFlags(AstNode* const nodep, uint8_t flags) { return !(~nodep->use
// Detect nodes affected by timing and/or requiring a process
class TimingSuspendableVisitor final : public VNVisitor {
private:
// TYPES
// Vertex of a dependency graph of suspendable nodes, e.g. if a node (process or task) is
// suspendable, all its dependents should also be suspendable
@ -450,7 +449,6 @@ public:
// Transform nodes affected by timing
class TimingControlVisitor final : public VNVisitor {
private:
// NODE STATE
// Ast{Always,NodeCCall,Fork,NodeAssign}::user1() -> bool. Set true if the node has
// been processed.

1
src/V3Trace.cpp
View File

@ -156,7 +156,6 @@ public:
// Trace state, as a visitor of each AstNode
class TraceVisitor final : public VNVisitor {
private:
// NODE STATE
// V3Hasher in V3DupFinder
// Ast*::user4() // V3Hasher calculation

1
src/V3TraceDecl.cpp
View File

@ -90,7 +90,6 @@ public:
// TraceDecl state, as a visitor of each AstNode
class TraceDeclVisitor final : public VNVisitor {
private:
// NODE STATE
// STATE

1
src/V3Undriven.cpp
View File

@ -265,7 +265,6 @@ public:
// Undriven state, as a visitor of each AstNode
class UndrivenVisitor final : public VNVisitorConst {
private:
// NODE STATE
// Netlist:
// AstVar::user1p -> UndrivenVar* for usage var, 0=not set yet

1
src/V3Unknown.cpp
View File

@ -41,7 +41,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//######################################################################
class UnknownVisitor final : public VNVisitor {
private:
// NODE STATE
// Cleared on Netlist
// AstSel::user() -> bool. Set true if already processed

1
src/V3Unroll.cpp
View File

@ -38,7 +38,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Unroll state, as a visitor of each AstNode
class UnrollVisitor final : public VNVisitor {
private:
// STATE
AstVar* m_forVarp; // Iterator variable
const AstVarScope* m_forVscp; // Iterator variable scope (nullptr for generate pass)

1
src/V3VariableOrder.cpp
View File

@ -36,7 +36,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Establish mtask variable sort order in mtasks mode
class VarTspSorter final : public V3TSP::TspStateBase {
private:
// MEMBERS
const MTaskIdSet& m_mtaskIds; // Mtask we're ordering
static unsigned s_serialNext; // Unique ID to establish serial order

1
src/V3Width.cpp
View File

@ -201,7 +201,6 @@ public:
//######################################################################
class WidthVisitor final : public VNVisitor {
private:
// TYPES
using TableMap = std::map<std::pair<const AstNodeDType*, VAttrType>, AstVar*>;
using PatVecMap = std::map<int, AstPatMember*>;

1
src/V3WidthSel.cpp
View File

@ -37,7 +37,6 @@ VL_DEFINE_DEBUG_FUNCTIONS;
// Width state, as a visitor of each AstNode
class WidthSelVisitor final : public VNVisitor {
private:
// IMPORTANT
//**** This is not a normal visitor, in that all iteration is instead
// done by the caller (V3Width). This avoids duplicating much of the

1
src/VlcBucket.h
View File

@ -31,7 +31,6 @@
// has hit that point with sufficient coverage.
class VlcBuckets final {
private:
// MEMBERS
uint64_t* m_datap = nullptr; ///< Pointer to first bucket (dynamically allocated)
uint64_t m_dataSize = 0; ///< Current entries in m_datap

2
src/VlcPoint.h
View File

@ -36,7 +36,6 @@
// VlcPoint - A coverage point (across all tests)
class VlcPoint final {
private:
// MEMBERS
string m_name; //< Name of the point
uint64_t m_pointNum; //< Point number
@ -108,7 +107,6 @@ public:
// VlcPoints - Container of all points
class VlcPoints final {
private:
// MEMBERS
using NameMap = std::map<const std::string, uint64_t>; // Sorted by name (ordered)
NameMap m_nameMap; //< Name to point-number

1
src/VlcSource.h
View File

@ -31,7 +31,6 @@ class VlcPoint;
// VlcColumnCount - count at specific source file, line and column
class VlcSourceCount final {
private:
// TYPES
using PointsSet = std::set<const VlcPoint*>;

1
src/VlcTest.h
View File

@ -30,7 +30,6 @@
// VlcTest - a single testrun i.e. a file containing coverage data
class VlcTest final {
private:
// MEMBERS
string m_name; //< Name of the test
double m_computrons; //< Runtime for the test