From 94a65f8e6453fccce3330d4d9ee7a204f3fb6ec9 Mon Sep 17 00:00:00 2001 From: Matthew Ballance Date: Wed, 18 Mar 2026 01:44:17 +0000 Subject: [PATCH] Comment new Ast classes, clean up accidentally added members, clean up a few interim workarounds, and adjust approach to stay out of sensitive paths Signed-off-by: Matthew Ballance --- src/V3Active.cpp | 6 ++++-- src/V3AstAttr.h | 18 ++++++++-------- src/V3AstNodeOther.h | 42 ++++++++++++++++++------------------- src/V3AstNodes.cpp | 31 ++++++--------------------- src/V3Covergroup.cpp | 12 +++++------ src/V3EmitV.cpp | 2 +- src/V3LinkParse.cpp | 11 +++++----- src/V3MergeCond.cpp | 4 ---- src/V3OrderGraphBuilder.cpp | 10 --------- src/V3SchedPartition.cpp | 3 --- src/V3Timing.cpp | 6 ------ src/V3Width.cpp | 26 +++++++++-------------- src/Verilator.cpp | 4 +--- src/verilog.y | 11 ++++++---- 14 files changed, 70 insertions(+), 116 deletions(-) diff --git a/src/V3Active.cpp b/src/V3Active.cpp index ff6133f4b..8e7a61584 100644 --- a/src/V3Active.cpp +++ b/src/V3Active.cpp @@ -724,8 +724,10 @@ class CovergroupSamplingVisitor final : public VNVisitor { AstActive* const activep = m_namer.getActive(fl, senTreep); VL_DO_DANGLING(senTreep->deleteTree(), senTreep); - // Add the CMethodCall statement to the active domain - activep->addStmtsp(cmethodCallp->makeStmt()); + // Wrap the sample() call in an AstAlways so SchedPartition handles it + // via visit(AstNodeProcedure*) like any other clocked always block. + activep->addStmtsp( + new AstAlways{fl, VAlwaysKwd::ALWAYS_FF, nullptr, cmethodCallp->makeStmt()}); UINFO(4, " Added automatic sample() call for covergroup " << varp->name() << endl); } diff --git a/src/V3AstAttr.h b/src/V3AstAttr.h index abd0e716d..b98641776 100644 --- a/src/V3AstAttr.h +++ b/src/V3AstAttr.h @@ -1110,18 +1110,18 @@ inline std::ostream& operator<<(std::ostream& os, const VCastable& rhs) { class VCoverBinsType final { public: enum en : uint8_t { - USER, - ARRAY, - AUTO, - BINS_IGNORE, // Renamed to avoid Windows macro conflict - BINS_ILLEGAL, // Renamed to avoid Windows macro conflict - DEFAULT, - BINS_WILDCARD, // Renamed to avoid Windows macro conflict - TRANSITION + BINS_USER, // Single bin with one or more values/ranges + BINS_ARRAY, // Array of bins with user-speciifed size + BINS_AUTO, // Auto-sized array of bins (eg auto_bin_max) + BINS_IGNORE, // Ignore bin + BINS_ILLEGAL, // Illegal bin + BINS_DEFAULT, // Default bin + BINS_WILDCARD, // Wildcard bin + BINS_TRANSITION // Transition bin }; enum en m_e; VCoverBinsType() - : m_e{USER} {} + : m_e{BINS_USER} {} // cppcheck-suppress noExplicitConstructor constexpr VCoverBinsType(en _e) : m_e{_e} {} diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h index 31877883a..59d2917c8 100644 --- a/src/V3AstNodeOther.h +++ b/src/V3AstNodeOther.h @@ -1039,18 +1039,15 @@ public: bool sameNode(const AstNode* /*samep*/) const override { return true; } }; -// Forward declarations for types used in constructors below -class AstCoverTransSet; -class AstCoverSelectExpr; - class AstCoverBin final : public AstNode { + // Captures data for a coverpoint 'bins' declaration // @astgen op1 := rangesp : List[AstNode] // @astgen op2 := iffp : Optional[AstNodeExpr] // @astgen op3 := arraySizep : Optional[AstNodeExpr] // @astgen op4 := transp : List[AstCoverTransSet] - string m_name; - VCoverBinsType m_type; - bool m_isArray = false; + const string m_name; // Base name of the bin + const VCoverBinsType m_type; // Bin type (eg AUTO, IGNORE, ILLEGAL) + bool m_isArray = false; // Bin is either an auto-sized array of values or transitions public: AstCoverBin(FileLine* fl, const string& name, AstNode* rangesp, bool isIgnore, bool isIllegal, @@ -1060,14 +1057,14 @@ public: , m_type{isWildcard ? VCoverBinsType::BINS_WILDCARD : (isIllegal ? VCoverBinsType::BINS_ILLEGAL : (isIgnore ? VCoverBinsType::BINS_IGNORE - : VCoverBinsType::USER))} { + : VCoverBinsType::BINS_USER))} { if (rangesp) addRangesp(rangesp); } // Constructor for automatic bins AstCoverBin(FileLine* fl, const string& name, AstNodeExpr* arraySizep) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{VCoverBinsType::AUTO} + , m_type{VCoverBinsType::BINS_AUTO} , m_isArray{true} { this->arraySizep(arraySizep); } @@ -1077,12 +1074,11 @@ public: , m_name{name} , m_type{type} {} // Constructor for transition bins - AstCoverBin(FileLine* fl, const string& name, AstCoverTransSet* transp, bool isIgnore, - bool isIllegal, bool isArrayBin = false) + AstCoverBin(FileLine* fl, const string& name, AstCoverTransSet* transp, + VCoverBinsType type = VCoverBinsType::BINS_TRANSITION, bool isArrayBin = false) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{isIllegal ? VCoverBinsType::BINS_ILLEGAL - : (isIgnore ? VCoverBinsType::BINS_IGNORE : VCoverBinsType::TRANSITION)} + , m_type{type} , m_isArray{isArrayBin} { if (transp) addTransp(transp); } @@ -1095,8 +1091,9 @@ public: void isArray(bool flag) { m_isArray = flag; } }; class AstCoverCrossBins final : public AstNode { + // Cross-point bin definition // @astgen op1 := selectp : Optional[AstCoverSelectExpr] - string m_name; + const string m_name; // Bin name public: AstCoverCrossBins(FileLine* fl, const string& name, AstCoverSelectExpr* selectp) @@ -1110,8 +1107,9 @@ public: string name() const override VL_MT_STABLE { return m_name; } }; class AstCoverOption final : public AstNode { + // Coverage-option assignment // @astgen op1 := valuep : AstNodeExpr - VCoverOptionType m_type; + const VCoverOptionType m_type; // Option being assigned public: AstCoverOption(FileLine* fl, VCoverOptionType type, AstNodeExpr* valuep) @@ -1125,6 +1123,7 @@ public: VCoverOptionType optionType() const { return m_type; } }; class AstCoverSelectExpr final : public AstNode { + // Represents a cross-bins selection expression (eg binsof(cp1) intersect {1,2}) // @astgen op1 := exprp : AstNodeExpr public: AstCoverSelectExpr(FileLine* fl, AstNodeExpr* exprp) @@ -1140,7 +1139,7 @@ class AstCoverTransItem final : public AstNode { // @astgen op1 := valuesp : List[AstNode] // @astgen op2 := repMinp : Optional[AstNodeExpr] // @astgen op3 := repMaxp : Optional[AstNodeExpr] - VTransRepType m_repType; + const VTransRepType m_repType; public: AstCoverTransItem(FileLine* fl, AstNode* valuesp, VTransRepType repType = VTransRepType::NONE) @@ -1166,12 +1165,14 @@ public: void dumpJson(std::ostream& str) const override; }; class AstCovergroup final : public AstNode { + // Represents a covergroup declaration. V3LinkParse transforms this + // into an AstClass with isCovergroup==true and attaches the clocking + // event as a new AstCovergroup sentinel in class membersp. // @astgen op1 := argsp : List[AstVar] // @astgen op2 := membersp : List[AstNode] // @astgen op3 := eventp : Optional[AstSenTree] // @astgen op4 := sampleArgsp : List[AstVar] - string m_name; - bool m_isClass = false; + string m_name; // covergroup name public: AstCovergroup(FileLine* fl, const string& name, AstVar* argsp, AstVar* sampleArgsp, @@ -1188,13 +1189,12 @@ public: void dumpJson(std::ostream& str) const override; string name() const override VL_MT_STABLE { return m_name; } void name(const string& name) override { m_name = name; } - bool isClass() const { return m_isClass; } - void isClass(bool flag) { m_isClass = flag; } bool maybePointedTo() const override { return true; } }; class AstCoverpointRef final : public AstNode { + // Reference to a coverpoint used in a cross // @astgen ptr := m_coverpointp : Optional[AstCoverpoint] - string m_name; + const string m_name; // coverpoint name public: AstCoverpointRef(FileLine* fl, const string& name) diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp index 1821a2ffc..8453c92b2 100644 --- a/src/V3AstNodes.cpp +++ b/src/V3AstNodes.cpp @@ -3499,14 +3499,9 @@ const char* AstNot::widthMismatch() const VL_MT_STABLE { //###################################################################### // Functional coverage dump methods -void AstCovergroup::dump(std::ostream& str) const { - this->AstNode::dump(str); - str << " " << m_name; - if (m_isClass) str << " [class]"; -} +void AstCovergroup::dump(std::ostream& str) const { this->AstNode::dump(str); } void AstCovergroup::dumpJson(std::ostream& str) const { - dumpJsonBoolFuncIf(str, isClass); dumpJsonGen(str); } @@ -3516,13 +3511,12 @@ void AstCoverpoint::dumpJson(std::ostream& str) const { this->AstNodeFuncCovItem void AstCoverBin::dump(std::ostream& str) const { this->AstNode::dump(str); - str << " " << m_name << " " << m_type.ascii(); + str << " " << m_type.ascii(); if (m_isArray) str << "[]"; } void AstCoverBin::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); - str << ", \"name\": " << VString::quotePercent(m_name); str << ", \"binsType\": \"" << m_type.ascii() << "\""; if (m_isArray) str << ", \"isArray\": true"; } @@ -3539,7 +3533,6 @@ void AstCoverTransItem::dumpJson(std::ostream& str) const { void AstCoverTransSet::dump(std::ostream& str) const { this->AstNode::dump(str); - str << " trans_set"; } void AstCoverTransSet::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); } @@ -3548,15 +3541,9 @@ void AstCoverCross::dump(std::ostream& str) const { this->AstNodeFuncCovItem::du void AstCoverCross::dumpJson(std::ostream& str) const { this->AstNodeFuncCovItem::dumpJson(str); } -void AstCoverCrossBins::dump(std::ostream& str) const { - this->AstNode::dump(str); - str << " " << m_name; -} +void AstCoverCrossBins::dump(std::ostream& str) const { this->AstNode::dump(str); } -void AstCoverCrossBins::dumpJson(std::ostream& str) const { - this->AstNode::dumpJson(str); - str << ", \"name\": " << VString::quotePercent(m_name); -} +void AstCoverCrossBins::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); } void AstCoverOption::dump(std::ostream& str) const { this->AstNode::dump(str); @@ -3568,15 +3555,9 @@ void AstCoverOption::dumpJson(std::ostream& str) const { str << ", \"optionType\": \"" << m_type.ascii() << "\""; } -void AstCoverpointRef::dump(std::ostream& str) const { - this->AstNode::dump(str); - str << " " << m_name; -} +void AstCoverpointRef::dump(std::ostream& str) const { this->AstNode::dump(str); } -void AstCoverpointRef::dumpJson(std::ostream& str) const { - this->AstNode::dumpJson(str); - str << ", \"name\": " << VString::quotePercent(m_name); -} +void AstCoverpointRef::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); } void AstCoverSelectExpr::dump(std::ostream& str) const { this->AstNode::dump(str); } diff --git a/src/V3Covergroup.cpp b/src/V3Covergroup.cpp index d96f914e7..26a3f91e3 100644 --- a/src/V3Covergroup.cpp +++ b/src/V3Covergroup.cpp @@ -120,7 +120,7 @@ class FunctionalCoverageVisitor final : public VNVisitor { AstCoverBin* const cbinp = VN_CAST(binp, CoverBin); AstNode* nextBinp = binp->nextp(); - if (cbinp && cbinp->binsType() == VCoverBinsType::AUTO) { + if (cbinp && cbinp->binsType() == VCoverBinsType::BINS_AUTO) { UINFO(4, " Expanding automatic bin: " << cbinp->name() << endl); // Get array size - must be a constant @@ -477,14 +477,14 @@ class FunctionalCoverageVisitor final : public VNVisitor { if (!cbinp) continue; // Defer default bins to second pass - if (cbinp->binsType() == VCoverBinsType::DEFAULT) { + if (cbinp->binsType() == VCoverBinsType::BINS_DEFAULT) { defaultBins.push_back(cbinp); continue; } // Handle array bins: create separate bin for each value/transition if (cbinp->isArray()) { - if (cbinp->binsType() == VCoverBinsType::TRANSITION) { + if (cbinp->binsType() == VCoverBinsType::BINS_TRANSITION) { hasTransition = true; generateTransitionArrayBins(coverpointp, cbinp, exprp, atLeastValue); } else { @@ -520,7 +520,7 @@ class FunctionalCoverageVisitor final : public VNVisitor { // Generate bin matching code in sample() // Handle transition bins specially - if (cbinp->binsType() == VCoverBinsType::TRANSITION) { + if (cbinp->binsType() == VCoverBinsType::BINS_TRANSITION) { hasTransition = true; generateTransitionBinMatchCode(coverpointp, cbinp, exprp, varp); } else { @@ -615,7 +615,7 @@ class FunctionalCoverageVisitor final : public VNVisitor { if (!cbinp) continue; // Skip default, ignore, and illegal bins - if (cbinp->binsType() == VCoverBinsType::DEFAULT + if (cbinp->binsType() == VCoverBinsType::BINS_DEFAULT || cbinp->binsType() == VCoverBinsType::BINS_IGNORE || cbinp->binsType() == VCoverBinsType::BINS_ILLEGAL) { continue; @@ -1285,7 +1285,7 @@ class FunctionalCoverageVisitor final : public VNVisitor { std::vector cpBins; for (AstNode* binp = cpp->binsp(); binp; binp = binp->nextp()) { AstCoverBin* const cbinp = VN_CAST(binp, CoverBin); - if (cbinp && cbinp->binsType() == VCoverBinsType::USER) { + if (cbinp && cbinp->binsType() == VCoverBinsType::BINS_USER) { cpBins.push_back(cbinp); } } diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index a93432e1a..dd3e7d753 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -340,7 +340,7 @@ class EmitVBaseVisitorConst VL_NOT_FINAL : public VNVisitorConst { default: putfs(nodep, "bins "); break; } puts(nodep->name()); - if (nodep->binsType() == VCoverBinsType::DEFAULT) { + if (nodep->binsType() == VCoverBinsType::BINS_DEFAULT) { puts(" = default"); } else if (nodep->transp()) { puts(" = "); diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index a955d643f..c1b5e473a 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -1162,9 +1162,10 @@ class LinkParseVisitor final : public VNVisitor { } } - // IEEE: option + // IEEE: option / type_option members allow external access (cg_inst.option.X) + // and require std:: types; std:: is kept because setUsesStdPackage() is called + // at parse time for every covergroup declaration. { - v3Global.setUsesStdPackage(); AstVar* const varp = new AstVar{nodep->fileline(), VVarType::MEMBER, "option", VFlagChildDType{}, new AstRefDType{nodep->fileline(), "vl_covergroup_options_t", @@ -1173,12 +1174,10 @@ class LinkParseVisitor final : public VNVisitor { nullptr}}; nodep->addMembersp(varp); } - - // IEEE: type_option { - v3Global.setUsesStdPackage(); AstVar* const varp - = new AstVar{nodep->fileline(), VVarType::MEMBER, "type_option", VFlagChildDType{}, + = new AstVar{nodep->fileline(), VVarType::MEMBER, "type_option", + VFlagChildDType{}, new AstRefDType{nodep->fileline(), "vl_covergroup_type_options_t", new AstClassOrPackageRef{nodep->fileline(), "std", nullptr, nullptr}, diff --git a/src/V3MergeCond.cpp b/src/V3MergeCond.cpp index 0ed6f4cd9..7e6d7abba 100644 --- a/src/V3MergeCond.cpp +++ b/src/V3MergeCond.cpp @@ -250,10 +250,6 @@ class CodeMotionAnalysisVisitor final : public VNVisitorConst { void analyzeVarRef(AstVarRef* nodep) { const VAccess access = nodep->access(); AstVar* const varp = nodep->varp(); - // Add null check - varp can be null in some contexts (e.g., SenTree VarRefs) - if (!varp) return; - // Skip if not in a statement context (m_propsp can be null) - if (!m_propsp) return; // Gather read and written variables if (access.isReadOrRW()) m_propsp->m_rdVars.insert(varp); if (access.isWriteOrRW()) m_propsp->m_wrVars.insert(varp); diff --git a/src/V3OrderGraphBuilder.cpp b/src/V3OrderGraphBuilder.cpp index f1a4a6198..c16ef8941 100644 --- a/src/V3OrderGraphBuilder.cpp +++ b/src/V3OrderGraphBuilder.cpp @@ -331,16 +331,6 @@ class OrderGraphBuilder final : public VNVisitor { void visit(AstCoverToggle* nodep) override { // iterateLogic(nodep); } - void visit(AstStmtExpr* nodep) override { - // StmtExpr wraps expressions used as statements (e.g., method calls). - // If it's under an AstActive but not already in a logic context, treat it as logic. - // Otherwise just iterate normally. - if (!m_logicVxp && m_domainp) { - iterateLogic(nodep); - } else { - iterateChildren(nodep); - } - } //--- Ignored nodes void visit(AstVar*) override {} diff --git a/src/V3SchedPartition.cpp b/src/V3SchedPartition.cpp index 43c83b3b5..194a030ac 100644 --- a/src/V3SchedPartition.cpp +++ b/src/V3SchedPartition.cpp @@ -240,9 +240,6 @@ class SchedGraphBuilder final : public VNVisitor { void visit(AstNodeProcedure* nodep) override { visitLogic(nodep); } void visit(AstNodeAssign* nodep) override { visitLogic(nodep); } void visit(AstCoverToggle* nodep) override { visitLogic(nodep); } - void visit(AstStmtExpr* nodep) override { - visitLogic(nodep); - } // Handle statement expressions like method calls // Pre and Post logic are handled separately void visit(AstAlwaysPre* nodep) override {} diff --git a/src/V3Timing.cpp b/src/V3Timing.cpp index 290eb3db2..5f57762f7 100644 --- a/src/V3Timing.cpp +++ b/src/V3Timing.cpp @@ -343,12 +343,6 @@ class TimingSuspendableVisitor final : public VNVisitor { } } void visit(AstNodeCCall* nodep) override { - // Skip automatic covergroup sampling calls (marked with user3==1) - if (nodep->user3()) { - iterateChildren(nodep); - return; - } - AstCFunc* funcp = nodep->funcp(); if (!funcp) { iterateChildren(nodep); diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 357c9cd79..84b4c8aea 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -224,6 +224,7 @@ class WidthVisitor final : public VNVisitor { const AstCell* m_cellp = nullptr; // Current cell for arrayed instantiations const AstEnumItem* m_enumItemp = nullptr; // Current enum item AstNodeFTask* m_ftaskp = nullptr; // Current function/task + AstClass* m_cgClassp = nullptr; // Current covergroup class AstNodeModule* m_modep = nullptr; // Current module const AstConstraint* m_constraintp = nullptr; // Current constraint AstNodeProcedure* m_procedurep = nullptr; // Current final/always @@ -1726,17 +1727,7 @@ class WidthVisitor final : public VNVisitor { } void visit(AstCgOptionAssign* nodep) override { // Extract covergroup option values and store in AstClass before deleting - // Find parent covergroup (AstClass with isCovergroup() == true) - AstClass* cgClassp = nullptr; - for (AstNode* parentp = nodep->backp(); parentp; parentp = parentp->backp()) { - if (AstClass* classp = VN_CAST(parentp, Class)) { - if (classp->isCovergroup()) { - cgClassp = classp; - break; - } - } - } - + AstClass* const cgClassp = m_cgClassp; if (cgClassp) { // Process supported options if (nodep->name() == "auto_bin_max" && !nodep->typeOption()) { @@ -3392,11 +3383,12 @@ class WidthVisitor final : public VNVisitor { return AstEqWild::newTyped(itemp->fileline(), exprp, itemp->unlinkFrBack()); } void visit(AstInsideRange* nodep) override { - // Just do each side; AstInside will rip these nodes out later - // When m_vup is null we are in a covergroup bin context (not an expression context). - // Fold constant arithmetic (e.g., NEGATE(100) -> -100) so the children have their - // types set before further tree processing. Use constifyEdit (not constifyParamsEdit) - // to avoid errors on any non-constant expressions. + // Just do each side; AstInside will rip these nodes out later. + // When m_vup is null, this range appears outside a normal expression context (e.g. + // in a covergroup bin declaration). Pre-fold constant arithmetic in that case + // (e.g., AstNegate(Const) -> Const) so children have their types set before widthing. + // We cannot do this unconditionally: in a normal 'inside' expression (m_vup set), + // range bounds may be enum refs not yet widthed, and constifyEdit would crash. if (!m_vup) { V3Const::constifyEdit(nodep->lhsp()); // lhsp may change V3Const::constifyEdit(nodep->rhsp()); // rhsp may change @@ -7473,6 +7465,8 @@ class WidthVisitor final : public VNVisitor { // Must do extends first, as we may in functions under this class // start following a tree of extends that takes us to other classes userIterateAndNext(nodep->extendsp(), nullptr); + VL_RESTORER(m_cgClassp); + if (nodep->isCovergroup()) m_cgClassp = nodep; userIterateChildren(nodep, nullptr); // First size all members } void visit(AstNodeModule* nodep) override { diff --git a/src/Verilator.cpp b/src/Verilator.cpp index 91a0e59bd..26eabfb9f 100644 --- a/src/Verilator.cpp +++ b/src/Verilator.cpp @@ -158,10 +158,7 @@ static void process() { } // Convert parseref's to varrefs, and other directly post parsing fixups - // Note: must run before removeStd() as it may create std:: references (e.g. covergroups) V3LinkParse::linkParse(v3Global.rootp()); - // Remove std package if unused (must be after V3LinkParse which may set usesStdPackage) - v3Global.removeStd(); // Cross-link signal names // Cross-link dotted hierarchical references V3LinkDot::linkDotPrimary(v3Global.rootp()); @@ -751,6 +748,7 @@ static bool verilate(const string& argString) { // Read first filename v3Global.readFiles(); + v3Global.removeStd(); // Link, etc, if needed if (!v3Global.opt.preprocOnly()) { // diff --git a/src/verilog.y b/src/verilog.y index 64f6d80f1..79bf8181a 100644 --- a/src/verilog.y +++ b/src/verilog.y @@ -6943,6 +6943,9 @@ covergroup_declaration: // ==IEEE: covergroup_declaration } $$ = new AstCovergroup{$1, *$2, static_cast($3), static_cast(sampleArgsp), $6, clockp}; + // Every covergroup has option/type_option members (added by V3LinkParse) + // referencing std:: types, so mark std as needed at parse time. + v3Global.setUsesStdPackage(); GRAMMARP->endLabel($8, $$, $8); } | yCOVERGROUP yEXTENDS idAny ';' /*cont*/ coverage_spec_or_optionListE @@ -7124,15 +7127,15 @@ bins_or_options: // ==IEEE: bins_or_options // // cgexpr part of trans_list | yBINS idAny/*bin_identifier*/ bins_orBraE '=' trans_list iffE { FileLine* isArray = $3; - $$ = new AstCoverBin{$2, *$2, static_cast($5), false, false, isArray != nullptr}; + $$ = new AstCoverBin{$2, *$2, static_cast($5), VCoverBinsType{VCoverBinsType::BINS_TRANSITION}, isArray != nullptr}; DEL($6); } | yIGNORE_BINS idAny/*bin_identifier*/ bins_orBraE '=' trans_list iffE { FileLine* isArray = $3; - $$ = new AstCoverBin{$2, *$2, static_cast($5), true, false, isArray != nullptr}; + $$ = new AstCoverBin{$2, *$2, static_cast($5), VCoverBinsType{VCoverBinsType::BINS_IGNORE}, isArray != nullptr}; DEL($6); } | yILLEGAL_BINS idAny/*bin_identifier*/ bins_orBraE '=' trans_list iffE { FileLine* isArray = $3; - $$ = new AstCoverBin{$2, *$2, static_cast($5), false, true, isArray != nullptr}; + $$ = new AstCoverBin{$2, *$2, static_cast($5), VCoverBinsType{VCoverBinsType::BINS_ILLEGAL}, isArray != nullptr}; DEL($6); } | yWILDCARD yBINS idAny/*bin_identifier*/ bins_orBraE '=' trans_list iffE { $$ = nullptr; BBCOVERIGN($1, "Ignoring unsupported: cover bin 'wildcard' trans list"); DEL($6, $7);} @@ -7142,7 +7145,7 @@ bins_or_options: // ==IEEE: bins_or_options { $$ = nullptr; BBCOVERIGN($1, "Ignoring unsupported: cover bin 'wildcard' trans list"); DEL($6, $7);} // | yBINS idAny/*bin_identifier*/ bins_orBraE '=' yDEFAULT iffE - { $$ = new AstCoverBin{$2, *$2, VCoverBinsType::DEFAULT}; + { $$ = new AstCoverBin{$2, *$2, VCoverBinsType::BINS_DEFAULT}; DEL($6); } | yIGNORE_BINS idAny/*bin_identifier*/ bins_orBraE '=' yDEFAULT iffE { $$ = new AstCoverBin{$2, *$2, VCoverBinsType::BINS_IGNORE};