Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

Remove redundant 'inline' keywords from definitions

Browse Source 
Also add checks to t/t_dist_cppstyle
This commit is contained in:
Geza Lore 2022-09-16 13:17:38 +01:00
parent 0c70a0dcbf
commit 38a8d7fb2e
45 changed files with 305 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
include/verilated.cpp
View File

@ -1003,22 +1003,22 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
} }
} }
static inline bool _vl_vsss_eof(FILE* fp, int floc) VL_MT_SAFE { static bool _vl_vsss_eof(FILE* fp, int floc) VL_MT_SAFE {
if (VL_LIKELY(fp)) { if (VL_LIKELY(fp)) {
return std::feof(fp) ? true : false; // true : false to prevent MSVC++ warning return std::feof(fp) ? true : false; // true : false to prevent MSVC++ warning
} else { } else {
return floc < 0; return floc < 0;
} }
} }
static inline void _vl_vsss_advance(FILE* fp, int& floc) VL_MT_SAFE { static void _vl_vsss_advance(FILE* fp, int& floc) VL_MT_SAFE {
if (VL_LIKELY(fp)) { if (VL_LIKELY(fp)) {
std::fgetc(fp); std::fgetc(fp);
} else { } else {
floc -= 8; floc -= 8;
} }
} }
static inline int _vl_vsss_peek(FILE* fp, int& floc, const WDataInP fromp, static int _vl_vsss_peek(FILE* fp, int& floc, const WDataInP fromp,
const std::string& fstr) VL_MT_SAFE { const std::string& fstr) VL_MT_SAFE {
// Get a character without advancing // Get a character without advancing
if (VL_LIKELY(fp)) { if (VL_LIKELY(fp)) {
const int data = std::fgetc(fp); const int data = std::fgetc(fp);
@ -1035,17 +1035,16 @@ static inline int _vl_vsss_peek(FILE* fp, int& floc, const WDataInP fromp,
} }
} }
} }
static inline void _vl_vsss_skipspace(FILE* fp, int& floc, const WDataInP fromp, static void _vl_vsss_skipspace(FILE* fp, int& floc, const WDataInP fromp,
const std::string& fstr) VL_MT_SAFE { const std::string& fstr) VL_MT_SAFE {
while (true) { while (true) {
const int c = _vl_vsss_peek(fp, floc, fromp, fstr); const int c = _vl_vsss_peek(fp, floc, fromp, fstr);
if (c == EOF || !std::isspace(c)) return; if (c == EOF || !std::isspace(c)) return;
_vl_vsss_advance(fp, floc); _vl_vsss_advance(fp, floc);
} }
} }
static inline void _vl_vsss_read_str(FILE* fp, int& floc, const WDataInP fromp, static void _vl_vsss_read_str(FILE* fp, int& floc, const WDataInP fromp, const std::string& fstr,
const std::string& fstr, char* tmpp, char* tmpp, const char* acceptp) VL_MT_SAFE {
const char* acceptp) VL_MT_SAFE {
// Read into tmp, consisting of characters from acceptp list // Read into tmp, consisting of characters from acceptp list
char* cp = tmpp; char* cp = tmpp;
while (true) { while (true) {
@ -1059,9 +1058,8 @@ static inline void _vl_vsss_read_str(FILE* fp, int& floc, const WDataInP fromp,
*cp++ = '\0'; *cp++ = '\0';
// VL_DBG_MSGF(" _read got='"<<tmpp<<"'\n"); // VL_DBG_MSGF(" _read got='"<<tmpp<<"'\n");
} }
static inline char* _vl_vsss_read_bin(FILE* fp, int& floc, const WDataInP fromp, static char* _vl_vsss_read_bin(FILE* fp, int& floc, const WDataInP fromp, const std::string& fstr,
const std::string& fstr, char* beginp, std::size_t n, char* beginp, std::size_t n, const bool inhibit = false) {
const bool inhibit = false) {
// Variant of _vl_vsss_read_str using the same underlying I/O functions but optimized // Variant of _vl_vsss_read_str using the same underlying I/O functions but optimized
// specifically for block reads of N bytes (read operations are not demarcated by // specifically for block reads of N bytes (read operations are not demarcated by
// whitespace). In the fp case, except descriptor to have been opened in binary mode. // whitespace). In the fp case, except descriptor to have been opened in binary mode.
@ -1073,12 +1071,11 @@ static inline char* _vl_vsss_read_bin(FILE* fp, int& floc, const WDataInP fromp,
} }
return beginp; return beginp;
} }
static inline void _vl_vsss_setbit(WDataOutP owp, int obits, int lsb, int nbits, static void _vl_vsss_setbit(WDataOutP owp, int obits, int lsb, int nbits, IData ld) VL_MT_SAFE {
IData ld) VL_MT_SAFE {
for (; nbits && lsb < obits; nbits--, lsb++, ld >>= 1) { VL_ASSIGNBIT_WI(lsb, owp, ld & 1); } for (; nbits && lsb < obits; nbits--, lsb++, ld >>= 1) { VL_ASSIGNBIT_WI(lsb, owp, ld & 1); }
} }
static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp, static void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp,
size_t posstart, size_t posend) VL_MT_SAFE { size_t posstart, size_t posend) VL_MT_SAFE {
// Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits. // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits.
int lsb = 0; int lsb = 0;
for (int i = 0, pos = static_cast<int>(posend) - 1; for (int i = 0, pos = static_cast<int>(posend) - 1;

18
include/verilated.h
View File

@ -274,7 +274,7 @@ protected:
public: public:
/// Returns the VerilatedContext this model is instantiated under /// Returns the VerilatedContext this model is instantiated under
/// Used to get to e.g. simulation time via contextp()->time() /// Used to get to e.g. simulation time via contextp()->time()
inline VerilatedContext* contextp() const { return &m_context; } VerilatedContext* contextp() const { return &m_context; }
/// Returns the hierarchical name of this module instance. /// Returns the hierarchical name of this module instance.
virtual const char* hierName() const = 0; virtual const char* hierName() const = 0;
/// Returns the name of this model (the name of the generated model class). /// Returns the name of this model (the name of the generated model class).
@ -457,9 +457,9 @@ public:
VerilatedCovContext* coveragep() VL_MT_SAFE; VerilatedCovContext* coveragep() VL_MT_SAFE;
/// Set debug level /// Set debug level
/// Debug is currently global, but for forward compatibility have a per-context method /// Debug is currently global, but for forward compatibility have a per-context method
static void debug(int val) VL_MT_SAFE; static inline void debug(int val) VL_MT_SAFE;
/// Return debug level /// Return debug level
static int debug() VL_MT_SAFE; static inline int debug() VL_MT_SAFE;
/// Set current number of errors/assertions /// Set current number of errors/assertions
void errorCount(int val) VL_MT_SAFE; void errorCount(int val) VL_MT_SAFE;
/// Increment current number of errors/assertions /// Increment current number of errors/assertions
@ -521,7 +521,7 @@ public:
/// ///
/// * Else, time comes from the legacy 'double sc_time_stamp()' which /// * Else, time comes from the legacy 'double sc_time_stamp()' which
/// must be a function defined by the user's wrapper. /// must be a function defined by the user's wrapper.
uint64_t time() const VL_MT_SAFE; inline uint64_t time() const VL_MT_SAFE;
/// Set current simulation time. See time() for side effect details /// Set current simulation time. See time() for side effect details
void time(uint64_t value) VL_MT_SAFE { m_s.m_time = value; } void time(uint64_t value) VL_MT_SAFE { m_s.m_time = value; }
/// Advance current simulation time. See time() for side effect details /// Advance current simulation time. See time() for side effect details
@ -652,13 +652,13 @@ public: // But internals only - called from VerilatedModule's
const char* name() const { return m_namep; } const char* name() const { return m_namep; }
const char* identifier() const { return m_identifierp; } const char* identifier() const { return m_identifierp; }
int8_t timeunit() const { return m_timeunit; } int8_t timeunit() const { return m_timeunit; }
inline VerilatedSyms* symsp() const { return m_symsp; } VerilatedSyms* symsp() const { return m_symsp; }
VerilatedVar* varFind(const char* namep) const VL_MT_SAFE_POSTINIT; VerilatedVar* varFind(const char* namep) const VL_MT_SAFE_POSTINIT;
VerilatedVarNameMap* varsp() const VL_MT_SAFE_POSTINIT { return m_varsp; } VerilatedVarNameMap* varsp() const VL_MT_SAFE_POSTINIT { return m_varsp; }
void scopeDump() const; void scopeDump() const;
void* exportFindError(int funcnum) const; void* exportFindError(int funcnum) const;
static void* exportFindNullError(int funcnum) VL_MT_SAFE; static void* exportFindNullError(int funcnum) VL_MT_SAFE;
static inline void* exportFind(const VerilatedScope* scopep, int funcnum) VL_MT_SAFE { static void* exportFind(const VerilatedScope* scopep, int funcnum) VL_MT_SAFE {
if (VL_UNLIKELY(!scopep)) return exportFindNullError(funcnum); if (VL_UNLIKELY(!scopep)) return exportFindNullError(funcnum);
if (VL_LIKELY(funcnum < scopep->m_funcnumMax)) { if (VL_LIKELY(funcnum < scopep->m_funcnumMax)) {
// m_callbacksp must be declared, as Max'es are > 0 // m_callbacksp must be declared, as Max'es are > 0
@ -727,7 +727,7 @@ public:
/// Return debug level /// Return debug level
/// When multithreaded this may not immediately react to another thread /// When multithreaded this may not immediately react to another thread
/// changing the level (no mutex) /// changing the level (no mutex)
static inline int debug() VL_MT_SAFE { return s_debug; } static int debug() VL_MT_SAFE { return s_debug; }
#else #else
/// Return constant 0 debug level, so C++'s optimizer rips up /// Return constant 0 debug level, so C++'s optimizer rips up
static constexpr int debug() VL_PURE { return 0; } static constexpr int debug() VL_PURE { return 0; }
@ -933,8 +933,8 @@ private:
#endif #endif
}; };
inline void VerilatedContext::debug(int val) VL_MT_SAFE { Verilated::debug(val); } void VerilatedContext::debug(int val) VL_MT_SAFE { Verilated::debug(val); }
inline int VerilatedContext::debug() VL_MT_SAFE { return Verilated::debug(); } int VerilatedContext::debug() VL_MT_SAFE { return Verilated::debug(); }
//========================================================================= //=========================================================================
// Data Types // Data Types

2
include/verilated_dpi.cpp
View File

@ -181,7 +181,7 @@ void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int w
//====================================================================== //======================================================================
// Open array internals // Open array internals
static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHandle h) { static const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHandle h) {
if (VL_UNLIKELY(!h)) { if (VL_UNLIKELY(!h)) {
VL_FATAL_MT(__FILE__, __LINE__, "", VL_FATAL_MT(__FILE__, __LINE__, "",
"%%Error: DPI svOpenArrayHandle function called with nullptr handle"); "%%Error: DPI svOpenArrayHandle function called with nullptr handle");

16
include/verilated_fst_c.h
View File

@ -161,13 +161,13 @@ class VerilatedFstBuffer VL_NOT_FINAL {
// Implementations of duck-typed methods for VerilatedTraceBuffer. These are // Implementations of duck-typed methods for VerilatedTraceBuffer. These are
// called from only one place (the full* methods), so always inline them. // called from only one place (the full* methods), so always inline them.
VL_ATTR_ALWINLINE inline void emitBit(uint32_t code, CData newval); VL_ATTR_ALWINLINE void emitBit(uint32_t code, CData newval);
VL_ATTR_ALWINLINE inline void emitCData(uint32_t code, CData newval, int bits); VL_ATTR_ALWINLINE void emitCData(uint32_t code, CData newval, int bits);
VL_ATTR_ALWINLINE inline void emitSData(uint32_t code, SData newval, int bits); VL_ATTR_ALWINLINE void emitSData(uint32_t code, SData newval, int bits);
VL_ATTR_ALWINLINE inline void emitIData(uint32_t code, IData newval, int bits); VL_ATTR_ALWINLINE void emitIData(uint32_t code, IData newval, int bits);
VL_ATTR_ALWINLINE inline void emitQData(uint32_t code, QData newval, int bits); VL_ATTR_ALWINLINE void emitQData(uint32_t code, QData newval, int bits);
VL_ATTR_ALWINLINE inline void emitWData(uint32_t code, const WData* newvalp, int bits); VL_ATTR_ALWINLINE void emitWData(uint32_t code, const WData* newvalp, int bits);
VL_ATTR_ALWINLINE inline void emitDouble(uint32_t code, double newval); VL_ATTR_ALWINLINE void emitDouble(uint32_t code, double newval);
}; };
//============================================================================= //=============================================================================
@ -232,7 +232,7 @@ public:
} }
// Internal class access // Internal class access
inline VerilatedFst* spTrace() { return &m_sptrace; } VerilatedFst* spTrace() { return &m_sptrace; }
}; };
#endif // guard #endif // guard

3
include/verilated_fst_sc.h
View File

@ -75,8 +75,7 @@ private:
//-------------------------------------------------- //--------------------------------------------------
// SystemC 2.1.v1 // SystemC 2.1.v1
#define DECL_TRACE_METHOD_A(tp) \ #define DECL_TRACE_METHOD_A(tp) void trace(const tp& object, const std::string& name) override;
void trace(const tp& object, const std::string& name) override;
#define DECL_TRACE_METHOD_B(tp) \ #define DECL_TRACE_METHOD_B(tp) \
void trace(const tp& object, const std::string& name, int width) override; void trace(const tp& object, const std::string& name, int width) override;

2
include/verilated_funcs.h
View File

@ -282,7 +282,7 @@ inline uint64_t vl_time_stamp64() {
# endif # endif
#endif #endif
inline uint64_t VerilatedContext::time() const VL_MT_SAFE { uint64_t VerilatedContext::time() const VL_MT_SAFE {
// When using non-default context, fastest path is return time // When using non-default context, fastest path is return time
if (VL_LIKELY(m_s.m_time)) return m_s.m_time; if (VL_LIKELY(m_s.m_time)) return m_s.m_time;
#if defined(SYSTEMC_VERSION) || (!defined(VL_TIME_CONTEXT) && !defined(VL_NO_LEGACY)) #if defined(SYSTEMC_VERSION) || (!defined(VL_TIME_CONTEXT) && !defined(VL_NO_LEGACY))

6
include/verilated_imp.h
View File

@ -356,7 +356,7 @@ public: // But only for verilated*.cpp
} }
} }
} }
inline FILE* fdToFp(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) { FILE* fdToFp(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock{m_fdMutex}; const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr; if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr;
@ -466,7 +466,7 @@ public:
// There's often many more scopes than userdata's and thus having a ~48byte // There's often many more scopes than userdata's and thus having a ~48byte
// per map overhead * N scopes would take much more space and cache thrashing. // per map overhead * N scopes would take much more space and cache thrashing.
// As scopep's are pointers, this implicitly handles multiple Context's // As scopep's are pointers, this implicitly handles multiple Context's
static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE { static void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
const VerilatedLockGuard lock{s().m_userMapMutex}; const VerilatedLockGuard lock{s().m_userMapMutex};
const auto it = s().m_userMap.find(std::make_pair(scopep, userKey)); const auto it = s().m_userMap.find(std::make_pair(scopep, userKey));
if (it != s().m_userMap.end()) { if (it != s().m_userMap.end()) {
@ -475,7 +475,7 @@ public:
s().m_userMap.emplace(std::make_pair(scopep, userKey), userData); s().m_userMap.emplace(std::make_pair(scopep, userKey), userData);
} }
} }
static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE { static void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
const VerilatedLockGuard lock{s().m_userMapMutex}; const VerilatedLockGuard lock{s().m_userMapMutex};
const auto& it = vlstd::as_const(s().m_userMap).find(std::make_pair(scopep, userKey)); const auto& it = vlstd::as_const(s().m_userMap).find(std::make_pair(scopep, userKey));
if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr; if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr;

7
include/verilated_profiler.h
View File

@ -45,8 +45,7 @@ class VlThreadPool;
//============================================================================= //=============================================================================
// Return high-precision counter for profiling, or 0x0 if not available // Return high-precision counter for profiling, or 0x0 if not available
VL_ATTR_ALWINLINE VL_ATTR_ALWINLINE QData VL_CPU_TICK() {
inline QData VL_CPU_TICK() {
uint64_t val; uint64_t val;
VL_GET_CPU_TICK(val); VL_GET_CPU_TICK(val);
return val; return val;
@ -171,9 +170,9 @@ public:
// METHODS // METHODS
// Is profiling enabled // Is profiling enabled
inline bool enabled() const { return m_enabled; } bool enabled() const { return m_enabled; }
// Append a trace record to the trace buffer of the current thread // Append a trace record to the trace buffer of the current thread
static inline VlExecutionRecord& addRecord() { static VlExecutionRecord& addRecord() {
t_trace.emplace_back(); t_trace.emplace_back();
return t_trace.back(); return t_trace.back();
} }

14
include/verilated_threads.h
View File

@ -103,7 +103,7 @@ public:
// Upstream mtasks must call this when they complete. // Upstream mtasks must call this when they complete.
// Returns true when the current MTaskVertex becomes ready to execute, // Returns true when the current MTaskVertex becomes ready to execute,
// false while it's still waiting on more dependencies. // false while it's still waiting on more dependencies.
inline bool signalUpstreamDone(bool evenCycle) { bool signalUpstreamDone(bool evenCycle) {
if (evenCycle) { if (evenCycle) {
const uint32_t upstreamDepsDone const uint32_t upstreamDepsDone
= 1 + m_upstreamDepsDone.fetch_add(1, std::memory_order_release); = 1 + m_upstreamDepsDone.fetch_add(1, std::memory_order_release);
@ -116,11 +116,11 @@ public:
return (upstreamDepsDone_prev == 1); return (upstreamDepsDone_prev == 1);
} }
} }
inline bool areUpstreamDepsDone(bool evenCycle) const { bool areUpstreamDepsDone(bool evenCycle) const {
const uint32_t target = evenCycle ? m_upstreamDepCount : 0; const uint32_t target = evenCycle ? m_upstreamDepCount : 0;
return m_upstreamDepsDone.load(std::memory_order_acquire) == target; return m_upstreamDepsDone.load(std::memory_order_acquire) == target;
} }
inline void waitUntilUpstreamDone(bool evenCycle) const { void waitUntilUpstreamDone(bool evenCycle) const {
unsigned ct = 0; unsigned ct = 0;
while (VL_UNLIKELY(!areUpstreamDepsDone(evenCycle))) { while (VL_UNLIKELY(!areUpstreamDepsDone(evenCycle))) {
VL_CPU_RELAX(); VL_CPU_RELAX();
@ -171,7 +171,7 @@ public:
// METHODS // METHODS
template <bool SpinWait> template <bool SpinWait>
inline void dequeWork(ExecRec* workp) VL_MT_SAFE_EXCLUDES(m_mutex) { void dequeWork(ExecRec* workp) VL_MT_SAFE_EXCLUDES(m_mutex) {
// Spin for a while, waiting for new data // Spin for a while, waiting for new data
if VL_CONSTEXPR_CXX17 (SpinWait) { if VL_CONSTEXPR_CXX17 (SpinWait) {
for (unsigned i = 0; i < VL_LOCK_SPINS; ++i) { for (unsigned i = 0; i < VL_LOCK_SPINS; ++i) {
@ -191,7 +191,7 @@ public:
m_ready.erase(m_ready.begin()); m_ready.erase(m_ready.begin());
m_ready_size.fetch_sub(1, std::memory_order_relaxed); m_ready_size.fetch_sub(1, std::memory_order_relaxed);
} }
inline void addTask(VlExecFnp fnp, VlSelfP selfp, bool evenCycle = false) void addTask(VlExecFnp fnp, VlSelfP selfp, bool evenCycle = false)
VL_MT_SAFE_EXCLUDES(m_mutex) { VL_MT_SAFE_EXCLUDES(m_mutex) {
bool notify; bool notify;
{ {
@ -223,8 +223,8 @@ public:
~VlThreadPool() override; ~VlThreadPool() override;
// METHODS // METHODS
inline int numThreads() const { return m_workers.size(); } int numThreads() const { return m_workers.size(); }
inline VlWorkerThread* workerp(int index) { VlWorkerThread* workerp(int index) {
assert(index >= 0); assert(index >= 0);
assert(index < m_workers.size()); assert(index < m_workers.size());
return m_workers[index]; return m_workers[index];

34
include/verilated_trace.h
View File

@ -318,8 +318,8 @@ protected:
void flushBase(); void flushBase();
#ifdef VL_THREADED #ifdef VL_THREADED
inline bool offload() const { return m_offload; } bool offload() const { return m_offload; }
inline bool parallel() const { return m_parallel; } bool parallel() const { return m_parallel; }
#else #else
static constexpr bool offload() { return false; } static constexpr bool offload() { return false; }
static constexpr bool parallel() { return false; } static constexpr bool parallel() { return false; }
@ -425,7 +425,7 @@ public:
// duck-typed void emitWData(uint32_t code, const WData* newvalp, int bits) = 0; // duck-typed void emitWData(uint32_t code, const WData* newvalp, int bits) = 0;
// duck-typed void emitDouble(uint32_t code, double newval) = 0; // duck-typed void emitDouble(uint32_t code, double newval) = 0;
VL_ATTR_ALWINLINE inline uint32_t* oldp(uint32_t code) { return m_sigs_oldvalp + code; } VL_ATTR_ALWINLINE uint32_t* oldp(uint32_t code) { return m_sigs_oldvalp + code; }
// Write to previous value buffer value and emit trace entry. // Write to previous value buffer value and emit trace entry.
void fullBit(uint32_t* oldp, CData newval); void fullBit(uint32_t* oldp, CData newval);
@ -441,27 +441,27 @@ public:
// thread and are called chg*Impl // thread and are called chg*Impl
// Check previous dumped value of signal. If changed, then emit trace entry // Check previous dumped value of signal. If changed, then emit trace entry
VL_ATTR_ALWINLINE inline void chgBit(uint32_t* oldp, CData newval) { VL_ATTR_ALWINLINE void chgBit(uint32_t* oldp, CData newval) {
const uint32_t diff = *oldp ^ newval; const uint32_t diff = *oldp ^ newval;
if (VL_UNLIKELY(diff)) fullBit(oldp, newval); if (VL_UNLIKELY(diff)) fullBit(oldp, newval);
} }
VL_ATTR_ALWINLINE inline void chgCData(uint32_t* oldp, CData newval, int bits) { VL_ATTR_ALWINLINE void chgCData(uint32_t* oldp, CData newval, int bits) {
const uint32_t diff = *oldp ^ newval; const uint32_t diff = *oldp ^ newval;
if (VL_UNLIKELY(diff)) fullCData(oldp, newval, bits); if (VL_UNLIKELY(diff)) fullCData(oldp, newval, bits);
} }
VL_ATTR_ALWINLINE inline void chgSData(uint32_t* oldp, SData newval, int bits) { VL_ATTR_ALWINLINE void chgSData(uint32_t* oldp, SData newval, int bits) {
const uint32_t diff = *oldp ^ newval; const uint32_t diff = *oldp ^ newval;
if (VL_UNLIKELY(diff)) fullSData(oldp, newval, bits); if (VL_UNLIKELY(diff)) fullSData(oldp, newval, bits);
} }
VL_ATTR_ALWINLINE inline void chgIData(uint32_t* oldp, IData newval, int bits) { VL_ATTR_ALWINLINE void chgIData(uint32_t* oldp, IData newval, int bits) {
const uint32_t diff = *oldp ^ newval; const uint32_t diff = *oldp ^ newval;
if (VL_UNLIKELY(diff)) fullIData(oldp, newval, bits); if (VL_UNLIKELY(diff)) fullIData(oldp, newval, bits);
} }
VL_ATTR_ALWINLINE inline void chgQData(uint32_t* oldp, QData newval, int bits) { VL_ATTR_ALWINLINE void chgQData(uint32_t* oldp, QData newval, int bits) {
const uint64_t diff = *reinterpret_cast<QData*>(oldp) ^ newval; const uint64_t diff = *reinterpret_cast<QData*>(oldp) ^ newval;
if (VL_UNLIKELY(diff)) fullQData(oldp, newval, bits); if (VL_UNLIKELY(diff)) fullQData(oldp, newval, bits);
} }
VL_ATTR_ALWINLINE inline void chgWData(uint32_t* oldp, const WData* newvalp, int bits) { VL_ATTR_ALWINLINE void chgWData(uint32_t* oldp, const WData* newvalp, int bits) {
for (int i = 0; i < (bits + 31) / 32; ++i) { for (int i = 0; i < (bits + 31) / 32; ++i) {
if (VL_UNLIKELY(oldp[i] ^ newvalp[i])) { if (VL_UNLIKELY(oldp[i] ^ newvalp[i])) {
fullWData(oldp, newvalp, bits); fullWData(oldp, newvalp, bits);
@ -469,7 +469,7 @@ public:
} }
} }
} }
VL_ATTR_ALWINLINE inline void chgDouble(uint32_t* oldp, double newval) { VL_ATTR_ALWINLINE void chgDouble(uint32_t* oldp, double newval) {
// cppcheck-suppress invalidPointerCast // cppcheck-suppress invalidPointerCast
if (VL_UNLIKELY(*reinterpret_cast<double*>(oldp) != newval)) fullDouble(oldp, newval); if (VL_UNLIKELY(*reinterpret_cast<double*>(oldp) != newval)) fullDouble(oldp, newval);
} }
@ -498,48 +498,48 @@ public:
// Hot path internal interface to Verilator generated code // Hot path internal interface to Verilator generated code
// Offloaded tracing. Just dump everything in the offload buffer // Offloaded tracing. Just dump everything in the offload buffer
inline void chgBit(uint32_t code, CData newval) { void chgBit(uint32_t code, CData newval) {
m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_BIT_0 | newval; m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_BIT_0 | newval;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
m_offloadBufferWritep += 2; m_offloadBufferWritep += 2;
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgCData(uint32_t code, CData newval, int bits) { void chgCData(uint32_t code, CData newval, int bits) {
m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_CDATA; m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_CDATA;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
m_offloadBufferWritep[2] = newval; m_offloadBufferWritep[2] = newval;
m_offloadBufferWritep += 3; m_offloadBufferWritep += 3;
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgSData(uint32_t code, SData newval, int bits) { void chgSData(uint32_t code, SData newval, int bits) {
m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_SDATA; m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_SDATA;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
m_offloadBufferWritep[2] = newval; m_offloadBufferWritep[2] = newval;
m_offloadBufferWritep += 3; m_offloadBufferWritep += 3;
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgIData(uint32_t code, IData newval, int bits) { void chgIData(uint32_t code, IData newval, int bits) {
m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_IDATA; m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_IDATA;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
m_offloadBufferWritep[2] = newval; m_offloadBufferWritep[2] = newval;
m_offloadBufferWritep += 3; m_offloadBufferWritep += 3;
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgQData(uint32_t code, QData newval, int bits) { void chgQData(uint32_t code, QData newval, int bits) {
m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_QDATA; m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_QDATA;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
*reinterpret_cast<QData*>(m_offloadBufferWritep + 2) = newval; *reinterpret_cast<QData*>(m_offloadBufferWritep + 2) = newval;
m_offloadBufferWritep += 4; m_offloadBufferWritep += 4;
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgWData(uint32_t code, const WData* newvalp, int bits) { void chgWData(uint32_t code, const WData* newvalp, int bits) {
m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_WDATA; m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_WDATA;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
m_offloadBufferWritep += 2; m_offloadBufferWritep += 2;
for (int i = 0; i < (bits + 31) / 32; ++i) { *m_offloadBufferWritep++ = newvalp[i]; } for (int i = 0; i < (bits + 31) / 32; ++i) { *m_offloadBufferWritep++ = newvalp[i]; }
VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp);); VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
} }
inline void chgDouble(uint32_t code, double newval) { void chgDouble(uint32_t code, double newval) {
m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_DOUBLE; m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::CHG_DOUBLE;
m_offloadBufferWritep[1] = code; m_offloadBufferWritep[1] = code;
// cppcheck-suppress invalidPointerCast // cppcheck-suppress invalidPointerCast

6
include/verilated_vcd_c.cpp
View File

@ -632,10 +632,10 @@ void VerilatedVcd::commitTraceBuffer(VerilatedVcd::Buffer* bufp) {
//============================================================================= //=============================================================================
// Trace rendering primitives // Trace rendering primitives
static inline void static void VerilatedVcdCCopyAndAppendNewLine(char* writep,
VerilatedVcdCCopyAndAppendNewLine(char* writep, const char* suffixp) VL_ATTR_NO_SANITIZE_ALIGN; const char* suffixp) VL_ATTR_NO_SANITIZE_ALIGN;
static inline void VerilatedVcdCCopyAndAppendNewLine(char* writep, const char* suffixp) { static void VerilatedVcdCCopyAndAppendNewLine(char* writep, const char* suffixp) {
// Copy the whole suffix (this avoid having hard to predict branches which // Copy the whole suffix (this avoid having hard to predict branches which
// helps a lot). Note: The maximum length of the suffix is // helps a lot). Note: The maximum length of the suffix is
// VL_TRACE_MAX_VCD_CODE_SIZE + 2 == 7, but we unroll this here for speed. // VL_TRACE_MAX_VCD_CODE_SIZE + 2 == 7, but we unroll this here for speed.

18
include/verilated_vcd_c.h
View File

@ -73,7 +73,7 @@ private:
void bufferResize(size_t minsize); void bufferResize(size_t minsize);
void bufferFlush() VL_MT_UNSAFE_ONE; void bufferFlush() VL_MT_UNSAFE_ONE;
inline void bufferCheck() { void bufferCheck() {
// Flush the write buffer if there's not enough space left for new information // Flush the write buffer if there's not enough space left for new information
// We only call this once per vector, so we need enough slop for a very wide "b###" line // We only call this once per vector, so we need enough slop for a very wide "b###" line
if (VL_UNLIKELY(m_writep > m_wrFlushp)) bufferFlush(); if (VL_UNLIKELY(m_writep > m_wrFlushp)) bufferFlush();
@ -210,13 +210,13 @@ class VerilatedVcdBuffer VL_NOT_FINAL {
// Implementation of VerilatedTraceBuffer interface // Implementation of VerilatedTraceBuffer interface
// Implementations of duck-typed methods for VerilatedTraceBuffer. These are // Implementations of duck-typed methods for VerilatedTraceBuffer. These are
// called from only one place (the full* methods), so always inline them. // called from only one place (the full* methods), so always inline them.
VL_ATTR_ALWINLINE inline void emitBit(uint32_t code, CData newval); VL_ATTR_ALWINLINE void emitBit(uint32_t code, CData newval);
VL_ATTR_ALWINLINE inline void emitCData(uint32_t code, CData newval, int bits); VL_ATTR_ALWINLINE void emitCData(uint32_t code, CData newval, int bits);
VL_ATTR_ALWINLINE inline void emitSData(uint32_t code, SData newval, int bits); VL_ATTR_ALWINLINE void emitSData(uint32_t code, SData newval, int bits);
VL_ATTR_ALWINLINE inline void emitIData(uint32_t code, IData newval, int bits); VL_ATTR_ALWINLINE void emitIData(uint32_t code, IData newval, int bits);
VL_ATTR_ALWINLINE inline void emitQData(uint32_t code, QData newval, int bits); VL_ATTR_ALWINLINE void emitQData(uint32_t code, QData newval, int bits);
VL_ATTR_ALWINLINE inline void emitWData(uint32_t code, const WData* newvalp, int bits); VL_ATTR_ALWINLINE void emitWData(uint32_t code, const WData* newvalp, int bits);
VL_ATTR_ALWINLINE inline void emitDouble(uint32_t code, double newval); VL_ATTR_ALWINLINE void emitDouble(uint32_t code, double newval);
}; };
//============================================================================= //=============================================================================
@ -313,7 +313,7 @@ public:
} }
// Internal class access // Internal class access
inline VerilatedVcd* spTrace() { return &m_sptrace; } VerilatedVcd* spTrace() { return &m_sptrace; }
}; };
#endif // guard #endif // guard

3
include/verilated_vcd_sc.h
View File

@ -77,8 +77,7 @@ private:
//-------------------------------------------------- //--------------------------------------------------
// SystemC 2.1.v1 // SystemC 2.1.v1
#define DECL_TRACE_METHOD_A(tp) \ #define DECL_TRACE_METHOD_A(tp) void trace(const tp& object, const std::string& name) override;
void trace(const tp& object, const std::string& name) override;
#define DECL_TRACE_METHOD_B(tp) \ #define DECL_TRACE_METHOD_B(tp) \
void trace(const tp& object, const std::string& name, int width) override; void trace(const tp& object, const std::string& name, int width) override;

2
include/verilated_vpi.cpp
View File

@ -114,7 +114,7 @@ public:
static VerilatedVpio* castp(vpiHandle h) { static VerilatedVpio* castp(vpiHandle h) {
return dynamic_cast<VerilatedVpio*>(reinterpret_cast<VerilatedVpio*>(h)); return dynamic_cast<VerilatedVpio*>(reinterpret_cast<VerilatedVpio*>(h));
} }
inline vpiHandle castVpiHandle() { return reinterpret_cast<vpiHandle>(this); } vpiHandle castVpiHandle() { return reinterpret_cast<vpiHandle>(this); }
// ACCESSORS // ACCESSORS
virtual const char* name() const { return "<null>"; } virtual const char* name() const { return "<null>"; }
virtual const char* fullname() const { return "<null>"; } virtual const char* fullname() const { return "<null>"; }

6
include/verilatedos.h
View File

@ -39,7 +39,7 @@
#ifdef __GNUC__ #ifdef __GNUC__
# define VL_ATTR_ALIGNED(alignment) __attribute__((aligned(alignment))) # define VL_ATTR_ALIGNED(alignment) __attribute__((aligned(alignment)))
# define VL_ATTR_ALWINLINE __attribute__((always_inline)) # define VL_ATTR_ALWINLINE __attribute__((always_inline)) inline
# define VL_ATTR_NOINLINE __attribute__((noinline)) # define VL_ATTR_NOINLINE __attribute__((noinline))
# define VL_ATTR_COLD __attribute__((cold)) # define VL_ATTR_COLD __attribute__((cold))
# define VL_ATTR_HOT __attribute__((hot)) # define VL_ATTR_HOT __attribute__((hot))
@ -548,8 +548,8 @@ struct reverse_wrapper {
explicit reverse_wrapper(const T& a_v) explicit reverse_wrapper(const T& a_v)
: m_v(a_v) {} : m_v(a_v) {}
inline auto begin() -> decltype(m_v.rbegin()) { return m_v.rbegin(); } auto begin() -> decltype(m_v.rbegin()) { return m_v.rbegin(); }
inline auto end() -> decltype(m_v.rend()) { return m_v.rend(); } auto end() -> decltype(m_v.rend()) { return m_v.rend(); }
}; };
// C++20's std::ranges::reverse_view // C++20's std::ranges::reverse_view

3
src/V3Ast.cpp
View File

@ -212,8 +212,7 @@ string AstNode::prettyTypeName() const {
//###################################################################### //######################################################################
// Insertion // Insertion
inline void AstNode::debugTreeChange(const AstNode* nodep, const char* prefix, int lineno, void AstNode::debugTreeChange(const AstNode* nodep, const char* prefix, int lineno, bool next) {
bool next) {
#ifdef VL_DEBUG #ifdef VL_DEBUG
// Called on all major tree changers. // Called on all major tree changers.
// Only for use for those really nasty bugs relating to internals // Only for use for those really nasty bugs relating to internals

214
src/V3Ast.h
View File

@ -93,11 +93,11 @@ public:
// const char* ascii() const {...}; // const char* ascii() const {...};
enum en m_e; enum en m_e;
// cppcheck-suppress uninitVar // responsibility of each subclass // cppcheck-suppress uninitVar // responsibility of each subclass
inline VNType() = default; VNType() = default;
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VNType(en _e) VNType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VNType(int _e) explicit VNType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };
@ -116,12 +116,12 @@ public:
static const char* const names[] = {"NONE", "VAUTOM", "VSTATIC"}; static const char* const names[] = {"NONE", "VAUTOM", "VSTATIC"};
return names[m_e]; return names[m_e];
} }
inline VLifetime() VLifetime()
: m_e{NONE} {} : m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VLifetime(en _e) VLifetime(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VLifetime(int _e) explicit VLifetime(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool isNone() const { return m_e == NONE; } bool isNone() const { return m_e == NONE; }
@ -157,12 +157,12 @@ public:
static const char* const names[] = {"[RV] <-", "[LV] =>", "[LV] <=>", "--"}; static const char* const names[] = {"[RV] <-", "[LV] =>", "[LV] <=>", "--"};
return names[m_e]; return names[m_e];
} }
inline VAccess() VAccess()
: m_e{READ} {} : m_e{READ} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VAccess(en _e) VAccess(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VAccess(int _e) explicit VAccess(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
VAccess invert() const { VAccess invert() const {
@ -194,19 +194,19 @@ public:
static const char* const names[] = {"UNSIGNED", "SIGNED", "NOSIGN"}; static const char* const names[] = {"UNSIGNED", "SIGNED", "NOSIGN"};
return names[m_e]; return names[m_e];
} }
inline VSigning() VSigning()
: m_e{UNSIGNED} {} : m_e{UNSIGNED} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VSigning(en _e) VSigning(en _e)
: m_e{_e} {} : m_e{_e} {}
static inline VSigning fromBool(bool isSigned) { // Factory method static VSigning fromBool(bool isSigned) { // Factory method
return isSigned ? VSigning{SIGNED} : VSigning{UNSIGNED}; return isSigned ? VSigning{SIGNED} : VSigning{UNSIGNED};
} }
explicit inline VSigning(int _e) explicit VSigning(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
inline bool isSigned() const { return m_e == SIGNED; } bool isSigned() const { return m_e == SIGNED; }
inline bool isNosign() const { return m_e == NOSIGN; } bool isNosign() const { return m_e == NOSIGN; }
// No isUnsigned() as it's ambiguous if NOSIGN should be included or not. // No isUnsigned() as it's ambiguous if NOSIGN should be included or not.
}; };
inline bool operator==(const VSigning& lhs, const VSigning& rhs) { return lhs.m_e == rhs.m_e; } inline bool operator==(const VSigning& lhs, const VSigning& rhs) { return lhs.m_e == rhs.m_e; }
@ -234,12 +234,12 @@ public:
ENUM_SIZE ENUM_SIZE
}; };
enum en m_e; enum en m_e;
inline VPragmaType() VPragmaType()
: m_e{ILLEGAL} {} : m_e{ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VPragmaType(en _e) VPragmaType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VPragmaType(int _e) explicit VPragmaType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };
@ -322,12 +322,12 @@ public:
} }
return false; return false;
} }
inline VEdgeType() VEdgeType()
: m_e{ET_ILLEGAL} {} : m_e{ET_ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VEdgeType(en _e) VEdgeType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VEdgeType(int _e) explicit VEdgeType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };
@ -403,12 +403,12 @@ public:
// clang-format on // clang-format on
return names[m_e]; return names[m_e];
} }
inline VAttrType() VAttrType()
: m_e{ILLEGAL} {} : m_e{ILLEGAL} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VAttrType(en _e) VAttrType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VAttrType(int _e) explicit VAttrType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };
@ -470,12 +470,12 @@ public:
UASSERT(0 == std::strcmp(VBasicDTypeKwd{_ENUM_MAX}.dpiType(), " MAX"), UASSERT(0 == std::strcmp(VBasicDTypeKwd{_ENUM_MAX}.dpiType(), " MAX"),
"SelfTest: Enum mismatch"); "SelfTest: Enum mismatch");
} }
inline VBasicDTypeKwd() VBasicDTypeKwd()
: m_e{UNKNOWN} {} : m_e{UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VBasicDTypeKwd(en _e) VBasicDTypeKwd(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VBasicDTypeKwd(int _e) explicit VBasicDTypeKwd(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
int width() const { int width() const {
@ -574,12 +574,12 @@ class VDirection final {
public: public:
enum en : uint8_t { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF }; enum en : uint8_t { NONE, INPUT, OUTPUT, INOUT, REF, CONSTREF };
enum en m_e; enum en m_e;
inline VDirection() VDirection()
: m_e{NONE} {} : m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VDirection(en _e) VDirection(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VDirection(int _e) explicit VDirection(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {
@ -620,12 +620,12 @@ public:
enum en : uint8_t { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END }; enum en : uint8_t { BU_FALSE = 0, BU_TRUE = 1, BU_UNKNOWN = 2, _ENUM_END };
enum en m_e; enum en m_e;
// CONSTRUCTOR - note defaults to *UNKNOWN* // CONSTRUCTOR - note defaults to *UNKNOWN*
inline VBoolOrUnknown() VBoolOrUnknown()
: m_e{BU_UNKNOWN} {} : m_e{BU_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VBoolOrUnknown(en _e) VBoolOrUnknown(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VBoolOrUnknown(int _e) explicit VBoolOrUnknown(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
const char* ascii() const { const char* ascii() const {
static const char* const names[] = {"FALSE", "TRUE", "UNK"}; static const char* const names[] = {"FALSE", "TRUE", "UNK"};
@ -659,12 +659,12 @@ public:
enum en : uint8_t { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 }; enum en : uint8_t { JOIN = 0, JOIN_ANY = 1, JOIN_NONE = 2 };
enum en m_e; enum en m_e;
// CONSTRUCTOR - note defaults to *UNKNOWN* // CONSTRUCTOR - note defaults to *UNKNOWN*
inline VJoinType() VJoinType()
: m_e{JOIN} {} : m_e{JOIN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VJoinType(en _e) VJoinType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VJoinType(int _e) explicit VJoinType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
const char* ascii() const { const char* ascii() const {
static const char* const names[] = {"JOIN", "JOIN_ANY", "JOIN_NONE"}; static const char* const names[] = {"JOIN", "JOIN_ANY", "JOIN_NONE"};
@ -712,12 +712,12 @@ public:
MEMBER MEMBER
}; };
enum en m_e; enum en m_e;
inline VVarType() VVarType()
: m_e{UNKNOWN} {} : m_e{UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VVarType(en _e) VVarType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VVarType(int _e) explicit VVarType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {
@ -764,12 +764,12 @@ public:
enum en : uint8_t { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END }; enum en : uint8_t { BP_UNKNOWN = 0, BP_LIKELY, BP_UNLIKELY, _ENUM_END };
enum en m_e; enum en m_e;
// CONSTRUCTOR - note defaults to *UNKNOWN* // CONSTRUCTOR - note defaults to *UNKNOWN*
inline VBranchPred() VBranchPred()
: m_e{BP_UNKNOWN} {} : m_e{BP_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VBranchPred(en _e) VBranchPred(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VBranchPred(int _e) explicit VBranchPred(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool unknown() const { return m_e == BP_UNKNOWN; } bool unknown() const { return m_e == BP_UNKNOWN; }
@ -805,12 +805,12 @@ public:
enum en : uint8_t { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END }; enum en : uint8_t { CLOCKER_UNKNOWN = 0, CLOCKER_YES, CLOCKER_NO, _ENUM_END };
enum en m_e; enum en m_e;
// CONSTRUCTOR - note defaults to *UNKNOWN* // CONSTRUCTOR - note defaults to *UNKNOWN*
inline VVarAttrClocker() VVarAttrClocker()
: m_e{CLOCKER_UNKNOWN} {} : m_e{CLOCKER_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VVarAttrClocker(en _e) VVarAttrClocker(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VVarAttrClocker(int _e) explicit VVarAttrClocker(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool unknown() const { return m_e == CLOCKER_UNKNOWN; } bool unknown() const { return m_e == CLOCKER_UNKNOWN; }
@ -847,12 +847,12 @@ class VAlwaysKwd final {
public: public:
enum en : uint8_t { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB }; enum en : uint8_t { ALWAYS, ALWAYS_FF, ALWAYS_LATCH, ALWAYS_COMB };
enum en m_e; enum en m_e;
inline VAlwaysKwd() VAlwaysKwd()
: m_e{ALWAYS} {} : m_e{ALWAYS} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VAlwaysKwd(en _e) VAlwaysKwd(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VAlwaysKwd(int _e) explicit VAlwaysKwd(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {
@ -870,12 +870,12 @@ class VCaseType final {
public: public:
enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE }; enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
enum en m_e; enum en m_e;
inline VCaseType() VCaseType()
: m_e{CT_CASE} {} : m_e{CT_CASE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VCaseType(en _e) VCaseType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VCaseType(int _e) explicit VCaseType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };
@ -903,7 +903,7 @@ public:
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
VDisplayType(en _e) VDisplayType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VDisplayType(int _e) explicit VDisplayType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool addNewline() const { return m_e != DT_WRITE; } bool addNewline() const { return m_e != DT_WRITE; }
@ -926,12 +926,12 @@ class VDumpCtlType final {
public: public:
enum en : uint8_t { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON }; enum en : uint8_t { FILE, VARS, ALL, FLUSH, LIMIT, OFF, ON };
enum en m_e; enum en m_e;
inline VDumpCtlType() VDumpCtlType()
: m_e{ON} {} : m_e{ON} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VDumpCtlType(en _e) VDumpCtlType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VDumpCtlType(int _e) explicit VDumpCtlType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {
@ -956,12 +956,12 @@ public:
PX_TEXT // Unknown ID component PX_TEXT // Unknown ID component
}; };
enum en m_e; enum en m_e;
inline VParseRefExp() VParseRefExp()
: m_e{PX_NONE} {} : m_e{PX_NONE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VParseRefExp(en _e) VParseRefExp(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VParseRefExp(int _e) explicit VParseRefExp(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {
@ -986,9 +986,9 @@ public:
enum en m_e; enum en m_e;
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VStrength(en strengthLevel) VStrength(en strengthLevel)
: m_e(strengthLevel) {} : m_e(strengthLevel) {}
explicit inline VStrength(int _e) explicit VStrength(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
@ -1080,12 +1080,12 @@ public:
INT_FWD_CLASS, // Interface (.h) needs a forward class declaration INT_FWD_CLASS, // Interface (.h) needs a forward class declaration
}; };
enum en m_e; enum en m_e;
inline VUseType() VUseType()
: m_e{IMP_FWD_CLASS} {} : m_e{IMP_FWD_CLASS} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VUseType(en _e) VUseType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VUseType(int _e) explicit VUseType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
bool isInclude() const { return m_e == IMP_INCLUDE || m_e == INT_INCLUDE; } bool isInclude() const { return m_e == IMP_INCLUDE || m_e == INT_INCLUDE; }
bool isFwdClass() const { return m_e == IMP_FWD_CLASS || m_e == INT_FWD_CLASS; } bool isFwdClass() const { return m_e == IMP_FWD_CLASS || m_e == INT_FWD_CLASS; }
@ -1309,23 +1309,23 @@ class VNVisitor VL_NOT_FINAL : public VNDeleter {
public: public:
/// Call visit()s on nodep /// Call visit()s on nodep
void iterate(AstNode* nodep); inline void iterate(AstNode* nodep);
/// Call visit()s on nodep /// Call visit()s on nodep
void iterateNull(AstNode* nodep); inline void iterateNull(AstNode* nodep);
/// Call visit()s on nodep's children /// Call visit()s on nodep's children
void iterateChildren(AstNode* nodep); inline void iterateChildren(AstNode* nodep);
/// Call visit()s on nodep's children in backp() order /// Call visit()s on nodep's children in backp() order
void iterateChildrenBackwards(AstNode* nodep); inline void iterateChildrenBackwards(AstNode* nodep);
/// Call visit()s on const nodep's children /// Call visit()s on const nodep's children
void iterateChildrenConst(AstNode* nodep); inline void iterateChildrenConst(AstNode* nodep);
/// Call visit()s on nodep (maybe nullptr) and nodep's nextp() list /// Call visit()s on nodep (maybe nullptr) and nodep's nextp() list
void iterateAndNextNull(AstNode* nodep); inline void iterateAndNextNull(AstNode* nodep);
/// Call visit()s on const nodep (maybe nullptr) and nodep's nextp() list /// Call visit()s on const nodep (maybe nullptr) and nodep's nextp() list
void iterateAndNextConstNull(AstNode* nodep); inline void iterateAndNextConstNull(AstNode* nodep);
/// Call visit()s on const nodep (maybe nullptr) and nodep's nextp() list, in reverse order /// Call visit()s on const nodep (maybe nullptr) and nodep's nextp() list, in reverse order
void iterateAndNextConstNullBackwards(AstNode* nodep); inline void iterateAndNextConstNullBackwards(AstNode* nodep);
/// Return edited nodep; see comments in V3Ast.cpp /// Return edited nodep; see comments in V3Ast.cpp
AstNode* iterateSubtreeReturnEdits(AstNode* nodep); inline AstNode* iterateSubtreeReturnEdits(AstNode* nodep);
virtual void visit(AstNode* nodep) = 0; virtual void visit(AstNode* nodep) = 0;
#include "V3Ast__gen_visitor_decls.h" // From ./astgen #include "V3Ast__gen_visitor_decls.h" // From ./astgen
@ -1353,7 +1353,7 @@ protected:
public: public:
VNRelinker() = default; VNRelinker() = default;
void relink(AstNode* newp); inline void relink(AstNode* newp);
AstNode* oldp() const { return m_oldp; } AstNode* oldp() const { return m_oldp; }
void dump(std::ostream& str = std::cout) const; void dump(std::ostream& str = std::cout) const;
}; };
@ -1525,7 +1525,7 @@ protected:
public: public:
// ACCESSORS // ACCESSORS
inline VNType type() const { return m_type; } VNType type() const { return m_type; }
const char* typeName() const { return type().ascii(); } // See also prettyTypeName const char* typeName() const { return type().ascii(); } // See also prettyTypeName
AstNode* nextp() const { return m_nextp; } AstNode* nextp() const { return m_nextp; }
AstNode* backp() const { return m_backp; } AstNode* backp() const { return m_backp; }
@ -1607,8 +1607,8 @@ public:
virtual string prettyOperatorName() const { return "operator " + prettyTypeName(); } virtual string prettyOperatorName() const { return "operator " + prettyTypeName(); }
FileLine* fileline() const { return m_fileline; } FileLine* fileline() const { return m_fileline; }
void fileline(FileLine* fl) { m_fileline = fl; } void fileline(FileLine* fl) { m_fileline = fl; }
bool width1() const; inline bool width1() const;
int widthInstrs() const; inline int widthInstrs() const;
void didWidth(bool flag) { m_flags.didWidth = flag; } void didWidth(bool flag) { m_flags.didWidth = flag; }
bool didWidth() const { return m_flags.didWidth; } bool didWidth() const { return m_flags.didWidth; }
bool didWidthAndSet() { bool didWidthAndSet() {
@ -1622,17 +1622,17 @@ public:
void protect(bool flag) { m_flags.protect = flag; } void protect(bool flag) { m_flags.protect = flag; }
// TODO stomp these width functions out, and call via dtypep() instead // TODO stomp these width functions out, and call via dtypep() instead
int width() const; inline int width() const;
int widthMin() const; inline int widthMin() const;
int widthMinV() const { int widthMinV() const {
return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width(); return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width();
} }
int widthWords() const { return VL_WORDS_I(width()); } int widthWords() const { return VL_WORDS_I(width()); }
bool isQuad() const { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); } bool isQuad() const { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); }
bool isWide() const { return (width() > VL_QUADSIZE); } bool isWide() const { return (width() > VL_QUADSIZE); }
bool isDouble() const; inline bool isDouble() const;
bool isSigned() const; inline bool isSigned() const;
bool isString() const; inline bool isString() const;
// clang-format off // clang-format off
VNUser user1u() const { VNUser user1u() const {
@ -1716,11 +1716,11 @@ public:
// ACCESSORS for specific types // ACCESSORS for specific types
// Alas these can't be virtual or they break when passed a nullptr // Alas these can't be virtual or they break when passed a nullptr
bool isZero() const; inline bool isZero() const;
bool isOne() const; inline bool isOne() const;
bool isNeqZero() const; inline bool isNeqZero() const;
bool isAllOnes() const; inline bool isAllOnes() const;
bool isAllOnesV() const; // Verilog width rules apply inline bool isAllOnesV() const; // Verilog width rules apply
// METHODS - data type changes especially for initial creation // METHODS - data type changes especially for initial creation
void dtypep(AstNodeDType* nodep) { void dtypep(AstNodeDType* nodep) {
@ -1832,9 +1832,9 @@ public:
} }
AstNode* cloneTree(bool cloneNextLink); // Not const, as sets clonep() on original nodep AstNode* cloneTree(bool cloneNextLink); // Not const, as sets clonep() on original nodep
bool gateTree() { return gateTreeIter(); } // Is tree isGateOptimizable? bool gateTree() { return gateTreeIter(); } // Is tree isGateOptimizable?
bool sameTree(const AstNode* node2p) const; // Does tree of this == node2p? inline bool sameTree(const AstNode* node2p) const; // Does tree of this == node2p?
// Does tree of this == node2p?, not allowing non-isGateOptimizable // Does tree of this == node2p?, not allowing non-isGateOptimizable
bool sameGateTree(const AstNode* node2p) const; inline bool sameGateTree(const AstNode* node2p) const;
void deleteTree(); // Always deletes the next link void deleteTree(); // Always deletes the next link
void checkTree(); // User Interface version void checkTree(); // User Interface version
void checkIter() const; void checkIter() const;
@ -1932,7 +1932,7 @@ private:
public: public:
// For use via the VN_IS macro only // For use via the VN_IS macro only
template <typename T, typename E> template <typename T, typename E>
inline static bool privateIs(const AstNode* nodep) { static bool privateIs(const AstNode* nodep) {
static_assert(!uselessCast<T, E>(), "Unnecessary VN_IS, node known to have target type."); static_assert(!uselessCast<T, E>(), "Unnecessary VN_IS, node known to have target type.");
static_assert(!impossibleCast<T, E>(), "Unnecessary VN_IS, node cannot be this type."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_IS, node cannot be this type.");
return nodep && privateTypeTest<T>(nodep); return nodep && privateTypeTest<T>(nodep);
@ -1940,14 +1940,14 @@ public:
// For use via the VN_CAST macro only // For use via the VN_CAST macro only
template <typename T, typename E> template <typename T, typename E>
inline static T* privateCast(AstNode* nodep) { static T* privateCast(AstNode* nodep) {
static_assert(!uselessCast<T, E>(), static_assert(!uselessCast<T, E>(),
"Unnecessary VN_CAST, node known to have target type."); "Unnecessary VN_CAST, node known to have target type.");
static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type.");
return nodep && privateTypeTest<T>(nodep) ? reinterpret_cast<T*>(nodep) : nullptr; return nodep && privateTypeTest<T>(nodep) ? reinterpret_cast<T*>(nodep) : nullptr;
} }
template <typename T, typename E> template <typename T, typename E>
inline static const T* privateCast(const AstNode* nodep) { static const T* privateCast(const AstNode* nodep) {
static_assert(!uselessCast<T, E>(), static_assert(!uselessCast<T, E>(),
"Unnecessary VN_CAST, node known to have target type."); "Unnecessary VN_CAST, node known to have target type.");
static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type.");
@ -1956,7 +1956,7 @@ public:
// For use via the VN_AS macro only // For use via the VN_AS macro only
template <typename T, typename E> template <typename T, typename E>
inline static T* privateAs(AstNode* nodep) { static T* privateAs(AstNode* nodep) {
static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type."); static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep, UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@ -1965,7 +1965,7 @@ public:
return reinterpret_cast<T*>(nodep); return reinterpret_cast<T*>(nodep);
} }
template <typename T, typename E> template <typename T, typename E>
inline static const T* privateAs(const AstNode* nodep) { static const T* privateAs(const AstNode* nodep) {
static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type."); static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep, UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@ -2172,7 +2172,7 @@ void AstNode::foreachImpl(ConstCorrectAstNode<T_Arg>* nodep, const std::function
constexpr int prefetchDistance = 2; constexpr int prefetchDistance = 2;
// Grow stack to given size // Grow stack to given size
const auto grow = [&](size_t size) VL_ATTR_ALWINLINE { const auto grow = [&](size_t size) {
const ptrdiff_t occupancy = topp - basep; const ptrdiff_t occupancy = topp - basep;
stack.resize(size); stack.resize(size);
basep = stack.data() + prefetchDistance; basep = stack.data() + prefetchDistance;
@ -2188,7 +2188,7 @@ void AstNode::foreachImpl(ConstCorrectAstNode<T_Arg>* nodep, const std::function
for (int i = -prefetchDistance; i; ++i) basep[i] = nodep; for (int i = -prefetchDistance; i; ++i) basep[i] = nodep;
// Visit given node, enqueue children for traversal // Visit given node, enqueue children for traversal
const auto visit = [&](Node* currp) VL_ATTR_ALWINLINE { const auto visit = [&](Node* currp) {
// Type test this node // Type test this node
if (AstNode::privateTypeTest<T_Arg_NonConst>(currp)) { if (AstNode::privateTypeTest<T_Arg_NonConst>(currp)) {
// Call the client function // Call the client function
@ -2253,7 +2253,7 @@ bool AstNode::predicateImpl(ConstCorrectAstNode<T_Arg>* nodep,
constexpr int prefetchDistance = 2; constexpr int prefetchDistance = 2;
// Grow stack to given size // Grow stack to given size
const auto grow = [&](size_t size) VL_ATTR_ALWINLINE { const auto grow = [&](size_t size) {
const ptrdiff_t occupancy = topp - basep; const ptrdiff_t occupancy = topp - basep;
stack.resize(size); stack.resize(size);
basep = stack.data() + prefetchDistance; basep = stack.data() + prefetchDistance;
@ -2269,7 +2269,7 @@ bool AstNode::predicateImpl(ConstCorrectAstNode<T_Arg>* nodep,
for (int i = -prefetchDistance; i; ++i) basep[i] = nodep; for (int i = -prefetchDistance; i; ++i) basep[i] = nodep;
// Visit given node, enqueue children for traversal, return true if result determined. // Visit given node, enqueue children for traversal, return true if result determined.
const auto visit = [&](Node* currp) VL_ATTR_ALWINLINE { const auto visit = [&](Node* currp) {
// Type test this node // Type test this node
if (AstNode::privateTypeTest<T_Arg_NonConst>(currp)) { if (AstNode::privateTypeTest<T_Arg_NonConst>(currp)) {
// Call the client function // Call the client function
@ -2322,7 +2322,7 @@ inline std::ostream& operator<<(std::ostream& os, const AstNode* rhs) {
} }
return os; return os;
} }
inline void VNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); } void VNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
//###################################################################### //######################################################################
@ -2369,25 +2369,25 @@ struct std::equal_to<VNRef<T_Node>> final {
//###################################################################### //######################################################################
// Inline VNVisitor METHODS // Inline VNVisitor METHODS
inline void VNVisitor::iterate(AstNode* nodep) { nodep->accept(*this); } void VNVisitor::iterate(AstNode* nodep) { nodep->accept(*this); }
inline void VNVisitor::iterateNull(AstNode* nodep) { void VNVisitor::iterateNull(AstNode* nodep) {
if (VL_LIKELY(nodep)) nodep->accept(*this); if (VL_LIKELY(nodep)) nodep->accept(*this);
} }
inline void VNVisitor::iterateChildren(AstNode* nodep) { nodep->iterateChildren(*this); } void VNVisitor::iterateChildren(AstNode* nodep) { nodep->iterateChildren(*this); }
inline void VNVisitor::iterateChildrenBackwards(AstNode* nodep) { void VNVisitor::iterateChildrenBackwards(AstNode* nodep) {
nodep->iterateChildrenBackwards(*this); nodep->iterateChildrenBackwards(*this);
} }
inline void VNVisitor::iterateChildrenConst(AstNode* nodep) { nodep->iterateChildrenConst(*this); } void VNVisitor::iterateChildrenConst(AstNode* nodep) { nodep->iterateChildrenConst(*this); }
inline void VNVisitor::iterateAndNextNull(AstNode* nodep) { void VNVisitor::iterateAndNextNull(AstNode* nodep) {
if (VL_LIKELY(nodep)) nodep->iterateAndNext(*this); if (VL_LIKELY(nodep)) nodep->iterateAndNext(*this);
} }
inline void VNVisitor::iterateAndNextConstNullBackwards(AstNode* nodep) { void VNVisitor::iterateAndNextConstNullBackwards(AstNode* nodep) {
if (VL_LIKELY(nodep)) nodep->iterateListBackwards(*this); if (VL_LIKELY(nodep)) nodep->iterateListBackwards(*this);
} }
inline void VNVisitor::iterateAndNextConstNull(AstNode* nodep) { void VNVisitor::iterateAndNextConstNull(AstNode* nodep) {
if (VL_LIKELY(nodep)) nodep->iterateAndNextConst(*this); if (VL_LIKELY(nodep)) nodep->iterateAndNextConst(*this);
} }
inline AstNode* VNVisitor::iterateSubtreeReturnEdits(AstNode* nodep) { AstNode* VNVisitor::iterateSubtreeReturnEdits(AstNode* nodep) {
return nodep->iterateSubtreeReturnEdits(*this); return nodep->iterateSubtreeReturnEdits(*this);
} }

63
src/V3AstInlines.h
View File

@ -25,71 +25,56 @@
//###################################################################### //######################################################################
// Inline METHODS // Inline METHODS
inline AstNode* AstNode::addNext(AstNode* newp) { return addNext(this, newp); } AstNode* AstNode::addNext(AstNode* newp) { return addNext(this, newp); }
inline AstNode* AstNode::addNextNull(AstNode* newp) { return addNextNull(this, newp); } AstNode* AstNode::addNextNull(AstNode* newp) { return addNextNull(this, newp); }
inline void AstNode::addPrev(AstNode* newp) { void AstNode::addPrev(AstNode* newp) {
replaceWith(newp); replaceWith(newp);
newp->addNext(this); newp->addNext(this);
} }
inline int AstNode::width() const { return dtypep() ? dtypep()->width() : 0; } int AstNode::width() const { return dtypep() ? dtypep()->width() : 0; }
inline int AstNode::widthMin() const { return dtypep() ? dtypep()->widthMin() : 0; } int AstNode::widthMin() const { return dtypep() ? dtypep()->widthMin() : 0; }
inline bool AstNode::width1() const { // V3Const uses to know it can optimize bool AstNode::width1() const { // V3Const uses to know it can optimize
return dtypep() && dtypep()->width() == 1; return dtypep() && dtypep()->width() == 1;
} }
inline int AstNode::widthInstrs() const { int AstNode::widthInstrs() const {
return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1)); return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1));
} }
inline bool AstNode::isDouble() const { bool AstNode::isDouble() const {
return dtypep() && VN_IS(dtypep(), BasicDType) && VN_AS(dtypep(), BasicDType)->isDouble(); return dtypep() && VN_IS(dtypep(), BasicDType) && VN_AS(dtypep(), BasicDType)->isDouble();
} }
inline bool AstNode::isString() const { bool AstNode::isString() const {
return dtypep() && dtypep()->basicp() && dtypep()->basicp()->isString(); return dtypep() && dtypep()->basicp() && dtypep()->basicp()->isString();
} }
inline bool AstNode::isSigned() const { return dtypep() && dtypep()->isSigned(); } bool AstNode::isSigned() const { return dtypep() && dtypep()->isSigned(); }
inline bool AstNode::isZero() const { bool AstNode::isZero() const {
return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqZero()); return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqZero());
} }
inline bool AstNode::isNeqZero() const { bool AstNode::isNeqZero() const {
return (VN_IS(this, Const) && VN_AS(this, Const)->num().isNeqZero()); return (VN_IS(this, Const) && VN_AS(this, Const)->num().isNeqZero());
} }
inline bool AstNode::isOne() const { bool AstNode::isOne() const { return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqOne()); }
return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqOne()); bool AstNode::isAllOnes() const {
}
inline bool AstNode::isAllOnes() const {
return (VN_IS(this, Const) && VN_AS(this, Const)->isEqAllOnes()); return (VN_IS(this, Const) && VN_AS(this, Const)->isEqAllOnes());
} }
inline bool AstNode::isAllOnesV() const { bool AstNode::isAllOnesV() const {
return (VN_IS(this, Const) && VN_AS(this, Const)->isEqAllOnesV()); return (VN_IS(this, Const) && VN_AS(this, Const)->isEqAllOnesV());
} }
inline bool AstNode::sameTree(const AstNode* node2p) const { bool AstNode::sameTree(const AstNode* node2p) const {
return sameTreeIter(this, node2p, true, false); return sameTreeIter(this, node2p, true, false);
} }
inline bool AstNode::sameGateTree(const AstNode* node2p) const { bool AstNode::sameGateTree(const AstNode* node2p) const {
return sameTreeIter(this, node2p, true, true); return sameTreeIter(this, node2p, true, true);
} }
inline void AstNodeVarRef::varp(AstVar* varp) { void AstNodeArrayDType::rangep(AstRange* nodep) { setOp2p(nodep); }
m_varp = varp; int AstNodeArrayDType::left() const { return rangep()->leftConst(); }
dtypeFrom(varp); int AstNodeArrayDType::right() const { return rangep()->rightConst(); }
} int AstNodeArrayDType::hi() const { return rangep()->hiConst(); }
int AstNodeArrayDType::lo() const { return rangep()->loConst(); }
inline bool AstNodeDType::isFourstate() const { return basicp()->isFourstate(); } int AstNodeArrayDType::elementsConst() const { return rangep()->elementsConst(); }
VNumRange AstNodeArrayDType::declRange() const { return VNumRange{left(), right()}; }
inline void AstNodeArrayDType::rangep(AstRange* nodep) { setOp2p(nodep); }
inline int AstNodeArrayDType::left() const { return rangep()->leftConst(); }
inline int AstNodeArrayDType::right() const { return rangep()->rightConst(); }
inline int AstNodeArrayDType::hi() const { return rangep()->hiConst(); }
inline int AstNodeArrayDType::lo() const { return rangep()->loConst(); }
inline int AstNodeArrayDType::elementsConst() const { return rangep()->elementsConst(); }
inline VNumRange AstNodeArrayDType::declRange() const { return VNumRange{left(), right()}; }
inline void AstIfaceRefDType::cloneRelink() {
if (m_cellp && m_cellp->clonep()) m_cellp = m_cellp->clonep();
if (m_ifacep && m_ifacep->clonep()) m_ifacep = m_ifacep->clonep();
if (m_modportp && m_modportp->clonep()) m_modportp = m_modportp->clonep();
}
AstRange::AstRange(FileLine* fl, int left, int right) AstRange::AstRange(FileLine* fl, int left, int right)
: ASTGEN_SUPER_Range(fl) { : ASTGEN_SUPER_Range(fl) {

14
src/V3AstNodeDType.h
View File

@ -172,7 +172,7 @@ public:
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
AstRange* rangep() const { return VN_AS(op2p(), Range); } // op2 = Array(s) of variable AstRange* rangep() const { return VN_AS(op2p(), Range); } // op2 = Array(s) of variable
void rangep(AstRange* nodep); inline void rangep(AstRange* nodep);
// METHODS // METHODS
AstBasicDType* basicp() const override { AstBasicDType* basicp() const override {
return subDTypep()->basicp(); return subDTypep()->basicp();
@ -184,12 +184,12 @@ public:
int widthTotalBytes() const override { int widthTotalBytes() const override {
return elementsConst() * subDTypep()->widthTotalBytes(); return elementsConst() * subDTypep()->widthTotalBytes();
} }
int left() const; inline int left() const;
int right() const; inline int right() const;
int hi() const; inline int hi() const;
int lo() const; inline int lo() const;
int elementsConst() const; inline int elementsConst() const;
VNumRange declRange() const; inline VNumRange declRange() const;
}; };
class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType { class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
// A struct or union; common handling // A struct or union; common handling

5
src/V3AstNodeMath.h
View File

@ -341,7 +341,10 @@ public:
VAccess access() const { return m_access; } VAccess access() const { return m_access; }
void access(const VAccess& flag) { m_access = flag; } // Avoid using this; Set in constructor void access(const VAccess& flag) { m_access = flag; } // Avoid using this; Set in constructor
AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable
void varp(AstVar* varp); void varp(AstVar* varp) {
m_varp = varp;
dtypeFrom((AstNode*)varp);
}
AstVarScope* varScopep() const { return m_varScopep; } AstVarScope* varScopep() const { return m_varScopep; }
void varScopep(AstVarScope* varscp) { m_varScopep = varscp; } void varScopep(AstVarScope* varscp) { m_varScopep = varscp; }
string selfPointer() const { return m_selfPointer; } string selfPointer() const { return m_selfPointer; }

7
src/V3AstNodes.cpp
View File

@ -683,6 +683,8 @@ AstVar* AstVar::scVarRecurse(AstNode* nodep) {
return nullptr; return nullptr;
} }
bool AstNodeDType::isFourstate() const { return basicp()->isFourstate(); }
class AstNodeDType::CTypeRecursed final { class AstNodeDType::CTypeRecursed final {
public: public:
string m_type; // The base type, e.g.: "Foo_t"s string m_type; // The base type, e.g.: "Foo_t"s
@ -1490,6 +1492,11 @@ void AstIfaceRefDType::dumpSmall(std::ostream& str) const {
this->AstNodeDType::dumpSmall(str); this->AstNodeDType::dumpSmall(str);
str << "iface"; str << "iface";
} }
void AstIfaceRefDType::cloneRelink() {
if (m_cellp && m_cellp->clonep()) m_cellp = m_cellp->clonep();
if (m_ifacep && m_ifacep->clonep()) m_ifacep = m_ifacep->clonep();
if (m_modportp && m_modportp->clonep()) m_modportp = m_modportp->clonep();
}
void AstInitArray::dump(std::ostream& str) const { void AstInitArray::dump(std::ostream& str) const {
this->AstNode::dump(str); this->AstNode::dump(str);
int n = 0; int n = 0;

4
src/V3AstUserAllocator.h
View File

@ -35,7 +35,7 @@ class AstUserAllocatorBase VL_NOT_FINAL {
private: private:
std::vector<T_Data*> m_allocated; std::vector<T_Data*> m_allocated;
inline T_Data* getUserp(const T_Node* nodep) const { T_Data* getUserp(const T_Node* nodep) const {
if VL_CONSTEXPR_CXX17 (T_UserN == 1) { if VL_CONSTEXPR_CXX17 (T_UserN == 1) {
const VNUser user = nodep->user1u(); const VNUser user = nodep->user1u();
return user.to<T_Data*>(); return user.to<T_Data*>();
@ -54,7 +54,7 @@ private:
} }
} }
inline void setUserp(T_Node* nodep, T_Data* userp) const { void setUserp(T_Node* nodep, T_Data* userp) const {
if VL_CONSTEXPR_CXX17 (T_UserN == 1) { if VL_CONSTEXPR_CXX17 (T_UserN == 1) {
nodep->user1u(VNUser{userp}); nodep->user1u(VNUser{userp});
} else if VL_CONSTEXPR_CXX17 (T_UserN == 2) { } else if VL_CONSTEXPR_CXX17 (T_UserN == 2) {

4
src/V3Broken.cpp
View File

@ -132,8 +132,8 @@ private:
public: public:
// METHODS // METHODS
void clear() { m_linkable.clear(); } void clear() { m_linkable.clear(); }
inline void addLinkable(const AstNode* nodep) { m_linkable.emplace(nodep); } void addLinkable(const AstNode* nodep) { m_linkable.emplace(nodep); }
inline bool isLinkable(const AstNode* nodep) const { return m_linkable.count(nodep) != 0; } bool isLinkable(const AstNode* nodep) const { return m_linkable.count(nodep) != 0; }
} s_linkableTable; } s_linkableTable;
bool V3Broken::isLinkable(const AstNode* nodep) { return s_linkableTable.isLinkable(nodep); } bool V3Broken::isLinkable(const AstNode* nodep) { return s_linkableTable.isLinkable(nodep); }

2
src/V3CCtors.cpp
View File

@ -44,7 +44,7 @@ private:
public: public:
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VCtorType(en _e) VCtorType(en _e)
: m_e{_e} {} : m_e{_e} {}
bool isClass() const { return m_e == CLASS; } bool isClass() const { return m_e == CLASS; }
bool isCoverage() const { return m_e == COVERAGE; } bool isCoverage() const { return m_e == COVERAGE; }

2
src/V3Config.cpp
View File

@ -309,7 +309,7 @@ public:
if (lineMatch(lineno, VPragmaType::FULL_CASE)) nodep->fullPragma(true); if (lineMatch(lineno, VPragmaType::FULL_CASE)) nodep->fullPragma(true);
if (lineMatch(lineno, VPragmaType::PARALLEL_CASE)) nodep->parallelPragma(true); if (lineMatch(lineno, VPragmaType::PARALLEL_CASE)) nodep->parallelPragma(true);
} }
inline void applyIgnores(FileLine* filelinep) { void applyIgnores(FileLine* filelinep) {
// HOT routine, called each parsed token line of this filename // HOT routine, called each parsed token line of this filename
if (m_lastIgnore.lineno != filelinep->lineno()) { if (m_lastIgnore.lineno != filelinep->lineno()) {
// UINFO(9, " ApplyIgnores for " << filelinep->ascii() << endl); // UINFO(9, " ApplyIgnores for " << filelinep->ascii() << endl);

6
src/V3Error.h
View File

@ -142,13 +142,13 @@ public:
}; };
// clang-format on // clang-format on
enum en m_e; enum en m_e;
inline V3ErrorCode() V3ErrorCode()
: m_e{EC_MIN} {} : m_e{EC_MIN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline V3ErrorCode(en _e) V3ErrorCode(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit V3ErrorCode(const char* msgp); // Matching code or ERROR explicit V3ErrorCode(const char* msgp); // Matching code or ERROR
explicit inline V3ErrorCode(int _e) explicit V3ErrorCode(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {

8
src/V3File.cpp
View File

@ -146,7 +146,7 @@ V3FileDependImp dependImp; // Depend implementation class
//###################################################################### //######################################################################
// V3FileDependImp // V3FileDependImp
inline void V3FileDependImp::writeDepend(const string& filename) { void V3FileDependImp::writeDepend(const string& filename) {
const std::unique_ptr<std::ofstream> ofp{V3File::new_ofstream(filename)}; const std::unique_ptr<std::ofstream> ofp{V3File::new_ofstream(filename)};
if (ofp->fail()) v3fatal("Can't write " << filename); if (ofp->fail()) v3fatal("Can't write " << filename);
@ -171,7 +171,7 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
} }
} }
inline std::vector<string> V3FileDependImp::getAllDeps() const { std::vector<string> V3FileDependImp::getAllDeps() const {
std::vector<string> r; std::vector<string> r;
for (const auto& itr : m_filenameList) { for (const auto& itr : m_filenameList) {
if (!itr.target() && itr.exists()) r.push_back(itr.filename()); if (!itr.target() && itr.exists()) r.push_back(itr.filename());
@ -179,7 +179,7 @@ inline std::vector<string> V3FileDependImp::getAllDeps() const {
return r; return r;
} }
inline void V3FileDependImp::writeTimes(const string& filename, const string& cmdlineIn) { void V3FileDependImp::writeTimes(const string& filename, const string& cmdlineIn) {
const std::unique_ptr<std::ofstream> ofp{V3File::new_ofstream(filename)}; const std::unique_ptr<std::ofstream> ofp{V3File::new_ofstream(filename)};
if (ofp->fail()) v3fatal("Can't write " << filename); if (ofp->fail()) v3fatal("Can't write " << filename);
@ -214,7 +214,7 @@ inline void V3FileDependImp::writeTimes(const string& filename, const string& cm
} }
} }
inline bool V3FileDependImp::checkTimes(const string& filename, const string& cmdlineIn) { bool V3FileDependImp::checkTimes(const string& filename, const string& cmdlineIn) {
const std::unique_ptr<std::ifstream> ifp{V3File::new_ifstream_nodepend(filename)}; const std::unique_ptr<std::ifstream> ifp{V3File::new_ifstream_nodepend(filename)};
if (ifp->fail()) { if (ifp->fail()) {
UINFO(2, " --check-times failed: no input " << filename << endl); UINFO(2, " --check-times failed: no input " << filename << endl);

12
src/V3FileLine.h
View File

@ -247,7 +247,11 @@ public:
// OPERATORS // OPERATORS
void v3errorEnd(std::ostringstream& str, const string& extra = ""); void v3errorEnd(std::ostringstream& str, const string& extra = "");
void v3errorEndFatal(std::ostringstream& str) VL_ATTR_NORETURN; void v3errorEndFatal(std::ostringstream& str) VL_ATTR_NORETURN {
v3errorEnd(str);
assert(0); // LCOV_EXCL_LINE
VL_UNREACHABLE
}
/// When building an error, prefix for printing continuation lines /// When building an error, prefix for printing continuation lines
/// e.g. information referring to the same FileLine as before /// e.g. information referring to the same FileLine as before
string warnMore() const; string warnMore() const;
@ -286,10 +290,4 @@ private:
}; };
std::ostream& operator<<(std::ostream& os, FileLine* fileline); std::ostream& operator<<(std::ostream& os, FileLine* fileline);
inline void FileLine::v3errorEndFatal(std::ostringstream& str) {
v3errorEnd(str);
assert(0); // LCOV_EXCL_LINE
VL_UNREACHABLE
}
#endif // Guard #endif // Guard

6
src/V3Graph.h
View File

@ -54,12 +54,12 @@ public:
// // an array dimension or loop bound. // // an array dimension or loop bound.
}; };
enum en m_e; enum en m_e;
inline GraphWay() GraphWay()
: m_e{FORWARD} {} : m_e{FORWARD} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline constexpr GraphWay(en _e) constexpr GraphWay(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline constexpr GraphWay(int _e) explicit constexpr GraphWay(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
const char* ascii() const { const char* ascii() const {

2
src/V3GraphAcyc.cpp
View File

@ -121,7 +121,7 @@ private:
void placeTryEdge(V3GraphEdge* edgep); void placeTryEdge(V3GraphEdge* edgep);
bool placeIterate(GraphAcycVertex* vertexp, uint32_t currentRank); bool placeIterate(GraphAcycVertex* vertexp, uint32_t currentRank);
inline bool origFollowEdge(V3GraphEdge* edgep) { bool origFollowEdge(V3GraphEdge* edgep) {
return (edgep->weight() && (m_origEdgeFuncp)(edgep)); return (edgep->weight() && (m_origEdgeFuncp)(edgep));
} }
V3GraphEdge* edgeFromEdge(V3GraphEdge* oldedgep, V3GraphVertex* fromp, V3GraphVertex* top) { V3GraphEdge* edgeFromEdge(V3GraphEdge* oldedgep, V3GraphVertex* fromp, V3GraphVertex* top) {

4
src/V3GraphAlg.h
View File

@ -38,9 +38,7 @@ protected:
, m_edgeFuncp{edgeFuncp} {} , m_edgeFuncp{edgeFuncp} {}
~GraphAlg() = default; ~GraphAlg() = default;
// METHODS // METHODS
inline bool followEdge(V3GraphEdge* edgep) { bool followEdge(V3GraphEdge* edgep) { return (edgep->weight() && (m_edgeFuncp)(edgep)); }
return (edgep->weight() && (m_edgeFuncp)(edgep));
}
}; };
//============================================================================ //============================================================================

2
src/V3Hash.h
View File

@ -26,7 +26,7 @@
class V3Hash final { class V3Hash final {
uint32_t m_value; // The 32-bit hash value. uint32_t m_value; // The 32-bit hash value.
inline static uint32_t combine(uint32_t a, uint32_t b) { static uint32_t combine(uint32_t a, uint32_t b) {
return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2)); return a ^ (b + 0x9e3779b9 + (a << 6) + (a >> 2));
} }

6
src/V3LangCode.h
View File

@ -55,13 +55,13 @@ public:
bool legal() const { return m_e != L_ERROR; } bool legal() const { return m_e != L_ERROR; }
// //
enum en m_e; enum en m_e;
inline V3LangCode() V3LangCode()
: m_e{L_ERROR} {} : m_e{L_ERROR} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline V3LangCode(en _e) V3LangCode(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit V3LangCode(const char* textp); explicit V3LangCode(const char* textp);
explicit inline V3LangCode(int _e) explicit V3LangCode(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };

6
src/V3Life.cpp
View File

@ -94,18 +94,18 @@ public:
consumed(); consumed();
} }
~LifeVarEntry() = default; ~LifeVarEntry() = default;
inline void simpleAssign(AstNodeAssign* assp) { // New simple A=.... assignment void simpleAssign(AstNodeAssign* assp) { // New simple A=.... assignment
m_assignp = assp; m_assignp = assp;
m_constp = nullptr; m_constp = nullptr;
m_everSet = true; m_everSet = true;
if (VN_IS(assp->rhsp(), Const)) m_constp = VN_AS(assp->rhsp(), Const); if (VN_IS(assp->rhsp(), Const)) m_constp = VN_AS(assp->rhsp(), Const);
} }
inline void complexAssign() { // A[x]=... or some complicated assignment void complexAssign() { // A[x]=... or some complicated assignment
m_assignp = nullptr; m_assignp = nullptr;
m_constp = nullptr; m_constp = nullptr;
m_everSet = true; m_everSet = true;
} }
inline void consumed() { // Rvalue read of A void consumed() { // Rvalue read of A
m_assignp = nullptr; m_assignp = nullptr;
} }
AstNodeAssign* assignp() const { return m_assignp; } AstNodeAssign* assignp() const { return m_assignp; }

2
src/V3LinkDot.cpp
View File

@ -1966,7 +1966,7 @@ private:
nodep->v3error("Illegal call of a task as a function: " << nodep->prettyNameQ()); nodep->v3error("Illegal call of a task as a function: " << nodep->prettyNameQ());
} }
} }
inline void checkNoDot(AstNode* nodep) { void checkNoDot(AstNode* nodep) {
if (VL_UNLIKELY(m_ds.m_dotPos != DP_NONE)) { if (VL_UNLIKELY(m_ds.m_dotPos != DP_NONE)) {
// UINFO(9, "ds=" << m_ds.ascii() << endl); // UINFO(9, "ds=" << m_ds.ascii() << endl);
nodep->v3error("Syntax Error: Not expecting " << nodep->type() << " under a " nodep->v3error("Syntax Error: Not expecting " << nodep->type() << " under a "

16
src/V3Options.h
View File

@ -39,12 +39,12 @@ class VOptionBool final {
public: public:
enum en : uint8_t { OPT_DEFAULT_FALSE = 0, OPT_DEFAULT_TRUE, OPT_TRUE, OPT_FALSE }; enum en : uint8_t { OPT_DEFAULT_FALSE = 0, OPT_DEFAULT_TRUE, OPT_TRUE, OPT_FALSE };
enum en m_e; enum en m_e;
inline VOptionBool() VOptionBool()
: m_e{OPT_DEFAULT_FALSE} {} : m_e{OPT_DEFAULT_FALSE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VOptionBool(en _e) VOptionBool(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VOptionBool(int _e) explicit VOptionBool(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool isDefault() const { return m_e == OPT_DEFAULT_FALSE || m_e == OPT_DEFAULT_TRUE; } bool isDefault() const { return m_e == OPT_DEFAULT_FALSE || m_e == OPT_DEFAULT_TRUE; }
@ -78,12 +78,12 @@ public:
enum : uint8_t { TS_DEFAULT = TS_1PS }; enum : uint8_t { TS_DEFAULT = TS_1PS };
enum en m_e; enum en m_e;
// CONSTRUCTOR // CONSTRUCTOR
inline VTimescale() VTimescale()
: m_e{NONE} {} : m_e{NONE} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline VTimescale(en _e) VTimescale(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline VTimescale(int _e) explicit VTimescale(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
// Construct from string // Construct from string
VTimescale(const string& value, bool& badr); VTimescale(const string& value, bool& badr);
@ -131,9 +131,9 @@ class TraceFormat final {
public: public:
enum en : uint8_t { VCD = 0, FST } m_e; enum en : uint8_t { VCD = 0, FST } m_e;
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline TraceFormat(en _e = VCD) TraceFormat(en _e = VCD)
: m_e{_e} {} : m_e{_e} {}
explicit inline TraceFormat(int _e) explicit TraceFormat(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
bool fst() const { return m_e == FST; } bool fst() const { return m_e == FST; }

6
src/V3Order.cpp
View File

@ -816,7 +816,7 @@ public:
OrderMoveDomScope::DomScopeMap OrderMoveDomScope::s_dsMap; OrderMoveDomScope::DomScopeMap OrderMoveDomScope::s_dsMap;
inline std::ostream& operator<<(std::ostream& lhs, const OrderMoveDomScope& rhs) { std::ostream& operator<<(std::ostream& lhs, const OrderMoveDomScope& rhs) {
lhs << rhs.name(); lhs << rhs.name();
return lhs; return lhs;
} }
@ -1349,7 +1349,7 @@ public:
// OrderMoveDomScope methods // OrderMoveDomScope methods
// Check the domScope is on ready list, add if not // Check the domScope is on ready list, add if not
inline void OrderMoveDomScope::ready(OrderProcess* opp) { void OrderMoveDomScope::ready(OrderProcess* opp) {
if (!m_onReadyList) { if (!m_onReadyList) {
m_onReadyList = true; m_onReadyList = true;
m_readyDomScopeE.pushBack(opp->m_pomReadyDomScope, this); m_readyDomScopeE.pushBack(opp->m_pomReadyDomScope, this);
@ -1357,7 +1357,7 @@ inline void OrderMoveDomScope::ready(OrderProcess* opp) {
} }
// Mark one vertex as finished, remove from ready list if done // Mark one vertex as finished, remove from ready list if done
inline void OrderMoveDomScope::movedVertex(OrderProcess* opp, OrderMoveVertex* vertexp) { void OrderMoveDomScope::movedVertex(OrderProcess* opp, OrderMoveVertex* vertexp) {
UASSERT_OBJ(m_onReadyList, vertexp, UASSERT_OBJ(m_onReadyList, vertexp,
"Moving vertex from ready when nothing was on que as ready."); "Moving vertex from ready when nothing was on que as ready.");
if (m_readyVertices.empty()) { // Else more work to get to later if (m_readyVertices.empty()) { // Else more work to get to later

6
src/V3OrderGraph.h
View File

@ -87,12 +87,12 @@ struct OrderVEdgeType {
return names[m_e]; return names[m_e];
} }
enum en m_e; enum en m_e;
inline OrderVEdgeType() OrderVEdgeType()
: m_e{VERTEX_UNKNOWN} {} : m_e{VERTEX_UNKNOWN} {}
// cppcheck-suppress noExplicitConstructor // cppcheck-suppress noExplicitConstructor
inline OrderVEdgeType(en _e) OrderVEdgeType(en _e)
: m_e{_e} {} : m_e{_e} {}
explicit inline OrderVEdgeType(int _e) explicit OrderVEdgeType(int _e)
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
operator en() const { return m_e; } operator en() const { return m_e; }
}; };

4
src/V3PreLex.h
View File

@ -143,7 +143,7 @@ public:
~VPreStream() { lexStreamDepthAdd(-1); } ~VPreStream() { lexStreamDepthAdd(-1); }
private: private:
void lexStreamDepthAdd(int delta); inline void lexStreamDepthAdd(int delta);
}; };
//====================================================================== //======================================================================
@ -237,6 +237,6 @@ private:
void scanSwitchStream(VPreStream* streamp); void scanSwitchStream(VPreStream* streamp);
}; };
inline void VPreStream::lexStreamDepthAdd(int delta) { m_lexp->streamDepthAdd(delta); } void VPreStream::lexStreamDepthAdd(int delta) { m_lexp->streamDepthAdd(delta); }
#endif // Guard #endif // Guard

12
src/V3String.cpp
View File

@ -31,7 +31,7 @@ std::map<string, string> VName::s_dehashMap;
// Wildcard // Wildcard
// Double procedures, inlined, unrolls loop much better // Double procedures, inlined, unrolls loop much better
inline bool VString::wildmatchi(const char* s, const char* p) { bool VString::wildmatchi(const char* s, const char* p) {
for (; *p; s++, p++) { for (; *p; s++, p++) {
if (*p != '*') { if (*p != '*') {
if (((*s) != (*p)) && *p != '?') return false; if (((*s) != (*p)) && *p != '?') return false;
@ -193,13 +193,11 @@ static const uint32_t sha256K[]
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
0xc67178f2}; 0xc67178f2};
static inline uint32_t shaRotr32(uint32_t lhs, uint32_t rhs) VL_ATTR_ALWINLINE; VL_ATTR_ALWINLINE
static inline uint32_t shaRotr32(uint32_t lhs, uint32_t rhs) { static uint32_t shaRotr32(uint32_t lhs, uint32_t rhs) { return lhs >> rhs | lhs << (32 - rhs); }
return lhs >> rhs | lhs << (32 - rhs);
}
static inline void sha256Block(uint32_t* h, const uint32_t* chunk) VL_ATTR_ALWINLINE; VL_ATTR_ALWINLINE
static inline void sha256Block(uint32_t* h, const uint32_t* chunk) { static void sha256Block(uint32_t* h, const uint32_t* chunk) {
uint32_t ah[8]; uint32_t ah[8];
const uint32_t* p = chunk; const uint32_t* p = chunk;

2
src/V3Subst.cpp
View File

@ -255,7 +255,7 @@ private:
return entryp; return entryp;
} }
} }
inline bool isSubstVar(AstVar* nodep) { return nodep->isStatementTemp() && !nodep->noSubst(); } bool isSubstVar(AstVar* nodep) { return nodep->isStatementTemp() && !nodep->noSubst(); }
// VISITORS // VISITORS
void visit(AstNodeAssign* nodep) override { void visit(AstNodeAssign* nodep) override {

6
src/V3TSP.cpp
View File

@ -122,7 +122,7 @@ public:
(new V3GraphEdge(this, tp, fp, cost))->user(userValue); (new V3GraphEdge(this, tp, fp, cost))->user(userValue);
} }
inline static uint32_t getEdgeId(const V3GraphEdge* edgep) { static uint32_t getEdgeId(const V3GraphEdge* edgep) {
return static_cast<uint32_t>(edgep->user()); return static_cast<uint32_t>(edgep->user());
} }
@ -138,7 +138,7 @@ private:
// We will keep sorted lists of edges as vectors // We will keep sorted lists of edges as vectors
using EdgeList = std::vector<V3GraphEdge*>; using EdgeList = std::vector<V3GraphEdge*>;
inline static bool edgeCmp(const V3GraphEdge* ap, const V3GraphEdge* bp) { static bool edgeCmp(const V3GraphEdge* ap, const V3GraphEdge* bp) {
// We pre-computed these when adding the edge to sort first by cost, then by identity // We pre-computed these when adding the edge to sort first by cost, then by identity
return ap->user() > bp->user(); return ap->user() > bp->user();
} }
@ -150,7 +150,7 @@ private:
} }
}; };
inline static Vertex* castVertexp(V3GraphVertex* vxp) { return static_cast<Vertex*>(vxp); } static Vertex* castVertexp(V3GraphVertex* vxp) { return static_cast<Vertex*>(vxp); }
public: public:
// From *this, populate *mstp with the minimum spanning tree. // From *this, populate *mstp with the minimum spanning tree.

2
test_regress/t/TestVpi.h
View File

@ -29,7 +29,7 @@ public:
, m_freeit(true) {} , m_freeit(true) {}
~TestVpiHandle() { release(); } ~TestVpiHandle() { release(); }
operator vpiHandle() const { return m_handle; } operator vpiHandle() const { return m_handle; }
inline TestVpiHandle& operator=(vpiHandle h) { TestVpiHandle& operator=(vpiHandle h) {
release(); release();
m_handle = h; m_handle = h;
return *this; return *this;

20
test_regress/t/t_dist_cppstyle.pl
View File

@ -24,8 +24,22 @@ foreach my $file (sort keys %files) {
my $contents = file_contents($filename); my $contents = file_contents($filename);
checkPattern($filename, $contents, checkPattern($filename, $contents,
qr/virtual[^{};]+override/, qr/[^\/]*virtual[^{};]+override/,
"'virtual' keyword is redundant on 'override' method"); "'virtual' keyword is redundant on 'override' method");
checkPattern($filename, $contents,
qr/ \s*(\w+ )*\s*(inline) [^;]+?\([^;]*?\)[^;]+?(?:{|:|=\s*default)/,
"'inline' keyword is redundant on method definitions inside classes");
checkPattern($filename, $contents,
qr/(?<!template <>\n)inline \S+ [^;:(]+::[^;:(]+\([^;]*\)[^;]+{/,
"Use 'inline' only on declaration inside classes (except for template specializatoins)");
if ($file =~ /\.(c|cpp)/) {
checkPattern($filename, $contents,
qr/(\w+\s+)*(inline)/,
"'inline' keyword is on functions defined in .cpp files");
}
} }
ok(1); ok(1);
@ -51,8 +65,8 @@ sub checkPattern {
my $offset = 0; my $offset = 0;
my $buffer = $contents; my $buffer = $contents;
while ($buffer =~ s/.*?^[^\/]*($pattern)//sm) { while ($buffer =~ s/.*?^($pattern)//sm) {
my $lineno = offset_to_lineno($contents, $offset + $-[1]); my $lineno = offset_to_lineno($contents, $offset + $-[-1]);
$offset += $+[1]; $offset += $+[1];
error("$filename:$lineno: $message"); error("$filename:$lineno: $message");
} }

2
test_regress/t/t_extend_class_c.h
View File

@ -13,5 +13,5 @@ public:
~t_extend_class_c() = default; ~t_extend_class_c() = default;
// METHODS // METHODS
// This function will be called from a instance created in Verilog // This function will be called from a instance created in Verilog
inline uint32_t my_math(uint32_t in) { return in + 1; } uint32_t my_math(uint32_t in) { return in + 1; }
}; };