Support randsequence (verilator#6131)

Author: wsnyder

src/CMakeLists.txt

@@ -156,6 +156,7 @@ set(HEADERS
     V3PreShell.h
     V3Premit.h
     V3ProtectLib.h
+    V3RandSequence.h
     V3Randomize.h
     V3Reloop.h
     V3Rtti.h
@@ -319,6 +320,7 @@ set(COMMON_SOURCES
     V3PreShell.cpp
     V3Premit.cpp
     V3ProtectLib.cpp
+    V3RandSequence.cpp
     V3Randomize.cpp
     V3Reloop.cpp
     V3Sampled.cpp

src/Makefile_obj.in

@@ -309,6 +309,7 @@ RAW_OBJS_PCH_ASTNOMT = \
   V3Param.o \
   V3Premit.o \
   V3ProtectLib.o \
+  V3RandSequence.o \
   V3Randomize.o \
   V3Reloop.o \
   V3Sampled.o \

src/V3AstAttr.h

@@ -940,7 +940,7 @@ inline std::ostream& operator<<(std::ostream& os, const VCMethod& rhs) {
 
 class VCaseType final {
 public:
-    enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
+    enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE, CT_RANDSEQUENCE };
     enum en m_e;
     VCaseType()
         : m_e{CT_CASE} {}

src/V3AstNodeExpr.h

@@ -1917,6 +1917,12 @@ class AstRand final : public AstNodeExpr {
         , m_urandom{urandom} {
         this->seedp(seedp);
     }
+    class SRandomU32 {};
+    AstRand(FileLine* fl, SRandomU32)
+        : ASTGEN_SUPER_Rand(fl)
+        , m_urandom{true} {
+        dtypeSetUInt32();
+    }
     ASTGEN_MEMBERS_AstRand;
     string emitVerilog() override {
         return seedp() ? (m_urandom ? "%f$urandom(%l)" : "%f$random(%l)")

src/V3AstNodeStmt.h

@@ -199,7 +199,7 @@ class AstNodeReadWriteMem VL_NOT_FINAL : public AstNodeStmt {
 
 // === AstNode ===
 class AstCaseItem final : public AstNode {
-    // Single item of AstCase/AstRandCase/AstRSCase
+    // Single item of AstCase/AstRandCase
     // @astgen op1 := condsp : List[AstNodeExpr]
     // @astgen op2 := stmtsp : List[AstNode]
 public:
@@ -887,42 +887,17 @@ class AstPrintTimeScale final : public AstNodeStmt {
     void timeunit(const VTimescale& flag) { m_timeunit = flag; }
     VTimescale timeunit() const { return m_timeunit; }
 };
-class AstRSCase final : public AstNodeStmt {
-    // Randsequence case statement
-    // @astgen op1 := exprp : AstNodeExpr // Condition (scurtinee) expression
-    // @astgen op2 := itemsp : List[AstCaseItem]
-public:
-    AstRSCase(FileLine* fl, AstNodeExpr* exprp, AstCaseItem* itemsp)
-        : ASTGEN_SUPER_Case(fl) {
-        this->exprp(exprp);
-        addItemsp(itemsp);
-    }
-    ASTGEN_MEMBERS_AstRSCase;
-    int instrCount() const override { return INSTR_COUNT_BRANCH; }
-    bool sameNode(const AstNode* samep) const override { return true; }
-};
-class AstRSIf final : public AstNodeStmt {
-    // Randsequence if
-    // @astgen op1 := condp : AstNodeExpr
-    // @astgen op2 := thensp : List[AstNode]
-    // @astgen op3 := elsesp : List[AstNode]
-public:
-    AstRSIf(FileLine* fl, AstNodeExpr* condp, AstNode* thensp, AstNode* elsesp)
-        : ASTGEN_SUPER_RSIf(fl) {
-        this->condp(condp);
-        addThensp(thensp);
-        addElsesp(elsesp);
-    }
-
+class AstRSBreak final : public AstNodeStmt {
+    // randsequence break
 public:
-    ASTGEN_MEMBERS_AstRSIf;
-    bool isGateOptimizable() const override { return false; }
-    bool isGateDedupable() const override { return false; }
-    int instrCount() const override { return INSTR_COUNT_BRANCH; }
-    bool sameNode(const AstNode* /*samep*/) const override { return true; }
+    explicit AstRSBreak(FileLine* fl)
+        : ASTGEN_SUPER_RSBreak(fl) {}
+    ASTGEN_MEMBERS_AstRSBreak;
+    string verilogKwd() const override { return "break"; }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstRSProd final : public AstNodeStmt {
-    // randomsquence production, under a AstRandSequence
+    // randomsequence production, under a AstRandSequence
     // @astgen op1 := fvarp : Optional[AstVar]
     // @astgen op2 := portsp : List[AstNode]
     // @astgen op3 := rulesp : List[AstRSRule]
@@ -935,12 +910,14 @@ class AstRSProd final : public AstNodeStmt {
         addRulesp(rulesp);
     }
     ASTGEN_MEMBERS_AstRSProd;
+    bool maybePointedTo() const override VL_MT_SAFE { return true; }
     string name() const override VL_MT_STABLE { return m_name; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
 };
 class AstRSProdItem final : public AstNodeStmt {
     // randomsquence production item
     // @astgen op1 := argsp : List[AstNodeExpr]
+    // @astgen ptr := m_prodp : Optional[AstRSProd]  // Pointer to production
     string m_name;  // Name of block, or "" to use first production
 public:
     AstRSProdItem(FileLine* fl, const string& name, AstNodeExpr* argsp)
@@ -951,6 +928,8 @@ class AstRSProdItem final : public AstNodeStmt {
     ASTGEN_MEMBERS_AstRSProdItem;
     string name() const override VL_MT_STABLE { return m_name; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
+    AstRSProd* prodp() const { return m_prodp; }
+    void prodp(AstRSProd* nodep) { m_prodp = nodep; }
 };
 class AstRSProdList final : public AstNodeStmt {
     // randomsquence production list
@@ -970,32 +949,26 @@ class AstRSProdList final : public AstNodeStmt {
     bool randJoin() const { return m_randJoin; }
     void randJoin(bool flag) { m_randJoin = flag; }
 };
-class AstRSRepeat final : public AstNodeStmt {
-    // randsequence repeat
-    // @astgen op1 := countp : AstNodeExpr
-    // @astgen op2 := stmtsp : List[AstNode]
+class AstRSReturn final : public AstNodeStmt {
+    // randsequence return
 public:
-    AstRSRepeat(FileLine* fl, AstNodeExpr* countp, AstNode* stmtsp)
-        : ASTGEN_SUPER_RSRepeat(fl) {
-        this->countp(countp);
-        addStmtsp(stmtsp);
-    }
-    ASTGEN_MEMBERS_AstRSRepeat;
-    bool isGateOptimizable() const override { return false; }
-    int instrCount() const override { return INSTR_COUNT_BRANCH; }
-    bool sameNode(const AstNode* /*samep*/) const override { return true; }
+    explicit AstRSReturn(FileLine* fl)
+        : ASTGEN_SUPER_RSReturn(fl) {}
+    ASTGEN_MEMBERS_AstRSReturn;
+    string verilogKwd() const override { return "return"; }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstRSRule final : public AstNodeStmt {
     // randomsquence rule
     // @astgen op1 := weightp : Optional[AstNodeExpr]
     // @astgen op2 := prodlistsp : List[AstRSProdList]
-    // @astgen op3 := stmtsp : List[AstNode]
+    // @astgen op3 := weightStmtsp : List[AstNode]
 public:
-    AstRSRule(FileLine* fl, AstNodeExpr* weightp, AstRSProdList* prodlistsp, AstNode* stmtsp)
+    AstRSRule(FileLine* fl, AstNodeExpr* weightp, AstRSProdList* prodlistsp, AstNode* weightStmtsp)
         : ASTGEN_SUPER_RSRule(fl) {
         this->weightp(weightp);
         addProdlistsp(prodlistsp);
-        addStmtsp(stmtsp);
+        addWeightStmtsp(weightStmtsp);
     }
     ASTGEN_MEMBERS_AstRSRule;
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
@@ -1013,16 +986,24 @@ class AstRandCase final : public AstNodeStmt {
 };
 class AstRandSequence final : public AstNodeStmt {
     // @astgen op2 := prodsp : List[AstRSProd]
-    string m_name;  // Name of block, or "" to use first production
+    // @astgen ptr := m_prodp : Optional[AstRSProd]  // Pointer to start production (if any)
+    string m_name;  // Created unique name
+    string m_start;  // Name of start production, or "" to use first production
 public:
-    AstRandSequence(FileLine* fl, const string& name, AstRSProd* prodsp)
+    AstRandSequence(FileLine* fl, const string& start, AstRSProd* prodsp)
         : ASTGEN_SUPER_RandSequence(fl)
-        , m_name{name} {
+        , m_start{start} {
         addProdsp(prodsp);
     }
     ASTGEN_MEMBERS_AstRandSequence;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string name() const override VL_MT_STABLE { return m_name; }  // * = Block name
+    void name(const string& name) override { m_name = name; }
+    string start() const VL_MT_STABLE { return m_start; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
+    AstRSProd* prodp() const { return m_prodp; }
+    void prodp(AstRSProd* nodep) { m_prodp = nodep; }
 };
 class AstRelease final : public AstNodeStmt {
     // Procedural 'release' statement

src/V3AstNodes.cpp

@@ -2271,6 +2271,14 @@ void AstTypedefFwd::dumpJson(std::ostream& str) const {
 }
 void AstNodeRange::dump(std::ostream& str) const { this->AstNode::dump(str); }
 void AstNodeRange::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
+void AstRandSequence::dump(std::ostream& str) const {
+    this->AstNode::dump(str);
+    str << " start=" << start();
+}
+void AstRandSequence::dumpJson(std::ostream& str) const {
+    if (!start().empty()) dumpJsonStr(str, "start", start());
+    dumpJsonGen(str);
+}
 void AstRange::dump(std::ostream& str) const {
     this->AstNodeRange::dump(str);
     if (fromBracket()) str << " [FB]";

src/V3Global.h

@@ -125,6 +125,7 @@ class V3Global final {
     bool m_hasForceableSignals = false;  // Need to apply V3Force pass
     bool m_hasSystemCSections = false;  // Has AstSystemCSection that need to be emitted
     bool m_useParallelBuild = false;  // Use parallel build for model
+    bool m_useRandSequence = false;  // Has `randsequence`
     bool m_useRandomizeMethods = false;  // Need to define randomize() class methods
     uint64_t m_currentHierBlockCost = 0;  // Total cost of this hier block, used for scheduling
 
@@ -203,6 +204,8 @@ class V3Global final {
     void hierGraphp(V3HierGraph* graphp) { m_hierGraphp = graphp; }
     bool useParallelBuild() const { return m_useParallelBuild; }
     void useParallelBuild(bool flag) { m_useParallelBuild = flag; }
+    bool useRandSequence() const { return m_useRandSequence; }
+    void useRandSequence(bool flag) { m_useRandSequence = flag; }
     bool useRandomizeMethods() const { return m_useRandomizeMethods; }
     void useRandomizeMethods(bool flag) { m_useRandomizeMethods = flag; }
     void saveJsonPtrFieldName(const std::string& fieldName);

src/V3LinkDot.cpp

@@ -94,6 +94,10 @@ class LinkNodeMatcherModport final : public VNodeMatcher {
 public:
     bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); }
 };
+class LinkNodeMatcherProd final : public VNodeMatcher {
+public:
+    bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, RSProd); }
+};
 class LinkNodeMatcherVar final : public VNodeMatcher {
 public:
     bool nodeMatch(const AstNode* nodep) const override {
@@ -246,20 +250,22 @@ class LinkDotState final {
             } else {
                 return "local type parameter";
             }
+        } else if (VN_IS(nodep, Begin)) {
+            return "block";
         } else if (VN_IS(nodep, Cell)) {
             return "instance";
         } else if (VN_IS(nodep, Constraint)) {
             return "constraint";
-        } else if (VN_IS(nodep, Task)) {
-            return "task";
         } else if (VN_IS(nodep, Func)) {
             return "function";
-        } else if (VN_IS(nodep, Begin)) {
-            return "block";
-        } else if (VN_IS(nodep, Iface)) {
-            return "interface";
         } else if (VN_IS(nodep, GenBlock)) {
             return "generate block";
+        } else if (VN_IS(nodep, Iface)) {
+            return "interface";
+        } else if (VN_IS(nodep, RSProd)) {
+            return "randsequence production";
+        } else if (VN_IS(nodep, Task)) {
+            return "task";
         } else {
             return nodep->prettyTypeName();
         }
@@ -1856,6 +1862,23 @@ class LinkDotFindVisitor final : public VNVisitor {
         }
     }
 
+    void visit(AstRandSequence* nodep) override {
+        VL_RESTORER(m_curSymp);
+        m_curSymp = m_statep->insertBlock(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
+        iterateChildren(nodep);
+    }
+    void visit(AstRSProd* nodep) override {
+        VL_RESTORER(m_curSymp);
+        m_curSymp = m_statep->insertBlock(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
+        if (nodep->fvarp())
+            nodep->fvarp()->v3warn(E_UNSUPPORTED,
+                                   "Unsupported: randsequence production function variable");
+        if (nodep->portsp())
+            nodep->portsp()->v3warn(E_UNSUPPORTED,
+                                    "Unsupported: randsequence production function ports");
+        iterateChildren(nodep);
+    }
+
     void visit(AstWithParse* nodep) override {  // FindVisitor::
         // Change WITHPARSE(FUNCREF, equation) to FUNCREF(WITH(equation))
         AstNodeFTaskRef* funcrefp = VN_CAST(nodep->funcrefp(), NodeFTaskRef);
@@ -2725,6 +2748,21 @@ class LinkDotResolveVisitor final : public VNVisitor {
         UASSERT_OBJ(ifaceTopVarp, nodep, "Can't find interface var ref: " << findName);
         return ifaceTopVarp;
     }
+    AstRSProd* findProd(AstNode* nodep, VSymEnt* parentEntp, const string& name) {
+        const VSymEnt* const foundp = parentEntp->findIdFallback(name);
+        AstRSProd* foundNodep = foundp ? VN_CAST(foundp->nodep(), RSProd) : nullptr;
+        if (!foundNodep) {
+            VSpellCheck speller;
+            LinkNodeMatcherProd matcher;
+            parentEntp->candidateIdFlat(&speller, &matcher);
+            const string suggest = speller.bestCandidateMsg(name);
+            UINFO(1, "   ErrParseRef curSymp=se" << cvtToHex(parentEntp));
+            nodep->v3error("Production " << AstNode::prettyNameQ(name) << " not found\n"
+                                         << (suggest.empty() ? "" : nodep->warnMore() + suggest));
+            return nullptr;
+        }
+        return foundNodep;
+    }
     void markAndCheckPinDup(AstPin* nodep, AstNode* refp, const char* whatp) {
         const auto pair = m_usedPins.emplace(refp, nodep);
         if (!pair.second) {
@@ -4722,6 +4760,27 @@ class LinkDotResolveVisitor final : public VNVisitor {
         checkNoDot(nodep);
         symIterateChildren(nodep, m_statep->getNodeSym(nodep));
     }
+    void visit(AstRandSequence* nodep) override {
+        LINKDOT_VISIT_START();
+        UINFO(5, indent() << "visit " << nodep);
+        checkNoDot(nodep);
+        if (!nodep->start().empty())
+            nodep->prodp(findProd(nodep, m_statep->getNodeSym(nodep), nodep->start()));
+        symIterateChildren(nodep, m_statep->getNodeSym(nodep));
+    }
+    void visit(AstRSProd* nodep) override {
+        LINKDOT_VISIT_START();
+        UINFO(5, indent() << "visit " << nodep);
+        checkNoDot(nodep);
+        symIterateChildren(nodep, m_statep->getNodeSym(nodep));
+    }
+    void visit(AstRSProdItem* nodep) override {
+        LINKDOT_VISIT_START();
+        UINFO(5, indent() << "visit " << nodep);
+        checkNoDot(nodep);
+        nodep->prodp(findProd(nodep, m_curSymp, nodep->name()));
+        iterateChildren(nodep);
+    }
     void visit(AstWith* nodep) override {
         LINKDOT_VISIT_START();
         UINFO(5, indent() << "visit " << nodep);

src/V3LinkJump.cpp

@@ -57,6 +57,7 @@ class LinkJumpVisitor final : public VNVisitor {
     AstNodeModule* m_modp = nullptr;  // Current module
     AstNodeFTask* m_ftaskp = nullptr;  // Current function/task
     AstNode* m_loopp = nullptr;  // Current loop
+    AstRandSequence* m_randsequencep = nullptr;  // Current randsequence
     bool m_loopInc = false;  // In loop increment
     bool m_inFork = false;  // Under fork
     int m_modRepeatNum = 0;  // Repeat counter
@@ -289,6 +290,11 @@ class LinkJumpVisitor final : public VNVisitor {
             iterateChildren(nodep);
         }
     }
+    void visit(AstRandSequence* nodep) override {
+        VL_RESTORER(m_randsequencep);
+        m_randsequencep = nodep;
+        iterateChildren(nodep);
+    }
     void visit(AstRepeat* nodep) override {
         // So later optimizations don't need to deal with them,
         //    REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
@@ -354,6 +360,10 @@ class LinkJumpVisitor final : public VNVisitor {
             nodep->v3error("Return isn't legal under fork (IEEE 1800-2023 9.2.3)");
             VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
             return;
+        } else if (!m_ftaskp && m_randsequencep) {
+            nodep->replaceWith(new AstRSReturn{nodep->fileline()});
+            VL_DO_DANGLING(pushDeletep(nodep), nodep);
+            return;
         } else if (!m_ftaskp) {
             nodep->v3error("Return isn't underneath a task or function");
         } else if (funcp && !nodep->lhsp() && !funcp->isConstructor()) {
@@ -377,7 +387,11 @@ class LinkJumpVisitor final : public VNVisitor {
     }
     void visit(AstBreak* nodep) override {
         iterateChildren(nodep);
-        if (!m_loopp) {
+        if (!m_loopp && m_randsequencep) {
+            nodep->replaceWith(new AstRSBreak{nodep->fileline()});
+            VL_DO_DANGLING(pushDeletep(nodep), nodep);
+            return;
+        } else if (!m_loopp) {
             nodep->v3error("break isn't underneath a loop");
         } else {
             // Jump to the end of the loop