forked from github/verilator
Merge branch 'master' into develop-v5
This commit is contained in:
Geza Lore
commit
766fb56651
1
Changes
1
Changes
@ -21,6 +21,7 @@ Verilator 4.223 devel
|
||||
|
||||
**Minor:**
|
||||
|
||||
* Support compile time trace signal selection with tracing_on/off (#3323). [Shunyao CAD]
|
||||
* Fix hang with large case statement optimization (#3405). [Mike Urbach]
|
||||
|
||||
|
||||
|
||||
@ -71,6 +71,7 @@ Markus Krause
|
||||
Marlon James
|
||||
Marshal Qiao
|
||||
Martin Schmidt
|
||||
Martin Stadler
|
||||
Matthew Ballance
|
||||
Michael Killough
|
||||
Michaël Lefebvre
|
||||
|
||||
@ -1676,9 +1676,28 @@ The grammar of configuration commands is as follows:
|
||||
|
||||
.. option:: tracing_off [-file "<filename>" [-lines <line> [ - <line> ]]]
|
||||
|
||||
Enable/disable waveform tracing for all future signals declared in the
|
||||
specified filename (or wildcard with '\*' or '?', or all files if
|
||||
omitted) and range of line numbers (or all lines if omitted).
|
||||
.. option:: tracing_on [-scope "<scopename>" [-levels <levels> ]]
|
||||
|
||||
For tracing_off, instances below any module in the files/ranges
|
||||
specified will also not be traced.
|
||||
.. option:: tracing_off [-scope "<scopename>" [-levels <levels> ]]
|
||||
|
||||
Enable/disable waveform tracing for all future signals declared in
|
||||
all files.
|
||||
|
||||
With -file, enable/disable waveform tracing in the specified
|
||||
filename (or wildcard with '\*' or '?'), and -line range of line
|
||||
numbers (or all lines if omitted).
|
||||
|
||||
For tracing_off with -file, instances below any module in the
|
||||
files/ranges specified will also not be traced. To overcome this
|
||||
feature, use tracing_on on the upper module declaration and on any
|
||||
cells, or use the -scope flavor of the command.
|
||||
|
||||
With -scope enable/disable waveform tracing for the specified scope (or
|
||||
wildcard with '\*' or '?'), and optional --levels number of levels
|
||||
below. These controls only take place after other file/line/module
|
||||
based controls have indicated the signal should be traced.
|
||||
|
||||
With -levels (used with -scope), the number of levels below that
|
||||
scope which the rule is to match, where 0 means all levels below, 1
|
||||
the exact level as the provided scope, and 2 meaning an additional
|
||||
level of children below the provided scope, etc.
|
||||
|
||||
@ -103,7 +103,7 @@ private:
|
||||
using ItemList = std::deque<VerilatedCovImpItem*>;
|
||||
|
||||
// MEMBERS
|
||||
VerilatedMutex m_mutex; // Protects all members
|
||||
mutable VerilatedMutex m_mutex; // Protects all members
|
||||
ValueIndexMap m_valueIndexes VL_GUARDED_BY(m_mutex); // Unique arbitrary value for values
|
||||
IndexValueMap m_indexValues VL_GUARDED_BY(m_mutex); // Unique arbitrary value for keys
|
||||
ItemList m_items VL_GUARDED_BY(m_mutex); // List of all items
|
||||
|
||||
@ -157,8 +157,8 @@ protected:
|
||||
friend class VerilatedCovImp;
|
||||
// CONSTRUCTORS
|
||||
// Internal: Only made as part of VerilatedCovImp
|
||||
VerilatedCovContext() {}
|
||||
virtual ~VerilatedCovContext() {}
|
||||
VerilatedCovContext() = default;
|
||||
virtual ~VerilatedCovContext() = default;
|
||||
|
||||
// METHODS
|
||||
// Internal: access to implementation class
|
||||
|
||||
@ -91,7 +91,7 @@ class VerilatedEvalMsgQueue final {
|
||||
|
||||
std::atomic<uint64_t> m_depth; // Current depth of queue (see comments below)
|
||||
|
||||
VerilatedMutex m_mutex; // Mutex protecting queue
|
||||
mutable VerilatedMutex m_mutex; // Mutex protecting queue
|
||||
VerilatedThreadQueue m_queue VL_GUARDED_BY(m_mutex); // Message queue
|
||||
public:
|
||||
// CONSTRUCTORS
|
||||
|
||||
@ -155,7 +155,7 @@ class VlExecutionProfiler final {
|
||||
|
||||
// STATE
|
||||
static VL_THREAD_LOCAL ExecutionTrace t_trace; // thread-local trace buffers
|
||||
VerilatedMutex m_mutex;
|
||||
mutable VerilatedMutex m_mutex;
|
||||
// Map from thread id to &t_trace of given thread
|
||||
std::map<uint32_t, ExecutionTrace*> m_traceps VL_GUARDED_BY(m_mutex);
|
||||
|
||||
|
||||
@ -150,7 +150,7 @@ private:
|
||||
};
|
||||
|
||||
// MEMBERS
|
||||
VerilatedMutex m_mutex;
|
||||
mutable VerilatedMutex m_mutex;
|
||||
std::condition_variable_any m_cv;
|
||||
// Only notify the condition_variable if the worker is waiting
|
||||
bool m_waiting VL_GUARDED_BY(m_mutex) = false;
|
||||
|
||||
@ -47,7 +47,7 @@
|
||||
// A simple synchronized first in first out queue
|
||||
template <class T> class VerilatedThreadQueue final { // LCOV_EXCL_LINE // lcov bug
|
||||
private:
|
||||
VerilatedMutex m_mutex; // Protects m_queue
|
||||
mutable VerilatedMutex m_mutex; // Protects m_queue
|
||||
std::condition_variable_any m_cv;
|
||||
std::deque<T> m_queue VL_GUARDED_BY(m_mutex);
|
||||
|
||||
@ -208,7 +208,7 @@ protected:
|
||||
//=========================================================================
|
||||
// Internals available to format specific implementations
|
||||
|
||||
VerilatedMutex m_mutex; // Ensure dump() etc only called from single thread
|
||||
mutable VerilatedMutex m_mutex; // Ensure dump() etc only called from single thread
|
||||
|
||||
uint32_t nextCode() const { return m_nextCode; }
|
||||
uint32_t numSignals() const { return m_numSignals; }
|
||||
|
||||
@ -317,7 +317,7 @@ public:
|
||||
iterate(nodep);
|
||||
m_graph.latchCheck(nodep, kwd == VAlwaysKwd::ALWAYS_LATCH);
|
||||
}
|
||||
virtual ~ActiveLatchCheckVisitor() {}
|
||||
virtual ~ActiveLatchCheckVisitor() = default;
|
||||
};
|
||||
|
||||
//######################################################################
|
||||
|
||||
@ -758,7 +758,7 @@ void AstNode::deleteTree() {
|
||||
#ifdef VL_LEAK_CHECKS
|
||||
void* AstNode::operator new(size_t size) {
|
||||
// Optimization note: Aligning to cache line is a loss, due to lost packing
|
||||
const AstNode* const objp = static_cast<AstNode*>(::operator new(size));
|
||||
AstNode* const objp = static_cast<AstNode*>(::operator new(size));
|
||||
V3Broken::addNewed(objp);
|
||||
return objp;
|
||||
}
|
||||
|
||||
133
src/V3Config.cpp
133
src/V3Config.cpp
@ -44,13 +44,8 @@ public:
|
||||
|
||||
/// Update into maps from other
|
||||
void update(const V3ConfigWildcardResolver& other) {
|
||||
typename Map::const_iterator it;
|
||||
for (it = other.m_mapResolved.begin(); it != other.m_mapResolved.end(); ++it) {
|
||||
m_mapResolved[it->first].update(it->second);
|
||||
}
|
||||
for (it = other.m_mapWildcard.begin(); it != other.m_mapWildcard.end(); ++it) {
|
||||
m_mapWildcard[it->first].update(it->second);
|
||||
}
|
||||
for (const auto& itr : other.m_mapResolved) m_mapResolved[itr.first].update(itr.second);
|
||||
for (const auto& itr : other.m_mapWildcard) m_mapWildcard[itr.first].update(itr.second);
|
||||
}
|
||||
|
||||
// Access and create a (wildcard) entity
|
||||
@ -68,12 +63,12 @@ public:
|
||||
// Cannot be resolved, create if matched
|
||||
|
||||
// Update this entity with all matches in the wildcards
|
||||
for (it = m_mapWildcard.begin(); it != m_mapWildcard.end(); ++it) {
|
||||
if (VString::wildmatch(name, it->first)) {
|
||||
for (const auto& wildent : m_mapWildcard) {
|
||||
if (VString::wildmatch(name, wildent.first)) {
|
||||
if (!newp) {
|
||||
newp = &m_mapResolved[name]; // Emplace and get pointer
|
||||
}
|
||||
newp->update(it->second);
|
||||
newp->update(wildent.second);
|
||||
}
|
||||
}
|
||||
return newp;
|
||||
@ -198,8 +193,8 @@ public:
|
||||
AstNode* const nodep = new AstPragma(modp->fileline(), type);
|
||||
modp->addStmtp(nodep);
|
||||
}
|
||||
for (auto it = m_modPragmas.cbegin(); it != m_modPragmas.cend(); ++it) {
|
||||
AstNode* const nodep = new AstPragma(modp->fileline(), *it);
|
||||
for (const auto& itr : m_modPragmas) {
|
||||
AstNode* const nodep = new AstPragma{modp->fileline(), itr};
|
||||
modp->addStmtp(nodep);
|
||||
}
|
||||
}
|
||||
@ -344,25 +339,124 @@ public:
|
||||
|
||||
using V3ConfigFileResolver = V3ConfigWildcardResolver<V3ConfigFile>;
|
||||
|
||||
//######################################################################
|
||||
// ScopeTrace tracking
|
||||
|
||||
class V3ConfigScopeTraceEntry final {
|
||||
public:
|
||||
const string m_scope; // Scope or regexp to match
|
||||
const bool m_on = false; // True to enable message
|
||||
int m_levels = 0; // # levels, 0 = all, 1 = only this, ...
|
||||
// CONSTRUCTORS
|
||||
V3ConfigScopeTraceEntry(const string& scope, bool on, int levels)
|
||||
: m_scope{scope}
|
||||
, m_on{on}
|
||||
, m_levels{levels} {}
|
||||
~V3ConfigScopeTraceEntry() = default;
|
||||
bool operator<(const V3ConfigScopeTraceEntry& other) const {
|
||||
if (m_on < other.m_on) return true;
|
||||
if (m_on > other.m_on) return false;
|
||||
if (m_levels < other.m_levels) return true;
|
||||
if (m_levels > other.m_levels) return false;
|
||||
return m_scope < other.m_scope;
|
||||
}
|
||||
};
|
||||
|
||||
// Tracks what matches are known to hit against V3ConfigScopeTraceEntries
|
||||
class V3ConfigScopeTraceEntryMatch final {
|
||||
public:
|
||||
const V3ConfigScopeTraceEntry* m_entryp;
|
||||
const string m_scopepart;
|
||||
V3ConfigScopeTraceEntryMatch(const V3ConfigScopeTraceEntry* entryp, const string& scopepart)
|
||||
: m_entryp{entryp}
|
||||
, m_scopepart{scopepart} {}
|
||||
bool operator<(const V3ConfigScopeTraceEntryMatch& other) const {
|
||||
if (m_entryp < other.m_entryp) return true;
|
||||
if (m_entryp > other.m_entryp) return false;
|
||||
return m_scopepart < other.m_scopepart;
|
||||
}
|
||||
};
|
||||
|
||||
class V3ConfigScopeTraceResolver final {
|
||||
std::vector<V3ConfigScopeTraceEntry> m_entries; // User specified on/offs and levels
|
||||
std::map<V3ConfigScopeTraceEntryMatch, bool> m_matchCache; // Matching entries for speed
|
||||
|
||||
public:
|
||||
void addScopeTraceOn(bool on, const string& scope, int levels) {
|
||||
UINFO(9, "addScopeTraceOn " << on << " '" << scope << "' "
|
||||
<< " levels=" << levels << endl);
|
||||
m_entries.emplace_back(V3ConfigScopeTraceEntry{scope, on, levels});
|
||||
m_matchCache.clear();
|
||||
}
|
||||
|
||||
bool getEntryMatch(const V3ConfigScopeTraceEntry* entp, const string& scopepart) {
|
||||
// Return if a entry matches the scopepart, with memoization
|
||||
const auto& key = V3ConfigScopeTraceEntryMatch{entp, scopepart};
|
||||
const auto& it = m_matchCache.find(key);
|
||||
if (it != m_matchCache.end()) return it->second; // Cached
|
||||
const bool matched = VString::wildmatch(scopepart, entp->m_scope);
|
||||
m_matchCache.emplace(key, matched);
|
||||
return matched;
|
||||
}
|
||||
|
||||
bool getScopeTraceOn(const string& scope) {
|
||||
// Apply in the order the user provided them, so they can choose on/off preferencing
|
||||
int maxLevel = 1;
|
||||
for (const auto& ch : scope) {
|
||||
if (ch == '.') ++maxLevel;
|
||||
}
|
||||
UINFO(9, "getScopeTraceOn " << scope << " maxLevel=" << maxLevel << endl);
|
||||
|
||||
bool enabled = true;
|
||||
for (const auto& ent : m_entries) {
|
||||
// We apply shortest match first for each rule component
|
||||
// (Otherwise the levels would be useless as "--scope top* --levels 1" would
|
||||
// always match at every scopepart, and we wound't know how to count levels)
|
||||
int partLevel = 1;
|
||||
for (string::size_type partEnd = 0; true;) {
|
||||
partEnd = scope.find('.', partEnd + 1);
|
||||
if (partEnd == string::npos) partEnd = scope.length();
|
||||
const std::string scopepart = scope.substr(0, partEnd);
|
||||
if (getEntryMatch(&ent, scopepart)) {
|
||||
const bool levelMatch
|
||||
= !ent.m_levels || (ent.m_levels >= maxLevel - partLevel);
|
||||
if (levelMatch) enabled = ent.m_on;
|
||||
UINFO(9, "getScopeTraceOn-part " << scope << " enabled=" << enabled
|
||||
<< " @ lev=" << partLevel
|
||||
<< (levelMatch ? "[match]" : "[miss]")
|
||||
<< " from scopepart=" << scopepart << endl);
|
||||
break;
|
||||
}
|
||||
if (partEnd == scope.length()) break;
|
||||
++partLevel;
|
||||
}
|
||||
}
|
||||
return enabled;
|
||||
}
|
||||
};
|
||||
|
||||
//######################################################################
|
||||
// Resolve modules and files in the design
|
||||
|
||||
class V3ConfigResolver final {
|
||||
V3ConfigModuleResolver m_modules; // Access to module names (with wildcards)
|
||||
V3ConfigFileResolver m_files; // Access to file names (with wildcards)
|
||||
V3ConfigScopeTraceResolver m_scopeTraces; // Regexp to trace enables
|
||||
std::unordered_map<string, std::unordered_map<string, uint64_t>>
|
||||
m_profileData; // Access to profile_data records
|
||||
FileLine* m_profileFileLine = nullptr;
|
||||
|
||||
static V3ConfigResolver s_singleton; // Singleton (not via local static, as that's slow)
|
||||
V3ConfigResolver() = default;
|
||||
~V3ConfigResolver() = default;
|
||||
|
||||
public:
|
||||
static V3ConfigResolver& s() { return s_singleton; }
|
||||
|
||||
static V3ConfigResolver& s() {
|
||||
static V3ConfigResolver s_singleton;
|
||||
return s_singleton;
|
||||
}
|
||||
V3ConfigModuleResolver& modules() { return m_modules; }
|
||||
V3ConfigFileResolver& files() { return m_files; }
|
||||
V3ConfigScopeTraceResolver& scopeTraces() { return m_scopeTraces; }
|
||||
|
||||
void addProfileData(FileLine* fl, const string& model, const string& key, uint64_t cost) {
|
||||
if (!m_profileFileLine) m_profileFileLine = fl;
|
||||
@ -379,8 +473,6 @@ public:
|
||||
FileLine* getProfileDataFileLine() const { return m_profileFileLine; } // Maybe null
|
||||
};
|
||||
|
||||
V3ConfigResolver V3ConfigResolver::s_singleton;
|
||||
|
||||
//######################################################################
|
||||
// V3Config
|
||||
|
||||
@ -434,6 +526,10 @@ void V3Config::addProfileData(FileLine* fl, const string& model, const string& k
|
||||
V3ConfigResolver::s().addProfileData(fl, model, key, cost);
|
||||
}
|
||||
|
||||
void V3Config::addScopeTraceOn(bool on, const string& scope, int levels) {
|
||||
V3ConfigResolver::s().scopeTraces().addScopeTraceOn(on, scope, levels);
|
||||
}
|
||||
|
||||
void V3Config::addVarAttr(FileLine* fl, const string& module, const string& ftask,
|
||||
const string& var, VAttrType attr, AstSenTree* sensep) {
|
||||
// Semantics: sensep only if public_flat_rw
|
||||
@ -540,6 +636,9 @@ uint64_t V3Config::getProfileData(const string& model, const string& key) {
|
||||
FileLine* V3Config::getProfileDataFileLine() {
|
||||
return V3ConfigResolver::s().getProfileDataFileLine();
|
||||
}
|
||||
bool V3Config::getScopeTraceOn(const string& scope) {
|
||||
return V3ConfigResolver::s().scopeTraces().getScopeTraceOn(scope);
|
||||
}
|
||||
|
||||
bool V3Config::waive(FileLine* filelinep, V3ErrorCode code, const string& message) {
|
||||
V3ConfigFile* filep = V3ConfigResolver::s().files().resolve(filelinep->filename());
|
||||
|
||||
@ -37,19 +37,21 @@ public:
|
||||
static void addModulePragma(const string& module, VPragmaType pragma);
|
||||
static void addProfileData(FileLine* fl, const string& model, const string& key,
|
||||
uint64_t cost);
|
||||
static void addWaiver(V3ErrorCode code, const string& filename, const string& message);
|
||||
static void addScopeTraceOn(bool on, const string& scope, int levels);
|
||||
static void addVarAttr(FileLine* fl, const string& module, const string& ftask,
|
||||
const string& signal, VAttrType type, AstSenTree* nodep);
|
||||
static void addWaiver(V3ErrorCode code, const string& filename, const string& message);
|
||||
|
||||
static void applyCase(AstCase* nodep);
|
||||
static void applyCoverageBlock(AstNodeModule* modulep, AstBegin* nodep);
|
||||
static void applyFTask(AstNodeModule* modulep, AstNodeFTask* ftaskp);
|
||||
static void applyIgnores(FileLine* filelinep);
|
||||
static void applyModule(AstNodeModule* modulep);
|
||||
static void applyFTask(AstNodeModule* modulep, AstNodeFTask* ftaskp);
|
||||
static void applyVarAttr(AstNodeModule* modulep, AstNodeFTask* ftaskp, AstVar* varp);
|
||||
|
||||
static uint64_t getProfileData(const string& model, const string& key);
|
||||
static FileLine* getProfileDataFileLine();
|
||||
static bool getScopeTraceOn(const string& scope);
|
||||
static bool waive(FileLine* filelinep, V3ErrorCode code, const string& message);
|
||||
};
|
||||
|
||||
|
||||
@ -25,9 +25,10 @@
|
||||
#include "verilated_trace_defs.h" // For VLT_TRACE_SCOPE_*
|
||||
|
||||
#include "V3Global.h"
|
||||
#include "V3TraceDecl.h"
|
||||
#include "V3Config.h"
|
||||
#include "V3EmitCBase.h"
|
||||
#include "V3Stats.h"
|
||||
#include "V3TraceDecl.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
@ -140,11 +141,14 @@ private:
|
||||
return "Verilator trace_off";
|
||||
} else if (!nodep->isTrace()) {
|
||||
return "Verilator instance trace_off";
|
||||
} else if (!v3Global.opt.traceUnderscore()) {
|
||||
} else {
|
||||
const string prettyName = varp->prettyName();
|
||||
if (!v3Global.opt.traceUnderscore()) {
|
||||
if (!prettyName.empty() && prettyName[0] == '_') return "Leading underscore";
|
||||
if (prettyName.find("._") != string::npos) return "Inlined leading underscore";
|
||||
}
|
||||
if (!V3Config::getScopeTraceOn(prettyName)) return "Vlt scope trace_off";
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
@ -138,12 +138,14 @@ vnum {vnum1}|{vnum2}|{vnum3}|{vnum4}|{vnum5}
|
||||
-?"-cost" { FL; return yVLT_D_COST; }
|
||||
-?"-file" { FL; return yVLT_D_FILE; }
|
||||
-?"-function" { FL; return yVLT_D_FUNCTION; }
|
||||
-?"-levels" { FL; return yVLT_D_LEVELS; }
|
||||
-?"-lines" { FL; return yVLT_D_LINES; }
|
||||
-?"-match" { FL; return yVLT_D_MATCH; }
|
||||
-?"-model" { FL; return yVLT_D_MODEL; }
|
||||
-?"-module" { FL; return yVLT_D_MODULE; }
|
||||
-?"-mtask" { FL; return yVLT_D_MTASK; }
|
||||
-?"-rule" { FL; return yVLT_D_RULE; }
|
||||
-?"-scope" { FL; return yVLT_D_SCOPE; }
|
||||
-?"-task" { FL; return yVLT_D_TASK; }
|
||||
-?"-var" { FL; return yVLT_D_VAR; }
|
||||
|
||||
|
||||
221
src/verilog.y
221
src/verilog.y
@ -366,12 +366,14 @@ BISONPRE_VERSION(3.7,%define api.header.include {"V3ParseBison.h"})
|
||||
%token<fl> yVLT_D_COST "--cost"
|
||||
%token<fl> yVLT_D_FILE "--file"
|
||||
%token<fl> yVLT_D_FUNCTION "--function"
|
||||
%token<fl> yVLT_D_LEVELS "--levels"
|
||||
%token<fl> yVLT_D_LINES "--lines"
|
||||
%token<fl> yVLT_D_MATCH "--match"
|
||||
%token<fl> yVLT_D_MODEL "--model"
|
||||
%token<fl> yVLT_D_MODULE "--module"
|
||||
%token<fl> yVLT_D_MTASK "--mtask"
|
||||
%token<fl> yVLT_D_RULE "--rule"
|
||||
%token<fl> yVLT_D_SCOPE "--scope"
|
||||
%token<fl> yVLT_D_TASK "--task"
|
||||
%token<fl> yVLT_D_VAR "--var"
|
||||
|
||||
@ -1134,7 +1136,8 @@ package_import_itemObj<strp>: // IEEE: part of package_import_item
|
||||
;
|
||||
|
||||
package_export_declaration<nodep>: // IEEE: package_export_declaration
|
||||
yEXPORT '*' yP_COLONCOLON '*' ';' { $$ = new AstPackageExportStarStar($<fl>2); SYMP->exportStarStar($<scp>1); }
|
||||
yEXPORT '*' yP_COLONCOLON '*' ';'
|
||||
{ $$ = new AstPackageExportStarStar{$<fl>2}; SYMP->exportStarStar($<scp>1); }
|
||||
| yEXPORT package_export_itemList ';' { $$ = $2; }
|
||||
;
|
||||
|
||||
@ -1322,23 +1325,31 @@ port<nodep>: // ==IEEE: port
|
||||
{ $$ = nullptr; BBUNSUP($<fl>2, "Unsupported: virtual or generic interfaces"); }
|
||||
//
|
||||
// // IEEE: ansi_port_declaration, with [port_direction] removed
|
||||
// // IEEE: [ net_port_header | interface_port_header ] port_identifier { unpacked_dimension } [ '=' constant_expression ]
|
||||
// // IEEE: [ net_port_header | interface_port_header ]
|
||||
// // port_identifier { unpacked_dimension } [ '=' constant_expression ]
|
||||
// // IEEE: [ net_port_header | variable_port_header ] '.' port_identifier '(' [ expression ] ')'
|
||||
// // IEEE: [ variable_port_header ] port_identifier { variable_dimension } [ '=' constant_expression ]
|
||||
// // IEEE: [ variable_port_header ] port_identifier
|
||||
// // { variable_dimension } [ '=' constant_expression ]
|
||||
// // Substitute net_port_header = [ port_direction ] net_port_type
|
||||
// // Substitute variable_port_header = [ port_direction ] variable_port_type
|
||||
// // Substitute net_port_type = [ net_type ] data_type_or_implicit
|
||||
// // Substitute variable_port_type = var_data_type
|
||||
// // Substitute var_data_type = data_type | yVAR data_type_or_implicit
|
||||
// // [ [ port_direction ] net_port_type | interface_port_header ] port_identifier { unpacked_dimension }
|
||||
// // [ [ port_direction ] var_data_type ] port_identifier variable_dimensionListE [ '=' constant_expression ]
|
||||
// // [ [ port_direction ] net_port_type | [ port_direction ] var_data_type ] '.' port_identifier '(' [ expression ] ')'
|
||||
// // [ [ port_direction ] net_port_type | interface_port_header]
|
||||
// // port_identifier { unpacked_dimension }
|
||||
// // [ [ port_direction ] var_data_type ]
|
||||
// // port_identifier variable_dimensionListE [ '=' constant_expression ]
|
||||
// // [ [ port_direction ] net_port_type | [ port_direction ] var_data_type ]
|
||||
// // '.' port_identifier '(' [ expression ] ')'
|
||||
//
|
||||
// // Remove optional '[...] id' is in portAssignment
|
||||
// // Remove optional '[port_direction]' is in port
|
||||
// // net_port_type | interface_port_header port_identifier { unpacked_dimension }
|
||||
// // net_port_type | interface_port_header port_identifier { unpacked_dimension }
|
||||
// // var_data_type port_identifier variable_dimensionListE [ '=' constExpr ]
|
||||
// // net_port_type | interface_port_header
|
||||
// // port_identifier { unpacked_dimension }
|
||||
// // net_port_type | interface_port_header
|
||||
// // port_identifier { unpacked_dimension }
|
||||
// // var_data_type
|
||||
// // port_identifier variable_dimensionListE [ '=' constExpr ]
|
||||
// // net_port_type | [ port_direction ] var_data_type '.' port_identifier '(' [ expr ] ')'
|
||||
// // Expand implicit_type
|
||||
//
|
||||
@ -1364,9 +1375,12 @@ port<nodep>: // ==IEEE: port
|
||||
| portDirNetE yVAR implicit_typeE portSig variable_dimensionListE sigAttrListE
|
||||
{ $$=$4; VARDTYPE($3); $$->addNextNull(VARDONEP($$,$5,$6)); }
|
||||
| portDirNetE signing portSig variable_dimensionListE sigAttrListE
|
||||
{ $$=$3; VARDTYPE_NDECL(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2)); $$->addNextNull(VARDONEP($$,$4,$5)); }
|
||||
{ $$=$3; VARDTYPE_NDECL(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2));
|
||||
$$->addNextNull(VARDONEP($$, $4, $5)); }
|
||||
| portDirNetE signingE rangeList portSig variable_dimensionListE sigAttrListE
|
||||
{ $$=$4; VARDTYPE_NDECL(GRAMMARP->addRange(new AstBasicDType($3->fileline(), LOGIC_IMPLICIT, $2), $3,true)); $$->addNextNull(VARDONEP($$,$5,$6)); }
|
||||
{ $$=$4; VARDTYPE_NDECL(GRAMMARP->addRange(
|
||||
new AstBasicDType{$3->fileline(), LOGIC_IMPLICIT, $2}, $3, true));
|
||||
$$->addNextNull(VARDONEP($$, $5, $6)); }
|
||||
| portDirNetE /*implicit*/ portSig variable_dimensionListE sigAttrListE
|
||||
{ $$=$2; /*VARDTYPE-same*/ $$->addNextNull(VARDONEP($$,$3,$4)); }
|
||||
//
|
||||
@ -1692,9 +1706,13 @@ net_dataTypeE<nodeDTypep>:
|
||||
// // Otherwise #(...) can't be determined to be a delay or parameters
|
||||
// // Submit this as a footnote to the committee
|
||||
var_data_type { $$ = $1; }
|
||||
| signingE rangeList delayE { $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC, $1),$2,true); } // not implicit
|
||||
| signing { $$ = new AstBasicDType($<fl>1, LOGIC, $1); } // not implicit
|
||||
| /*implicit*/ delayE { $$ = new AstBasicDType(CRELINE(), LOGIC); } // not implicit
|
||||
| signingE rangeList delayE
|
||||
{ $$ = GRAMMARP->addRange(new AstBasicDType{$2->fileline(), LOGIC, $1},
|
||||
$2, true); } // not implicit
|
||||
| signing
|
||||
{ $$ = new AstBasicDType{$<fl>1, LOGIC, $1}; } // not implicit
|
||||
| /*implicit*/ delayE
|
||||
{ $$ = new AstBasicDType{CRELINE(), LOGIC}; } // not implicit
|
||||
;
|
||||
|
||||
net_type: // ==IEEE: net_type
|
||||
@ -1855,10 +1873,15 @@ data_typeBasic<nodeDTypep>: // IEEE: part of data_type
|
||||
|
||||
data_typeNoRef<nodeDTypep>: // ==IEEE: data_type, excluding class_type etc references
|
||||
data_typeBasic { $$ = $1; }
|
||||
| struct_unionDecl packed_dimensionListE { $$ = GRAMMARP->createArray(new AstDefImplicitDType($1->fileline(),"__typeimpsu"+cvtToStr(GRAMMARP->s_modTypeImpNum++),
|
||||
SYMP,VFlagChildDType(),$1),$2,true); }
|
||||
| enumDecl { $$ = new AstDefImplicitDType($1->fileline(),"__typeimpenum"+cvtToStr(GRAMMARP->s_modTypeImpNum++),
|
||||
SYMP,VFlagChildDType(),$1); }
|
||||
| struct_unionDecl packed_dimensionListE
|
||||
{ $$ = GRAMMARP->createArray(
|
||||
new AstDefImplicitDType{$1->fileline(),
|
||||
"__typeimpsu" + cvtToStr(GRAMMARP->s_modTypeImpNum++),
|
||||
SYMP, VFlagChildDType{}, $1}, $2, true); }
|
||||
| enumDecl
|
||||
{ $$ = new AstDefImplicitDType{$1->fileline(),
|
||||
"__typeimpenum" + cvtToStr(GRAMMARP->s_modTypeImpNum++),
|
||||
SYMP, VFlagChildDType{}, $1}; }
|
||||
| ySTRING { $$ = new AstBasicDType($1,VBasicDTypeKwd::STRING); }
|
||||
| yCHANDLE { $$ = new AstBasicDType($1,VBasicDTypeKwd::CHANDLE); }
|
||||
| yEVENT { $$ = new AstBasicDType($1,VBasicDTypeKwd::EVENTVALUE); }
|
||||
@ -1926,9 +1949,11 @@ list_of_member_decl_assignments<nodep>: // Derived from IEEE: list_of_variable_d
|
||||
;
|
||||
|
||||
member_decl_assignment<memberDTypep>: // Derived from IEEE: variable_decl_assignment
|
||||
// // At present we allow only packed structures/unions. So this is different from variable_decl_assignment
|
||||
// // At present we allow only packed structures/unions.
|
||||
// // So this is different from variable_decl_assignment
|
||||
id variable_dimensionListE
|
||||
{ if ($2) $2->v3warn(UNPACKED, "Unsupported: Unpacked array in packed struct/union (struct/union converted to unpacked)");
|
||||
{ if ($2) $2->v3warn(UNPACKED, "Unsupported: Unpacked array in packed struct/union"
|
||||
" (struct/union converted to unpacked)");
|
||||
$$ = new AstMemberDType($<fl>1, *$1, VFlagChildDType(),
|
||||
AstNodeDType::cloneTreeNull(GRAMMARP->m_memDTypep, true));
|
||||
PARSEP->tagNodep($$);
|
||||
@ -2046,19 +2071,25 @@ packedSigningE<signstate>:
|
||||
|
||||
// IEEE: part of data_type
|
||||
enumDecl<nodeDTypep>:
|
||||
yENUM enum_base_typeE '{' enum_nameList '}' { $$ = new AstEnumDType($1,VFlagChildDType(),$2,$4); }
|
||||
yENUM enum_base_typeE '{' enum_nameList '}'
|
||||
{ $$ = new AstEnumDType{$1, VFlagChildDType{}, $2, $4}; }
|
||||
;
|
||||
|
||||
enum_base_typeE<nodeDTypep>: // IEEE: enum_base_type
|
||||
/* empty */ { $$ = new AstBasicDType(CRELINE(), VBasicDTypeKwd::INT); }
|
||||
/* empty */
|
||||
{ $$ = new AstBasicDType(CRELINE(), VBasicDTypeKwd::INT); }
|
||||
// // Not in spec, but obviously "enum [1:0]" should work
|
||||
// // implicit_type expanded, without empty
|
||||
// // Note enum base types are always packed data types
|
||||
| signingE rangeList { $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC_IMPLICIT, $1),$2,true); }
|
||||
| signing { $$ = new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $1); }
|
||||
| signingE rangeList
|
||||
{ $$ = GRAMMARP->addRange(new AstBasicDType{$2->fileline(), LOGIC_IMPLICIT, $1}, $2, true); }
|
||||
| signing
|
||||
{ $$ = new AstBasicDType{$<fl>1, LOGIC_IMPLICIT, $1}; }
|
||||
//
|
||||
| integer_atom_type signingE { $1->setSignedState($2); $$ = $1; }
|
||||
| integer_vector_type signingE rangeListE { $1->setSignedState($2); $$ = GRAMMARP->addRange($1,$3,true); }
|
||||
| integer_atom_type signingE
|
||||
{ $1->setSignedState($2); $$ = $1; }
|
||||
| integer_vector_type signingE rangeListE
|
||||
{ $1->setSignedState($2); $$ = GRAMMARP->addRange($1, $3, true); }
|
||||
// // below can be idAny or yaID__aTYPE
|
||||
// // IEEE requires a type, though no shift conflict if idAny
|
||||
// // IEEE: type_identifier [ packed_dimension ]
|
||||
@ -2076,13 +2107,17 @@ enum_nameList<nodep>:
|
||||
;
|
||||
|
||||
enum_name_declaration<nodep>: // ==IEEE: enum_name_declaration
|
||||
idAny/*enum_identifier*/ enumNameRangeE enumNameStartE { $$ = new AstEnumItem($<fl>1, *$1, $2, $3); }
|
||||
idAny/*enum_identifier*/ enumNameRangeE enumNameStartE
|
||||
{ $$ = new AstEnumItem($<fl>1, *$1, $2, $3); }
|
||||
;
|
||||
|
||||
enumNameRangeE<nodep>: // IEEE: second part of enum_name_declaration
|
||||
/* empty */ { $$ = nullptr; }
|
||||
| '[' intnumAsConst ']' { $$ = new AstRange($1, new AstConst($1, 0), new AstConst($1, $2->toSInt()-1)); }
|
||||
| '[' intnumAsConst ':' intnumAsConst ']' { $$ = new AstRange($1,$2,$4); }
|
||||
/* empty */
|
||||
{ $$ = nullptr; }
|
||||
| '[' intnumAsConst ']'
|
||||
{ $$ = new AstRange{$1, new AstConst($1, 0), new AstConst($1, $2->toSInt() - 1)}; }
|
||||
| '[' intnumAsConst ':' intnumAsConst ']'
|
||||
{ $$ = new AstRange{$1, $2, $4}; }
|
||||
;
|
||||
|
||||
enumNameStartE<nodep>: // IEEE: third part of enum_name_declaration
|
||||
@ -2091,7 +2126,7 @@ enumNameStartE<nodep>: // IEEE: third part of enum_name_declaration
|
||||
;
|
||||
|
||||
intnumAsConst<constp>:
|
||||
yaINTNUM { $$ = new AstConst($<fl>1,*$1); }
|
||||
yaINTNUM { $$ = new AstConst{$<fl>1, *$1}; }
|
||||
;
|
||||
|
||||
//************************************************
|
||||
@ -2122,12 +2157,14 @@ class_property<nodep>: // ==IEEE: class_property, which is {property_qualifier}
|
||||
;
|
||||
|
||||
data_declarationVar<varp>: // IEEE: part of data_declaration
|
||||
// // The first declaration has complications between assuming what's the type vs ID declaring
|
||||
// // The first declaration has complications between assuming what's
|
||||
// // the type vs ID declaring
|
||||
data_declarationVarFront list_of_variable_decl_assignments ';' { $$ = $2; }
|
||||
;
|
||||
|
||||
data_declarationVarClass<varp>: // IEEE: part of data_declaration (for class_property)
|
||||
// // The first declaration has complications between assuming what's the type vs ID declaring
|
||||
// // The first declaration has complications between assuming what's
|
||||
// // the type vs ID declaring
|
||||
data_declarationVarFrontClass list_of_variable_decl_assignments ';' { $$ = $2; }
|
||||
;
|
||||
|
||||
@ -2174,7 +2211,8 @@ data_declarationVarFrontClass: // IEEE: part of data_declaration (for class_prop
|
||||
yVAR lifetimeE data_type { VARRESET_NONLIST(VAR); VARLIFE($2); VARDTYPE($3); }
|
||||
| yVAR lifetimeE { VARRESET_NONLIST(VAR); VARLIFE($2); }
|
||||
| yVAR lifetimeE signingE rangeList
|
||||
{ /*VARRESET-in-ddVar*/ VARDTYPE(GRAMMARP->addRange(new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $3), $4,true));
|
||||
{ /*VARRESET-in-ddVar*/
|
||||
VARDTYPE(GRAMMARP->addRange(new AstBasicDType{$<fl>1, LOGIC_IMPLICIT, $3}, $4, true));
|
||||
VARLIFE($2); }
|
||||
//
|
||||
// // Expanded: "constE lifetimeE data_type"
|
||||
@ -2193,9 +2231,12 @@ data_declarationVarFrontClass: // IEEE: part of data_declaration (for class_prop
|
||||
|
||||
implicit_typeE<nodeDTypep>: // IEEE: part of *data_type_or_implicit
|
||||
// // Also expanded in data_declaration
|
||||
/* empty */ { $$ = nullptr; }
|
||||
| signingE rangeList { $$ = GRAMMARP->addRange(new AstBasicDType($2->fileline(), LOGIC_IMPLICIT, $1),$2,true); }
|
||||
| signing { $$ = new AstBasicDType($<fl>1, LOGIC_IMPLICIT, $1); }
|
||||
/* empty */
|
||||
{ $$ = nullptr; }
|
||||
| signingE rangeList
|
||||
{ $$ = GRAMMARP->addRange(new AstBasicDType{$2->fileline(), LOGIC_IMPLICIT, $1}, $2, true); }
|
||||
| signing
|
||||
{ $$ = new AstBasicDType{$<fl>1, LOGIC_IMPLICIT, $1}; }
|
||||
;
|
||||
|
||||
//UNSUPassertion_variable_declaration: // IEEE: assertion_variable_declaration
|
||||
@ -2236,7 +2277,8 @@ type_declaration<nodep>: // ==IEEE: type_declaration
|
||||
// // Alternative is use of idAny below, but this will cause conflicts with ablve
|
||||
| yTYPEDEF idType ';' { $$ = GRAMMARP->createTypedefFwd($<fl>2, *$2); }
|
||||
// // Combines into above "data_type id" rule
|
||||
// // Verilator: Not important what it is in the AST, just need to make sure the yaID__aTYPE gets returned
|
||||
// // Verilator: Not important what it is in the AST, just need
|
||||
// // to make sure the yaID__aTYPE gets returned
|
||||
| yTYPEDEF id ';' { $$ = GRAMMARP->createTypedefFwd($<fl>2, *$2); }
|
||||
| yTYPEDEF yENUM idAny ';' { $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
|
||||
| yTYPEDEF ySTRUCT idAny ';' { $$ = GRAMMARP->createTypedefFwd($<fl>3, *$3); }
|
||||
@ -2313,7 +2355,8 @@ module_or_generate_item<nodep>: // ==IEEE: module_or_generate_item
|
||||
// // not here, see etcInst in module_common_item
|
||||
// // We joined udp & module definitions, so this goes here
|
||||
| combinational_body { $$ = $1; }
|
||||
// // This module_common_item shared with interface_or_generate_item:module_common_item
|
||||
// // This module_common_item shared with
|
||||
// // interface_or_generate_item:module_common_item
|
||||
| module_common_item { $$ = $1; }
|
||||
;
|
||||
|
||||
@ -2372,8 +2415,10 @@ aliasEqList: // IEEE: part of net_alias
|
||||
;
|
||||
|
||||
bind_directive<nodep>: // ==IEEE: bind_directive + bind_target_scope
|
||||
// // ';' - Note IEEE grammar is wrong, includes extra ';' - it's already in module_instantiation
|
||||
// // We merged the rules - id may be a bind_target_instance or module_identifier or interface_identifier
|
||||
// // ';' - Note IEEE grammar is wrong, includes extra ';'
|
||||
// // - it's already in module_instantiation
|
||||
// // We merged the rules - id may be a bind_target_instance or
|
||||
// // module_identifier or interface_identifier
|
||||
yBIND bind_target_instance bind_instantiation { $$ = new AstBind($<fl>2, *$2, $3); }
|
||||
| yBIND bind_target_instance ':' bind_target_instance_list bind_instantiation
|
||||
{ $$ = nullptr; BBUNSUP($1, "Unsupported: Bind with instance list"); }
|
||||
@ -2535,10 +2580,18 @@ genvar_iteration<nodep>: // ==IEEE: genvar_iteration
|
||||
| varRefBase yP_SSRIGHTEQ expr { $$ = new AstAssign($2,$1,new AstShiftRS($2,$1->cloneTree(true),$3)); }
|
||||
// // inc_or_dec_operator
|
||||
// When support ++ as a real AST type, maybe AstWhile::precondsp() becomes generic AstNodeMathStmt?
|
||||
| yP_PLUSPLUS varRefBase { $$ = new AstAssign($1,$2,new AstAdd ($1,$2->cloneTree(true), new AstConst($1, AstConst::StringToParse(), "'b1"))); }
|
||||
| yP_MINUSMINUS varRefBase { $$ = new AstAssign($1,$2,new AstSub ($1,$2->cloneTree(true), new AstConst($1, AstConst::StringToParse(), "'b1"))); }
|
||||
| varRefBase yP_PLUSPLUS { $$ = new AstAssign($2,$1,new AstAdd ($2,$1->cloneTree(true), new AstConst($2, AstConst::StringToParse(), "'b1"))); }
|
||||
| varRefBase yP_MINUSMINUS { $$ = new AstAssign($2,$1,new AstSub ($2,$1->cloneTree(true), new AstConst($2, AstConst::StringToParse(), "'b1"))); }
|
||||
| yP_PLUSPLUS varRefBase
|
||||
{ $$ = new AstAssign{$1, $2, new AstAdd{$1, $2->cloneTree(true),
|
||||
new AstConst{$1, AstConst::StringToParse{}, "'b1"}}}; }
|
||||
| yP_MINUSMINUS varRefBase
|
||||
{ $$ = new AstAssign{$1, $2, new AstSub{$1, $2->cloneTree(true),
|
||||
new AstConst{$1, AstConst::StringToParse{}, "'b1"}}}; }
|
||||
| varRefBase yP_PLUSPLUS
|
||||
{ $$ = new AstAssign{$2, $1, new AstAdd{$2, $1->cloneTree(true),
|
||||
new AstConst{$2, AstConst::StringToParse{}, "'b1"}}}; }
|
||||
| varRefBase yP_MINUSMINUS
|
||||
{ $$ = new AstAssign{$2, $1, new AstSub{$2, $1->cloneTree(true),
|
||||
new AstConst{$2, AstConst::StringToParse{}, "'b1"}}}; }
|
||||
;
|
||||
|
||||
case_generate_itemListE<nodep>: // IEEE: [{ case_generate_itemList }]
|
||||
@ -2625,10 +2678,13 @@ netSigList<varp>: // IEEE: list_of_port_identifiers
|
||||
;
|
||||
|
||||
netSig<varp>: // IEEE: net_decl_assignment - one element from list_of_port_identifiers
|
||||
netId sigAttrListE { $$ = VARDONEA($<fl>1,*$1, nullptr, $2); }
|
||||
| netId sigAttrListE '=' expr { $$ = VARDONEA($<fl>1,*$1, nullptr, $2);
|
||||
$$->addNext(new AstAssignW($3, new AstVarRef($<fl>1, *$1, VAccess::WRITE), $4)); }
|
||||
| netId variable_dimensionList sigAttrListE { $$ = VARDONEA($<fl>1,*$1, $2, $3); }
|
||||
netId sigAttrListE
|
||||
{ $$ = VARDONEA($<fl>1,*$1, nullptr, $2); }
|
||||
| netId sigAttrListE '=' expr
|
||||
{ $$ = VARDONEA($<fl>1, *$1, nullptr, $2);
|
||||
$$->addNext(new AstAssignW{$3, new AstVarRef{$<fl>1, *$1, VAccess::WRITE}, $4}); }
|
||||
| netId variable_dimensionList sigAttrListE
|
||||
{ $$ = VARDONEA($<fl>1,*$1, $2, $3); }
|
||||
;
|
||||
|
||||
netId<strp>:
|
||||
@ -2823,8 +2879,10 @@ instRangeList<nodeRangep>:
|
||||
;
|
||||
|
||||
instRange<nodeRangep>:
|
||||
'[' constExpr ']' { $$ = new AstRange($1, new AstConst($1, 0), new AstSub($1, $2, new AstConst($1, 1))); }
|
||||
| '[' constExpr ':' constExpr ']' { $$ = new AstRange($1,$2,$4); }
|
||||
'[' constExpr ']'
|
||||
{ $$ = new AstRange{$1, new AstConst{$1, 0}, new AstSub{$1, $2, new AstConst{$1, 1}}}; }
|
||||
| '[' constExpr ':' constExpr ']'
|
||||
{ $$ = new AstRange{$1, $2, $4}; }
|
||||
;
|
||||
|
||||
cellparamList<pinp>:
|
||||
@ -2908,7 +2966,8 @@ event_control<senTreep>: // ==IEEE: event_control
|
||||
| '@' senitemVar { $$ = new AstSenTree($1,$2); } /* For events only */
|
||||
// // IEEE: sequence_instance
|
||||
// // sequence_instance without parens matches idClassSel above.
|
||||
// // Ambiguity: "'@' sequence (-for-sequence" versus expr:delay_or_event_controlE "'@' id (-for-expr
|
||||
// // Ambiguity: "'@' sequence (-for-sequence" versus
|
||||
// // expr:delay_or_event_controlE "'@' id (-for-expr
|
||||
// // For now we avoid this, as it's very unlikely someone would mix
|
||||
// // 1995 delay with a sequence with parameters.
|
||||
// // Alternatively split this out of event_control, and delay_or_event_controlE
|
||||
@ -3226,15 +3285,16 @@ statement_item<nodep>: // IEEE: statement_item
|
||||
|
||||
statementFor<beginp>: // IEEE: part of statement
|
||||
yFOR '(' for_initialization expr ';' for_stepE ')' stmtBlock
|
||||
{ $$ = new AstBegin($1, "", $3, false, true);
|
||||
$$->addStmtsp(new AstWhile($1, $4,$8,$6)); }
|
||||
{ $$ = new AstBegin{$1, "", $3, false, true};
|
||||
$$->addStmtsp(new AstWhile{$1, $4, $8, $6}); }
|
||||
| yFOR '(' for_initialization ';' for_stepE ')' stmtBlock
|
||||
{ $$ = new AstBegin($1, "", $3, false, true);
|
||||
$$->addStmtsp(new AstWhile($1, new AstConst($1,AstConst::BitTrue()), $7, $5)); }
|
||||
{ $$ = new AstBegin{$1, "", $3, false, true};
|
||||
$$->addStmtsp(new AstWhile{$1, new AstConst{$1, AstConst::BitTrue()}, $7, $5}); }
|
||||
;
|
||||
|
||||
statementVerilatorPragmas<nodep>:
|
||||
yVL_COVERAGE_BLOCK_OFF { $$ = new AstPragma($1,VPragmaType::COVERAGE_BLOCK_OFF); }
|
||||
yVL_COVERAGE_BLOCK_OFF
|
||||
{ $$ = new AstPragma{$1, VPragmaType::COVERAGE_BLOCK_OFF}; }
|
||||
;
|
||||
|
||||
//UNSUPoperator_assignment<nodep>: // IEEE: operator_assignment
|
||||
@ -3443,9 +3503,11 @@ patternKey<nodep>: // IEEE: merge structure_pattern_key, array_pattern_key, ass
|
||||
//UNSUP simple_type { $1->v3error("Unsupported: '{} with data type as key"); $$ = $1; }
|
||||
// // simple_type reference looks like constExpr
|
||||
// // Verilator:
|
||||
// // The above expressions cause problems because "foo" may be a constant identifier
|
||||
// // (if array) or a reference to the "foo"member (if structure)
|
||||
// // So for now we only allow a true constant number, or a identifier which we treat as a structure member name
|
||||
// // The above expressions cause problems because "foo" may be
|
||||
// // a constant identifier (if array) or a reference to the
|
||||
// // "foo"member (if structure)
|
||||
// // So for now we only allow a true constant number, or an
|
||||
// // identifier which we treat as a structure member name
|
||||
yaINTNUM { $$ = new AstConst($<fl>1,*$1); }
|
||||
| yaFLOATNUM { $$ = new AstConst($<fl>1,AstConst::RealDouble(),$1); }
|
||||
| id { $$ = new AstText($<fl>1,*$1); }
|
||||
@ -5490,7 +5552,8 @@ pexpr<nodep>: // IEEE: property_expr (The name pexpr is important as regexps j
|
||||
// // IEEE: "property_instance"
|
||||
// // Looks just like a function/method call
|
||||
//
|
||||
// // Note "clocking_event pexpr" overlaps property_statement_spec: clocking_event property_statement
|
||||
// // Note "clocking_event pexpr" overlaps
|
||||
// // property_statement_spec: clocking_event property_statement
|
||||
//
|
||||
// // Include property_specDisable to match property_spec rule
|
||||
//UNSUP clocking_event yDISABLE yIFF '(' expr ')' pexpr %prec prSEQ_CLOCKING { }
|
||||
@ -5519,7 +5582,8 @@ pexpr<nodep>: // IEEE: property_expr (The name pexpr is important as regexps j
|
||||
//UNSUP //
|
||||
//UNSUP // // IEEE: "sequence_instance [ sequence_abbrev ]"
|
||||
//UNSUP // // version without sequence_abbrev looks just like normal function call
|
||||
//UNSUP // // version w/sequence_abbrev matches above; expression_or_dist:expr:func boolean_abbrev:sequence_abbrev
|
||||
//UNSUP // // version w/sequence_abbrev matches above;
|
||||
//UNSUP // // expression_or_dist:expr:func boolean_abbrev:sequence_abbrev
|
||||
//UNSUP //
|
||||
//UNSUP // // IEEE: '(' expression_or_dist {',' sequence_match_item } ')' [ boolean_abbrev ]
|
||||
//UNSUP // // IEEE: '(' sexpr {',' sequence_match_item } ')' [ sequence_abbrev ]
|
||||
@ -6313,7 +6377,8 @@ solve_before_list<nodep>: // ==IEEE: solve_before_list
|
||||
;
|
||||
|
||||
constraint_primary<nodep>: // ==IEEE: constraint_primary
|
||||
// // exprScope more general than: [ implicit_class_handle '.' | class_scope ] hierarchical_identifier select
|
||||
// // exprScope more general than:
|
||||
// // [ implicit_class_handle '.' | class_scope ] hierarchical_identifier select
|
||||
exprScope { $$ = $1; }
|
||||
;
|
||||
|
||||
@ -6387,26 +6452,52 @@ colon<fl>: // Generic colon that isn't making a label (e.g. in a case_item)
|
||||
|
||||
vltItem:
|
||||
|
||||
vltOffFront { V3Config::addIgnore($1, false, "*", 0, 0); }
|
||||
vltOffFront
|
||||
{ V3Config::addIgnore($1, false, "*", 0, 0); }
|
||||
| vltOffFront yVLT_D_FILE yaSTRING
|
||||
{ V3Config::addIgnore($1, false, *$3, 0, 0); }
|
||||
| vltOffFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
|
||||
{ V3Config::addIgnore($1, false, *$3, $5->toUInt(), $5->toUInt()+1); }
|
||||
| vltOffFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM '-' yaINTNUM
|
||||
{ V3Config::addIgnore($1, false, *$3, $5->toUInt(), $7->toUInt()+1); }
|
||||
| vltOffFront yVLT_D_SCOPE yaSTRING
|
||||
{ if ($1 != V3ErrorCode::I_TRACING) {
|
||||
$<fl>1->v3error("Argument -scope only supported for tracing_on/off");
|
||||
} else {
|
||||
V3Config::addScopeTraceOn(false, *$3, 0);
|
||||
}}
|
||||
| vltOffFront yVLT_D_SCOPE yaSTRING yVLT_D_LEVELS yaINTNUM
|
||||
{ if ($1 != V3ErrorCode::I_TRACING) {
|
||||
$<fl>1->v3error("Argument -scope only supported for tracing_on/off_off");
|
||||
} else {
|
||||
V3Config::addScopeTraceOn(false, *$3, $5->toUInt());
|
||||
}}
|
||||
| vltOffFront yVLT_D_FILE yaSTRING yVLT_D_MATCH yaSTRING
|
||||
{ if (($1 == V3ErrorCode::I_COVERAGE) || ($1 == V3ErrorCode::I_TRACING)) {
|
||||
$<fl>1->v3error("Argument -match only supported for lint_off");
|
||||
} else {
|
||||
V3Config::addWaiver($1,*$3,*$5);
|
||||
}}
|
||||
| vltOnFront { V3Config::addIgnore($1, true, "*", 0, 0); }
|
||||
| vltOnFront
|
||||
{ V3Config::addIgnore($1, true, "*", 0, 0); }
|
||||
| vltOnFront yVLT_D_FILE yaSTRING
|
||||
{ V3Config::addIgnore($1, true, *$3, 0, 0); }
|
||||
| vltOnFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM
|
||||
{ V3Config::addIgnore($1, true, *$3, $5->toUInt(), $5->toUInt()+1); }
|
||||
| vltOnFront yVLT_D_FILE yaSTRING yVLT_D_LINES yaINTNUM '-' yaINTNUM
|
||||
{ V3Config::addIgnore($1, true, *$3, $5->toUInt(), $7->toUInt()+1); }
|
||||
| vltOnFront yVLT_D_SCOPE yaSTRING
|
||||
{ if ($1 != V3ErrorCode::I_TRACING) {
|
||||
$<fl>1->v3error("Argument -scope only supported for tracing_on/off");
|
||||
} else {
|
||||
V3Config::addScopeTraceOn(true, *$3, 0);
|
||||
}}
|
||||
| vltOnFront yVLT_D_SCOPE yaSTRING yVLT_D_LEVELS yaINTNUM
|
||||
{ if ($1 != V3ErrorCode::I_TRACING) {
|
||||
$<fl>1->v3error("Argument -scope only supported for tracing_on/off_off");
|
||||
} else {
|
||||
V3Config::addScopeTraceOn(true, *$3, $5->toUInt());
|
||||
}}
|
||||
| vltVarAttrFront vltDModuleE vltDFTaskE vltVarAttrVarE attr_event_controlE
|
||||
{ V3Config::addVarAttr($<fl>1, *$2, *$3, *$4, $1, $5); }
|
||||
| vltInlineFront vltDModuleE vltDFTaskE
|
||||
|
||||
@ -40,7 +40,7 @@ public:
|
||||
__LINE__, m_info.product);
|
||||
}
|
||||
}
|
||||
~TestSimulator() {}
|
||||
~TestSimulator() = default;
|
||||
// METHORS
|
||||
private:
|
||||
static TestSimulator& singleton() {
|
||||
|
||||
@ -9,8 +9,8 @@
|
||||
class t_extend_class_c {
|
||||
public:
|
||||
// CONSTRUCTORS
|
||||
t_extend_class_c() {}
|
||||
~t_extend_class_c() {}
|
||||
t_extend_class_c() = default;
|
||||
~t_extend_class_c() = default;
|
||||
// METHODS
|
||||
// This function will be called from a instance created in Verilog
|
||||
inline uint32_t my_math(uint32_t in) { return in + 1; }
|
||||
|
||||
157
test_regress/t/t_trace_scope_vlt.out
Normal file
157
test_regress/t/t_trace_scope_vlt.out
Normal file
@ -0,0 +1,157 @@
|
||||
$version Generated by VerilatedVcd $end
|
||||
$date Thu May 12 22:13:21 2022 $end
|
||||
$timescale 1ps $end
|
||||
|
||||
$scope module top $end
|
||||
$var wire 1 ) clk $end
|
||||
$scope module t $end
|
||||
$var wire 1 ) clk $end
|
||||
$scope module sub1a $end
|
||||
$var wire 32 * ADD [31:0] $end
|
||||
$var wire 32 # cyc [31:0] $end
|
||||
$var wire 32 $ value [31:0] $end
|
||||
$upscope $end
|
||||
$scope module sub1b $end
|
||||
$var wire 32 + ADD [31:0] $end
|
||||
$var wire 32 # cyc [31:0] $end
|
||||
$var wire 32 % value [31:0] $end
|
||||
$scope module sub2a $end
|
||||
$var wire 32 # cyc [31:0] $end
|
||||
$var wire 32 & value [31:0] $end
|
||||
$upscope $end
|
||||
$scope module sub2b $end
|
||||
$var wire 32 , ADD [31:0] $end
|
||||
$var wire 32 # cyc [31:0] $end
|
||||
$var wire 32 ' value [31:0] $end
|
||||
$upscope $end
|
||||
$scope module sub2c $end
|
||||
$var wire 32 - ADD [31:0] $end
|
||||
$var wire 32 # cyc [31:0] $end
|
||||
$var wire 32 ( value [31:0] $end
|
||||
$upscope $end
|
||||
$upscope $end
|
||||
$upscope $end
|
||||
$upscope $end
|
||||
$enddefinitions $end
|
||||
|
||||
|
||||
#0
|
||||
b00000000000000000000000000000000 #
|
||||
b00000000000000000000000000001010 $
|
||||
b00000000000000000000000000010100 %
|
||||
b00000000000000000000000000010101 &
|
||||
b00000000000000000000000000010110 '
|
||||
b00000000000000000000000000010111 (
|
||||
0)
|
||||
b00000000000000000000000000001010 *
|
||||
b00000000000000000000000000010100 +
|
||||
b00000000000000000000000000010110 ,
|
||||
b00000000000000000000000000010111 -
|
||||
#10
|
||||
b00000000000000000000000000000001 #
|
||||
b00000000000000000000000000001011 $
|
||||
b00000000000000000000000000010101 %
|
||||
b00000000000000000000000000010110 &
|
||||
b00000000000000000000000000010111 '
|
||||
b00000000000000000000000000011000 (
|
||||
1)
|
||||
#15
|
||||
0)
|
||||
#20
|
||||
b00000000000000000000000000000010 #
|
||||
b00000000000000000000000000001100 $
|
||||
b00000000000000000000000000010110 %
|
||||
b00000000000000000000000000010111 &
|
||||
b00000000000000000000000000011000 '
|
||||
b00000000000000000000000000011001 (
|
||||
1)
|
||||
#25
|
||||
0)
|
||||
#30
|
||||
b00000000000000000000000000000011 #
|
||||
b00000000000000000000000000001101 $
|
||||
b00000000000000000000000000010111 %
|
||||
b00000000000000000000000000011000 &
|
||||
b00000000000000000000000000011001 '
|
||||
b00000000000000000000000000011010 (
|
||||
1)
|
||||
#35
|
||||
0)
|
||||
#40
|
||||
b00000000000000000000000000000100 #
|
||||
b00000000000000000000000000001110 $
|
||||
b00000000000000000000000000011000 %
|
||||
b00000000000000000000000000011001 &
|
||||
b00000000000000000000000000011010 '
|
||||
b00000000000000000000000000011011 (
|
||||
1)
|
||||
#45
|
||||
0)
|
||||
#50
|
||||
b00000000000000000000000000000101 #
|
||||
b00000000000000000000000000001111 $
|
||||
b00000000000000000000000000011001 %
|
||||
b00000000000000000000000000011010 &
|
||||
b00000000000000000000000000011011 '
|
||||
b00000000000000000000000000011100 (
|
||||
1)
|
||||
#55
|
||||
0)
|
||||
#60
|
||||
b00000000000000000000000000000110 #
|
||||
b00000000000000000000000000010000 $
|
||||
b00000000000000000000000000011010 %
|
||||
b00000000000000000000000000011011 &
|
||||
b00000000000000000000000000011100 '
|
||||
b00000000000000000000000000011101 (
|
||||
1)
|
||||
#65
|
||||
0)
|
||||
#70
|
||||
b00000000000000000000000000000111 #
|
||||
b00000000000000000000000000010001 $
|
||||
b00000000000000000000000000011011 %
|
||||
b00000000000000000000000000011100 &
|
||||
b00000000000000000000000000011101 '
|
||||
b00000000000000000000000000011110 (
|
||||
1)
|
||||
#75
|
||||
0)
|
||||
#80
|
||||
b00000000000000000000000000001000 #
|
||||
b00000000000000000000000000010010 $
|
||||
b00000000000000000000000000011100 %
|
||||
b00000000000000000000000000011101 &
|
||||
b00000000000000000000000000011110 '
|
||||
b00000000000000000000000000011111 (
|
||||
1)
|
||||
#85
|
||||
0)
|
||||
#90
|
||||
b00000000000000000000000000001001 #
|
||||
b00000000000000000000000000010011 $
|
||||
b00000000000000000000000000011101 %
|
||||
b00000000000000000000000000011110 &
|
||||
b00000000000000000000000000011111 '
|
||||
b00000000000000000000000000100000 (
|
||||
1)
|
||||
#95
|
||||
0)
|
||||
#100
|
||||
b00000000000000000000000000001010 #
|
||||
b00000000000000000000000000010100 $
|
||||
b00000000000000000000000000011110 %
|
||||
b00000000000000000000000000011111 &
|
||||
b00000000000000000000000000100000 '
|
||||
b00000000000000000000000000100001 (
|
||||
1)
|
||||
#105
|
||||
0)
|
||||
#110
|
||||
b00000000000000000000000000001011 #
|
||||
b00000000000000000000000000010101 $
|
||||
b00000000000000000000000000011111 %
|
||||
b00000000000000000000000000100000 &
|
||||
b00000000000000000000000000100001 '
|
||||
b00000000000000000000000000100010 (
|
||||
1)
|
||||
26
test_regress/t/t_trace_scope_vlt.pl
Executable file
26
test_regress/t/t_trace_scope_vlt.pl
Executable file
@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env perl
|
||||
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
|
||||
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
|
||||
#
|
||||
# Copyright 2003-2009 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_all => 1);
|
||||
|
||||
top_filename("t/t_trace_scope_vlt.v");
|
||||
|
||||
compile(
|
||||
v_flags2 => ["--trace t/t_trace_scope_vlt.vlt"],
|
||||
);
|
||||
|
||||
execute(
|
||||
check_finished => 1,
|
||||
);
|
||||
|
||||
vcd_identical("$Self->{obj_dir}/simx.vcd", $Self->{golden_filename});
|
||||
|
||||
ok(1);
|
||||
1;
|
||||
42
test_regress/t/t_trace_scope_vlt.v
Normal file
42
test_regress/t/t_trace_scope_vlt.v
Normal file
@ -0,0 +1,42 @@
|
||||
// DESCRIPTION: Verilator: Verilog Test module
|
||||
//
|
||||
// This file ONLY is placed under the Creative Commons Public Domain, for
|
||||
// any use, without warranty, 2022 by Wilson Snyder.
|
||||
// SPDX-License-Identifier: CC0-1.0
|
||||
|
||||
module t (/*AUTOARG*/
|
||||
// Inputs
|
||||
clk
|
||||
);
|
||||
|
||||
input clk;
|
||||
int cyc;
|
||||
|
||||
sub1 #(10) sub1a (.*);
|
||||
sub1 #(20) sub1b (.*);
|
||||
|
||||
always @ (posedge clk) begin
|
||||
cyc <= cyc + 1;
|
||||
if (cyc == 10) begin
|
||||
$write("*-* All Finished *-*\n");
|
||||
$finish;
|
||||
end
|
||||
end
|
||||
|
||||
endmodule
|
||||
|
||||
module sub1 #(parameter int ADD)
|
||||
(input int cyc);
|
||||
|
||||
wire int value = cyc + ADD;
|
||||
|
||||
sub2 #(ADD + 1) sub2a(.*);
|
||||
sub2 #(ADD + 2) sub2b(.*);
|
||||
sub2 #(ADD + 3) sub2c(.*);
|
||||
endmodule
|
||||
|
||||
module sub2 #(parameter int ADD)
|
||||
(input int cyc);
|
||||
|
||||
wire int value = cyc + ADD;
|
||||
endmodule
|
||||
13
test_regress/t/t_trace_scope_vlt.vlt
Normal file
13
test_regress/t/t_trace_scope_vlt.vlt
Normal file
@ -0,0 +1,13 @@
|
||||
// DESCRIPTION: Verilator: Verilog Test module
|
||||
//
|
||||
// This file ONLY is placed into the Public Domain, for any use,
|
||||
// without warranty, 2022 by Wilson Snyder.
|
||||
// SPDX-License-Identifier: CC0-1.0
|
||||
|
||||
`verilator_config
|
||||
|
||||
tracing_off -scope "t*" -levels 0
|
||||
tracing_on -scope "t.clk"
|
||||
tracing_on -scope "t.sub1a" -levels 1
|
||||
tracing_on -scope "t.sub1b" -levels 2
|
||||
tracing_off -scope "*.sub2a.ADD"
|
||||
@ -1,7 +1,22 @@
|
||||
%Error: t/t_vlt_syntax_bad.vlt:9:20: sensitivity not expected for attribute
|
||||
9 | public -module "t" @(posedge clk)
|
||||
| ^
|
||||
%Error: t/t_vlt_syntax_bad.vlt:10:1: isolate_assignments only applies to signals or functions/tasks
|
||||
10 | isolate_assignments -module "t"
|
||||
%Error: t/t_vlt_syntax_bad.vlt:11:1: isolate_assignments only applies to signals or functions/tasks
|
||||
11 | isolate_assignments -module "t"
|
||||
| ^~~~~~~~~~~~~~~~~~~
|
||||
%Error: t/t_vlt_syntax_bad.vlt:13:1: Argument -match only supported for lint_off
|
||||
13 | tracing_off --file "*" -match "nothing"
|
||||
| ^~~~~~~~~~~
|
||||
%Error: t/t_vlt_syntax_bad.vlt:15:1: Argument -scope only supported for tracing_on/off
|
||||
15 | lint_off --rule UNOPTFLAT -scope "top*"
|
||||
| ^~~~~~~~
|
||||
%Error: t/t_vlt_syntax_bad.vlt:16:1: Argument -scope only supported for tracing_on/off_off
|
||||
16 | lint_off --rule UNOPTFLAT -scope "top*" -levels 0
|
||||
| ^~~~~~~~
|
||||
%Error: t/t_vlt_syntax_bad.vlt:17:1: Argument -scope only supported for tracing_on/off
|
||||
17 | lint_on --rule UNOPTFLAT -scope "top*"
|
||||
| ^~~~~~~
|
||||
%Error: t/t_vlt_syntax_bad.vlt:18:1: Argument -scope only supported for tracing_on/off_off
|
||||
18 | lint_on --rule UNOPTFLAT -scope "top*" -levels 0
|
||||
| ^~~~~~~
|
||||
%Error: Exiting due to
|
||||
|
||||
@ -7,4 +7,12 @@
|
||||
`verilator_config
|
||||
|
||||
public -module "t" @(posedge clk)
|
||||
// only signals/functions/tasks
|
||||
isolate_assignments -module "t"
|
||||
// -match not supported
|
||||
tracing_off --file "*" -match "nothing"
|
||||
// -scope not supported
|
||||
lint_off --rule UNOPTFLAT -scope "top*"
|
||||
lint_off --rule UNOPTFLAT -scope "top*" -levels 0
|
||||
lint_on --rule UNOPTFLAT -scope "top*"
|
||||
lint_on --rule UNOPTFLAT -scope "top*" -levels 0
|
||||
|
||||
@ -334,9 +334,14 @@ function(verilate TARGET)
|
||||
|
||||
target_link_libraries(${TARGET} PUBLIC
|
||||
${${VERILATE_PREFIX}_USER_LDLIBS}
|
||||
"$<$<BOOL:$<TARGET_PROPERTY:VERILATOR_THREADED>>:${VERILATOR_MT_CFLAGS}>"
|
||||
)
|
||||
|
||||
if (${VERILATE_PREFIX}_THREADS OR ${VERILATE_PREFIX}_TRACE_THREADS)
|
||||
target_link_libraries(${TARGET} PUBLIC
|
||||
${VERILATOR_MT_CFLAGS}
|
||||
)
|
||||
endif()
|
||||
|
||||
target_compile_features(${TARGET} PRIVATE cxx_std_11)
|
||||
endfunction()
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user