diff --git a/include/verilated_std.sv b/include/verilated_std.sv index b86340695..51695cf17 100644 --- a/include/verilated_std.sv +++ b/include/verilated_std.sv @@ -181,8 +181,8 @@ package std; static task killQueue(ref process processQueue[$]); `ifdef VERILATOR_TIMING - while (processQueue.size() > 0) begin - processQueue.pop_back().kill(); + repeat (processQueue.size()) begin + processQueue.pop_front().kill(); end `endif endtask diff --git a/include/verilated_timing.cpp b/include/verilated_timing.cpp index 51dd88b9a..e189a443b 100644 --- a/include/verilated_timing.cpp +++ b/include/verilated_timing.cpp @@ -238,10 +238,56 @@ void VlDynamicTriggerScheduler::dump() const { //====================================================================== // VlForkSync:: Methods -void VlForkSync::done(const char* filename, int lineno) { +void VlProcess::forkSyncOnKill(VlForkSyncState* forkSyncp) { + m_forkSyncOnKillp = forkSyncp; + m_forkSyncOnKillDone = false; +} + +void VlProcess::forkSyncOnKillClear(VlForkSyncState* forkSyncp) { + if (m_forkSyncOnKillp != forkSyncp) return; + m_forkSyncOnKillp = nullptr; + m_forkSyncOnKillDone = false; +} + +void VlProcess::state(int s) { + if (s == KILLED && m_state != KILLED && m_state != FINISHED && m_forkSyncOnKillp + && !m_forkSyncOnKillDone) { + m_forkSyncOnKillDone = true; + m_state = s; + m_forkSyncOnKillp->done(); + return; + } + m_state = s; +} + +VlForkSyncState::~VlForkSyncState() { + for (const VlProcessRef& processp : m_onKillProcessps) processp->forkSyncOnKillClear(this); +} + +void VlForkSync::onKill(VlProcessRef process) { + if (!process) return; + m_state->m_onKillProcessps.emplace_back(process); + process->forkSyncOnKill(m_state.get()); +} + +void VlForkSyncState::done(const char* filename, int lineno) { VL_DEBUG_IF(VL_DBG_MSGF(" Process forked at %s:%d finished\n", filename, lineno);); - if (m_join->m_counter > 0) m_join->m_counter--; - if (m_join->m_counter == 0) m_join->m_susp.resume(); + if (!m_inited) { + ++m_pendingDones; + return; + } + if (m_counter > 0) m_counter--; + if (m_counter != 0) return; + if (m_inDone) { + m_resumePending = true; + return; + } + m_inDone = true; + do { + m_resumePending = false; + m_susp.resume(); + } while (m_resumePending && m_inited && m_counter == 0); + m_inDone = false; } //====================================================================== diff --git a/include/verilated_timing.h b/include/verilated_timing.h index a657ac458..c87e216ef 100644 --- a/include/verilated_timing.h +++ b/include/verilated_timing.h @@ -383,40 +383,59 @@ struct VlForever final { //============================================================================= // VlForkSync is used to manage fork..join and fork..join_any constructs. -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 final { - size_t m_counter = 0; // When reaches 0, resume suspended coroutine - VlCoroutineHandle m_susp; // Coroutine to resume - }; +// Shared fork..join state, because VlForkSync is copied into generated coroutine frames. +class VlForkSyncState final { +public: + size_t m_counter = 0; // When reaches 0, resume suspended coroutine + VlCoroutineHandle m_susp; // Coroutine to resume + bool m_inited = false; + size_t m_pendingDones = 0; // done() calls seen before init() (e.g. early killed branch) + bool m_inDone = false; // Guard against re-entrant resume recursion from nested kills + bool m_resumePending = false; // Join reached zero again while inside done() + std::vector m_onKillProcessps; // Branches registered for kill hooks - // The join info is shared among all forked processes - std::shared_ptr m_join; + VlForkSyncState() // Construct with a null coroutine handle + : m_susp{VlProcessRef{}} {} + ~VlForkSyncState(); + void done(const char* filename = VL_UNKNOWN, int lineno = 0); +}; + +class VlForkSync final { + std::shared_ptr m_state{std::make_shared()}; public: // Create the join object and set the counter to the specified number - void init(size_t count, VlProcessRef process) { m_join.reset(new VlJoin{count, {process}}); } + void init(size_t count, VlProcessRef process) { + const size_t pendingDones = m_state->m_pendingDones; + m_state->m_pendingDones = 0; + count = (pendingDones >= count) ? 0 : (count - pendingDones); + m_state->m_counter = count; + m_state->m_susp = {process}; + m_state->m_inited = true; + } + // Register process kill callback so killed fork branches still decrement join counter + void onKill(VlProcessRef process); // Called whenever any of the forked processes finishes. If the join counter reaches 0, the // main process gets resumed - void done(const char* filename = VL_UNKNOWN, int lineno = 0); + void done(const char* filename = VL_UNKNOWN, int lineno = 0) { + m_state->done(filename, lineno); + } // Used by coroutines for co_awaiting a join auto join(VlProcessRef process, const char* filename = VL_UNKNOWN, int lineno = 0) { - assert(m_join); VL_DEBUG_IF( VL_DBG_MSGF(" Awaiting join of fork at: %s:%d\n", filename, lineno);); struct Awaitable final { VlProcessRef process; // Data of the suspended process, null if not needed - const std::shared_ptr join; // Join to await on + const std::shared_ptr state; // Join to await on VlFileLineDebug fileline; - bool await_ready() { return join->m_counter == 0; } // Suspend if join still exists + bool await_ready() { return state->m_counter == 0; } // Suspend if join still exists void await_suspend(std::coroutine_handle<> coro) { - join->m_susp = {coro, process, fileline}; + state->m_susp = {coro, process, fileline}; } void await_resume() const {} }; - return Awaitable{process, m_join, VlFileLineDebug{filename, lineno}}; + return Awaitable{process, m_state, VlFileLineDebug{filename, lineno}}; } }; diff --git a/include/verilated_types.h b/include/verilated_types.h index c50cc044a..b1cd61c80 100644 --- a/include/verilated_types.h +++ b/include/verilated_types.h @@ -109,12 +109,17 @@ constexpr IData VL_CLOG2_CE_Q(QData lhs) VL_PURE { // Metadata of processes using VlProcessRef = std::shared_ptr; +class VlForkSync; +class VlForkSyncState; class VlProcess final { // MEMBERS int m_state; // Current state of the process VlProcessRef m_parentp = nullptr; // Parent process, if exists std::set m_children; // Active child processes + VlForkSyncState* m_forkSyncOnKillp + = nullptr; // Optional fork..join counter to decrement on kill + bool m_forkSyncOnKillDone = false; // Ensure on-kill callback fires only once public: // TYPES @@ -145,14 +150,18 @@ public: void detach(VlProcess* childp) { m_children.erase(childp); } int state() const { return m_state; } - void state(int s) { m_state = s; } + void state(int s); void disable() { state(KILLED); disableFork(); } void disableFork() { - for (VlProcess* childp : m_children) childp->disable(); + // childp->disable() may resume coroutines and mutate m_children + const std::set children = m_children; + for (VlProcess* childp : children) childp->disable(); } + void forkSyncOnKill(VlForkSyncState* forkSyncp); + void forkSyncOnKillClear(VlForkSyncState* forkSyncp); bool completed() const { return state() == FINISHED || state() == KILLED; } bool completedFork() const { for (const VlProcess* const childp : m_children) diff --git a/src/V3AstAttr.h b/src/V3AstAttr.h index a0e7fd495..4d383337e 100644 --- a/src/V3AstAttr.h +++ b/src/V3AstAttr.h @@ -815,6 +815,7 @@ public: FORK_DONE, FORK_INIT, FORK_JOIN, + FORK_ON_KILL, RANDOMIZER_BASIC_STD_RANDOMIZATION, RANDOMIZER_CLEARCONSTRAINTS, RANDOMIZER_CLEARALL, @@ -959,6 +960,7 @@ inline std::ostream& operator<<(std::ostream& os, const VCMethod& rhs) { {FORK_DONE, "done", false}, \ {FORK_INIT, "init", false}, \ {FORK_JOIN, "join", false}, \ + {FORK_ON_KILL, "onKill", false}, \ {RANDOMIZER_BASIC_STD_RANDOMIZATION, "basicStdRandomization", false}, \ {RANDOMIZER_CLEARCONSTRAINTS, "clearConstraints", false}, \ {RANDOMIZER_CLEARALL, "clearAll", false}, \ diff --git a/src/V3Fork.cpp b/src/V3Fork.cpp index e5f636338..2e40faa24 100644 --- a/src/V3Fork.cpp +++ b/src/V3Fork.cpp @@ -597,6 +597,39 @@ class ForkVisitor final : public VNVisitor { // We did wrap the body return true; } + static bool isForkJoinNoneSentinelDelay(const AstNode* const nodep) { + const AstDelay* const delayp = VN_CAST(nodep, Delay); + if (!delayp) return false; + const AstConst* const constp = VN_CAST(delayp->lhsp(), Const); + return constp && (constp->toUQuad() == std::numeric_limits::max()); + } + static bool isDisableQueuePushSelfStmt(const AstNode* const nodep) { + // Detect LinkJump-generated registration: + // __VprocessQueue_*.push_back(std::process::self()) + const AstStmtExpr* const stmtExprp = VN_CAST(nodep, StmtExpr); + if (!stmtExprp) return false; + const AstCMethodHard* const methodp = VN_CAST(stmtExprp->exprp(), CMethodHard); + if (!methodp || methodp->name() != "push_back") return false; + const AstVarRef* const queueRefp = VN_CAST(methodp->fromp(), VarRef); + return queueRefp && queueRefp->name().rfind("__VprocessQueue_", 0) == 0; + } + static void moveForkSentinelAfterDisableQueuePushes(AstBegin* const beginp) { + AstNode* const firstStmtp = beginp->stmtsp(); + if (!isForkJoinNoneSentinelDelay(firstStmtp)) return; + + AstNode* insertBeforep = firstStmtp->nextp(); + while (insertBeforep && isDisableQueuePushSelfStmt(insertBeforep)) { + insertBeforep = insertBeforep->nextp(); + } + if (insertBeforep == firstStmtp->nextp()) return; + + AstNode* const delayp = firstStmtp->unlinkFrBack(); + if (insertBeforep) { + insertBeforep->addHereThisAsNext(delayp); + } else { + beginp->addStmtsp(delayp); + } + } // VISITORS void visit(AstNodeModule* nodep) override { @@ -634,6 +667,7 @@ class ForkVisitor final : public VNVisitor { new AstConst{fl, AstConst::Unsized64{}, std::numeric_limits::max()}, false}; itemp->stmtsp()->addHereThisAsNext(delayp); + moveForkSentinelAfterDisableQueuePushes(itemp); } } diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index 0fd82701e..a5c0870e6 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -37,6 +37,7 @@ #include "V3Error.h" #include "V3UniqueNames.h" +#include #include VL_DEFINE_DEBUG_FUNCTIONS; @@ -65,6 +66,12 @@ class LinkJumpVisitor final : public VNVisitor { std::vector m_blockStack; // All begin blocks above current node V3UniqueNames m_queueNames{ "__VprocessQueue"}; // Names for queues needed for 'disable' handling + std::unordered_map m_taskDisableQueues; // Per-task process queues + std::unordered_map m_beginDisableQueues; // Per-begin process queues + std::unordered_map + m_taskDisableBegins; // Per-task process wrappers + std::unordered_map + m_beginDisableBegins; // Per-begin process wrappers // METHODS // Get (and create if necessary) the JumpBlock for this statement @@ -177,6 +184,123 @@ class LinkJumpVisitor final : public VNVisitor { return new AstStmtExpr{ fl, new AstMethodCall{fl, queueRefp, "push_back", new AstArg{fl, "", processSelfp}}}; } + static AstStmtExpr* getQueuePushProcessSelfp(FileLine* const fl, AstVar* const processQueuep) { + AstPackage* const topPkgp = v3Global.rootp()->dollarUnitPkgAddp(); + AstVarRef* const queueWriteRefp + = new AstVarRef{fl, topPkgp, processQueuep, VAccess::WRITE}; + return getQueuePushProcessSelfp(queueWriteRefp); + } + static AstStmtExpr* getQueueKillStmtp(FileLine* const fl, AstVar* const processQueuep) { + AstPackage* const topPkgp = v3Global.rootp()->dollarUnitPkgAddp(); + AstClass* const processClassp + = VN_AS(getMemberp(v3Global.rootp()->stdPackagep(), "process"), Class); + AstVarRef* const queueRefp = new AstVarRef{fl, topPkgp, processQueuep, VAccess::READWRITE}; + AstTaskRef* const killQueueCall + = new AstTaskRef{fl, VN_AS(getMemberp(processClassp, "killQueue"), Task), + new AstArg{fl, "", queueRefp}}; + killQueueCall->classOrPackagep(processClassp); + return new AstStmtExpr{fl, killQueueCall}; + } + static void prependStmtsp(AstNodeFTask* const nodep, AstNode* const stmtp) { + if (AstNode* const origStmtsp = nodep->stmtsp()) { + origStmtsp->unlinkFrBackWithNext(); + stmtp->addNext(origStmtsp); + } + nodep->addStmtsp(stmtp); + } + static void prependStmtsp(AstNodeBlock* const nodep, AstNode* const stmtp) { + if (AstNode* const origStmtsp = nodep->stmtsp()) { + origStmtsp->unlinkFrBackWithNext(); + stmtp->addNext(origStmtsp); + } + nodep->addStmtsp(stmtp); + } + static bool directlyUnderFork(const AstNode* const nodep) { + if (nodep->backp()->nextp() == nodep) return directlyUnderFork(nodep->backp()); + return VN_IS(nodep->backp(), Fork); + } + AstBegin* getOrCreateTaskDisableBeginp(AstTask* const taskp, FileLine* const fl) { + const auto it = m_taskDisableBegins.find(taskp); + if (it != m_taskDisableBegins.end()) return it->second; + + AstBegin* const taskBodyp = new AstBegin{fl, "", nullptr, false}; + // Disable-by-name rewrites kill this detached task-body process, so mark it as process + // backed to ensure fork/join kill-accounting hooks are always emitted. + taskBodyp->setNeedProcess(); + if (taskp->stmtsp()) taskBodyp->addStmtsp(taskp->stmtsp()->unlinkFrBackWithNext()); + + AstFork* const forkp = new AstFork{fl, VJoinType::JOIN}; + forkp->addForksp(taskBodyp); + taskp->addStmtsp(forkp); + + m_taskDisableBegins.emplace(taskp, taskBodyp); + return taskBodyp; + } + AstVar* getOrCreateTaskDisableQueuep(AstTask* const taskp, FileLine* const fl) { + const auto it = m_taskDisableQueues.find(taskp); + if (it != m_taskDisableQueues.end()) return it->second; + + AstPackage* const topPkgp = v3Global.rootp()->dollarUnitPkgAddp(); + AstClass* const processClassp + = VN_AS(getMemberp(v3Global.rootp()->stdPackagep(), "process"), Class); + AstVar* const processQueuep = new AstVar{ + fl, VVarType::VAR, m_queueNames.get(taskp->name()), VFlagChildDType{}, + new AstQueueDType{fl, VFlagChildDType{}, + new AstClassRefDType{fl, processClassp, nullptr}, nullptr}}; + processQueuep->lifetime(VLifetime::STATIC_EXPLICIT); + topPkgp->addStmtsp(processQueuep); + + AstStmtExpr* const pushCurrentProcessp = getQueuePushProcessSelfp(fl, processQueuep); + AstBegin* const taskBodyp = getOrCreateTaskDisableBeginp(taskp, fl); + prependStmtsp(taskBodyp, pushCurrentProcessp); + m_taskDisableQueues.emplace(taskp, processQueuep); + return processQueuep; + } + AstBegin* getOrCreateBeginDisableBeginp(AstBegin* const beginp, FileLine* const fl) { + const auto it = m_beginDisableBegins.find(beginp); + if (it != m_beginDisableBegins.end()) return it->second; + + AstBegin* const beginBodyp = new AstBegin{fl, "", nullptr, false}; + if (beginp->stmtsp()) beginBodyp->addStmtsp(beginp->stmtsp()->unlinkFrBackWithNext()); + + AstFork* const forkp = new AstFork{fl, VJoinType::JOIN}; + forkp->addForksp(beginBodyp); + beginp->addStmtsp(forkp); + + m_beginDisableBegins.emplace(beginp, beginBodyp); + return beginBodyp; + } + AstVar* getOrCreateBeginDisableQueuep(AstBegin* const beginp, FileLine* const fl) { + const auto it = m_beginDisableQueues.find(beginp); + if (it != m_beginDisableQueues.end()) return it->second; + + AstPackage* const topPkgp = v3Global.rootp()->dollarUnitPkgAddp(); + AstClass* const processClassp + = VN_AS(getMemberp(v3Global.rootp()->stdPackagep(), "process"), Class); + AstVar* const processQueuep = new AstVar{ + fl, VVarType::VAR, m_queueNames.get(beginp->name()), VFlagChildDType{}, + new AstQueueDType{fl, VFlagChildDType{}, + new AstClassRefDType{fl, processClassp, nullptr}, nullptr}}; + processQueuep->lifetime(VLifetime::STATIC_EXPLICIT); + topPkgp->addStmtsp(processQueuep); + + AstStmtExpr* const pushCurrentProcessp = getQueuePushProcessSelfp(fl, processQueuep); + AstBegin* const beginBodyp = getOrCreateBeginDisableBeginp(beginp, fl); + prependStmtsp(beginBodyp, pushCurrentProcessp); + + // Named-block disable must also terminate detached descendants created by forks + // under the block, so track each fork branch process in the same queue. + beginBodyp->foreach([&](AstFork* const forkp) { + for (AstBegin* branchp = forkp->forksp(); branchp; + branchp = VN_AS(branchp->nextp(), Begin)) { + AstStmtExpr* const pushBranchProcessp + = getQueuePushProcessSelfp(fl, processQueuep); + prependStmtsp(branchp, pushBranchProcessp); + } + }); + m_beginDisableQueues.emplace(beginp, processQueuep); + return processQueuep; + } void handleDisableOnFork(AstDisable* const nodep, const std::vector& forks) { // The support utilizes the process::kill()` method. For each `disable` a queue of // processes is declared. At the beginning of each fork that can be disabled, its process @@ -210,17 +334,9 @@ class LinkJumpVisitor final : public VNVisitor { if (pushCurrentProcessp->backp()) { pushCurrentProcessp = pushCurrentProcessp->cloneTree(false); } - if (beginp->stmtsp()) { - // There is no need to add it to empty block - beginp->stmtsp()->addHereThisAsNext(pushCurrentProcessp); - } + prependStmtsp(beginp, pushCurrentProcessp); } - AstVarRef* const queueRefp = new AstVarRef{fl, topPkgp, processQueuep, VAccess::READWRITE}; - AstTaskRef* const killQueueCall - = new AstTaskRef{fl, VN_AS(getMemberp(processClassp, "killQueue"), Task), - new AstArg{fl, "", queueRefp}}; - killQueueCall->classOrPackagep(processClassp); - AstStmtExpr* const killStmtp = new AstStmtExpr{fl, killQueueCall}; + AstStmtExpr* const killStmtp = getQueueKillStmtp(fl, processQueuep); nodep->addNextHere(killStmtp); // 'process::kill' does not immediately kill the current process @@ -239,12 +355,6 @@ class LinkJumpVisitor final : public VNVisitor { } } } - static bool directlyUnderFork(const AstNode* const nodep) { - if (nodep->backp()->nextp() == nodep) return directlyUnderFork(nodep->backp()); - if (VN_IS(nodep->backp(), Fork)) return true; - return false; - } - // VISITORS void visit(AstNodeModule* nodep) override { if (nodep->dead()) return; @@ -417,9 +527,26 @@ class LinkJumpVisitor final : public VNVisitor { void visit(AstDisable* nodep) override { UINFO(8, " DISABLE " << nodep); AstNode* const targetp = nodep->targetp(); - UASSERT_OBJ(targetp, nodep, "Unlinked disable statement"); - if (VN_IS(targetp, Task)) { - nodep->v3warn(E_UNSUPPORTED, "Unsupported: disabling task by name"); + if (!targetp) { + // Linking errors on the disable target are already reported upstream. + // Drop this node to avoid cascading into an internal assertion. + VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep); + return; + } + if (AstTask* const taskp = VN_CAST(targetp, Task)) { + AstVar* const processQueuep = getOrCreateTaskDisableQueuep(taskp, nodep->fileline()); + AstStmtExpr* const killStmtp = getQueueKillStmtp(nodep->fileline(), processQueuep); + nodep->addNextHere(killStmtp); + + // process::kill does not terminate the currently running process immediately. + // If we disable the current task by name from inside itself, jump to its end. + if (m_ftaskp == taskp) { + AstNode* jumpTargetp = taskp; + const auto it = m_taskDisableBegins.find(taskp); + if (it != m_taskDisableBegins.end()) jumpTargetp = it->second; + AstJumpBlock* const blockp = getJumpBlock(jumpTargetp, false); + killStmtp->addNextHere(new AstJumpGo{nodep->fileline(), blockp}); + } } else if (AstFork* const forkp = VN_CAST(targetp, Fork)) { std::vector forks; for (AstBegin* itemp = forkp->forksp(); itemp; itemp = VN_AS(itemp->nextp(), Begin)) { @@ -428,22 +555,37 @@ class LinkJumpVisitor final : public VNVisitor { handleDisableOnFork(nodep, forks); } else if (AstBegin* const beginp = VN_CAST(targetp, Begin)) { if (existsBlockAbove(beginp->name())) { - if (beginp->user3()) { - nodep->v3warn(E_UNSUPPORTED, - "Unsupported: disabling block that contains a fork"); - } else { + if (!beginp->user3()) { // Jump to the end of the named block AstJumpBlock* const blockp = getJumpBlock(beginp, false); nodep->addNextHere(new AstJumpGo{nodep->fileline(), blockp}); + } else { + AstVar* const processQueuep + = getOrCreateBeginDisableQueuep(beginp, nodep->fileline()); + AstStmtExpr* const killStmtp + = getQueueKillStmtp(nodep->fileline(), processQueuep); + nodep->addNextHere(killStmtp); + + // process::kill does not terminate the currently running process immediately. + // If disable executes inside a fork branch of this named block, jump to the + // end of that branch to prevent statements after disable from executing. + AstBegin* currentBeginp = nullptr; + for (AstNodeBlock* const blockp : vlstd::reverse_view(m_blockStack)) { + if (VN_IS(blockp, Begin)) { + currentBeginp = VN_AS(blockp, Begin); + break; + } + } + if (currentBeginp && directlyUnderFork(currentBeginp)) { + AstJumpBlock* const blockp = getJumpBlock(currentBeginp, false); + killStmtp->addNextHere(new AstJumpGo{nodep->fileline(), blockp}); + } } } else { - if (directlyUnderFork(beginp)) { - std::vector forks{beginp}; - handleDisableOnFork(nodep, forks); - } else { - nodep->v3warn(E_UNSUPPORTED, "disable isn't underneath a begin with name: '" - << beginp->name() << "'"); - } + AstVar* const processQueuep + = getOrCreateBeginDisableQueuep(beginp, nodep->fileline()); + AstStmtExpr* const killStmtp = getQueueKillStmtp(nodep->fileline(), processQueuep); + nodep->addNextHere(killStmtp); } } else { nodep->v3fatalSrc("Disable linked with node of unhandled type " diff --git a/src/V3Timing.cpp b/src/V3Timing.cpp index b3eac4afb..316a9c642 100644 --- a/src/V3Timing.cpp +++ b/src/V3Timing.cpp @@ -742,6 +742,34 @@ class TimingControlVisitor final : public VNVisitor { addDebugInfo(donep); beginp->addStmtsp(donep->makeStmt()); } + static bool hasDisableQueuePushSelfPrefix(const AstBegin* const beginp) { + // LinkJump prepends disable-by-name registration as: + // __VprocessQueue_*.push_back(std::process::self()) + const AstStmtExpr* const stmtExprp = VN_CAST(beginp->stmtsp(), StmtExpr); + if (!stmtExprp) return false; + const AstCMethodHard* const methodp = VN_CAST(stmtExprp->exprp(), CMethodHard); + if (!methodp || methodp->name() != "push_back") return false; + const AstVarRef* const queueRefp = VN_CAST(methodp->fromp(), VarRef); + return queueRefp && queueRefp->name().rfind("__VprocessQueue_", 0) == 0; + } + // Register a callback so killing a process-backed fork branch decrements the join counter + void addForkOnKill(AstBegin* const beginp, AstVarScope* const forkVscp) const { + if (!beginp->needProcess() && !hasDisableQueuePushSelfPrefix(beginp)) return; + FileLine* const flp = beginp->fileline(); + AstCMethodHard* const onKillp = new AstCMethodHard{ + flp, new AstVarRef{flp, forkVscp, VAccess::WRITE}, VCMethod::FORK_ON_KILL}; + onKillp->dtypeSetVoid(); + AstCExpr* const processp = new AstCExpr{flp, "vlProcess"}; + processp + ->dtypeSetVoid(); // Opaque process reference; type is irrelevant for hardcoded emit + onKillp->addPinsp(processp); + AstNodeStmt* const stmtp = onKillp->makeStmt(); + if (beginp->stmtsp()) { + beginp->stmtsp()->addHereThisAsNext(stmtp); + } else { + beginp->addStmtsp(stmtp); + } + } // Handle the 'join' part of a fork..join void makeForkJoin(AstFork* const forkp) { // Create a fork sync var @@ -754,6 +782,7 @@ class TimingControlVisitor final : public VNVisitor { unsigned joinCount = 0; // Needed for join counter // Add a .done() to each begin for (AstNode* beginp = forkp->forksp(); beginp; beginp = beginp->nextp()) { + addForkOnKill(VN_AS(beginp, Begin), forkVscp); addForkDone(VN_AS(beginp, Begin), forkVscp); joinCount++; } diff --git a/test_regress/t/t_disable.out b/test_regress/t/t_disable.out deleted file mode 100644 index e3b1a7498..000000000 --- a/test_regress/t/t_disable.out +++ /dev/null @@ -1,5 +0,0 @@ -%Error-UNSUPPORTED: t/t_disable.v:17:9: Unsupported: disabling block that contains a fork - 17 | disable forked; - | ^~~~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error: Exiting due to diff --git a/test_regress/t/t_disable.py b/test_regress/t/t_disable.py index c7d9b21a5..276645160 100755 --- a/test_regress/t/t_disable.py +++ b/test_regress/t/t_disable.py @@ -9,8 +9,10 @@ import vltest_bootstrap -test.scenarios('linter') +test.scenarios('simulator') -test.lint(fails=True, expect_filename=test.golden_filename) +test.compile(timing_loop=True, verilator_flags2=["--timing"]) + +test.execute() test.passes() diff --git a/test_regress/t/t_disable_bad.out b/test_regress/t/t_disable_bad.out index d708f635c..90b807ff6 100644 --- a/test_regress/t/t_disable_bad.out +++ b/test_regress/t/t_disable_bad.out @@ -2,7 +2,4 @@ 9 | disable abcd; | ^~~~ ... See the manual at https://verilator.org/verilator_doc.html?v=latest for more assistance. -%Error: Internal Error: t/t_disable_bad.v:9:5: ../V3LinkJump.cpp:#: Unlinked disable statement - 9 | disable abcd; - | ^~~~~~~ - ... This fatal error may be caused by the earlier error(s); resolve those first. +%Error: Exiting due to diff --git a/test_regress/t/t_disable_empty.out b/test_regress/t/t_disable_empty.out deleted file mode 100644 index 584a6d714..000000000 --- a/test_regress/t/t_disable_empty.out +++ /dev/null @@ -1,5 +0,0 @@ -%Error-UNSUPPORTED: t/t_disable_empty.v:12:5: disable isn't underneath a begin with name: 'block' - 12 | disable block; - | ^~~~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error: Exiting due to diff --git a/test_regress/t/t_disable_empty.py b/test_regress/t/t_disable_empty.py index 382ad0d44..7ded63f3a 100755 --- a/test_regress/t/t_disable_empty.py +++ b/test_regress/t/t_disable_empty.py @@ -11,6 +11,8 @@ import vltest_bootstrap test.scenarios('simulator') -test.lint(fails=True, expect_filename=test.golden_filename) +test.compile(verilator_flags2=["--binary"]) + +test.execute() test.passes() diff --git a/test_regress/t/t_disable_task_by_name.py b/test_regress/t/t_disable_task_by_name.py new file mode 100755 index 000000000..390bba1b8 --- /dev/null +++ b/test_regress/t/t_disable_task_by_name.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python3 +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of either the GNU Lesser General Public License Version 3 +# or the Perl Artistic License Version 2.0. +# SPDX-FileCopyrightText: 2026 Wilson Snyder +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +import vltest_bootstrap + +test.scenarios('simulator') + +test.compile(timing_loop=True, verilator_flags2=["--timing"]) + +test.execute() + +test.passes() diff --git a/test_regress/t/t_disable_task_by_name.v b/test_regress/t/t_disable_task_by_name.v new file mode 100644 index 000000000..2cefedeae --- /dev/null +++ b/test_regress/t/t_disable_task_by_name.v @@ -0,0 +1,436 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This program is free software; you can redistribute it and/or modify it +// under the terms of either the GNU Lesser General Public License Version 3 +// or the Perl Artistic License Version 2.0. +// SPDX-FileCopyrightText: 2026 Wilson Snyder +// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +int x = 0; +int y = 0; +int z = 0; +int always_value = 0; + +int self_entry = 0; +int self_after_disable = 0; + +int par_started = 0; +int par_finished = 0; +int par_parent_continued = 0; +int named_block_fork_fail = 0; +int task_named_block_fork_fail = 0; +event named_block_fork_ev; +event task_named_block_fork_ev; + +class StaticCls; + static int ticks = 0; + + static task run(); + forever begin + #10; + ticks++; + end + endtask + + static task stop(); + disable run; + endtask +endclass + +task increment_x; + x++; + #2; + x++; +endtask + +task increment_y; + y++; + #5; + y++; +endtask + +task finish_z; + z++; +endtask + +task always_foo; + always_value = #2 1; +endtask + +task self_stop; + self_entry = 1; + disable self_stop; + self_after_disable = 1; +endtask + +task worker; + par_started++; + #20; + par_finished++; +endtask + +task parent_disables_worker; + fork + worker(); + worker(); + join_none + #5; + disable worker; + par_parent_continued = 1; +endtask + +task task_named_block_fork_disable; + begin : t_named_block + fork + begin + #5; + task_named_block_fork_fail = 1; + end + begin + @task_named_block_fork_ev; + disable t_named_block; + task_named_block_fork_fail = 2; + end + join + task_named_block_fork_fail = 3; + end +endtask + +class Cls; + int m_time = 0; + + task get_and_send(); + forever begin + #10; + m_time += 10; + end + endtask + + task post_shutdown_phase(); + disable get_and_send; + endtask +endclass + +class NamedA; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask + + task stop(); + disable run; + endtask +endclass + +class NamedB; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask +endclass + +class BaseNamed; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask +endclass + +class ChildNamed extends BaseNamed; + int child_v = 0; + + task run(); + forever begin + #10; + child_v++; + end + endtask + + task stop(); + disable run; + endtask +endclass + +package PkgRun; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask + + task stop(); + disable run; + endtask +endpackage + +interface Ifc; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask + + task stop(); + disable run; + endtask +endinterface + +program Prog; + int v = 0; + + task run(); + forever begin + #10; + v++; + end + endtask + + task stop(); + disable run; + endtask +endprogram + +module WorkerMod; + int m = 0; + + task run(); + forever begin + #10; + m++; + end + endtask +endmodule + +module t; + Ifc ifc1(); + Prog prog1(); + WorkerMod mod1(); + + always #6 disable always_foo; + + initial begin + automatic Cls c = new; + automatic NamedA a = new; + automatic NamedB b = new; + automatic BaseNamed base_obj = new; + automatic ChildNamed child_obj = new; + int m_time_before_shutdown; + int mod1_before; + int a_before; + int b_before; + int static_before; + int base_before; + int child_before; + int ifc_before; + int prog_before; + int pkg_before; + + // Disable task by name from an external always block while task executes + always_value = 0; + #5; + always_foo; + #4; + if (always_value != 0) $stop; + + // Module task disabled by sibling process in a fork + fork + increment_x(); + #1 disable increment_x; + join_none + #10; + if (x != 1) $stop; + // Re-disabling after prior disable (no active invocations) is a no-op + disable increment_x; + #1; + if (x != 1) $stop; + + // Another basic module-task disable-by-name case + fork + increment_y(); + #3 disable increment_y; + join_none + #10; + if (y != 1) $stop; + + // Disable named block containing fork from inside a fork branch + fork + begin : named_block_under_test + fork + begin + #5; + named_block_fork_fail = 1; + end + begin + @named_block_fork_ev; + disable named_block_under_test; + named_block_fork_fail = 2; + end + join + named_block_fork_fail = 3; + end + join_none + #2; + ->named_block_fork_ev; + #10; + if (named_block_fork_fail != 0) $stop; + + // Same case as above, but with the named block inside a task + fork + task_named_block_fork_disable(); + join_none + #2; + ->task_named_block_fork_ev; + #10; + if (task_named_block_fork_fail != 0) $stop; + + // Disabling a task after it already finished is a no-op + finish_z(); + if (z != 1) $stop; + disable finish_z; + #1; + if (z != 1) $stop; + + // Self-disable in task by name + self_stop(); + if (self_entry != 1) $stop; + if (self_after_disable != 0) $stop; + + // Same task launched in parallel, disabled from parent task context + parent_disables_worker(); + #30; + if (par_started != 2) $stop; + if (par_finished != 0) $stop; + if (par_parent_continued != 1) $stop; + + // Same task launched in parallel, disabled from sibling process context + par_started = 0; + par_finished = 0; + fork + worker(); + worker(); + begin + #5; + disable worker; + end + join_none + #30; + if (par_started != 2) $stop; + if (par_finished != 0) $stop; + + // Static class task disabled by name from another static task + fork + StaticCls::run(); + StaticCls::run(); + join_none + #25; + if (StaticCls::ticks == 0) $stop; + static_before = StaticCls::ticks; + StaticCls::stop(); + #30; + if (StaticCls::ticks != static_before) $stop; + + // Same task name in different class scopes: disable only one scope + fork + a.run(); + b.run(); + join_none + #25; + if (a.v == 0 || b.v == 0) $stop; + a_before = a.v; + b_before = b.v; + a.stop(); + #30; + if (a.v != a_before) $stop; + if (b.v <= b_before) $stop; + + // Same task name across inheritance scopes: disable only derived task + fork + base_obj.run(); + child_obj.run(); + join_none + #25; + if (base_obj.v == 0 || child_obj.child_v == 0) $stop; + base_before = base_obj.v; + child_before = child_obj.child_v; + child_obj.stop(); + #30; + if (child_obj.child_v != child_before) $stop; + if (base_obj.v <= base_before) $stop; + + // Interface task disabled by name through interface scope + fork + ifc1.run(); + join_none + #25; + if (ifc1.v == 0) $stop; + ifc_before = ifc1.v; + ifc1.stop(); + #30; + if (ifc1.v != ifc_before) $stop; + + // Program task disabled by name through program scope + fork + prog1.run(); + join_none + #25; + if (prog1.v == 0) $stop; + prog_before = prog1.v; + prog1.stop(); + #30; + if (prog1.v != prog_before) $stop; + + // Package task disabled by name through package scope + fork + PkgRun::run(); + join_none + #25; + if (PkgRun::v == 0) $stop; + pkg_before = PkgRun::v; + PkgRun::stop(); + #30; + if (PkgRun::v != pkg_before) $stop; + + // Dotted hierarchical task disable of module task by instance path + fork + mod1.run(); + join_none + #25; + if (mod1.m == 0) $stop; + mod1_before = mod1.m; + disable mod1.run; + #30; + if (mod1.m != mod1_before) $stop; + + // Class task disabled by name from outside that task + fork + c.get_and_send(); + join_none + #35; + if (c.m_time == 0) $fatal; + m_time_before_shutdown = c.m_time; + c.post_shutdown_phase(); + #30; + if (c.m_time != m_time_before_shutdown) $fatal; + + $write("*-* All Finished *-*\n"); + $finish; + end +endmodule diff --git a/test_regress/t/t_disable_task_join.py b/test_regress/t/t_disable_task_join.py new file mode 100755 index 000000000..55da782f9 --- /dev/null +++ b/test_regress/t/t_disable_task_join.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python3 +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of either the GNU Lesser General Public License Version 3 +# or the Perl Artistic License Version 2.0. +# SPDX-FileCopyrightText: 2024-2026 Wilson Snyder +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +import vltest_bootstrap + +test.scenarios('simulator') + +test.compile(timing_loop=True, verilator_flags2=["--timing"]) + +test.execute() + +test.passes() diff --git a/test_regress/t/t_disable_task_join.v b/test_regress/t/t_disable_task_join.v new file mode 100644 index 000000000..a57571722 --- /dev/null +++ b/test_regress/t/t_disable_task_join.v @@ -0,0 +1,237 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This file ONLY is placed under the Creative Commons Public Domain +// SPDX-FileCopyrightText: 2025 Antmicro +// SPDX-License-Identifier: CC0-1.0 + +int x = 0; +int y = 0; +int z = 0; +int w = 0; +int jf = 0; +int ddj = 0; +int ddja = 0; +int ddjn = 0; +int dj_done = 0; +int dja_done = 0; +int djn_done = 0; +int race_disable = 0; + +task increment_x; + x++; + #2; + x++; +endtask + +task increment_y; + y++; + #2; + y++; +endtask + +class driver; + int m_time = 0; + + task get_and_send(); + forever begin + #10; + m_time += 10; + end + endtask + + task post_shutdown_phase(); + disable get_and_send; + endtask +endclass + +module t; + + driver c; + task automatic progress(input string label); + $display("DBG:t_disable_task_join:%s t=%0t x=%0d y=%0d z=%0d w=%0d m_time=%0d", + label, $time, x, y, z, w, (c == null) ? -1 : c.m_time); + endtask + + initial begin + progress("start"); + fork + increment_x(); + #1 disable increment_x; + join + + if (x != 1) $fatal(1, "x=%0d expected 1", x); + + c = new; + fork + c.get_and_send; + join_none + if (c.m_time != 0) $fatal(1, "c.m_time=%0d expected 0 before first delay", c.m_time); + + #11; + if ($time != 12) $fatal(1, "$time=%0t expected 12", $time); + if (c.m_time != 10) $fatal(1, "c.m_time=%0d expected 10 after 11 ticks", c.m_time); + + #20; + if ($time != 32) $fatal(1, "$time=%0t expected 32", $time); + if (c.m_time != 30) $fatal(1, "c.m_time=%0d expected 30 before disable", c.m_time); + c.post_shutdown_phase; + + #20; + if ($time != 52) $fatal(1, "$time=%0t expected 52", $time); + if (c.m_time != 30) $fatal(1, "c.m_time=%0d expected 30 after disable", c.m_time); + progress("after_class_task_disable"); + + // Additional regression: join_any should also complete when disable kills a forked task + fork + increment_y(); + #1 disable increment_y; + join_any + #3; + if (y != 1) $fatal(1, "y=%0d expected 1", y); + progress("after_join_any_task_disable"); + + // Additional regression: named-block disable with join + fork + begin : worker_join + z++; + #2; + z++; + end + #1 disable worker_join; + join + if (z != 1) $fatal(1, "z=%0d expected 1", z); + progress("after_named_block_join_disable"); + + // Additional regression: named-block disable with join_any + fork + begin : worker_join_any + w++; + #2; + w++; + end + #1 disable worker_join_any; + join_any + #3; + if (w != 1) $fatal(1, "w=%0d expected 1", w); + progress("after_named_block_join_any_disable"); + + // disable fork from inside a join_any branch + fork + begin + fork + begin + #1; + jf = 1; + end + begin + #5; + jf = 99; + end + join_none + #2; + disable fork; + end + begin + #3; + end + join_any + #6; + if (jf != 1) $fatal(1, "jf=%0d expected 1", jf); + progress("after_disable_fork"); + + // multiple sequential disables of the same target under join + fork + begin : twice_join + #5; + ddj = 99; + end + begin + #1 disable twice_join; + #1 disable twice_join; + end + join + if (ddj != 0) $fatal(1, "ddj=%0d expected 0", ddj); + + // multiple sequential disables of the same target under join_any + fork + begin : twice_join_any + #5; + ddja = 99; + end + begin + #1 disable twice_join_any; + #1 disable twice_join_any; + end + join_any + #6; + if (ddja != 0) $fatal(1, "ddja=%0d expected 0", ddja); + + // multiple sequential disables of the same target under join_none + begin + fork + begin : twice_join_none + #5; + ddjn = 99; + end + join_none + #1 disable twice_join_none; + #1 disable twice_join_none; + #6; + end + if (ddjn != 0) $fatal(1, "ddjn=%0d expected 0", ddjn); + + // disable after target is already finished (join) + fork + begin : done_join + #1; + dj_done = 1; + end + join + disable done_join; + if (dj_done != 1) $fatal(1, "dj_done=%0d expected 1", dj_done); + + // disable after target is already finished (join_any) + fork + begin : done_join_any + #1; + dja_done = 1; + end + #2; + join_any + #2; + disable done_join_any; + if (dja_done != 1) $fatal(1, "dja_done=%0d expected 1", dja_done); + + // disable after target is already finished (join_none) + begin + fork + begin : done_join_none + #1; + djn_done = 1; + end + join_none + #2; + disable done_join_none; + #1; + end + if (djn_done != 1) $fatal(1, "djn_done=%0d expected 1", djn_done); + + // competing disables in the same time slot targeting the same block + fork + begin : race_target + #5; + race_disable = 99; + end + #1 disable race_target; + #1 disable race_target; + join + if (race_disable != 0) $fatal(1, "race_disable=%0d expected 0", race_disable); + progress("after_race_disable"); + + progress("before_finish"); + + $write("*-* All Finished *-*\n"); + $finish; + end + +endmodule diff --git a/test_regress/t/t_disable_task_scope_bad.out b/test_regress/t/t_disable_task_scope_bad.out new file mode 100644 index 000000000..48b3881fc --- /dev/null +++ b/test_regress/t/t_disable_task_scope_bad.out @@ -0,0 +1,20 @@ +%Error: t/t_disable_task_scope_bad.v:36:18: Can't find definition of 'missing_task' in dotted block/task: 'ifc1.missing_task' + 36 | disable ifc1.missing_task; + | ^~~~~~~~~~~~ + ... Known scopes under 'ifc1': + ... See the manual at https://verilator.org/verilator_doc.html?v=latest for more assistance. +%Error: t/t_disable_task_scope_bad.v:37:19: Can't find definition of 'missing_task' in dotted block/task: 'prog1.missing_task' + 37 | disable prog1.missing_task; + | ^~~~~~~~~~~~ + ... Known scopes under 'prog1': +%Error: t/t_disable_task_scope_bad.v:38:26: Can't find definition of 'missing_task' in dotted block/task: 'outer1.inner.missing_task' + 38 | disable outer1.inner.missing_task; + | ^~~~~~~~~~~~ + ... Known scopes under 'outer1.inner': +%Error: t/t_disable_task_scope_bad.v:39:18: Found definition of 'ifc1.data' as a VAR but expected a block/task + 39 | disable ifc1.data; + | ^~~~ +%Error: t/t_disable_task_scope_bad.v:40:19: Found definition of 'prog1.data' as a VAR but expected a block/task + 40 | disable prog1.data; + | ^~~~ +%Error: Exiting due to diff --git a/test_regress/t/t_disable_task_scope_bad.py b/test_regress/t/t_disable_task_scope_bad.py new file mode 100755 index 000000000..bc540caa3 --- /dev/null +++ b/test_regress/t/t_disable_task_scope_bad.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +# DESCRIPTION: Verilator: Verilog Test driver/expect definition +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of either the GNU Lesser General Public License Version 3 +# or the Perl Artistic License Version 2.0. +# SPDX-FileCopyrightText: 2024-2026 Wilson Snyder +# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +import vltest_bootstrap + +test.scenarios('linter') + +test.lint(fails=True, expect_filename=test.golden_filename) + +test.passes() diff --git a/test_regress/t/t_disable_task_scope_bad.v b/test_regress/t/t_disable_task_scope_bad.v new file mode 100644 index 000000000..8afd8b52c --- /dev/null +++ b/test_regress/t/t_disable_task_scope_bad.v @@ -0,0 +1,42 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This program is free software; you can redistribute it and/or modify it +// under the terms of either the GNU Lesser General Public License Version 3 +// or the Perl Artistic License Version 2.0. +// SPDX-FileCopyrightText: 2026 Wilson Snyder +// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +interface Ifc; + task run; + endtask + int data = 0; +endinterface + +program Prog; + task run; + endtask + int data = 0; +endprogram + +module Inner; + task run; + endtask +endmodule + +module Outer; + Inner inner(); +endmodule + +module t; + Ifc ifc1(); + Prog prog1(); + Outer outer1(); + + initial begin + disable ifc1.missing_task; + disable prog1.missing_task; + disable outer1.inner.missing_task; + disable ifc1.data; + disable prog1.data; + end +endmodule diff --git a/test_regress/t/t_disable_task_target_bad.out b/test_regress/t/t_disable_task_target_bad.out new file mode 100644 index 000000000..8d14a77c3 --- /dev/null +++ b/test_regress/t/t_disable_task_target_bad.out @@ -0,0 +1,11 @@ +%Error: t/t_disable_task_target_bad.v:23:13: Found definition of 'foo' as a VAR but expected a block/task + 23 | disable foo; + | ^~~ + ... See the manual at https://verilator.org/verilator_doc.html?v=latest for more assistance. +%Error: t/t_disable_task_target_bad.v:24:13: Found definition of 'c' as a VAR but expected a block/task + 24 | disable c.run; + | ^ +%Error: t/t_disable_task_target_bad.v:24:15: Can't find definition of block/task: 'run' + 24 | disable c.run; + | ^~~ +%Error: Exiting due to diff --git a/test_regress/t/t_disable_task_unsup.py b/test_regress/t/t_disable_task_target_bad.py similarity index 85% rename from test_regress/t/t_disable_task_unsup.py rename to test_regress/t/t_disable_task_target_bad.py index 382ad0d44..38cf36b43 100755 --- a/test_regress/t/t_disable_task_unsup.py +++ b/test_regress/t/t_disable_task_target_bad.py @@ -4,12 +4,12 @@ # This program is free software; you can redistribute it and/or modify it # under the terms of either the GNU Lesser General Public License Version 3 # or the Perl Artistic License Version 2.0. -# SPDX-FileCopyrightText: 2024 Wilson Snyder +# SPDX-FileCopyrightText: 2026 Wilson Snyder # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 import vltest_bootstrap -test.scenarios('simulator') +test.scenarios('linter') test.lint(fails=True, expect_filename=test.golden_filename) diff --git a/test_regress/t/t_disable_task_target_bad.v b/test_regress/t/t_disable_task_target_bad.v new file mode 100644 index 000000000..50116fff5 --- /dev/null +++ b/test_regress/t/t_disable_task_target_bad.v @@ -0,0 +1,26 @@ +// DESCRIPTION: Verilator: Verilog Test module +// +// This program is free software; you can redistribute it and/or modify it +// under the terms of either the GNU Lesser General Public License Version 3 +// or the Perl Artistic License Version 2.0. +// SPDX-FileCopyrightText: 2026 Wilson Snyder +// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 + +class Cls; + task run; + endtask +endclass + +module t; + task foo; + endtask + + Cls c; + + initial begin + int foo; + c = new; + disable foo; + disable c.run; + end +endmodule diff --git a/test_regress/t/t_disable_task_unsup.out b/test_regress/t/t_disable_task_unsup.out deleted file mode 100644 index 024eadd80..000000000 --- a/test_regress/t/t_disable_task_unsup.out +++ /dev/null @@ -1,8 +0,0 @@ -%Error-UNSUPPORTED: t/t_disable_task_unsup.v:37:10: Unsupported: disabling task by name - 37 | #1 disable increment_x; - | ^~~~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest -%Error-UNSUPPORTED: t/t_disable_task_unsup.v:26:5: Unsupported: disabling task by name - 26 | disable get_and_send; - | ^~~~~~~ -%Error: Exiting due to diff --git a/test_regress/t/t_disable_task_unsup.v b/test_regress/t/t_disable_task_unsup.v deleted file mode 100644 index 6331ba64f..000000000 --- a/test_regress/t/t_disable_task_unsup.v +++ /dev/null @@ -1,65 +0,0 @@ -// DESCRIPTION: Verilator: Verilog Test module -// -// This file ONLY is placed under the Creative Commons Public Domain -// SPDX-FileCopyrightText: 2025 Antmicro -// SPDX-License-Identifier: CC0-1.0 - -int x = 0; - -task increment_x; - x++; - #2; - x++; -endtask - -class driver; - int m_time = 0; - - task get_and_send(); - forever begin - #10; - m_time += 10; - end - endtask - - task post_shutdown_phase(); - disable get_and_send; - endtask -endclass - -module t; - - driver c; - - initial begin - fork - increment_x(); - #1 disable increment_x; - join - - if (x != 1) $stop; - - c = new; - fork - c.get_and_send; - join_none - if (c.m_time != 0) $stop; - - #11; - if ($time != 12) $stop; - if (c.m_time != 10) $stop; - - #20; - if ($time != 32) $stop; - if (c.m_time != 30) $stop; - c.post_shutdown_phase; - - #20; - if ($time != 52) $stop; - if (c.m_time != 30) $stop; - - $write("*-* All Finished *-*\n"); - $finish; - end - -endmodule diff --git a/test_regress/t/t_func_return_bad.out b/test_regress/t/t_func_return_bad.out index ca4146501..8c64e4045 100644 --- a/test_regress/t/t_func_return_bad.out +++ b/test_regress/t/t_func_return_bad.out @@ -14,8 +14,4 @@ %Error: t/t_func_return_bad.v:19:5: break isn't underneath a loop 19 | break; | ^~~~~ -%Error-UNSUPPORTED: t/t_func_return_bad.v:22:5: disable isn't underneath a begin with name: 'foo' - 22 | disable foo; - | ^~~~~~~ - ... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest %Error: Exiting due to