mirror of
https://github.com/verilator/verilator.git
synced 2025-01-01 04:07:34 +00:00
Support assertcontrol directive type (#5310)
Signed-off-by: Bartłomiej Chmiel <bchmiel@antmicro.com>
This commit is contained in:
Bartłomiej Chmiel
GitHub
parent
6fa1ade4e0
commit
7d5e19365e
@ -2504,24 +2504,47 @@ VerilatedContext::Serialized::Serialized() {
|
||||
m_timeprecision = picosecond; // Initial value until overridden by _Vconfigure
|
||||
}
|
||||
|
||||
bool VerilatedContext::assertOn() const VL_MT_SAFE {
|
||||
const VerilatedLockGuard lock{m_mutex};
|
||||
return m_s.m_assertOn;
|
||||
}
|
||||
bool VerilatedContext::assertOn() const VL_MT_SAFE { return m_s.m_assertOn; }
|
||||
void VerilatedContext::assertOn(bool flag) VL_MT_SAFE {
|
||||
const VerilatedLockGuard lock{m_mutex};
|
||||
// set all assert types to 'on' when true, set all types to 'off' when false
|
||||
m_s.m_assertOn = std::numeric_limits<VerilatedAssertType_t>::max()
|
||||
* static_cast<VerilatedAssertType_t>(flag);
|
||||
// Set all assert and directive types when true, clear otherwise.
|
||||
m_s.m_assertOn = VL_MASK_I(ASSERT_ON_WIDTH) * flag;
|
||||
}
|
||||
bool VerilatedContext::assertOnGet(VerilatedAssertType_t flags) const VL_MT_SAFE {
|
||||
return m_s.m_assertOn & flags;
|
||||
bool VerilatedContext::assertOnGet(VerilatedAssertType_t type,
|
||||
VerilatedAssertDirectiveType_t directive) const VL_MT_SAFE {
|
||||
// Check if selected directive type bit in the assertOn is enabled for assertion type.
|
||||
// Note: it is assumed that this is checked only for one type at the time.
|
||||
|
||||
// Flag unspecified assertion types as disabled.
|
||||
if (type == 0) return false;
|
||||
|
||||
// Get index of 3-bit group guarding assertion type status.
|
||||
// Since the assertOnGet is generated __always__ for a single assert type, we assume that only
|
||||
// a single bit will be set. Thus, ceil log2 will work fine.
|
||||
VL_DEBUG_IFDEF(assert((type & (type - 1)) == 0););
|
||||
const IData typeMaskPosition = VL_CLOG2_I(type);
|
||||
|
||||
// Check if directive type bit is enabled in corresponding assertion type bits.
|
||||
return m_s.m_assertOn & (directive << (typeMaskPosition * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH));
|
||||
}
|
||||
void VerilatedContext::assertOnSet(VerilatedAssertType_t flags) VL_MT_SAFE {
|
||||
m_s.m_assertOn |= flags;
|
||||
void VerilatedContext::assertOnSet(VerilatedAssertType_t types,
|
||||
VerilatedAssertDirectiveType_t directives) VL_MT_SAFE {
|
||||
// For each assertion type, set directive bits.
|
||||
|
||||
// Iterate through all positions of assertion type bits. If bit for this assertion type is set,
|
||||
// set directive type bits mask at this group index.
|
||||
for (int i = 0; i < std::numeric_limits<VerilatedAssertType_t>::digits; ++i) {
|
||||
if (VL_BITISSET_I(types, i))
|
||||
m_s.m_assertOn |= directives << (i * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH);
|
||||
}
|
||||
}
|
||||
void VerilatedContext::assertOnClear(VerilatedAssertType_t flags) VL_MT_SAFE {
|
||||
m_s.m_assertOn &= flags;
|
||||
void VerilatedContext::assertOnClear(VerilatedAssertType_t types,
|
||||
VerilatedAssertDirectiveType_t directives) VL_MT_SAFE {
|
||||
// Iterate through all positions of assertion type bits. If bit for this assertion type is set,
|
||||
// clear directive type bits mask at this group index.
|
||||
for (int i = 0; i < std::numeric_limits<VerilatedAssertType_t>::digits; ++i) {
|
||||
if (VL_BITISSET_I(types, i))
|
||||
m_s.m_assertOn &= ~(directives << (i * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH));
|
||||
}
|
||||
}
|
||||
void VerilatedContext::calcUnusedSigs(bool flag) VL_MT_SAFE {
|
||||
const VerilatedLockGuard lock{m_mutex};
|
||||
|
||||
@ -165,7 +165,15 @@ enum class VerilatedAssertType : uint8_t {
|
||||
ASSERT_TYPE_UNIQUE0 = (1 << 6),
|
||||
ASSERT_TYPE_PRIORITY = (1 << 7),
|
||||
};
|
||||
|
||||
// IEEE 1800-2023 Table 20-7
|
||||
enum class VerilatedAssertDirectiveType : uint8_t {
|
||||
DIRECTIVE_TYPE_ASSERT = (1 << 0),
|
||||
DIRECTIVE_TYPE_COVER = (1 << 1),
|
||||
DIRECTIVE_TYPE_ASSUME = (1 << 2),
|
||||
};
|
||||
using VerilatedAssertType_t = std::underlying_type<VerilatedAssertType>::type;
|
||||
using VerilatedAssertDirectiveType_t = std::underlying_type<VerilatedAssertDirectiveType>::type;
|
||||
|
||||
//=============================================================================
|
||||
// Utility functions
|
||||
@ -361,6 +369,19 @@ public:
|
||||
class VerilatedContext VL_NOT_FINAL {
|
||||
friend class VerilatedContextImp;
|
||||
|
||||
private:
|
||||
// MEMBERS
|
||||
// Numer of assertion directive type members. Then each of them will represented as 1-bit in a
|
||||
// mask.
|
||||
static constexpr size_t ASSERT_DIRECTIVE_TYPE_MASK_WIDTH = 3;
|
||||
// Specifies how many groups of directive type bit groups there are based on a number of
|
||||
// assertion types.
|
||||
// Note: we add one bit to store information whether Verilator's internal
|
||||
// directive types are enabled, for example `violation if`s.
|
||||
static constexpr size_t ASSERT_ON_WIDTH
|
||||
= ASSERT_DIRECTIVE_TYPE_MASK_WIDTH * std::numeric_limits<VerilatedAssertType_t>::digits
|
||||
+ 1;
|
||||
|
||||
protected:
|
||||
// TYPES
|
||||
using traceBaseModelCb_t
|
||||
@ -374,8 +395,11 @@ protected:
|
||||
// No std::strings or pointers or will serialize badly!
|
||||
// Fast path
|
||||
uint64_t m_time = 0; // Current $time (unscaled), 0=at zero, or legacy
|
||||
std::atomic<VerilatedAssertType_t> m_assertOn{
|
||||
std::numeric_limits<VerilatedAssertType_t>::max()}; // Enabled assertion types
|
||||
std::atomic<uint32_t> m_assertOn{
|
||||
std::numeric_limits<uint32_t>::max()}; // Enabled assertions,
|
||||
// for each VerilatedAssertType we store
|
||||
// 3-bits, one for each directive type. Last
|
||||
// bit guards internal directive types.
|
||||
bool m_calcUnusedSigs = false; // Waves file on, need all signals calculated
|
||||
bool m_fatalOnError = true; // Fatal on $stop/non-fatal error
|
||||
bool m_fatalOnVpiError = true; // Fatal on vpi error/unsupported
|
||||
@ -468,11 +492,14 @@ public:
|
||||
/// Enable all assertion types
|
||||
void assertOn(bool flag) VL_MT_SAFE;
|
||||
/// Get enabled status for given assertion types
|
||||
bool assertOnGet(VerilatedAssertType_t flags) const VL_MT_SAFE;
|
||||
bool assertOnGet(VerilatedAssertType_t type,
|
||||
VerilatedAssertDirectiveType_t directive) const VL_MT_SAFE;
|
||||
/// Set enabled status for given assertion types
|
||||
void assertOnSet(VerilatedAssertType_t flags) VL_MT_SAFE;
|
||||
void assertOnSet(VerilatedAssertType_t types,
|
||||
VerilatedAssertDirectiveType_t directives) VL_MT_SAFE;
|
||||
/// Clear enabled status for given assertion types
|
||||
void assertOnClear(VerilatedAssertType_t flags) VL_MT_SAFE;
|
||||
void assertOnClear(VerilatedAssertType_t types,
|
||||
VerilatedAssertDirectiveType_t directives) VL_MT_SAFE;
|
||||
/// Return if calculating of unused signals (for traces)
|
||||
bool calcUnusedSigs() const VL_MT_SAFE { return m_s.m_calcUnusedSigs; }
|
||||
/// Enable calculation of unused signals (for traces)
|
||||
|
||||
141
src/V3Assert.cpp
141
src/V3Assert.cpp
@ -20,23 +20,16 @@
|
||||
|
||||
#include "V3Stats.h"
|
||||
|
||||
#include <limits>
|
||||
VL_DEFINE_DEBUG_FUNCTIONS;
|
||||
|
||||
//######################################################################
|
||||
// Assert class functions
|
||||
|
||||
class AssertVisitor final : public VNVisitor {
|
||||
// TYPES
|
||||
enum class DirectiveType : uint8_t {
|
||||
INTRINSIC, // AstNodeAssertIntrinsinc
|
||||
CASE, // unique/unique0/priority case related checks
|
||||
IF, // unique/unique0/priority if related checks
|
||||
ASSERT, // assert statement
|
||||
COVER, // cover statement
|
||||
ASSUME, // assume statement
|
||||
};
|
||||
using VAssertType_t = std::underlying_type<VAssertType::en>::type;
|
||||
// CONSTANTS
|
||||
static constexpr uint8_t ALL_ASSERT_TYPES
|
||||
= std::numeric_limits<std::underlying_type<VAssertType::en>::type>::max();
|
||||
|
||||
// NODE STATE/TYPES
|
||||
// Cleared on netlist
|
||||
// AstNode::user() -> bool. True if processed
|
||||
@ -58,10 +51,39 @@ class AssertVisitor final : public VNVisitor {
|
||||
bool m_inSampled = false; // True inside a sampled expression
|
||||
|
||||
// METHODS
|
||||
static bool assertTypeOn(DirectiveType type) {
|
||||
if (v3Global.opt.assertOn()) return true;
|
||||
if (type == DirectiveType::CASE && v3Global.opt.assertCaseOn()) return true;
|
||||
return false;
|
||||
static AstNodeExpr* assertOnCond(FileLine* fl, VAssertType type,
|
||||
VAssertDirectiveType directiveType) {
|
||||
switch (directiveType) {
|
||||
case VAssertDirectiveType::INTRINSIC: return new AstConst{fl, AstConst::BitTrue{}};
|
||||
case VAssertDirectiveType::VIOLATION_CASE: {
|
||||
if (v3Global.opt.assertCaseOn()) {
|
||||
return new AstCExpr{fl, "vlSymsp->_vm_contextp__->assertOn()", 1};
|
||||
}
|
||||
// If assertions are off, have constant propagation rip them out later
|
||||
// This allows syntax errors and such to be detected normally.
|
||||
return new AstConst{fl, AstConst::BitFalse{}};
|
||||
}
|
||||
case VAssertDirectiveType::ASSERT:
|
||||
case VAssertDirectiveType::COVER:
|
||||
case VAssertDirectiveType::ASSUME: {
|
||||
if (v3Global.opt.assertOn()) {
|
||||
return new AstCExpr{fl,
|
||||
"vlSymsp->_vm_contextp__->assertOnGet("s + std::to_string(type)
|
||||
+ ", "s + std::to_string(directiveType) + ")"s,
|
||||
1};
|
||||
}
|
||||
return new AstConst{fl, AstConst::BitFalse{}};
|
||||
}
|
||||
case VAssertDirectiveType::INTERNAL:
|
||||
case VAssertDirectiveType::VIOLATION_IF:
|
||||
case VAssertDirectiveType::RESTRICT: {
|
||||
if (v3Global.opt.assertOn()) {
|
||||
return new AstCExpr{fl, "vlSymsp->_vm_contextp__->assertOn()", 1};
|
||||
}
|
||||
return new AstConst{fl, AstConst::BitFalse{}};
|
||||
}
|
||||
}
|
||||
VL_UNREACHABLE;
|
||||
}
|
||||
string assertDisplayMessage(AstNode* nodep, const string& prefix, const string& message,
|
||||
VDisplayType severity) {
|
||||
@ -77,11 +99,11 @@ class AssertVisitor final : public VNVisitor {
|
||||
}
|
||||
static bool resolveAssertType(AstAssertCtl* nodep) {
|
||||
if (!nodep->assertTypesp()) {
|
||||
nodep->ctlAssertTypes(std::numeric_limits<VAssertType_t>::max());
|
||||
nodep->ctlAssertTypes(VAssertType{ALL_ASSERT_TYPES});
|
||||
return true;
|
||||
}
|
||||
if (const AstConst* const assertTypesp = VN_CAST(nodep->assertTypesp(), Const)) {
|
||||
nodep->ctlAssertTypes(assertTypesp->toUInt());
|
||||
nodep->ctlAssertTypes(VAssertType{assertTypesp->toSInt()});
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@ -93,6 +115,18 @@ class AssertVisitor final : public VNVisitor {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
static bool resolveDirectiveType(AstAssertCtl* nodep) {
|
||||
if (!nodep->directiveTypesp()) {
|
||||
nodep->ctlDirectiveTypes(VAssertDirectiveType::ASSERT | VAssertDirectiveType::ASSUME
|
||||
| VAssertDirectiveType::COVER);
|
||||
return true;
|
||||
}
|
||||
if (const AstConst* const directiveTypesp = VN_CAST(nodep->directiveTypesp(), Const)) {
|
||||
nodep->ctlDirectiveTypes(VAssertDirectiveType{directiveTypesp->toSInt()});
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
void replaceDisplay(AstDisplay* nodep, const string& prefix) {
|
||||
nodep->fmtp()->text(
|
||||
assertDisplayMessage(nodep, prefix, nodep->fmtp()->text(), nodep->displayType()));
|
||||
@ -133,21 +167,13 @@ class AssertVisitor final : public VNVisitor {
|
||||
varrefp->classOrPackagep(v3Global.rootp()->dollarUnitPkgAddp());
|
||||
return varrefp;
|
||||
}
|
||||
static AstNodeStmt* newIfAssertOn(AstNode* bodyp, DirectiveType directiveType,
|
||||
VAssertType::en type = VAssertType::INTERNAL) {
|
||||
static AstNodeStmt* newIfAssertOn(AstNode* bodyp, VAssertDirectiveType directiveType,
|
||||
VAssertType type = VAssertType::INTERNAL) {
|
||||
// Add a internal if to check assertions are on.
|
||||
// Don't make this a AND term, as it's unlikely to need to test this.
|
||||
FileLine* const fl = bodyp->fileline();
|
||||
|
||||
// If assertions are off, have constant propagation rip them out later
|
||||
// This allows syntax errors and such to be detected normally.
|
||||
AstNodeExpr* const condp
|
||||
= type == VAssertType::INTERNAL
|
||||
? static_cast<AstNodeExpr*>(new AstConst{fl, AstConst::BitTrue{}})
|
||||
: assertTypeOn(directiveType) ? static_cast<AstNodeExpr*>(new AstCExpr{
|
||||
fl, "vlSymsp->_vm_contextp__->assertOnGet("s + std::to_string(type) + ")"s, 1})
|
||||
: static_cast<AstNodeExpr*>(
|
||||
new AstConst{fl, AstConst::BitFalse{}});
|
||||
AstNodeExpr* const condp = assertOnCond(fl, type, directiveType);
|
||||
AstNodeIf* const newp = new AstIf{fl, condp, bodyp};
|
||||
newp->isBoundsCheck(true); // To avoid LATCH warning
|
||||
newp->user1(true); // Don't assert/cover this if
|
||||
@ -167,8 +193,8 @@ class AssertVisitor final : public VNVisitor {
|
||||
return bodysp;
|
||||
}
|
||||
|
||||
AstNodeStmt* newFireAssert(AstNodeStmt* nodep, DirectiveType directiveType,
|
||||
VAssertType::en assertType, const string& message,
|
||||
AstNodeStmt* newFireAssert(AstNodeStmt* nodep, VAssertDirectiveType directiveType,
|
||||
VAssertType assertType, const string& message,
|
||||
AstNodeExpr* exprsp = nullptr) {
|
||||
AstNodeStmt* bodysp = newFireAssertUnchecked(nodep, message, exprsp);
|
||||
bodysp = newIfAssertOn(bodysp, directiveType, assertType);
|
||||
@ -214,7 +240,7 @@ class AssertVisitor final : public VNVisitor {
|
||||
}
|
||||
|
||||
if (bodysp && passsp) bodysp = bodysp->addNext(passsp);
|
||||
if (bodysp) bodysp = newIfAssertOn(bodysp, DirectiveType::COVER, nodep->type());
|
||||
if (bodysp) bodysp = newIfAssertOn(bodysp, nodep->directive(), nodep->type());
|
||||
ifp = new AstIf{nodep->fileline(), propp, bodysp};
|
||||
ifp->isBoundsCheck(true); // To avoid LATCH warning
|
||||
bodysp = ifp;
|
||||
@ -230,9 +256,7 @@ class AssertVisitor final : public VNVisitor {
|
||||
// It's more LIKELY that we'll take the nullptr if clause
|
||||
// than the sim-killing else clause:
|
||||
ifp->branchPred(VBranchPred::BP_LIKELY);
|
||||
const DirectiveType directiveType
|
||||
= VN_IS(nodep, AssertIntrinsic) ? DirectiveType::INTRINSIC : DirectiveType::ASSERT;
|
||||
bodysp = newIfAssertOn(ifp, directiveType, nodep->type());
|
||||
bodysp = newIfAssertOn(ifp, nodep->directive(), nodep->type());
|
||||
} else {
|
||||
nodep->v3fatalSrc("Unknown node type");
|
||||
}
|
||||
@ -303,11 +327,11 @@ class AssertVisitor final : public VNVisitor {
|
||||
= ((allow_none || hasDefaultElse)
|
||||
? static_cast<AstNodeExpr*>(new AstOneHot0{nodep->fileline(), propp})
|
||||
: static_cast<AstNodeExpr*>(new AstOneHot{nodep->fileline(), propp}));
|
||||
const VAssertType::en assertType
|
||||
const VAssertType assertType
|
||||
= nodep->uniquePragma() ? VAssertType::UNIQUE : VAssertType::UNIQUE0;
|
||||
AstIf* const checkifp
|
||||
= new AstIf{nodep->fileline(), new AstLogNot{nodep->fileline(), ohot},
|
||||
newFireAssert(nodep, DirectiveType::IF, assertType,
|
||||
newFireAssert(nodep, VAssertDirectiveType::VIOLATION_IF, assertType,
|
||||
"'unique if' statement violated"),
|
||||
newifp};
|
||||
checkifp->isBoundsCheck(true); // To avoid LATCH warning
|
||||
@ -330,7 +354,7 @@ class AssertVisitor final : public VNVisitor {
|
||||
}
|
||||
const AstNodeDType* exprDtypep = nodep->exprp()->dtypep()->skipRefp();
|
||||
|
||||
VAssertType::en assertType = VAssertType::INTERNAL;
|
||||
VAssertType assertType = VAssertType::INTERNAL;
|
||||
if (nodep->priorityPragma()) {
|
||||
assertType = VAssertType::PRIORITY;
|
||||
} else if (nodep->uniquePragma()) {
|
||||
@ -348,7 +372,7 @@ class AssertVisitor final : public VNVisitor {
|
||||
if (!has_default) {
|
||||
nodep->addItemsp(new AstCaseItem{
|
||||
nodep->fileline(), nullptr /*DEFAULT*/,
|
||||
newFireAssert(nodep, DirectiveType::CASE, assertType,
|
||||
newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
|
||||
nodep->pragmaString() + ", but non-match found" + valFmt,
|
||||
valFmt.empty() ? nullptr
|
||||
: nodep->exprp()->cloneTreePure(false))});
|
||||
@ -405,11 +429,11 @@ class AssertVisitor final : public VNVisitor {
|
||||
const string pragmaStr = nodep->pragmaString();
|
||||
if (!allow_none)
|
||||
zeroIfp->addThensp(
|
||||
newFireAssert(nodep, DirectiveType::CASE, assertType,
|
||||
newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
|
||||
pragmaStr + ", but none matched" + valFmt,
|
||||
valFmt.empty() ? nullptr : exprp->cloneTreePure(false)));
|
||||
zeroIfp->addElsesp(
|
||||
newFireAssert(nodep, DirectiveType::CASE, assertType,
|
||||
newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
|
||||
pragmaStr + ", but multiple matches found" + valFmt,
|
||||
valFmt.empty() ? nullptr : exprp->cloneTreePure(false)));
|
||||
ohotIfp->addThensp(zeroIfp);
|
||||
@ -586,10 +610,11 @@ class AssertVisitor final : public VNVisitor {
|
||||
"Unsupported: non-constant assert assertion-type expression");
|
||||
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
|
||||
return;
|
||||
} else if (nodep->ctlAssertTypes()
|
||||
& (VAssertType::EXPECT | VAssertType::UNIQUE | VAssertType::UNIQUE0
|
||||
| VAssertType::PRIORITY)
|
||||
&& !(nodep->ctlAssertTypes() == std::numeric_limits<VAssertType_t>::max())) {
|
||||
}
|
||||
if (nodep->ctlAssertTypes() != ALL_ASSERT_TYPES
|
||||
&& nodep->ctlAssertTypes().containsAny(VAssertType::EXPECT | VAssertType::UNIQUE
|
||||
| VAssertType::UNIQUE0
|
||||
| VAssertType::PRIORITY)) {
|
||||
nodep->v3warn(E_UNSUPPORTED, "Unsupported: assert control assertion_type");
|
||||
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
|
||||
return;
|
||||
@ -599,26 +624,32 @@ class AssertVisitor final : public VNVisitor {
|
||||
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
|
||||
return;
|
||||
}
|
||||
if (!resolveDirectiveType(nodep)) {
|
||||
nodep->v3warn(E_UNSUPPORTED,
|
||||
"Unsupported: non-const assert directive type expression");
|
||||
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
|
||||
return;
|
||||
}
|
||||
|
||||
FileLine* const fl = nodep->fileline();
|
||||
switch (nodep->ctlType()) {
|
||||
case VAssertCtlType::ON:
|
||||
UINFO(9, "Generating assertctl for a module: " << m_modp << endl);
|
||||
nodep->replaceWith(new AstCExpr{fl,
|
||||
"vlSymsp->_vm_contextp__->assertOnSet("s
|
||||
+ std::to_string(nodep->ctlAssertTypes())
|
||||
+ ");\n"s,
|
||||
1});
|
||||
nodep->replaceWith(new AstCExpr{
|
||||
fl,
|
||||
"vlSymsp->_vm_contextp__->assertOnSet("s + std::to_string(nodep->ctlAssertTypes())
|
||||
+ ", "s + std::to_string(nodep->ctlDirectiveTypes()) + ");\n"s,
|
||||
1});
|
||||
break;
|
||||
case VAssertCtlType::OFF:
|
||||
case VAssertCtlType::KILL: {
|
||||
UINFO(9, "Generating assertctl for a module: " << m_modp << endl);
|
||||
nodep->replaceWith(new AstCExpr{
|
||||
fl,
|
||||
"vlSymsp->_vm_contextp__->assertOnClear("s
|
||||
+ std::to_string(static_cast<VAssertType_t>(~nodep->ctlAssertTypes()))
|
||||
+ ");\n"s,
|
||||
1});
|
||||
nodep->replaceWith(new AstCExpr{fl,
|
||||
"vlSymsp->_vm_contextp__->assertOnClear("s
|
||||
+ std::to_string(nodep->ctlAssertTypes()) + " ,"s
|
||||
+ std::to_string(nodep->ctlDirectiveTypes())
|
||||
+ ");\n"s,
|
||||
1});
|
||||
break;
|
||||
}
|
||||
case VAssertCtlType::LOCK:
|
||||
|
||||
53
src/V3Ast.h
53
src/V3Ast.h
@ -1154,6 +1154,53 @@ constexpr bool operator==(VAssertCtlType::en lhs, const VAssertCtlType& rhs) {
|
||||
|
||||
// ######################################################################
|
||||
|
||||
class VAssertDirectiveType final {
|
||||
public:
|
||||
// IEEE 1800-2023 Table 20-7
|
||||
enum en : uint8_t {
|
||||
INTERNAL = 0, // Non IEEE type, for directives to be evaluated from expression.
|
||||
ASSERT = (1 << 0),
|
||||
COVER = (1 << 1),
|
||||
ASSUME = (1 << 2),
|
||||
VIOLATION_CASE = (1 << 3), // Non IEEE type, for case constructs
|
||||
// with unique, unique0 or priority pragmas.
|
||||
VIOLATION_IF = (1 << 4), // Non IEEE type, for if constructs
|
||||
// with unique, unique0 or priority pragmas.
|
||||
INTRINSIC = (1 << 5), // Non IEEE type, for intrinsic assertions.
|
||||
RESTRICT = (1 << 6), // Non IEEE type, for ignored restrict assertions.
|
||||
};
|
||||
enum en m_e;
|
||||
VAssertDirectiveType()
|
||||
: m_e{ASSERT} {}
|
||||
// cppcheck-suppress noExplicitConstructor
|
||||
constexpr VAssertDirectiveType(en _e)
|
||||
: m_e{_e} {}
|
||||
explicit VAssertDirectiveType(int _e)
|
||||
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
|
||||
const char* ascii() const {
|
||||
static const char* const names[]
|
||||
= {"INTERNAL", "ASSERT", "COVER", "ASSUME",
|
||||
"VIOLATION_CASE", "VIOLATION_IF", "INTRINSIC", "RESTRICT"};
|
||||
return names[m_e];
|
||||
}
|
||||
constexpr operator en() const { return m_e; }
|
||||
};
|
||||
constexpr bool operator==(const VAssertDirectiveType& lhs, const VAssertDirectiveType& rhs) {
|
||||
return lhs.m_e == rhs.m_e;
|
||||
}
|
||||
constexpr bool operator==(const VAssertDirectiveType& lhs, VAssertDirectiveType::en rhs) {
|
||||
return lhs.m_e == rhs;
|
||||
}
|
||||
constexpr bool operator==(VAssertDirectiveType::en lhs, const VAssertDirectiveType& rhs) {
|
||||
return lhs == rhs.m_e;
|
||||
}
|
||||
constexpr VAssertDirectiveType::en operator|(VAssertDirectiveType::en lhs,
|
||||
VAssertDirectiveType::en rhs) {
|
||||
return VAssertDirectiveType::en(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
|
||||
}
|
||||
|
||||
// ######################################################################
|
||||
|
||||
class VAssertType final {
|
||||
public:
|
||||
// IEEE 1800-2023 Table 20-6
|
||||
@ -1172,10 +1219,11 @@ public:
|
||||
VAssertType()
|
||||
: m_e{INTERNAL} {}
|
||||
// cppcheck-suppress noExplicitConstructor
|
||||
constexpr explicit VAssertType(en _e)
|
||||
constexpr VAssertType(en _e)
|
||||
: m_e{_e} {}
|
||||
explicit VAssertType(int _e)
|
||||
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
|
||||
bool containsAny(VAssertType other) const { return m_e & other.m_e; }
|
||||
const char* ascii() const {
|
||||
static const char* const names[] = {"INTERNAL",
|
||||
"CONCURRENT",
|
||||
@ -1195,6 +1243,9 @@ constexpr bool operator==(const VAssertType& lhs, const VAssertType& rhs) {
|
||||
}
|
||||
constexpr bool operator==(const VAssertType& lhs, VAssertType::en rhs) { return lhs.m_e == rhs; }
|
||||
constexpr bool operator==(VAssertType::en lhs, const VAssertType& rhs) { return lhs == rhs.m_e; }
|
||||
constexpr VAssertType::en operator|(VAssertType::en lhs, VAssertType::en rhs) {
|
||||
return VAssertType::en(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
|
||||
}
|
||||
|
||||
// ######################################################################
|
||||
|
||||
|
||||
@ -399,12 +399,15 @@ class AstNodeCoverOrAssert VL_NOT_FINAL : public AstNodeStmt {
|
||||
// @astgen op4 := passsp: List[AstNode] // Statements when propp is passing/truthly
|
||||
string m_name; // Name to report
|
||||
const VAssertType m_type; // Assertion/cover type
|
||||
const VAssertDirectiveType m_directive; // Assertion directive type
|
||||
|
||||
public:
|
||||
AstNodeCoverOrAssert(VNType t, FileLine* fl, AstNode* propp, AstNode* passsp,
|
||||
VAssertType::en type, const string& name = "")
|
||||
AstNodeCoverOrAssert(VNType t, FileLine* fl, AstNode* propp, AstNode* passsp, VAssertType type,
|
||||
VAssertDirectiveType directive, const string& name = "")
|
||||
: AstNodeStmt{t, fl}
|
||||
, m_name{name}
|
||||
, m_type{type} {
|
||||
, m_type{type}
|
||||
, m_directive{directive} {
|
||||
this->propp(propp);
|
||||
this->addPasssp(passsp);
|
||||
}
|
||||
@ -415,10 +418,11 @@ public:
|
||||
void dump(std::ostream& str = std::cout) const override;
|
||||
void dumpJson(std::ostream& str = std::cout) const override;
|
||||
VAssertType type() const { return m_type; }
|
||||
VAssertDirectiveType directive() const { return m_directive; }
|
||||
bool immediate() const {
|
||||
return this->type()
|
||||
& (VAssertType::SIMPLE_IMMEDIATE | VAssertType::OBSERVED_DEFERRED_IMMEDIATE
|
||||
| VAssertType::FINAL_DEFERRED_IMMEDIATE)
|
||||
return this->type().containsAny(VAssertType::SIMPLE_IMMEDIATE
|
||||
| VAssertType::OBSERVED_DEFERRED_IMMEDIATE
|
||||
| VAssertType::FINAL_DEFERRED_IMMEDIATE)
|
||||
|| this->type() == VAssertType::INTERNAL;
|
||||
}
|
||||
};
|
||||
@ -2615,13 +2619,12 @@ public:
|
||||
class AstAssertCtl final : public AstNodeStmt {
|
||||
// @astgen op1 := controlTypep : AstNodeExpr
|
||||
// @astgen op2 := assertTypesp : Optional[AstNodeExpr]
|
||||
// @astgen op3 := levelp : AstNodeExpr
|
||||
// @astgen op4 := itemsp : List[AstNodeExpr]
|
||||
// @astgen op3 := directiveTypesp : Optional[AstNodeExpr]
|
||||
// Type of assertcontrol task; either known from parser or from evaluated
|
||||
// controlTypep expression.
|
||||
VAssertCtlType m_ctlType; // $assert keyword type (control_type)
|
||||
using VAssertType_t = std::underlying_type<VAssertType::en>::type;
|
||||
VAssertType_t m_assertTypes; // Type of assertions affected
|
||||
VAssertType m_assertTypes; // Types of assertions affected
|
||||
VAssertDirectiveType m_directiveTypes; // Types of directives affected
|
||||
|
||||
public:
|
||||
AstAssertCtl(FileLine* fl, VAssertCtlType ctlType, AstNodeExpr* levelp = nullptr,
|
||||
@ -2637,8 +2640,10 @@ public:
|
||||
bool isOutputter() override { return true; }
|
||||
VAssertCtlType ctlType() const { return m_ctlType; }
|
||||
void ctlType(int32_t type) { m_ctlType = VAssertCtlType{type}; }
|
||||
VAssertType_t ctlAssertTypes() const { return m_assertTypes; }
|
||||
void ctlAssertTypes(VAssertType_t types) { m_assertTypes = types; }
|
||||
VAssertType ctlAssertTypes() const { return m_assertTypes; }
|
||||
void ctlAssertTypes(VAssertType types) { m_assertTypes = types; }
|
||||
VAssertDirectiveType ctlDirectiveTypes() const { return m_directiveTypes; }
|
||||
void ctlDirectiveTypes(VAssertDirectiveType types) { m_directiveTypes = types; }
|
||||
void dump(std::ostream& str = std::cout) const override;
|
||||
void dumpJson(std::ostream& str = std::cout) const override;
|
||||
};
|
||||
@ -3653,9 +3658,9 @@ class AstAssert final : public AstNodeCoverOrAssert {
|
||||
|
||||
public:
|
||||
ASTGEN_MEMBERS_AstAssert;
|
||||
AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, VAssertType::en type,
|
||||
const string& name = "")
|
||||
: ASTGEN_SUPER_Assert(fl, propp, passsp, type, name) {
|
||||
AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, VAssertType type,
|
||||
VAssertDirectiveType directive, const string& name = "")
|
||||
: ASTGEN_SUPER_Assert(fl, propp, passsp, type, directive, name) {
|
||||
this->addFailsp(failsp);
|
||||
}
|
||||
};
|
||||
@ -3667,7 +3672,8 @@ public:
|
||||
AstAssertIntrinsic(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp,
|
||||
const string& name = "")
|
||||
// Intrinsic asserts are always enabled thus 'type' field is set to INTERNAL.
|
||||
: ASTGEN_SUPER_AssertIntrinsic(fl, propp, passsp, VAssertType::INTERNAL, name) {
|
||||
: ASTGEN_SUPER_AssertIntrinsic(fl, propp, passsp, VAssertType::INTERNAL,
|
||||
VAssertDirectiveType::INTRINSIC, name) {
|
||||
this->addFailsp(failsp);
|
||||
}
|
||||
};
|
||||
@ -3675,16 +3681,17 @@ class AstCover final : public AstNodeCoverOrAssert {
|
||||
// @astgen op3 := coverincsp: List[AstNode] // Coverage node
|
||||
public:
|
||||
ASTGEN_MEMBERS_AstCover;
|
||||
AstCover(FileLine* fl, AstNode* propp, AstNode* stmtsp, VAssertType::en type,
|
||||
AstCover(FileLine* fl, AstNode* propp, AstNode* stmtsp, VAssertType type,
|
||||
const string& name = "")
|
||||
: ASTGEN_SUPER_Cover(fl, propp, stmtsp, type, name) {}
|
||||
: ASTGEN_SUPER_Cover(fl, propp, stmtsp, type, VAssertDirectiveType::COVER, name) {}
|
||||
};
|
||||
class AstRestrict final : public AstNodeCoverOrAssert {
|
||||
public:
|
||||
ASTGEN_MEMBERS_AstRestrict;
|
||||
AstRestrict(FileLine* fl, AstNode* propp)
|
||||
// Intrinsic asserts are always ignored thus 'type' field is set to INTERNAL.
|
||||
: ASTGEN_SUPER_Restrict(fl, propp, nullptr, VAssertType::INTERNAL) {}
|
||||
: ASTGEN_SUPER_Restrict(fl, propp, nullptr, VAssertType::INTERNAL,
|
||||
VAssertDirectiveType::RESTRICT) {}
|
||||
};
|
||||
|
||||
// === AstNodeFor ===
|
||||
|
||||
@ -1485,25 +1485,20 @@ void AstAlways::dumpJson(std::ostream& str) const {
|
||||
dumpJsonStr(str, "keyword", keyword().ascii());
|
||||
dumpJsonGen(str);
|
||||
}
|
||||
AstAssertCtl::AstAssertCtl(FileLine* fl, VAssertCtlType ctlType, AstNodeExpr* levelp,
|
||||
AstNodeExpr* itemsp)
|
||||
AstAssertCtl::AstAssertCtl(FileLine* fl, VAssertCtlType ctlType, AstNodeExpr*, AstNodeExpr*)
|
||||
: ASTGEN_SUPER_AssertCtl(fl)
|
||||
, m_ctlType{ctlType} {
|
||||
controlTypep(new AstConst{fl, ctlType});
|
||||
if (!levelp) levelp = new AstConst{fl, 0};
|
||||
this->levelp(levelp);
|
||||
addItemsp(itemsp);
|
||||
}
|
||||
AstAssertCtl::AstAssertCtl(FileLine* fl, AstNodeExpr* controlTypep, AstNodeExpr* assertTypesp,
|
||||
AstNodeExpr*, AstNodeExpr* levelp, AstNodeExpr* itemsp)
|
||||
AstNodeExpr* directiveTypep, AstNodeExpr*, AstNodeExpr*)
|
||||
: ASTGEN_SUPER_AssertCtl(fl)
|
||||
, m_ctlType{VAssertCtlType::_TO_BE_EVALUATED}
|
||||
, m_assertTypes{VAssertType::INTERNAL} {
|
||||
, m_assertTypes{VAssertType::INTERNAL}
|
||||
, m_directiveTypes{VAssertDirectiveType::INTERNAL} {
|
||||
this->controlTypep(controlTypep);
|
||||
this->assertTypesp(assertTypesp);
|
||||
if (!levelp) levelp = new AstConst{fl, 0};
|
||||
this->levelp(levelp);
|
||||
addItemsp(itemsp);
|
||||
this->directiveTypesp(directiveTypep);
|
||||
}
|
||||
void AstAssertCtl::dump(std::ostream& str) const {
|
||||
this->AstNode::dump(str);
|
||||
|
||||
@ -117,6 +117,7 @@ struct V3ParseBisonYYSType final {
|
||||
V3ErrorCode::en errcodeen;
|
||||
VAttrType::en attrtypeen;
|
||||
VAssertType::en asserttypeen;
|
||||
VAssertDirectiveType::en assertdirectivetypeen;
|
||||
VLifetime::en lifetime;
|
||||
VStrength::en strength;
|
||||
|
||||
|
||||
@ -6003,18 +6003,18 @@ immediate_assertion_statement<nodep>: // ==IEEE: immediate_assertion_statement
|
||||
simple_immediate_assertion_statement<nodep>: // ==IEEE: simple_immediate_assertion_statement
|
||||
// // action_block expanded here, for compatibility with AstAssert
|
||||
assertOrAssume '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE
|
||||
{ $$ = new AstAssert{$1, $3, $5, nullptr, VAssertType::SIMPLE_IMMEDIATE}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $3, $5, nullptr, VAssertType::SIMPLE_IMMEDIATE, $1}; }
|
||||
| assertOrAssume '(' expr ')' yELSE stmtBlock
|
||||
{ $$ = new AstAssert{$1, $3, nullptr, $6, VAssertType::SIMPLE_IMMEDIATE}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $3, nullptr, $6, VAssertType::SIMPLE_IMMEDIATE, $1}; }
|
||||
| assertOrAssume '(' expr ')' stmtBlock yELSE stmtBlock
|
||||
{ $$ = new AstAssert{$1, $3, $5, $7, VAssertType::SIMPLE_IMMEDIATE}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $3, $5, $7, VAssertType::SIMPLE_IMMEDIATE, $1}; }
|
||||
// // IEEE: simple_immediate_cover_statement
|
||||
| yCOVER '(' expr ')' stmt { $$ = new AstCover{$1, $3, $5, VAssertType::SIMPLE_IMMEDIATE}; }
|
||||
;
|
||||
|
||||
assertOrAssume<fl>:
|
||||
yASSERT { $$ = $1; }
|
||||
| yASSUME { $$ = $1; }
|
||||
assertOrAssume<assertdirectivetypeen>:
|
||||
yASSERT { $$ = VAssertDirectiveType::ASSERT; }
|
||||
| yASSUME { $$ = VAssertDirectiveType::ASSUME; }
|
||||
;
|
||||
|
||||
final_zero<asserttypeen>: // IEEE: part of deferred_immediate_assertion_statement
|
||||
@ -6028,11 +6028,11 @@ final_zero<asserttypeen>: // IEEE: part of deferred_immediat
|
||||
deferred_immediate_assertion_statement<nodep>: // ==IEEE: deferred_immediate_assertion_statement
|
||||
// // IEEE: deferred_immediate_assert_statement
|
||||
assertOrAssume final_zero '(' expr ')' stmtBlock %prec prLOWER_THAN_ELSE
|
||||
{ $$ = new AstAssert{$1, $4, $6, nullptr, $2}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $4, $6, nullptr, $2, $1}; }
|
||||
| assertOrAssume final_zero '(' expr ')' yELSE stmtBlock
|
||||
{ $$ = new AstAssert{$1, $4, nullptr, $7, $2}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $4, nullptr, $7, $2, $1}; }
|
||||
| assertOrAssume final_zero '(' expr ')' stmtBlock yELSE stmtBlock
|
||||
{ $$ = new AstAssert{$1, $4, $6, $8, $2}; }
|
||||
{ $$ = new AstAssert{$<fl>1, $4, $6, $8, $2, $1}; }
|
||||
// // IEEE: deferred_immediate_cover_statement
|
||||
| yCOVER final_zero '(' expr ')' stmt { $$ = new AstCover{$1, $4, $6, $2}; }
|
||||
;
|
||||
@ -6050,11 +6050,11 @@ concurrent_assertion_statement<nodep>: // ==IEEE: concurrent_assertion_statemen
|
||||
// // IEEE: assume_property_statement
|
||||
// // action_block expanded here
|
||||
assertOrAssume yPROPERTY '(' property_spec ')' stmt %prec prLOWER_THAN_ELSE
|
||||
{ $$ = new AstAssert{$1, new AstSampled{$1, $4}, $6, nullptr, VAssertType::CONCURRENT}; }
|
||||
{ $$ = new AstAssert{$<fl>1, new AstSampled{$<fl>1, $4}, $6, nullptr, VAssertType::CONCURRENT, $1}; }
|
||||
| assertOrAssume yPROPERTY '(' property_spec ')' stmt yELSE stmt
|
||||
{ $$ = new AstAssert{$1, new AstSampled{$1, $4}, $6, $8, VAssertType::CONCURRENT}; }
|
||||
{ $$ = new AstAssert{$<fl>1, new AstSampled{$<fl>1, $4}, $6, $8, VAssertType::CONCURRENT, $1}; }
|
||||
| assertOrAssume yPROPERTY '(' property_spec ')' yELSE stmt
|
||||
{ $$ = new AstAssert{$1, new AstSampled{$1, $4}, nullptr, $7, VAssertType::CONCURRENT}; }
|
||||
{ $$ = new AstAssert{$<fl>1, new AstSampled{$<fl>1, $4}, nullptr, $7, VAssertType::CONCURRENT, $1}; }
|
||||
// // IEEE: cover_property_statement
|
||||
| yCOVER yPROPERTY '(' property_spec ')' stmtBlock
|
||||
{ $$ = new AstCover{$1, $4, $6, VAssertType::CONCURRENT}; }
|
||||
|
||||
113
test_regress/t/t_assert_ctl_arg.cpp
Normal file
113
test_regress/t/t_assert_ctl_arg.cpp
Normal file
@ -0,0 +1,113 @@
|
||||
// -*- mode: C++; c-file-style: "cc-mode" -*-
|
||||
//
|
||||
// DESCRIPTION: Verilator: Verilog Test module
|
||||
//
|
||||
// This file ONLY is placed under the Creative Commons Public Domain, for
|
||||
// any use, without warranty, 2024 by Wilson Snyder.
|
||||
// SPDX-License-Identifier: CC0-1.0
|
||||
|
||||
#include "verilated_cov.h"
|
||||
#include <verilated.h>
|
||||
#include VM_PREFIX_INCLUDE
|
||||
|
||||
// These require the above. Comment prevents clang-format moving them
|
||||
#include "TestCheck.h"
|
||||
|
||||
unsigned int main_time = 0;
|
||||
|
||||
double sc_time_stamp() { return main_time; }
|
||||
//======================================================================
|
||||
|
||||
int errors = 0;
|
||||
|
||||
void verilatedTest() {
|
||||
const std::unique_ptr<VerilatedContext> contextp{new VerilatedContext};
|
||||
// Assert enable/disable
|
||||
contextp->assertOn(true);
|
||||
TEST_CHECK_NZ(contextp->assertOn());
|
||||
contextp->assertOn(false);
|
||||
TEST_CHECK_Z(contextp->assertOn());
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 1));
|
||||
|
||||
// Setting one type
|
||||
contextp->assertOnSet(1, 1);
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(1, 1));
|
||||
TEST_CHECK_NZ(contextp->assertOn());
|
||||
TEST_CHECK_Z(contextp->assertOnGet(2, 2));
|
||||
|
||||
// Setting types
|
||||
contextp->assertOn(false);
|
||||
contextp->assertOnSet(1, 3);
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(1, 3));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(1, 2));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(1, 1));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 0));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(2, 0));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(0, 0));
|
||||
|
||||
// Setting multiple types separately
|
||||
contextp->assertOn(false);
|
||||
contextp->assertOnSet(0, 1);
|
||||
contextp->assertOnSet(1, 2);
|
||||
contextp->assertOnSet(2, 3);
|
||||
TEST_CHECK_NZ(contextp->assertOn());
|
||||
TEST_CHECK_Z(contextp->assertOnGet(0, 1));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 1));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(1, 2));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(2, 1));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(2, 2));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(2, 3));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(0, 2));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(4, 1));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(8, 7));
|
||||
|
||||
// Clearing selected types
|
||||
contextp->assertOn(true);
|
||||
contextp->assertOnClear(1, 3);
|
||||
contextp->assertOnClear(1, 4);
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 1));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 2));
|
||||
TEST_CHECK_Z(contextp->assertOnGet(1, 4));
|
||||
contextp->assertOnClear(4, 4);
|
||||
TEST_CHECK_Z(contextp->assertOnGet(4, 4));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(4, 1));
|
||||
TEST_CHECK_NZ(contextp->assertOnGet(4, 2));
|
||||
TEST_CHECK_NZ(contextp->assertOn());
|
||||
|
||||
// Clearing all assert types
|
||||
contextp->assertOn(true);
|
||||
contextp->assertOnClear(255, 7);
|
||||
// Everything is disabled except internal asserts
|
||||
TEST_CHECK_NZ(contextp->assertOn());
|
||||
contextp->assertOn(false);
|
||||
// Now everything is disabled
|
||||
TEST_CHECK_Z(contextp->assertOn());
|
||||
}
|
||||
int main(int argc, char** argv) {
|
||||
verilatedTest();
|
||||
if (errors) return 10;
|
||||
|
||||
const std::unique_ptr<VerilatedContext> contextp{new VerilatedContext};
|
||||
contextp->threads(1);
|
||||
contextp->commandArgs(argc, argv);
|
||||
contextp->debug(0);
|
||||
|
||||
srand48(5);
|
||||
|
||||
const std::unique_ptr<VM_PREFIX> topp{new VM_PREFIX{"top"}};
|
||||
constexpr uint64_t sim_time = 100;
|
||||
while ((contextp->time() < sim_time) && !contextp->gotFinish()) {
|
||||
topp->clk = !topp->clk;
|
||||
topp->eval();
|
||||
contextp->timeInc(1);
|
||||
}
|
||||
const std::string filename = std::string{VL_STRINGIFY(TEST_OBJ_DIR) "/coverage.dat"};
|
||||
contextp->coveragep()->write(filename);
|
||||
|
||||
if (!contextp->gotFinish()) {
|
||||
vl_fatal(__FILE__, __LINE__, "main", "%Error: Timeout; never got a $finish");
|
||||
}
|
||||
topp->final();
|
||||
|
||||
return 0;
|
||||
}
|
||||
415
test_regress/t/t_assert_ctl_arg.out
Normal file
415
test_regress/t/t_assert_ctl_arg.out
Normal file
@ -0,0 +1,415 @@
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:49
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:49
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
-Info: t/t_assert_ctl_arg.v:135: Verilog $stop, ignored due to +verilator+error+limit
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:49
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:49
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:49
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:49
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:49
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:49
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:49
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:49
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:49
|
||||
Passed 'top.t.cover_simple_immediate_stmt_49' at t/t_assert_ctl_arg.v:49
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:51
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:51
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:51
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:51
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:51
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:51
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:51
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:56
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:56
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:56
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:56
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:56
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:56
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:56
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:56
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:56
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:56
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:56
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_56' at t/t_assert_ctl_arg.v:56
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:58
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:58
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:58
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:58
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:58
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:58
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:58
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:63
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:63
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:63
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:63
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:63
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:63
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:63
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:63
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:63
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:63
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:63
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_63' at t/t_assert_ctl_arg.v:63
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:65
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:65
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:65
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:65
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:65
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:65
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:65
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:69
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:69
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:69
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:69
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:69
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:69
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:69
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:71
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:71
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:71
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:71
|
||||
Passed 'top.t.cover_simple_immediate_stmt_71' at t/t_assert_ctl_arg.v:71
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_71' at t/t_assert_ctl_arg.v:71
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_71' at t/t_assert_ctl_arg.v:71
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:73
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:73
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:73
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:73
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:73
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:73
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:73
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:76
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:76
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:76
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:76
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:76
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:76
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:76
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:76
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:76
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:76
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:76
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:76
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:76
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:76
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:76
|
||||
Passed 'top.t.cover_simple_immediate_stmt_76' at t/t_assert_ctl_arg.v:76
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_76' at t/t_assert_ctl_arg.v:76
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:78
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:78
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:78
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:78
|
||||
Passed 'top.t.cover_simple_immediate_stmt_78' at t/t_assert_ctl_arg.v:78
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_78' at t/t_assert_ctl_arg.v:78
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_78' at t/t_assert_ctl_arg.v:78
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:80
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:80
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:80
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:80
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:80
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:80
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:80
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:80
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:80
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:80
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:80
|
||||
Passed 'top.t.cover_simple_immediate_stmt_80' at t/t_assert_ctl_arg.v:80
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:82
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:82
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:82
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:82
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:82
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:82
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:82
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:82
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:82
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:82
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:82
|
||||
Passed 'top.t.cover_simple_immediate_stmt_82' at t/t_assert_ctl_arg.v:82
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:84
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:84
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:84
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:84
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:84
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:84
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:84
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:86
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:86
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:86
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:86
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:86
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:86
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:86
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:86
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:86
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:86
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:86
|
||||
Passed 'top.t.cover_simple_immediate_stmt_86' at t/t_assert_ctl_arg.v:86
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:88
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:88
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:88
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:88
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:88
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:88
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:88
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:90
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:90
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:90
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:90
|
||||
Passed 'top.t.cover_simple_immediate_stmt_90' at t/t_assert_ctl_arg.v:90
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_90' at t/t_assert_ctl_arg.v:90
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_90' at t/t_assert_ctl_arg.v:90
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:92
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:92
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:92
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:92
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:92
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:92
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:92
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:97
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:97
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:97
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:97
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:97
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:97
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:97
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:97
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:97
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:97
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:97
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:97
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:97
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:100
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:100
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:100
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:100
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:100
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:100
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:100
|
||||
Passed 'top.t.cover_simple_immediate_stmt_100' at t/t_assert_ctl_arg.v:100
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_100' at t/t_assert_ctl_arg.v:100
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_100' at t/t_assert_ctl_arg.v:100
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:103
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:103
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:103
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:103
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:103
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:103
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:103
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:103
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:103
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:103
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:103
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:103
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:103
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:106
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:106
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:106
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:106
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:106
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:106
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:106
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:106
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:106
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:106
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:106
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:106
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:106
|
||||
Passed 'top.t.cover_simple_immediate_stmt_106' at t/t_assert_ctl_arg.v:106
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_106' at t/t_assert_ctl_arg.v:106
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_106' at t/t_assert_ctl_arg.v:106
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:108
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:135: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:149: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:155: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:163: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:108
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:108
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:108
|
||||
Passed 'top.t.cover_simple_immediate_stmt_108' at t/t_assert_ctl_arg.v:108
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_108' at t/t_assert_ctl_arg.v:108
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_108' at t/t_assert_ctl_arg.v:108
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:110
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:110
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:110
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:110
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:110
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:110
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:110
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_arg.v:112
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_arg.v:112
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_arg.v:112
|
||||
[0] %Error: t_assert_ctl_arg.v:141: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_arg.v:112
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_arg.v:112
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_arg.v:112
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_arg.v:112
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_arg.v:112
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_arg.v:112
|
||||
[0] %Error: t_assert_ctl_arg.v:169: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_arg.v:112
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_arg.v:112
|
||||
Passed 'top.t.cover_simple_immediate_stmt_112' at t/t_assert_ctl_arg.v:112
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_112' at t/t_assert_ctl_arg.v:112
|
||||
Disabling concurrent asserts, time: 10
|
||||
Enabling concurrent asserts, time: 20
|
||||
[20] %Error: t_assert_ctl_arg.v:180: Assertion failed in top.t.concurrent.assert_concurrent: 'assert' failed.
|
||||
Failed 'top.t.concurrent.assert_concurrent_else' at t/t_assert_ctl_arg.v:181
|
||||
Failed 'top.t.concurrent.assert_concurrent_stmt_else' at t/t_assert_ctl_arg.v:183
|
||||
[20] %Error: t_assert_ctl_arg.v:185: Assertion failed in top.t.concurrent.assume_concurrent: 'assert' failed.
|
||||
Failed 'top.t.concurrent.assume_concurrent_else' at t/t_assert_ctl_arg.v:186
|
||||
Failed 'top.t.concurrent.assume_concurrent_stmt_else' at t/t_assert_ctl_arg.v:188
|
||||
@ -11,8 +11,10 @@ if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); di
|
||||
scenarios(vlt => 1);
|
||||
|
||||
compile(
|
||||
verilator_flags2 => ['--assert --timing --coverage-user'],
|
||||
nc_flags2 => ["+nccovoverwrite +nccoverage+all +nccovtest+$Self->{name}"]
|
||||
make_top_shell => 0,
|
||||
make_main => 0,
|
||||
verilator_flags2 => ["--assert", "--timing", "--coverage-user", "--exe $Self->{t_dir}/$Self->{name}.cpp"],
|
||||
nc_flags2 => ["+nccovoverwrite", "+nccoverage+all", "+nccovtest+$Self->{name}"],
|
||||
);
|
||||
|
||||
execute(
|
||||
@ -20,7 +22,7 @@ execute(
|
||||
expect_filename => $Self->{golden_filename},
|
||||
);
|
||||
|
||||
files_identical($Self->{coverage_filename}, "t/t_assert_ctl_assertion_type_coverage.out");
|
||||
files_identical($Self->{coverage_filename}, "$Self->{t_dir}/t_assert_ctl_arg_coverage.out");
|
||||
|
||||
ok(1);
|
||||
1;
|
||||
@ -34,27 +34,31 @@ module t (/*AUTOARG*/
|
||||
let OBSERVED_DEFERRED_IMMEDIATE = 4;
|
||||
let FINAL_DEFERRED_IMMEDIATE = 8;
|
||||
|
||||
let ALL = CONCURRENT|SIMPLE_IMMEDIATE|OBSERVED_DEFERRED_IMMEDIATE|FINAL_DEFERRED_IMMEDIATE;
|
||||
let ALL_TYPES = CONCURRENT|SIMPLE_IMMEDIATE|OBSERVED_DEFERRED_IMMEDIATE|FINAL_DEFERRED_IMMEDIATE;
|
||||
|
||||
let ASSERT = 1;
|
||||
let COVER = 2;
|
||||
let ASSUME = 4;
|
||||
|
||||
concurrent concurrent(.clk(clk));
|
||||
|
||||
initial begin
|
||||
// simple immediate
|
||||
$assertcontrol(OFF, ALL);
|
||||
$assertcontrol(OFF, ALL_TYPES);
|
||||
$assertcontrol(ON, SIMPLE_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS
|
||||
$assertcontrol(OFF, SIMPLE_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS
|
||||
|
||||
// observed deferred immediate
|
||||
$assertcontrol(OFF, ALL);
|
||||
$assertcontrol(OFF, ALL_TYPES);
|
||||
$assertcontrol(ON, OBSERVED_DEFERRED_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS
|
||||
$assertcontrol(OFF, OBSERVED_DEFERRED_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS
|
||||
|
||||
// final deferred immediate
|
||||
$assertcontrol(OFF, ALL);
|
||||
$assertcontrol(OFF, ALL_TYPES);
|
||||
$assertcontrol(ON, FINAL_DEFERRED_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS
|
||||
$assertcontrol(OFF, FINAL_DEFERRED_IMMEDIATE);
|
||||
@ -80,17 +84,38 @@ module t (/*AUTOARG*/
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(ON, SIMPLE_IMMEDIATE);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(OFF, ALL);
|
||||
$assertcontrol(OFF, ALL_TYPES);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(ON, ALL);
|
||||
$assertcontrol(ON, ALL_TYPES);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(KILL, ALL);
|
||||
$assertcontrol(KILL, ALL_TYPES);
|
||||
`RUN_ALL_ASSERTS;
|
||||
|
||||
// directive_type test
|
||||
$assertoff;
|
||||
$assertcontrol(ON, ALL_TYPES, ASSERT);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(OFF, ALL_TYPES, ASSERT);
|
||||
$assertcontrol(ON, ALL_TYPES, COVER);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(OFF, ALL_TYPES, COVER);
|
||||
$assertcontrol(ON, ALL_TYPES, ASSUME);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(OFF, ALL_TYPES, ASSUME);
|
||||
$assertcontrol(ON, ALL_TYPES, ASSERT|COVER);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(ON, ALL_TYPES, ASSUME);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertoff;
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertcontrol(ON, SIMPLE_IMMEDIATE|FINAL_DEFERRED_IMMEDIATE, COVER|ASSUME);
|
||||
`RUN_ALL_ASSERTS;
|
||||
$assertoff;
|
||||
|
||||
// concurrent test
|
||||
#10;
|
||||
$display("Disabling concurrent asserts, time: %g", $time);
|
||||
$assertcontrol(ON, ALL);
|
||||
$assertcontrol(ON, ALL_TYPES);
|
||||
$assertcontrol(OFF, CONCURRENT);
|
||||
#10;
|
||||
$display("Enabling concurrent asserts, time: %g", $time);
|
||||
153
test_regress/t/t_assert_ctl_arg_coverage.out
Normal file
153
test_regress/t/t_assert_ctl_arg_coverage.out
Normal file
@ -0,0 +1,153 @@
|
||||
# SystemC::Coverage-3
|
||||
C 'ft/t_assert_ctl_arg.vl100n32pagev_user/tocover_simple_immediate_100htop.t.cover_simple_immediate_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl100n37pagev_user/tocover_simple_immediate_stmt_100htop.t.cover_simple_immediate_stmt_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl100n40pagev_user/tocover_final_deferred_immediate_100htop.t.cover_final_deferred_immediate_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl100n43pagev_user/tocover_observed_deferred_immediate_100htop.t.cover_observed_deferred_immediate_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl100n45pagev_user/tocover_final_deferred_immediate_stmt_100htop.t.cover_final_deferred_immediate_stmt_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl100n48pagev_user/tocover_observed_deferred_immediate_stmt_100htop.t.cover_observed_deferred_immediate_stmt_100' 1
|
||||
C 'ft/t_assert_ctl_arg.vl103n32pagev_user/tocover_simple_immediate_103htop.t.cover_simple_immediate_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl103n37pagev_user/tocover_simple_immediate_stmt_103htop.t.cover_simple_immediate_stmt_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl103n40pagev_user/tocover_final_deferred_immediate_103htop.t.cover_final_deferred_immediate_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl103n43pagev_user/tocover_observed_deferred_immediate_103htop.t.cover_observed_deferred_immediate_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl103n45pagev_user/tocover_final_deferred_immediate_stmt_103htop.t.cover_final_deferred_immediate_stmt_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl103n48pagev_user/tocover_observed_deferred_immediate_stmt_103htop.t.cover_observed_deferred_immediate_stmt_103' 0
|
||||
C 'ft/t_assert_ctl_arg.vl106n32pagev_user/tocover_simple_immediate_106htop.t.cover_simple_immediate_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl106n37pagev_user/tocover_simple_immediate_stmt_106htop.t.cover_simple_immediate_stmt_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl106n40pagev_user/tocover_final_deferred_immediate_106htop.t.cover_final_deferred_immediate_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl106n43pagev_user/tocover_observed_deferred_immediate_106htop.t.cover_observed_deferred_immediate_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl106n45pagev_user/tocover_final_deferred_immediate_stmt_106htop.t.cover_final_deferred_immediate_stmt_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl106n48pagev_user/tocover_observed_deferred_immediate_stmt_106htop.t.cover_observed_deferred_immediate_stmt_106' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n32pagev_user/tocover_simple_immediate_108htop.t.cover_simple_immediate_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n37pagev_user/tocover_simple_immediate_stmt_108htop.t.cover_simple_immediate_stmt_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n40pagev_user/tocover_final_deferred_immediate_108htop.t.cover_final_deferred_immediate_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n43pagev_user/tocover_observed_deferred_immediate_108htop.t.cover_observed_deferred_immediate_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n45pagev_user/tocover_final_deferred_immediate_stmt_108htop.t.cover_final_deferred_immediate_stmt_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl108n48pagev_user/tocover_observed_deferred_immediate_stmt_108htop.t.cover_observed_deferred_immediate_stmt_108' 1
|
||||
C 'ft/t_assert_ctl_arg.vl110n32pagev_user/tocover_simple_immediate_110htop.t.cover_simple_immediate_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl110n37pagev_user/tocover_simple_immediate_stmt_110htop.t.cover_simple_immediate_stmt_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl110n40pagev_user/tocover_final_deferred_immediate_110htop.t.cover_final_deferred_immediate_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl110n43pagev_user/tocover_observed_deferred_immediate_110htop.t.cover_observed_deferred_immediate_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl110n45pagev_user/tocover_final_deferred_immediate_stmt_110htop.t.cover_final_deferred_immediate_stmt_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl110n48pagev_user/tocover_observed_deferred_immediate_stmt_110htop.t.cover_observed_deferred_immediate_stmt_110' 0
|
||||
C 'ft/t_assert_ctl_arg.vl112n32pagev_user/tocover_simple_immediate_112htop.t.cover_simple_immediate_112' 1
|
||||
C 'ft/t_assert_ctl_arg.vl112n37pagev_user/tocover_simple_immediate_stmt_112htop.t.cover_simple_immediate_stmt_112' 1
|
||||
C 'ft/t_assert_ctl_arg.vl112n40pagev_user/tocover_final_deferred_immediate_112htop.t.cover_final_deferred_immediate_112' 1
|
||||
C 'ft/t_assert_ctl_arg.vl112n43pagev_user/tocover_observed_deferred_immediate_112htop.t.cover_observed_deferred_immediate_112' 0
|
||||
C 'ft/t_assert_ctl_arg.vl112n45pagev_user/tocover_final_deferred_immediate_stmt_112htop.t.cover_final_deferred_immediate_stmt_112' 1
|
||||
C 'ft/t_assert_ctl_arg.vl112n48pagev_user/tocover_observed_deferred_immediate_stmt_112htop.t.cover_observed_deferred_immediate_stmt_112' 0
|
||||
C 'ft/t_assert_ctl_arg.vl190n22pagev_user/concurrentocover_concurrenthtop.t.concurrent.cover_concurrent' 0
|
||||
C 'ft/t_assert_ctl_arg.vl191n27pagev_user/concurrentocover_concurrent_stmthtop.t.concurrent.cover_concurrent_stmt' 0
|
||||
C 'ft/t_assert_ctl_arg.vl49n31pagev_user/tocover_simple_immediate_49htop.t.cover_simple_immediate_49' 1
|
||||
C 'ft/t_assert_ctl_arg.vl49n36pagev_user/tocover_simple_immediate_stmt_49htop.t.cover_simple_immediate_stmt_49' 1
|
||||
C 'ft/t_assert_ctl_arg.vl49n39pagev_user/tocover_final_deferred_immediate_49htop.t.cover_final_deferred_immediate_49' 0
|
||||
C 'ft/t_assert_ctl_arg.vl49n42pagev_user/tocover_observed_deferred_immediate_49htop.t.cover_observed_deferred_immediate_49' 0
|
||||
C 'ft/t_assert_ctl_arg.vl49n44pagev_user/tocover_final_deferred_immediate_stmt_49htop.t.cover_final_deferred_immediate_stmt_49' 0
|
||||
C 'ft/t_assert_ctl_arg.vl49n47pagev_user/tocover_observed_deferred_immediate_stmt_49htop.t.cover_observed_deferred_immediate_stmt_49' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n31pagev_user/tocover_simple_immediate_51htop.t.cover_simple_immediate_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n36pagev_user/tocover_simple_immediate_stmt_51htop.t.cover_simple_immediate_stmt_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n39pagev_user/tocover_final_deferred_immediate_51htop.t.cover_final_deferred_immediate_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n42pagev_user/tocover_observed_deferred_immediate_51htop.t.cover_observed_deferred_immediate_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n44pagev_user/tocover_final_deferred_immediate_stmt_51htop.t.cover_final_deferred_immediate_stmt_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl51n47pagev_user/tocover_observed_deferred_immediate_stmt_51htop.t.cover_observed_deferred_immediate_stmt_51' 0
|
||||
C 'ft/t_assert_ctl_arg.vl56n31pagev_user/tocover_simple_immediate_56htop.t.cover_simple_immediate_56' 0
|
||||
C 'ft/t_assert_ctl_arg.vl56n36pagev_user/tocover_simple_immediate_stmt_56htop.t.cover_simple_immediate_stmt_56' 0
|
||||
C 'ft/t_assert_ctl_arg.vl56n39pagev_user/tocover_final_deferred_immediate_56htop.t.cover_final_deferred_immediate_56' 0
|
||||
C 'ft/t_assert_ctl_arg.vl56n42pagev_user/tocover_observed_deferred_immediate_56htop.t.cover_observed_deferred_immediate_56' 1
|
||||
C 'ft/t_assert_ctl_arg.vl56n44pagev_user/tocover_final_deferred_immediate_stmt_56htop.t.cover_final_deferred_immediate_stmt_56' 0
|
||||
C 'ft/t_assert_ctl_arg.vl56n47pagev_user/tocover_observed_deferred_immediate_stmt_56htop.t.cover_observed_deferred_immediate_stmt_56' 1
|
||||
C 'ft/t_assert_ctl_arg.vl58n31pagev_user/tocover_simple_immediate_58htop.t.cover_simple_immediate_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl58n36pagev_user/tocover_simple_immediate_stmt_58htop.t.cover_simple_immediate_stmt_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl58n39pagev_user/tocover_final_deferred_immediate_58htop.t.cover_final_deferred_immediate_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl58n42pagev_user/tocover_observed_deferred_immediate_58htop.t.cover_observed_deferred_immediate_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl58n44pagev_user/tocover_final_deferred_immediate_stmt_58htop.t.cover_final_deferred_immediate_stmt_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl58n47pagev_user/tocover_observed_deferred_immediate_stmt_58htop.t.cover_observed_deferred_immediate_stmt_58' 0
|
||||
C 'ft/t_assert_ctl_arg.vl63n31pagev_user/tocover_simple_immediate_63htop.t.cover_simple_immediate_63' 0
|
||||
C 'ft/t_assert_ctl_arg.vl63n36pagev_user/tocover_simple_immediate_stmt_63htop.t.cover_simple_immediate_stmt_63' 0
|
||||
C 'ft/t_assert_ctl_arg.vl63n39pagev_user/tocover_final_deferred_immediate_63htop.t.cover_final_deferred_immediate_63' 1
|
||||
C 'ft/t_assert_ctl_arg.vl63n42pagev_user/tocover_observed_deferred_immediate_63htop.t.cover_observed_deferred_immediate_63' 0
|
||||
C 'ft/t_assert_ctl_arg.vl63n44pagev_user/tocover_final_deferred_immediate_stmt_63htop.t.cover_final_deferred_immediate_stmt_63' 1
|
||||
C 'ft/t_assert_ctl_arg.vl63n47pagev_user/tocover_observed_deferred_immediate_stmt_63htop.t.cover_observed_deferred_immediate_stmt_63' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n31pagev_user/tocover_simple_immediate_65htop.t.cover_simple_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n36pagev_user/tocover_simple_immediate_stmt_65htop.t.cover_simple_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n39pagev_user/tocover_final_deferred_immediate_65htop.t.cover_final_deferred_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n42pagev_user/tocover_observed_deferred_immediate_65htop.t.cover_observed_deferred_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n44pagev_user/tocover_final_deferred_immediate_stmt_65htop.t.cover_final_deferred_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl65n47pagev_user/tocover_observed_deferred_immediate_stmt_65htop.t.cover_observed_deferred_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n31pagev_user/tocover_simple_immediate_69htop.t.cover_simple_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n36pagev_user/tocover_simple_immediate_stmt_69htop.t.cover_simple_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n39pagev_user/tocover_final_deferred_immediate_69htop.t.cover_final_deferred_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n42pagev_user/tocover_observed_deferred_immediate_69htop.t.cover_observed_deferred_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n44pagev_user/tocover_final_deferred_immediate_stmt_69htop.t.cover_final_deferred_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl69n47pagev_user/tocover_observed_deferred_immediate_stmt_69htop.t.cover_observed_deferred_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_arg.vl71n31pagev_user/tocover_simple_immediate_71htop.t.cover_simple_immediate_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl71n36pagev_user/tocover_simple_immediate_stmt_71htop.t.cover_simple_immediate_stmt_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl71n39pagev_user/tocover_final_deferred_immediate_71htop.t.cover_final_deferred_immediate_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl71n42pagev_user/tocover_observed_deferred_immediate_71htop.t.cover_observed_deferred_immediate_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl71n44pagev_user/tocover_final_deferred_immediate_stmt_71htop.t.cover_final_deferred_immediate_stmt_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl71n47pagev_user/tocover_observed_deferred_immediate_stmt_71htop.t.cover_observed_deferred_immediate_stmt_71' 1
|
||||
C 'ft/t_assert_ctl_arg.vl73n31pagev_user/tocover_simple_immediate_73htop.t.cover_simple_immediate_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl73n36pagev_user/tocover_simple_immediate_stmt_73htop.t.cover_simple_immediate_stmt_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl73n39pagev_user/tocover_final_deferred_immediate_73htop.t.cover_final_deferred_immediate_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl73n42pagev_user/tocover_observed_deferred_immediate_73htop.t.cover_observed_deferred_immediate_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl73n44pagev_user/tocover_final_deferred_immediate_stmt_73htop.t.cover_final_deferred_immediate_stmt_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl73n47pagev_user/tocover_observed_deferred_immediate_stmt_73htop.t.cover_observed_deferred_immediate_stmt_73' 0
|
||||
C 'ft/t_assert_ctl_arg.vl76n31pagev_user/tocover_simple_immediate_76htop.t.cover_simple_immediate_76' 1
|
||||
C 'ft/t_assert_ctl_arg.vl76n36pagev_user/tocover_simple_immediate_stmt_76htop.t.cover_simple_immediate_stmt_76' 1
|
||||
C 'ft/t_assert_ctl_arg.vl76n39pagev_user/tocover_final_deferred_immediate_76htop.t.cover_final_deferred_immediate_76' 0
|
||||
C 'ft/t_assert_ctl_arg.vl76n42pagev_user/tocover_observed_deferred_immediate_76htop.t.cover_observed_deferred_immediate_76' 1
|
||||
C 'ft/t_assert_ctl_arg.vl76n44pagev_user/tocover_final_deferred_immediate_stmt_76htop.t.cover_final_deferred_immediate_stmt_76' 0
|
||||
C 'ft/t_assert_ctl_arg.vl76n47pagev_user/tocover_observed_deferred_immediate_stmt_76htop.t.cover_observed_deferred_immediate_stmt_76' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n31pagev_user/tocover_simple_immediate_78htop.t.cover_simple_immediate_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n36pagev_user/tocover_simple_immediate_stmt_78htop.t.cover_simple_immediate_stmt_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n39pagev_user/tocover_final_deferred_immediate_78htop.t.cover_final_deferred_immediate_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n42pagev_user/tocover_observed_deferred_immediate_78htop.t.cover_observed_deferred_immediate_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n44pagev_user/tocover_final_deferred_immediate_stmt_78htop.t.cover_final_deferred_immediate_stmt_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl78n47pagev_user/tocover_observed_deferred_immediate_stmt_78htop.t.cover_observed_deferred_immediate_stmt_78' 1
|
||||
C 'ft/t_assert_ctl_arg.vl80n31pagev_user/tocover_simple_immediate_80htop.t.cover_simple_immediate_80' 1
|
||||
C 'ft/t_assert_ctl_arg.vl80n36pagev_user/tocover_simple_immediate_stmt_80htop.t.cover_simple_immediate_stmt_80' 1
|
||||
C 'ft/t_assert_ctl_arg.vl80n39pagev_user/tocover_final_deferred_immediate_80htop.t.cover_final_deferred_immediate_80' 0
|
||||
C 'ft/t_assert_ctl_arg.vl80n42pagev_user/tocover_observed_deferred_immediate_80htop.t.cover_observed_deferred_immediate_80' 0
|
||||
C 'ft/t_assert_ctl_arg.vl80n44pagev_user/tocover_final_deferred_immediate_stmt_80htop.t.cover_final_deferred_immediate_stmt_80' 0
|
||||
C 'ft/t_assert_ctl_arg.vl80n47pagev_user/tocover_observed_deferred_immediate_stmt_80htop.t.cover_observed_deferred_immediate_stmt_80' 0
|
||||
C 'ft/t_assert_ctl_arg.vl82n31pagev_user/tocover_simple_immediate_82htop.t.cover_simple_immediate_82' 1
|
||||
C 'ft/t_assert_ctl_arg.vl82n36pagev_user/tocover_simple_immediate_stmt_82htop.t.cover_simple_immediate_stmt_82' 1
|
||||
C 'ft/t_assert_ctl_arg.vl82n39pagev_user/tocover_final_deferred_immediate_82htop.t.cover_final_deferred_immediate_82' 0
|
||||
C 'ft/t_assert_ctl_arg.vl82n42pagev_user/tocover_observed_deferred_immediate_82htop.t.cover_observed_deferred_immediate_82' 0
|
||||
C 'ft/t_assert_ctl_arg.vl82n44pagev_user/tocover_final_deferred_immediate_stmt_82htop.t.cover_final_deferred_immediate_stmt_82' 0
|
||||
C 'ft/t_assert_ctl_arg.vl82n47pagev_user/tocover_observed_deferred_immediate_stmt_82htop.t.cover_observed_deferred_immediate_stmt_82' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n31pagev_user/tocover_simple_immediate_84htop.t.cover_simple_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n36pagev_user/tocover_simple_immediate_stmt_84htop.t.cover_simple_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n39pagev_user/tocover_final_deferred_immediate_84htop.t.cover_final_deferred_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n42pagev_user/tocover_observed_deferred_immediate_84htop.t.cover_observed_deferred_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n44pagev_user/tocover_final_deferred_immediate_stmt_84htop.t.cover_final_deferred_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl84n47pagev_user/tocover_observed_deferred_immediate_stmt_84htop.t.cover_observed_deferred_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_arg.vl86n31pagev_user/tocover_simple_immediate_86htop.t.cover_simple_immediate_86' 1
|
||||
C 'ft/t_assert_ctl_arg.vl86n36pagev_user/tocover_simple_immediate_stmt_86htop.t.cover_simple_immediate_stmt_86' 1
|
||||
C 'ft/t_assert_ctl_arg.vl86n39pagev_user/tocover_final_deferred_immediate_86htop.t.cover_final_deferred_immediate_86' 0
|
||||
C 'ft/t_assert_ctl_arg.vl86n42pagev_user/tocover_observed_deferred_immediate_86htop.t.cover_observed_deferred_immediate_86' 0
|
||||
C 'ft/t_assert_ctl_arg.vl86n44pagev_user/tocover_final_deferred_immediate_stmt_86htop.t.cover_final_deferred_immediate_stmt_86' 0
|
||||
C 'ft/t_assert_ctl_arg.vl86n47pagev_user/tocover_observed_deferred_immediate_stmt_86htop.t.cover_observed_deferred_immediate_stmt_86' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n31pagev_user/tocover_simple_immediate_88htop.t.cover_simple_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n36pagev_user/tocover_simple_immediate_stmt_88htop.t.cover_simple_immediate_stmt_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n39pagev_user/tocover_final_deferred_immediate_88htop.t.cover_final_deferred_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n42pagev_user/tocover_observed_deferred_immediate_88htop.t.cover_observed_deferred_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n44pagev_user/tocover_final_deferred_immediate_stmt_88htop.t.cover_final_deferred_immediate_stmt_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl88n47pagev_user/tocover_observed_deferred_immediate_stmt_88htop.t.cover_observed_deferred_immediate_stmt_88' 0
|
||||
C 'ft/t_assert_ctl_arg.vl90n31pagev_user/tocover_simple_immediate_90htop.t.cover_simple_immediate_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl90n36pagev_user/tocover_simple_immediate_stmt_90htop.t.cover_simple_immediate_stmt_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl90n39pagev_user/tocover_final_deferred_immediate_90htop.t.cover_final_deferred_immediate_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl90n42pagev_user/tocover_observed_deferred_immediate_90htop.t.cover_observed_deferred_immediate_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl90n44pagev_user/tocover_final_deferred_immediate_stmt_90htop.t.cover_final_deferred_immediate_stmt_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl90n47pagev_user/tocover_observed_deferred_immediate_stmt_90htop.t.cover_observed_deferred_immediate_stmt_90' 1
|
||||
C 'ft/t_assert_ctl_arg.vl92n31pagev_user/tocover_simple_immediate_92htop.t.cover_simple_immediate_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl92n36pagev_user/tocover_simple_immediate_stmt_92htop.t.cover_simple_immediate_stmt_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl92n39pagev_user/tocover_final_deferred_immediate_92htop.t.cover_final_deferred_immediate_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl92n42pagev_user/tocover_observed_deferred_immediate_92htop.t.cover_observed_deferred_immediate_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl92n44pagev_user/tocover_final_deferred_immediate_stmt_92htop.t.cover_final_deferred_immediate_stmt_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl92n47pagev_user/tocover_observed_deferred_immediate_stmt_92htop.t.cover_observed_deferred_immediate_stmt_92' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n31pagev_user/tocover_simple_immediate_97htop.t.cover_simple_immediate_97' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n36pagev_user/tocover_simple_immediate_stmt_97htop.t.cover_simple_immediate_stmt_97' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n39pagev_user/tocover_final_deferred_immediate_97htop.t.cover_final_deferred_immediate_97' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n42pagev_user/tocover_observed_deferred_immediate_97htop.t.cover_observed_deferred_immediate_97' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n44pagev_user/tocover_final_deferred_immediate_stmt_97htop.t.cover_final_deferred_immediate_stmt_97' 0
|
||||
C 'ft/t_assert_ctl_arg.vl97n47pagev_user/tocover_observed_deferred_immediate_stmt_97htop.t.cover_observed_deferred_immediate_stmt_97' 0
|
||||
31
test_regress/t/t_assert_ctl_arg_noinl.pl
Executable file
31
test_regress/t/t_assert_ctl_arg_noinl.pl
Executable file
@ -0,0 +1,31 @@
|
||||
#!/usr/bin/env perl
|
||||
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
|
||||
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
|
||||
#
|
||||
# Copyright 2024 by Wilson Snyder. 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-License-Identifier: LGPL-3.0-only OR Artistic-2.0
|
||||
|
||||
scenarios(vlt => 1);
|
||||
|
||||
top_filename("t_assert_ctl_arg.v");
|
||||
compile(
|
||||
make_top_shell => 0,
|
||||
make_main => 0,
|
||||
verilator_flags2 => [
|
||||
"--assert", "--timing", "--coverage-user", "--exe $Self->{t_dir}/t_assert_ctl_arg.cpp", "-fno-inline"
|
||||
],
|
||||
nc_flags2 => ["+nccovoverwrite", "+nccoverage+all", "+nccovtest+$Self->{name}"],
|
||||
);
|
||||
|
||||
execute(
|
||||
all_run_flags => ["+verilator+error+limit+100"],
|
||||
expect_filename => "$Self->{t_dir}/t_assert_ctl_arg.out",
|
||||
);
|
||||
|
||||
files_identical($Self->{coverage_filename}, "$Self->{t_dir}/t_assert_ctl_arg_coverage.out");
|
||||
|
||||
ok(1);
|
||||
1;
|
||||
18
test_regress/t/t_assert_ctl_arg_unsup.out
Normal file
18
test_regress/t/t_assert_ctl_arg_unsup.out
Normal file
@ -0,0 +1,18 @@
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_arg_unsup.v:15:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
15 | $assertcontrol(OFF, EXPECT);
|
||||
| ^~~~~~~~~~~~~~
|
||||
... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_arg_unsup.v:16:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
16 | $assertcontrol(OFF, UNIQUE);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_arg_unsup.v:17:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
17 | $assertcontrol(OFF, UNIQUE0);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_arg_unsup.v:18:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
18 | $assertcontrol(OFF, PRIORITY);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error: Exiting due to
|
||||
@ -1,290 +0,0 @@
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:45
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
-Info: t/t_assert_ctl_assertion_type.v:110: Verilog $stop, ignored due to +verilator+error+limit
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:45
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:45
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:45
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:45
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:45
|
||||
Passed 'top.t.cover_simple_immediate_stmt_45' at t/t_assert_ctl_assertion_type.v:45
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:47
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:47
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:52
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:124: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:52
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:52
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:130: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:52
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:52
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:52
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_52' at t/t_assert_ctl_assertion_type.v:52
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:54
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:54
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:59
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:138: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:59
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:59
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:59
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:144: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:59
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:59
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_59' at t/t_assert_ctl_assertion_type.v:59
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:61
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:61
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:65
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:65
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:67
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:124: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:130: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:138: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:67
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:144: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:67
|
||||
Passed 'top.t.cover_simple_immediate_stmt_67' at t/t_assert_ctl_assertion_type.v:67
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_67' at t/t_assert_ctl_assertion_type.v:67
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_67' at t/t_assert_ctl_assertion_type.v:67
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:69
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:69
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:72
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:124: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:130: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:72
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:72
|
||||
Passed 'top.t.cover_simple_immediate_stmt_72' at t/t_assert_ctl_assertion_type.v:72
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_72' at t/t_assert_ctl_assertion_type.v:72
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:74
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:124: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:130: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:138: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:74
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:144: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:74
|
||||
Passed 'top.t.cover_simple_immediate_stmt_74' at t/t_assert_ctl_assertion_type.v:74
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_74' at t/t_assert_ctl_assertion_type.v:74
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_74' at t/t_assert_ctl_assertion_type.v:74
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:76
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:76
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:76
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:76
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:76
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:76
|
||||
Passed 'top.t.cover_simple_immediate_stmt_76' at t/t_assert_ctl_assertion_type.v:76
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:78
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:78
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:78
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:78
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:78
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:78
|
||||
Passed 'top.t.cover_simple_immediate_stmt_78' at t/t_assert_ctl_assertion_type.v:78
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:80
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:80
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:82
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:82
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:82
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:82
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:82
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:82
|
||||
Passed 'top.t.cover_simple_immediate_stmt_82' at t/t_assert_ctl_assertion_type.v:82
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:84
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:84
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:86
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:110: Assertion failed in top.$unit.run_simple_immediate.assert_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_simple_immediate.assert_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:116: Assertion failed in top.$unit.run_simple_immediate.assume_simple_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_simple_immediate.assume_simple_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:124: Assertion failed in top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assert_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:130: Assertion failed in top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_observed_deferred_immediate.assume_observed_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:138: Assertion failed in top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assert_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:86
|
||||
[0] %Error: t_assert_ctl_assertion_type.v:144: Assertion failed in top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate: 'assert' failed.
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Failed 'top.$unit.run_final_deferred_immediate.assume_final_deferred_immediate_stmt_else' at t/t_assert_ctl_assertion_type.v:86
|
||||
Passed 'top.t.cover_simple_immediate_stmt_86' at t/t_assert_ctl_assertion_type.v:86
|
||||
Passed 'top.t.cover_observed_deferred_immediate_stmt_86' at t/t_assert_ctl_assertion_type.v:86
|
||||
Passed 'top.t.cover_final_deferred_immediate_stmt_86' at t/t_assert_ctl_assertion_type.v:86
|
||||
==========
|
||||
Running all asserts at: t/t_assert_ctl_assertion_type.v:88
|
||||
==========
|
||||
Testing assert_simple_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Testing assume_simple_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Testing assert_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Testing assume_observed_deferred_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Testing assert_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Testing assume_final_deferred_immediate at t/t_assert_ctl_assertion_type.v:88
|
||||
Disabling concurrent asserts, time: 10
|
||||
Enabling concurrent asserts, time: 20
|
||||
[20] %Error: t_assert_ctl_assertion_type.v:155: Assertion failed in top.t.concurrent.assert_concurrent: 'assert' failed.
|
||||
Failed 'top.t.concurrent.assert_concurrent_else' at t/t_assert_ctl_assertion_type.v:156
|
||||
Failed 'top.t.concurrent.assert_concurrent_stmt_else' at t/t_assert_ctl_assertion_type.v:158
|
||||
[20] %Error: t_assert_ctl_assertion_type.v:160: Assertion failed in top.t.concurrent.assume_concurrent: 'assert' failed.
|
||||
Failed 'top.t.concurrent.assume_concurrent_else' at t/t_assert_ctl_assertion_type.v:161
|
||||
Failed 'top.t.concurrent.assume_concurrent_stmt_else' at t/t_assert_ctl_assertion_type.v:163
|
||||
@ -1,111 +0,0 @@
|
||||
# SystemC::Coverage-3
|
||||
C 'ft/t_assert_ctl_assertion_type.vl165n22pagev_user/concurrentocover_concurrenthtop.t.concurrent.cover_concurrent' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl166n27pagev_user/concurrentocover_concurrent_stmthtop.t.concurrent.cover_concurrent_stmt' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n31pagev_user/tocover_simple_immediate_45htop.t.cover_simple_immediate_45' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n36pagev_user/tocover_simple_immediate_stmt_45htop.t.cover_simple_immediate_stmt_45' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n39pagev_user/tocover_final_deferred_immediate_45htop.t.cover_final_deferred_immediate_45' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n42pagev_user/tocover_observed_deferred_immediate_45htop.t.cover_observed_deferred_immediate_45' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n44pagev_user/tocover_final_deferred_immediate_stmt_45htop.t.cover_final_deferred_immediate_stmt_45' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl45n47pagev_user/tocover_observed_deferred_immediate_stmt_45htop.t.cover_observed_deferred_immediate_stmt_45' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n31pagev_user/tocover_simple_immediate_47htop.t.cover_simple_immediate_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n36pagev_user/tocover_simple_immediate_stmt_47htop.t.cover_simple_immediate_stmt_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n39pagev_user/tocover_final_deferred_immediate_47htop.t.cover_final_deferred_immediate_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n42pagev_user/tocover_observed_deferred_immediate_47htop.t.cover_observed_deferred_immediate_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n44pagev_user/tocover_final_deferred_immediate_stmt_47htop.t.cover_final_deferred_immediate_stmt_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl47n47pagev_user/tocover_observed_deferred_immediate_stmt_47htop.t.cover_observed_deferred_immediate_stmt_47' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n31pagev_user/tocover_simple_immediate_52htop.t.cover_simple_immediate_52' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n36pagev_user/tocover_simple_immediate_stmt_52htop.t.cover_simple_immediate_stmt_52' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n39pagev_user/tocover_final_deferred_immediate_52htop.t.cover_final_deferred_immediate_52' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n42pagev_user/tocover_observed_deferred_immediate_52htop.t.cover_observed_deferred_immediate_52' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n44pagev_user/tocover_final_deferred_immediate_stmt_52htop.t.cover_final_deferred_immediate_stmt_52' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl52n47pagev_user/tocover_observed_deferred_immediate_stmt_52htop.t.cover_observed_deferred_immediate_stmt_52' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n31pagev_user/tocover_simple_immediate_54htop.t.cover_simple_immediate_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n36pagev_user/tocover_simple_immediate_stmt_54htop.t.cover_simple_immediate_stmt_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n39pagev_user/tocover_final_deferred_immediate_54htop.t.cover_final_deferred_immediate_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n42pagev_user/tocover_observed_deferred_immediate_54htop.t.cover_observed_deferred_immediate_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n44pagev_user/tocover_final_deferred_immediate_stmt_54htop.t.cover_final_deferred_immediate_stmt_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl54n47pagev_user/tocover_observed_deferred_immediate_stmt_54htop.t.cover_observed_deferred_immediate_stmt_54' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n31pagev_user/tocover_simple_immediate_59htop.t.cover_simple_immediate_59' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n36pagev_user/tocover_simple_immediate_stmt_59htop.t.cover_simple_immediate_stmt_59' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n39pagev_user/tocover_final_deferred_immediate_59htop.t.cover_final_deferred_immediate_59' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n42pagev_user/tocover_observed_deferred_immediate_59htop.t.cover_observed_deferred_immediate_59' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n44pagev_user/tocover_final_deferred_immediate_stmt_59htop.t.cover_final_deferred_immediate_stmt_59' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl59n47pagev_user/tocover_observed_deferred_immediate_stmt_59htop.t.cover_observed_deferred_immediate_stmt_59' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n31pagev_user/tocover_simple_immediate_61htop.t.cover_simple_immediate_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n36pagev_user/tocover_simple_immediate_stmt_61htop.t.cover_simple_immediate_stmt_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n39pagev_user/tocover_final_deferred_immediate_61htop.t.cover_final_deferred_immediate_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n42pagev_user/tocover_observed_deferred_immediate_61htop.t.cover_observed_deferred_immediate_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n44pagev_user/tocover_final_deferred_immediate_stmt_61htop.t.cover_final_deferred_immediate_stmt_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl61n47pagev_user/tocover_observed_deferred_immediate_stmt_61htop.t.cover_observed_deferred_immediate_stmt_61' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n31pagev_user/tocover_simple_immediate_65htop.t.cover_simple_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n36pagev_user/tocover_simple_immediate_stmt_65htop.t.cover_simple_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n39pagev_user/tocover_final_deferred_immediate_65htop.t.cover_final_deferred_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n42pagev_user/tocover_observed_deferred_immediate_65htop.t.cover_observed_deferred_immediate_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n44pagev_user/tocover_final_deferred_immediate_stmt_65htop.t.cover_final_deferred_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl65n47pagev_user/tocover_observed_deferred_immediate_stmt_65htop.t.cover_observed_deferred_immediate_stmt_65' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n31pagev_user/tocover_simple_immediate_67htop.t.cover_simple_immediate_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n36pagev_user/tocover_simple_immediate_stmt_67htop.t.cover_simple_immediate_stmt_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n39pagev_user/tocover_final_deferred_immediate_67htop.t.cover_final_deferred_immediate_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n42pagev_user/tocover_observed_deferred_immediate_67htop.t.cover_observed_deferred_immediate_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n44pagev_user/tocover_final_deferred_immediate_stmt_67htop.t.cover_final_deferred_immediate_stmt_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl67n47pagev_user/tocover_observed_deferred_immediate_stmt_67htop.t.cover_observed_deferred_immediate_stmt_67' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n31pagev_user/tocover_simple_immediate_69htop.t.cover_simple_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n36pagev_user/tocover_simple_immediate_stmt_69htop.t.cover_simple_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n39pagev_user/tocover_final_deferred_immediate_69htop.t.cover_final_deferred_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n42pagev_user/tocover_observed_deferred_immediate_69htop.t.cover_observed_deferred_immediate_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n44pagev_user/tocover_final_deferred_immediate_stmt_69htop.t.cover_final_deferred_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl69n47pagev_user/tocover_observed_deferred_immediate_stmt_69htop.t.cover_observed_deferred_immediate_stmt_69' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n31pagev_user/tocover_simple_immediate_72htop.t.cover_simple_immediate_72' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n36pagev_user/tocover_simple_immediate_stmt_72htop.t.cover_simple_immediate_stmt_72' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n39pagev_user/tocover_final_deferred_immediate_72htop.t.cover_final_deferred_immediate_72' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n42pagev_user/tocover_observed_deferred_immediate_72htop.t.cover_observed_deferred_immediate_72' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n44pagev_user/tocover_final_deferred_immediate_stmt_72htop.t.cover_final_deferred_immediate_stmt_72' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl72n47pagev_user/tocover_observed_deferred_immediate_stmt_72htop.t.cover_observed_deferred_immediate_stmt_72' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n31pagev_user/tocover_simple_immediate_74htop.t.cover_simple_immediate_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n36pagev_user/tocover_simple_immediate_stmt_74htop.t.cover_simple_immediate_stmt_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n39pagev_user/tocover_final_deferred_immediate_74htop.t.cover_final_deferred_immediate_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n42pagev_user/tocover_observed_deferred_immediate_74htop.t.cover_observed_deferred_immediate_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n44pagev_user/tocover_final_deferred_immediate_stmt_74htop.t.cover_final_deferred_immediate_stmt_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl74n47pagev_user/tocover_observed_deferred_immediate_stmt_74htop.t.cover_observed_deferred_immediate_stmt_74' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n31pagev_user/tocover_simple_immediate_76htop.t.cover_simple_immediate_76' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n36pagev_user/tocover_simple_immediate_stmt_76htop.t.cover_simple_immediate_stmt_76' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n39pagev_user/tocover_final_deferred_immediate_76htop.t.cover_final_deferred_immediate_76' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n42pagev_user/tocover_observed_deferred_immediate_76htop.t.cover_observed_deferred_immediate_76' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n44pagev_user/tocover_final_deferred_immediate_stmt_76htop.t.cover_final_deferred_immediate_stmt_76' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl76n47pagev_user/tocover_observed_deferred_immediate_stmt_76htop.t.cover_observed_deferred_immediate_stmt_76' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n31pagev_user/tocover_simple_immediate_78htop.t.cover_simple_immediate_78' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n36pagev_user/tocover_simple_immediate_stmt_78htop.t.cover_simple_immediate_stmt_78' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n39pagev_user/tocover_final_deferred_immediate_78htop.t.cover_final_deferred_immediate_78' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n42pagev_user/tocover_observed_deferred_immediate_78htop.t.cover_observed_deferred_immediate_78' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n44pagev_user/tocover_final_deferred_immediate_stmt_78htop.t.cover_final_deferred_immediate_stmt_78' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl78n47pagev_user/tocover_observed_deferred_immediate_stmt_78htop.t.cover_observed_deferred_immediate_stmt_78' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n31pagev_user/tocover_simple_immediate_80htop.t.cover_simple_immediate_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n36pagev_user/tocover_simple_immediate_stmt_80htop.t.cover_simple_immediate_stmt_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n39pagev_user/tocover_final_deferred_immediate_80htop.t.cover_final_deferred_immediate_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n42pagev_user/tocover_observed_deferred_immediate_80htop.t.cover_observed_deferred_immediate_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n44pagev_user/tocover_final_deferred_immediate_stmt_80htop.t.cover_final_deferred_immediate_stmt_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl80n47pagev_user/tocover_observed_deferred_immediate_stmt_80htop.t.cover_observed_deferred_immediate_stmt_80' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n31pagev_user/tocover_simple_immediate_82htop.t.cover_simple_immediate_82' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n36pagev_user/tocover_simple_immediate_stmt_82htop.t.cover_simple_immediate_stmt_82' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n39pagev_user/tocover_final_deferred_immediate_82htop.t.cover_final_deferred_immediate_82' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n42pagev_user/tocover_observed_deferred_immediate_82htop.t.cover_observed_deferred_immediate_82' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n44pagev_user/tocover_final_deferred_immediate_stmt_82htop.t.cover_final_deferred_immediate_stmt_82' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl82n47pagev_user/tocover_observed_deferred_immediate_stmt_82htop.t.cover_observed_deferred_immediate_stmt_82' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n31pagev_user/tocover_simple_immediate_84htop.t.cover_simple_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n36pagev_user/tocover_simple_immediate_stmt_84htop.t.cover_simple_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n39pagev_user/tocover_final_deferred_immediate_84htop.t.cover_final_deferred_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n42pagev_user/tocover_observed_deferred_immediate_84htop.t.cover_observed_deferred_immediate_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n44pagev_user/tocover_final_deferred_immediate_stmt_84htop.t.cover_final_deferred_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl84n47pagev_user/tocover_observed_deferred_immediate_stmt_84htop.t.cover_observed_deferred_immediate_stmt_84' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n31pagev_user/tocover_simple_immediate_86htop.t.cover_simple_immediate_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n36pagev_user/tocover_simple_immediate_stmt_86htop.t.cover_simple_immediate_stmt_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n39pagev_user/tocover_final_deferred_immediate_86htop.t.cover_final_deferred_immediate_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n42pagev_user/tocover_observed_deferred_immediate_86htop.t.cover_observed_deferred_immediate_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n44pagev_user/tocover_final_deferred_immediate_stmt_86htop.t.cover_final_deferred_immediate_stmt_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl86n47pagev_user/tocover_observed_deferred_immediate_stmt_86htop.t.cover_observed_deferred_immediate_stmt_86' 1
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n31pagev_user/tocover_simple_immediate_88htop.t.cover_simple_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n36pagev_user/tocover_simple_immediate_stmt_88htop.t.cover_simple_immediate_stmt_88' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n39pagev_user/tocover_final_deferred_immediate_88htop.t.cover_final_deferred_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n42pagev_user/tocover_observed_deferred_immediate_88htop.t.cover_observed_deferred_immediate_88' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n44pagev_user/tocover_final_deferred_immediate_stmt_88htop.t.cover_final_deferred_immediate_stmt_88' 0
|
||||
C 'ft/t_assert_ctl_assertion_type.vl88n47pagev_user/tocover_observed_deferred_immediate_stmt_88htop.t.cover_observed_deferred_immediate_stmt_88' 0
|
||||
@ -1,18 +0,0 @@
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_assertion_type_unsup.v:15:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
15 | $assertcontrol(OFF, EXPECT);
|
||||
| ^~~~~~~~~~~~~~
|
||||
... For error description see https://verilator.org/warn/UNSUPPORTED?v=latest
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_assertion_type_unsup.v:16:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
16 | $assertcontrol(OFF, UNIQUE);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_assertion_type_unsup.v:17:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
17 | $assertcontrol(OFF, UNIQUE0);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error-UNSUPPORTED: t/t_assert_ctl_assertion_type_unsup.v:18:7: Unsupported: assert control assertion_type
|
||||
: ... note: In instance 't'
|
||||
18 | $assertcontrol(OFF, PRIORITY);
|
||||
| ^~~~~~~~~~~~~~
|
||||
%Error: Exiting due to
|
||||
@ -491,53 +491,41 @@
|
||||
{"type":"ASSERTCTL","name":"","addr":"(WH)","loc":"d,86:7,86:17","ctlType":"$assertoff",
|
||||
"controlTypep": [
|
||||
{"type":"CONST","name":"32'h4","addr":"(XH)","loc":"d,86:7,86:17","dtypep":"(MC)"}
|
||||
],"assertTypesp": [],
|
||||
"levelp": [
|
||||
{"type":"CONST","name":"32'h0","addr":"(YH)","loc":"d,86:7,86:17","dtypep":"(MC)"}
|
||||
],"itemsp": []},
|
||||
{"type":"ASSERTCTL","name":"","addr":"(ZH)","loc":"d,87:7,87:18","ctlType":"$assertkill",
|
||||
],"assertTypesp": [],"directiveTypesp": []},
|
||||
{"type":"ASSERTCTL","name":"","addr":"(YH)","loc":"d,87:7,87:18","ctlType":"$assertkill",
|
||||
"controlTypep": [
|
||||
{"type":"CONST","name":"32'h5","addr":"(AI)","loc":"d,87:7,87:18","dtypep":"(MC)"}
|
||||
],"assertTypesp": [],
|
||||
"levelp": [
|
||||
{"type":"CONST","name":"32'h0","addr":"(BI)","loc":"d,87:7,87:18","dtypep":"(MC)"}
|
||||
],"itemsp": []},
|
||||
{"type":"ASSERT","name":"","addr":"(CI)","loc":"d,88:7,88:13","type":"[SIMPLE_IMMEDIATE]",
|
||||
{"type":"CONST","name":"32'h5","addr":"(ZH)","loc":"d,87:7,87:18","dtypep":"(MC)"}
|
||||
],"assertTypesp": [],"directiveTypesp": []},
|
||||
{"type":"ASSERT","name":"","addr":"(AI)","loc":"d,88:7,88:13","type":"[SIMPLE_IMMEDIATE]",
|
||||
"propp": [
|
||||
{"type":"CONST","name":"?32?sh0","addr":"(DI)","loc":"d,88:14,88:15","dtypep":"(L)"}
|
||||
{"type":"CONST","name":"?32?sh0","addr":"(BI)","loc":"d,88:14,88:15","dtypep":"(L)"}
|
||||
],"sentreep": [],"failsp": [],"passsp": []},
|
||||
{"type":"ASSERTCTL","name":"","addr":"(EI)","loc":"d,89:7,89:16","ctlType":"$asserton",
|
||||
{"type":"ASSERTCTL","name":"","addr":"(CI)","loc":"d,89:7,89:16","ctlType":"$asserton",
|
||||
"controlTypep": [
|
||||
{"type":"CONST","name":"32'h3","addr":"(FI)","loc":"d,89:7,89:16","dtypep":"(MC)"}
|
||||
],"assertTypesp": [],
|
||||
"levelp": [
|
||||
{"type":"CONST","name":"32'h0","addr":"(GI)","loc":"d,89:7,89:16","dtypep":"(MC)"}
|
||||
],"itemsp": []},
|
||||
{"type":"ASSERTCTL","name":"","addr":"(HI)","loc":"d,90:7,90:21","ctlType":"",
|
||||
{"type":"CONST","name":"32'h3","addr":"(DI)","loc":"d,89:7,89:16","dtypep":"(MC)"}
|
||||
],"assertTypesp": [],"directiveTypesp": []},
|
||||
{"type":"ASSERTCTL","name":"","addr":"(EI)","loc":"d,90:7,90:21","ctlType":"",
|
||||
"controlTypep": [
|
||||
{"type":"CONST","name":"?32?sh3","addr":"(II)","loc":"d,90:22,90:23","dtypep":"(QD)"}
|
||||
{"type":"CONST","name":"?32?sh3","addr":"(FI)","loc":"d,90:22,90:23","dtypep":"(QD)"}
|
||||
],
|
||||
"assertTypesp": [
|
||||
{"type":"CONST","name":"?32?sh8","addr":"(JI)","loc":"d,90:25,90:26","dtypep":"(JF)"}
|
||||
],
|
||||
"levelp": [
|
||||
{"type":"CONST","name":"32'h0","addr":"(KI)","loc":"d,90:7,90:21","dtypep":"(MC)"}
|
||||
],"itemsp": []}
|
||||
{"type":"CONST","name":"?32?sh8","addr":"(GI)","loc":"d,90:25,90:26","dtypep":"(JF)"}
|
||||
],"directiveTypesp": []}
|
||||
]}
|
||||
]}
|
||||
]}
|
||||
],"activesp": []}
|
||||
],"filesp": [],
|
||||
"miscsp": [
|
||||
{"type":"TYPETABLE","name":"","addr":"(C)","loc":"a,0:0,0:0","constraintRefp":"UNLINKED","emptyQueuep":"UNLINKED","queueIndexp":"UNLINKED","streamp":"UNLINKED","voidp":"(LI)",
|
||||
{"type":"TYPETABLE","name":"","addr":"(C)","loc":"a,0:0,0:0","constraintRefp":"UNLINKED","emptyQueuep":"UNLINKED","queueIndexp":"UNLINKED","streamp":"UNLINKED","voidp":"(HI)",
|
||||
"typesp": [
|
||||
{"type":"BASICDTYPE","name":"integer","addr":"(MI)","loc":"c,31:27,31:28","dtypep":"(MI)","keyword":"integer","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"integer","addr":"(II)","loc":"c,31:27,31:28","dtypep":"(II)","keyword":"integer","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(L)","loc":"c,33:32,33:33","dtypep":"(L)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(UE)","loc":"c,50:22,50:24","dtypep":"(UE)","keyword":"logic","generic":true,"rangep": []},
|
||||
{"type":"VOIDDTYPE","name":"","addr":"(LI)","loc":"c,51:21,51:30","dtypep":"(LI)","generic":false},
|
||||
{"type":"VOIDDTYPE","name":"","addr":"(HI)","loc":"c,51:21,51:30","dtypep":"(HI)","generic":false},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(QD)","loc":"c,125:22,125:23","dtypep":"(QD)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(NI)","loc":"c,127:22,127:23","dtypep":"(NI)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(OI)","loc":"c,162:17,162:56","dtypep":"(OI)","keyword":"logic","range":"295:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(JI)","loc":"c,127:22,127:23","dtypep":"(JI)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(KI)","loc":"c,162:17,162:56","dtypep":"(KI)","keyword":"logic","range":"295:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"string","addr":"(BG)","loc":"c,162:10,162:16","dtypep":"(BG)","keyword":"string","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(Q)","loc":"d,14:9,14:11","dtypep":"(Q)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
{"type":"BASICDTYPE","name":"logic","addr":"(BB)","loc":"d,18:10,18:12","dtypep":"(BB)","keyword":"logic","range":"31:0","generic":true,"rangep": []},
|
||||
@ -552,9 +540,9 @@
|
||||
]},
|
||||
{"type":"CONSTPOOL","name":"","addr":"(D)","loc":"a,0:0,0:0",
|
||||
"modulep": [
|
||||
{"type":"MODULE","name":"@CONST-POOL@","addr":"(PI)","loc":"a,0:0,0:0","origName":"@CONST-POOL@","level":0,"modPublic":false,"inLibrary":false,"dead":false,"recursiveClone":false,"recursive":false,"timeunit":"NONE","inlinesp": [],
|
||||
{"type":"MODULE","name":"@CONST-POOL@","addr":"(LI)","loc":"a,0:0,0:0","origName":"@CONST-POOL@","level":0,"modPublic":false,"inLibrary":false,"dead":false,"recursiveClone":false,"recursive":false,"timeunit":"NONE","inlinesp": [],
|
||||
"stmtsp": [
|
||||
{"type":"SCOPE","name":"@CONST-POOL@","addr":"(QI)","loc":"a,0:0,0:0","aboveScopep":"UNLINKED","aboveCellp":"UNLINKED","modp":"(PI)","varsp": [],"blocksp": [],"inlinesp": []}
|
||||
{"type":"SCOPE","name":"@CONST-POOL@","addr":"(MI)","loc":"a,0:0,0:0","aboveScopep":"UNLINKED","aboveCellp":"UNLINKED","modp":"(LI)","varsp": [],"blocksp": [],"inlinesp": []}
|
||||
],"activesp": []}
|
||||
]}
|
||||
]}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user