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

Internals: Fix some clang-tidy issues. No functional change intended.

Browse Source
This commit is contained in:
Wilson Snyder 2022-07-30 11:52:35 -04:00
parent dce8f3d25d
commit a2d26b45bb
34 changed files with 160 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile.in
View File

@ -322,12 +322,13 @@ cppcheck: $(CPPCHECK_DEP)
$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 -DVL_THREADED=1 $(CPPCHECK_INC) $<
CLANGTIDY = clang-tidy
CLANGTIDY_FLAGS = -config='' -checks='-fuchsia-*,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-init-variables'
CLANGTIDY_FLAGS = -config='' \
-header-filter='.*' \
-checks='-fuchsia-*,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-init-variables,-cppcoreguidelines-avoid-goto,-modernize-avoid-c-arrays,-readability-magic-numbers,-readability-simplify-boolean-expr,-cppcoreguidelines-macro-usage' \
CLANGTIDY_DEP = $(subst .h,.h.tidy,$(CPPCHECK_H)) \
$(subst .cpp,.cpp.tidy,$(CPPCHECK_CPP))
CLANGTIDY_DEFS = -DVL_DEBUG=1 -DVL_THREADED=1 -DVL_CPPCHECK=1
# cppcoreguidelines-avoid-goto modernize-avoid-c-arrays readability-magic-numbers readability-simplify-boolean-expr
# cppcoreguidelines-macro-usage
clang-tidy: $(CLANGTIDY_DEP)
%.cpp.tidy: %.cpp

11
include/verilated.cpp
View File

@ -700,7 +700,8 @@ std::string _vl_vsformat_time(char* tmp, T ld, int timeunit, bool left, size_t w
= VL_EXTEND_WQ(b, 0, tmp2, std::numeric_limits<uint64_t>::max()); // breaks shifted
if (VL_GT_W(w, integer, max64Bit)) {
WDataOutP v = VL_ASSIGN_W(b, tmp3, integer); // breaks fracDigitsPow10
VlWide<w> zero, ten;
VlWide<w> zero;
VlWide<w> ten;
VL_ZERO_W(b, zero);
VL_EXTEND_WI(b, 0, ten, 10);
char buf[128]; // 128B is obviously long enough to represent 128bit integer in decimal
@ -1850,8 +1851,7 @@ VlReadMem::VlReadMem(bool hex, int bits, const std::string& filename, QData star
, m_bits{bits}
, m_filename(filename) // Need () or GCC 4.8 false warning
, m_end{end}
, m_addr{start}
, m_linenum{0} {
, m_addr{start} {
m_fp = std::fopen(filename.c_str(), "r");
if (VL_UNLIKELY(!m_fp)) {
// We don't report the Verilog source filename as it slow to have to pass it down
@ -1985,8 +1985,7 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
VlWriteMem::VlWriteMem(bool hex, int bits, const std::string& filename, QData start, QData end)
: m_hex{hex}
, m_bits{bits}
, m_addr{0} {
, m_bits{bits} {
if (VL_UNLIKELY(start > end)) {
VL_FATAL_MT(filename.c_str(), 0, "", "$writemem invalid address range");
return;
@ -2311,7 +2310,7 @@ std::string VerilatedContext::dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMut
return m_dumpfile;
}
std::string VerilatedContext::dumpfileCheck() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
const std::string out = dumpfile();
std::string out = dumpfile();
if (VL_UNLIKELY(out.empty())) {
VL_PRINTF_MT("%%Warning: $dumpvar ignored as not proceeded by $dumpfile\n");
return "";

4
include/verilated.h
View File

@ -558,7 +558,8 @@ public:
/// releases - contact the authors before production use.
void scopesDump() const VL_MT_SAFE;
public: // But for internal use only
// METHODS - public but for internal use only
// Internal: access to implementation class
VerilatedContextImp* impp() { return reinterpret_cast<VerilatedContextImp*>(this); }
const VerilatedContextImp* impp() const {
@ -884,7 +885,6 @@ public:
}
#endif
public:
// METHODS - INTERNAL USE ONLY (but public due to what uses it)
// Internal: Create a new module name by concatenating two strings
// Returns pointer to thread-local static data (overwritten on next call)

2
include/verilated_cov.cpp
View File

@ -205,7 +205,7 @@ private:
// Forward to . so we have a whole word
const std::string suffix = *bpost ? std::string{bpost + 1} : "";
const std::string out = prefix + "*" + suffix;
std::string out = prefix + "*" + suffix;
// cout << "\nch pre="<<prefix<<" s="<<suffix<<"\nch a="<<old<<"\nch b="<<add
// <<"\ncho="<<out<<endl;

5
include/verilated_cov.h
View File

@ -120,7 +120,8 @@ public:
/// Zero coverage points
void zero() VL_MT_SAFE;
public: // But Internal use only
// METHODS - public but Internal use only
// Insert a coverage item
// We accept from 1-30 key/value pairs, all as strings.
// Call _insert1, followed by _insert2 and _insert3
@ -158,7 +159,7 @@ protected:
// CONSTRUCTORS
// Internal: Only made as part of VerilatedCovImp
VerilatedCovContext() = default;
virtual ~VerilatedCovContext() = default;
~VerilatedCovContext() override = default;
// METHODS
// Internal: access to implementation class

3
include/verilated_fst_c.cpp
View File

@ -92,8 +92,7 @@ static_assert(static_cast<int>(FST_ST_VCD_PROGRAM) == static_cast<int>(VLT_TRACE
//=============================================================================
// VerilatedFst
VerilatedFst::VerilatedFst(void* fst)
: m_fst{fst} {}
VerilatedFst::VerilatedFst(void* /*fst*/) {}
VerilatedFst::~VerilatedFst() {
if (m_fst) fstWriterClose(m_fst);

2
include/verilated_fst_c.h
View File

@ -48,7 +48,7 @@ private:
//=========================================================================
// FST specific internals
void* m_fst;
void* m_fst = nullptr;
std::map<uint32_t, fstHandle> m_code2symbol;
std::map<int, fstEnumHandle> m_local2fstdtype;
std::list<std::string> m_curScope;

2
include/verilated_fst_sc.h
View File

@ -51,7 +51,7 @@ public:
}
spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
}
virtual ~VerilatedFstSc() { close(); }
~VerilatedFstSc() override { close(); }
// METHODS
/// Called by SystemC simulate()

37
include/verilated_imp.h
View File

@ -143,11 +143,10 @@ class VerilatedThreadMsgQueue final {
public:
// CONSTRUCTORS
VerilatedThreadMsgQueue() {}
~VerilatedThreadMsgQueue() {
// The only call of this with a non-empty queue is a fatal error.
// So this does not flush the queue, as the destination queue is not known to this class.
}
VerilatedThreadMsgQueue() = default;
~VerilatedThreadMsgQueue() = default;
// The only call of destructor with a non-empty queue is a fatal error.
// So this does not flush the queue, as the destination queue is not known to this class.
private:
VL_UNCOPYABLE(VerilatedThreadMsgQueue);
@ -188,11 +187,11 @@ class VerilatedFpList final {
public:
using const_iterator = FILE* const*;
explicit VerilatedFpList() {}
explicit VerilatedFpList() = default;
const_iterator begin() const { return m_fp; }
const_iterator end() const { return m_fp + m_sz; }
std::size_t size() const { return m_sz; }
std::size_t capacity() const { return 31; }
static std::size_t capacity() { return 31; }
void push_back(FILE* fd) {
if (VL_LIKELY(size() < capacity())) m_fp[m_sz++] = fd;
}
@ -236,12 +235,11 @@ class VerilatedContextImp final : VerilatedContext {
return s_s;
}
private:
public: // But only for verilated*.cpp
// CONSTRUCTORS - no data can live here, use only VerilatedContext
VerilatedContextImp() = delete;
~VerilatedContextImp() = delete;
public: // But only for verilated*.cpp
// METHODS - extending into VerilatedContext, call via impp()->
// Random seed handling
@ -272,13 +270,12 @@ public: // But only for verilated*.cpp
std::string argPlusMatch(const char* prefixp) VL_MT_SAFE_EXCLUDES(m_argMutex);
std::pair<int, char**> argc_argv() VL_MT_SAFE_EXCLUDES(m_argMutex);
public: // But only for verilated*.cpp
// METHODS - scope name
// METHODS - scope name - INTERNAL only for verilated*.cpp
void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE;
void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE;
public: // But only for verilated*.cpp
// METHODS - file IO
// METHODS - file IO - INTERNAL only for verilated*.cpp
IData fdNewMcd(const char* filenamep) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock{m_fdMutex};
if (m_fdFreeMct.empty()) return 0;
@ -298,7 +295,7 @@ public: // But only for verilated*.cpp
const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, m_fdps.size());
const std::size_t excess = 10;
m_fdps.resize(start + excess);
std::fill(m_fdps.begin() + start, m_fdps.end(), (FILE*)0);
std::fill(m_fdps.begin() + start, m_fdps.end(), static_cast<FILE*>(nullptr));
m_fdFree.resize(excess);
for (std::size_t i = 0, id = start; i < m_fdFree.size(); ++i, ++id) {
m_fdFree[i] = id;
@ -344,7 +341,7 @@ public: // But only for verilated*.cpp
if (VL_UNLIKELY(idx <= 2)) return; // stdout/stdin/stderr
if (VL_UNLIKELY(!m_fdps[idx])) return; // Already free
std::fclose(m_fdps[idx]);
m_fdps[idx] = (FILE*)0;
m_fdps[idx] = nullptr;
m_fdFree.push_back(idx);
} else {
// MCD case
@ -464,7 +461,6 @@ public:
// METHODS - debug
static void versionDump() VL_MT_SAFE;
public:
// METHODS - user scope tracking
// We implement this as a single large map instead of one map per scope.
// There's often many more scopes than userdata's and thus having a ~48byte
@ -486,7 +482,8 @@ public:
return it->second;
}
public: // But only for verilated.cpp
// METHODS - But only for verilated.cpp
// Symbol table destruction cleans up the entries for each scope.
static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope on destruction, so we only iterate.
@ -512,8 +509,7 @@ public: // But only for verilated.cpp
}
}
public: // But only for verilated*.cpp
// METHODS - hierarchy
// METHODS - hierarchy - only for verilated*.cpp
static void hierarchyAdd(const VerilatedScope* fromp, const VerilatedScope* top) VL_MT_SAFE {
// Slow ok - called at construction for VPI accessible elements
const VerilatedLockGuard lock{s().m_hierMapMutex};
@ -534,8 +530,7 @@ public: // But only for verilated*.cpp
return &s().m_hierMap;
}
public: // But only for verilated*.cpp
// METHODS - export names
// METHODS - export names - only for verilated*.cpp
// Each function prototype is converted to a function number which we
// then use to index a 2D table also indexed by scope number, because we

4
include/verilated_profiler.h
View File

@ -165,14 +165,14 @@ class VlExecutionProfiler final : public VerilatedVirtualBase {
public:
// CONSTRUCTOR
explicit VlExecutionProfiler(VerilatedContext& context);
virtual ~VlExecutionProfiler() = default;
~VlExecutionProfiler() override = default;
// METHODS
// Is profiling enabled
inline bool enabled() const { return m_enabled; }
// Append a trace record to the trace buffer of the current thread
inline VlExecutionRecord& addRecord() {
static inline VlExecutionRecord& addRecord() {
t_trace.emplace_back();
return t_trace.back();
}

5
include/verilated_save.h
View File

@ -77,7 +77,7 @@ public:
virtual void flush() VL_MT_UNSAFE_ONE {}
/// Write data to stream
VerilatedSerialize& write(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
const uint8_t* __restrict dp = (const uint8_t* __restrict)datap;
const uint8_t* __restrict dp = static_cast<const uint8_t* __restrict>(datap);
while (size) {
bufferCheck();
size_t blk = size;
@ -287,7 +287,8 @@ inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& r
uint32_t len = 0;
os >> len;
rhs.resize(len);
return os.read((void*)rhs.data(), len);
// C cast is required below
return os.read((void*)(rhs.data()), len);
}
VerilatedSerialize& operator<<(VerilatedSerialize& os, VerilatedContext* rhsp);
VerilatedDeserialize& operator>>(VerilatedDeserialize& os, VerilatedContext* rhsp);

1
include/verilated_sym_props.h
View File

@ -134,7 +134,6 @@ public:
initUnpacked(ulims);
}
public:
~VerilatedVarProps() = default;
// METHODS
bool magicOk() const { return m_magic == MAGIC; }

13
include/verilated_threads.h
View File

@ -136,13 +136,10 @@ class VlWorkerThread final {
private:
// TYPES
struct ExecRec {
VlExecFnp m_fnp; // Function to execute
VlSelfP m_selfp; // Symbol table to execute
bool m_evenCycle; // Even/odd for flag alternation
ExecRec()
: m_fnp{nullptr}
, m_selfp{nullptr}
, m_evenCycle{false} {}
VlExecFnp m_fnp = nullptr; // Function to execute
VlSelfP m_selfp = nullptr; // Symbol table to execute
bool m_evenCycle = false; // Even/odd for flag alternation
ExecRec() = default;
ExecRec(VlExecFnp fnp, VlSelfP selfp, bool evenCycle)
: m_fnp{fnp}
, m_selfp{selfp}
@ -222,7 +219,7 @@ public:
// pool will create these threads and make them available to execute tasks
// via this->workerp(index)->addTask(...)
VlThreadPool(VerilatedContext* contextp, unsigned nThreads);
virtual ~VlThreadPool();
~VlThreadPool() override;
// METHODS
inline int numThreads() const { return m_workers.size(); }

4
include/verilated_trace.h
View File

@ -401,7 +401,7 @@ protected:
EData* const m_sigs_enabledp; // Bit vector of enabled codes (nullptr = all on)
explicit VerilatedTraceBuffer(Trace& owner);
virtual ~VerilatedTraceBuffer() = default;
~VerilatedTraceBuffer() override = default;
public:
//=========================================================================
@ -487,7 +487,7 @@ class VerilatedTraceOffloadBuffer final : public VerilatedTraceBuffer<T_Buffer>
uint32_t* const m_offloadBufferEndp; // End of offload buffer
explicit VerilatedTraceOffloadBuffer(Trace& owner);
virtual ~VerilatedTraceOffloadBuffer() = default;
~VerilatedTraceOffloadBuffer() override = default;
public:
//=========================================================================

3
include/verilated_vcd_c.h
View File

@ -113,7 +113,7 @@ protected:
void commitTraceBuffer(Buffer*) override;
// Configure sub-class
void configure(const VerilatedTraceConfig&) override { return; };
void configure(const VerilatedTraceConfig&) override{};
public:
//=========================================================================
@ -253,7 +253,6 @@ public:
/// Destruct, flush, and close the dump
virtual ~VerilatedVcdC() { close(); }
public:
// METHODS - User called
/// Return if file is open

2
include/verilated_vcd_sc.h
View File

@ -54,7 +54,7 @@ public:
spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
}
/// Destruct, flush, and close the dump
virtual ~VerilatedVcdSc() { close(); }
~VerilatedVcdSc() override { close(); }
// METHODS - for SC kernel
// Called by SystemC simulate()

2
include/verilated_vpi.h
View File

@ -47,7 +47,7 @@ public:
static bool callValueCbs() VL_MT_UNSAFE_ONE;
/// Call callbacks of arbitrary types.
/// User wrapper code should call this from their main loops.
static bool callCbs(const uint32_t reason) VL_MT_UNSAFE_ONE;
static bool callCbs(uint32_t reason) VL_MT_UNSAFE_ONE;
/// Returns time of the next registered VPI callback, or
/// ~(0ULL) if none are registered
static QData cbNextDeadline() VL_MT_UNSAFE_ONE;

12
src/V3Ast.h
View File

@ -95,7 +95,7 @@ public:
// const char* ascii() const {...};
enum en m_e;
// cppcheck-suppress uninitVar // responsibility of each subclass
inline VNType() {}
inline VNType() = default;
// cppcheck-suppress noExplicitConstructor
inline VNType(en _e)
: m_e{_e} {}
@ -997,7 +997,7 @@ public:
return false;
}
//
VNumRange() {}
VNumRange() = default;
VNumRange(int hi, int lo, bool littleEndian) { init(hi, lo, littleEndian); }
VNumRange(int left, int right)
: m_left{left}
@ -1123,7 +1123,7 @@ class VNUser final {
} m_u;
public:
VNUser() {}
VNUser() = default;
// non-explicit:
// cppcheck-suppress noExplicitConstructor
VNUser(int i) {
@ -2444,7 +2444,7 @@ public:
void fromp(AstNode* nodep) { return setOp1p(nodep); }
void rhsp(AstNode* nodep) { return setOp2p(nodep); }
void thsp(AstNode* nodep) { return setOp3p(nodep); }
void attrp(AstAttrOf* nodep) { return setOp4p((AstNode*)nodep); }
void attrp(AstAttrOf* nodep) { return setOp4p(reinterpret_cast<AstNode*>(nodep)); }
// METHODS
virtual bool same(const AstNode*) const override { return true; }
};
@ -2536,7 +2536,7 @@ public:
AstNode* bodysp() const { return op4p(); } // op4 = body of loop
virtual bool isGateOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_BRANCH; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstNodeIf VL_NOT_FINAL : public AstNodeStmt {
@ -2563,7 +2563,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isGateDedupable() const override { return true; }
virtual int instrCount() const override { return INSTR_COUNT_BRANCH; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
void branchPred(VBranchPred flag) { m_branchPred = flag; }
VBranchPred branchPred() const { return m_branchPred; }
void isBoundsCheck(bool flag) { m_isBoundsCheck = flag; }

142
src/V3AstNodes.h
View File

@ -189,7 +189,7 @@ public:
explicit AstEmpty(FileLine* fl)
: ASTGEN_SUPER_Empty(fl) {}
ASTNODE_NODE_FUNCS(Empty)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstEmptyQueue final : public AstNodeMath {
@ -199,7 +199,7 @@ public:
ASTNODE_NODE_FUNCS(EmptyQueue)
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual string emitVerilog() override { return "{}"; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual bool cleanOut() const override { return true; }
};
@ -246,7 +246,7 @@ public:
bool littleEndian() const { return leftConst() < rightConst(); }
virtual void dump(std::ostream& str) const override;
virtual string emitC() { V3ERROR_NA_RETURN(""); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstBracketRange final : public AstNodeRange {
@ -260,7 +260,7 @@ public:
ASTNODE_NODE_FUNCS(BracketRange)
virtual string emitC() { V3ERROR_NA_RETURN(""); }
virtual string emitVerilog() { V3ERROR_NA_RETURN(""); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
// Will be removed in V3Width, which relies on this
// being a child not a dtype pointed node
virtual bool maybePointedTo() const override { return false; }
@ -275,7 +275,7 @@ public:
ASTNODE_NODE_FUNCS(UnsizedRange)
virtual string emitC() { V3ERROR_NA_RETURN(""); }
virtual string emitVerilog() { return "[]"; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstWildcardRange final : public AstNodeRange {
@ -286,7 +286,7 @@ public:
ASTNODE_NODE_FUNCS(WildcardRange)
virtual string emitC() { V3ERROR_NA_RETURN(""); }
virtual string emitVerilog() { return "[*]"; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstGatePin final : public AstNodeMath {
@ -660,7 +660,7 @@ class AstDynArrayDType final : public AstNodeDType {
// Dynamic array data type, ie "[]"
// Children: DTYPE (moved to refDTypep() in V3Width)
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
public:
AstDynArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)
: ASTGEN_SUPER_DynArrayDType(fl) {
@ -1042,7 +1042,7 @@ class AstConstDType final : public AstNodeDType {
// ConstDType are removed in V3LinkLValue and become AstVar::isConst.
// When more generic types are supported AstConstDType will be propagated further.
private:
AstNodeDType* m_refDTypep; // Inherit from this base data type
AstNodeDType* m_refDTypep = nullptr; // Inherit from this base data type
public:
AstConstDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp)
: ASTGEN_SUPER_ConstDType(fl) {
@ -1201,7 +1201,7 @@ class AstQueueDType final : public AstNodeDType {
// Queue array data type, ie "[ $ ]"
// Children: DTYPE (moved to refDTypep() in V3Width)
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
public:
AstQueueDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp, AstNode* boundp)
: ASTGEN_SUPER_QueueDType(fl) {
@ -1395,7 +1395,7 @@ class AstMemberDType final : public AstNodeDType {
// A member of a struct/union
// PARENT: AstNodeUOrStructDType
private:
AstNodeDType* m_refDTypep; // Elements of this type (after widthing)
AstNodeDType* m_refDTypep = nullptr; // Elements of this type (after widthing)
string m_name; // Name of variable
string m_tag; // Holds the string of the verilator tag -- used in XML output.
int m_lsb = -1; // Within this level's packed struct, the LSB of the first bit of the member
@ -1584,8 +1584,8 @@ class AstEnumDType final : public AstNodeDType {
// Children: ENUMVALUEs
private:
string m_name; // Name from upper typedef, if any
AstNodeDType* m_refDTypep; // Elements are of this type after V3Width
const int m_uniqueNum;
AstNodeDType* m_refDTypep = nullptr; // Elements are of this type after V3Width
const int m_uniqueNum = 0;
public:
AstEnumDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp, AstNode* itemsp)
@ -1708,7 +1708,7 @@ public:
return true;
} // esp for V3Const::ifSameAssign
virtual bool isPredictOptimizable() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
// Special operators
// Return base var (or const) nodep dereferences
@ -1749,7 +1749,7 @@ public:
return true;
} // esp for V3Const::ifSameAssign
virtual bool isPredictOptimizable() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
};
@ -1787,7 +1787,7 @@ public:
return true;
} // esp for V3Const::ifSameAssign
virtual bool isPredictOptimizable() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
};
@ -1814,7 +1814,7 @@ public:
virtual bool cleanRhs() const override { return true; }
virtual bool sizeMattersLhs() const override { return false; }
virtual bool sizeMattersRhs() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstSelLoopVars final : public AstNode {
@ -1827,7 +1827,7 @@ public:
addNOp2p(elementsp);
}
ASTNODE_NODE_FUNCS(SelLoopVars)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual bool maybePointedTo() const override { return false; }
AstNode* fromp() const { return op1p(); }
void fromp(AstNode* nodep) { setOp1p(nodep); }
@ -3357,7 +3357,7 @@ public:
addNOp2p(exprp);
}
ASTNODE_NODE_FUNCS(WithParse)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
//
AstNode* funcrefp() const { return op1p(); }
AstNode* exprp() const { return op2p(); }
@ -3377,7 +3377,7 @@ public:
, m_name{name}
, m_index(index) {}
ASTNODE_NODE_FUNCS(LambdaArgRef)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual string emitVerilog() override { return name(); }
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual bool cleanOut() const override { return true; }
@ -3404,7 +3404,7 @@ public:
addNOp3p(exprp);
}
ASTNODE_NODE_FUNCS(With)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual bool hasDType() const override { return true; }
virtual const char* broken() const override {
BROKEN_RTN(!indexArgRefp()); // varp needed to know lambda's arg dtype
@ -3578,7 +3578,7 @@ public:
addNOp2p(bodysp);
}
ASTNODE_NODE_FUNCS(AlwaysPublic)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
//
AstSenTree* sensesp() const { return VN_AS(op1p(), SenTree); } // op1 = Sensitivity list
AstNode* bodysp() const { return op2p(); } // op2 = Statements to evaluate
@ -3909,7 +3909,7 @@ public:
}
ASTNODE_NODE_FUNCS(CoverToggle)
virtual int instrCount() const override { return 3 + INSTR_COUNT_BRANCH + INSTR_COUNT_LD; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return true; }
virtual bool isOutputter() const override {
@ -3931,7 +3931,7 @@ public:
setNOp2p(stmtsp);
}
ASTNODE_NODE_FUNCS(Delay)
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
//
AstNode* lhsp() const { return op1p(); } // op1 = delay value
void lhsp(AstNode* nodep) { setOp1p(nodep); }
@ -4137,7 +4137,7 @@ public:
virtual bool isPredictOptimizable() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool cleanOut() const { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
VDumpCtlType ctlType() const { return m_ctlType; }
AstNode* exprp() const { return op1p(); } // op2 = Expressions to output
void exprp(AstNode* nodep) { setOp1p(nodep); }
@ -4208,7 +4208,7 @@ public:
virtual bool isOutputter() const override { return false; }
virtual bool cleanOut() const { return false; }
virtual int instrCount() const override { return INSTR_COUNT_PLI; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
void fmtp(AstSFormatF* nodep) { addOp1p(nodep); } // op1 = To-String formatter
AstSFormatF* fmtp() const { return VN_AS(op1p(), SFormatF); }
AstNode* lhsp() const { return op3p(); }
@ -4231,7 +4231,7 @@ public:
virtual bool isPure() const override { return true; }
virtual bool isOutputter() const override { return false; }
virtual int instrCount() const override { return 0; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* lhsp() const { return op1p(); } // op1 = Expressions to eval
void lhsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to eval
};
@ -4272,7 +4272,7 @@ public:
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op2p(); }
void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); }
};
@ -4293,7 +4293,7 @@ public:
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op1p(); }
AstNode* filenamep() const { return op2p(); }
AstNode* modep() const { return op3p(); }
@ -4314,7 +4314,7 @@ public:
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op1p(); }
AstNode* filenamep() const { return op2p(); }
};
@ -4334,7 +4334,7 @@ public:
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op2p(); }
void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); }
};
@ -4362,7 +4362,7 @@ public:
virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering
virtual bool isOutputter() const override { return true; } // SPECIAL: makes output
virtual bool cleanOut() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* memp() const { return op1p(); }
void memp(AstNode* nodep) { setOp1p(nodep); }
AstNode* filep() const { return op2p(); }
@ -4391,7 +4391,7 @@ public:
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool cleanOut() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op2p(); }
void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); }
};
@ -4414,7 +4414,7 @@ public:
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool cleanOut() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op2p(); }
void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); }
};
@ -4440,7 +4440,7 @@ public:
virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering
virtual bool isOutputter() const override { return true; } // SPECIAL: makes output
virtual bool cleanOut() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* filep() const { return op2p(); }
void filep(AstNode* nodep) { setOp2p(nodep); }
AstNode* offset() const { return op3p(); }
@ -4604,7 +4604,7 @@ public:
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* lhsp() const { return op1p(); }
};
@ -4625,7 +4625,7 @@ public:
virtual bool isOutputter() const override { return true; }
virtual bool isUnlikely() const override { return true; }
virtual bool cleanOut() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* lhsp() const { return op1p(); }
};
@ -4646,7 +4646,7 @@ public:
virtual bool isPredictOptimizable() const override { return false; }
virtual bool isPure() const override { return !outp(); }
virtual bool cleanOut() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* searchp() const { return op1p(); } // op1 = Search expression
void searchp(AstNode* nodep) { setOp1p(nodep); }
AstNode* outp() const { return op2p(); } // op2 = Expressions to output
@ -4668,7 +4668,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual bool cleanOut() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstNode* searchp() const { return op1p(); } // op1 = Search expression
void searchp(AstNode* nodep) { setOp1p(nodep); }
};
@ -4692,7 +4692,7 @@ public:
AstNode* bodysp() const { return op4p(); } // op4 = body of loop
virtual bool isGateOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_BRANCH; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstRepeat final : public AstNodeStmt {
@ -4709,7 +4709,7 @@ public:
return false;
} // Not relevant - converted to FOR
virtual int instrCount() const override { return INSTR_COUNT_BRANCH; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstWait final : public AstNodeStmt {
@ -4742,7 +4742,7 @@ public:
void addIncsp(AstNode* newp) { addOp4p(newp); }
virtual bool isGateOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_BRANCH; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
// Stop statement searchback here
virtual void addBeforeStmt(AstNode* newp, AstNode* belowp) override;
// Stop statement searchback here
@ -4862,7 +4862,7 @@ public:
ASTNODE_NODE_FUNCS(JumpBlock)
virtual int instrCount() const override { return 0; }
virtual bool maybePointedTo() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
// op1 = Statements
AstNode* stmtsp() const { return op1p(); } // op1 = List of statements
void addStmtsp(AstNode* nodep) { addNOp1p(nodep); }
@ -4948,7 +4948,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual int instrCount() const override { return widthInstrs() * 2; } // xor, or/logor
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstConsAssoc final : public AstNodeMath {
@ -4967,7 +4967,7 @@ public:
virtual bool cleanOut() const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
AstNode* defaultp() const { return op1p(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstSetAssoc final : public AstNodeMath {
// Set an assoc array element and return object, '{}
@ -4989,7 +4989,7 @@ public:
AstNode* lhsp() const { return op1p(); }
AstNode* keyp() const { return op2p(); }
AstNode* valuep() const { return op3p(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstConsWildcard final : public AstNodeMath {
@ -5008,7 +5008,7 @@ public:
virtual bool cleanOut() const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
AstNode* defaultp() const { return op1p(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstSetWildcard final : public AstNodeMath {
// Set a wildcard assoc array element and return object, '{}
@ -5030,7 +5030,7 @@ public:
AstNode* lhsp() const { return op1p(); }
AstNode* keyp() const { return op2p(); }
AstNode* valuep() const { return op3p(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstConsDynArray final : public AstNodeMath {
@ -5051,7 +5051,7 @@ public:
virtual int instrCount() const override { return widthInstrs(); }
AstNode* lhsp() const { return op1p(); } // op1 = expression
AstNode* rhsp() const { return op2p(); } // op2 = expression
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstConsQueue final : public AstNodeMath {
@ -5072,7 +5072,7 @@ public:
virtual int instrCount() const override { return widthInstrs(); }
AstNode* lhsp() const { return op1p(); } // op1 = expression
AstNode* rhsp() const { return op2p(); } // op2 = expression
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstBegin final : public AstNodeBlock {
@ -5249,7 +5249,7 @@ public:
: ASTGEN_SUPER_New(fl, false, "new", pinsp) {}
ASTNODE_NODE_FUNCS(New)
virtual bool cleanOut() const { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual bool hasDType() const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
};
@ -5268,7 +5268,7 @@ public:
virtual string emitVerilog() override { return "new"; }
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual bool cleanOut() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
AstNode* rhsp() const { return op1p(); }
};
@ -5288,7 +5288,7 @@ public:
virtual string emitVerilog() override { return "new"; }
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual bool cleanOut() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual int instrCount() const override { return widthInstrs(); }
AstNode* sizep() const { return op1p(); }
AstNode* rhsp() const { return op2p(); }
@ -5721,7 +5721,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_PLI; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
bool combinable(const AstRand* samep) const {
return !seedp() && !samep->seedp() && reset() == samep->reset()
&& urandom() == samep->urandom();
@ -5772,7 +5772,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_TIME; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual void dump(std::ostream& str = std::cout) const override;
void timeunit(const VTimescale& flag) { m_timeunit = flag; }
VTimescale timeunit() const { return m_timeunit; }
@ -5793,7 +5793,7 @@ public:
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_TIME; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
virtual void dump(std::ostream& str = std::cout) const override;
void timeunit(const VTimescale& flag) { m_timeunit = flag; }
VTimescale timeunit() const { return m_timeunit; }
@ -5818,7 +5818,7 @@ public:
virtual bool isSubstOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual int instrCount() const override { return INSTR_COUNT_PLI; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
//======================================================================
@ -6406,7 +6406,7 @@ public:
virtual bool cleanOut() const override { return true; }
virtual bool cleanLhs() const override { return true; }
virtual bool sizeMattersLhs() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstFEof final : public AstNodeUniop {
@ -6448,7 +6448,7 @@ public:
AstNode* filep() const { return op1p(); }
void strp(AstNode* nodep) { setOp2p(nodep); }
AstNode* strp() const { return op2p(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstFGetC final : public AstNodeUniop {
@ -8573,7 +8573,7 @@ public:
AstNode* exprp() const { return op1p(); } // op1 = expression
AstSenTree* sentreep() const { return VN_AS(op2p(), SenTree); } // op2 = clock domain
void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstPast final : public AstNodeMath {
@ -8596,7 +8596,7 @@ public:
AstNode* ticksp() const { return op2p(); } // op2 = ticks or nullptr means 1
AstSenTree* sentreep() const { return VN_AS(op4p(), SenTree); } // op4 = clock domain
void sentreep(AstSenTree* sentreep) { addOp4p(sentreep); } // op4 = clock domain
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstRose final : public AstNodeMath {
@ -8617,7 +8617,7 @@ public:
AstNode* exprp() const { return op1p(); } // op1 = expression
AstSenTree* sentreep() const { return VN_AS(op2p(), SenTree); } // op2 = clock domain
void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstSampled final : public AstNodeMath {
@ -8636,7 +8636,7 @@ public:
virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); }
virtual int instrCount() const override { return 0; }
AstNode* exprp() const { return op1p(); } // op1 = expression
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstStable final : public AstNodeMath {
@ -8657,7 +8657,7 @@ public:
AstNode* exprp() const { return op1p(); } // op1 = expression
AstSenTree* sentreep() const { return VN_AS(op2p(), SenTree); } // op2 = clock domain
void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
class AstPattern final : public AstNodeMath {
@ -8732,7 +8732,7 @@ public:
void rhsp(AstNode* nodep) { return setOp2p(nodep); }
AstSenTree* sentreep() const { return VN_AS(op4p(), SenTree); } // op4 = clock domain
void sentreep(AstSenTree* sentreep) { addOp4p(sentreep); } // op4 = clock domain
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
//======================================================================
@ -8953,7 +8953,7 @@ public:
virtual bool isPredictOptimizable() const override { return false; }
virtual bool isPure() const override { return false; }
virtual bool isOutputter() const override { return true; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
};
//======================================================================
@ -8973,7 +8973,7 @@ public:
ASTNODE_BASE_FUNCS(NodeFile)
virtual void dump(std::ostream& str) const override;
virtual string name() const override { return m_name; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
void tblockp(AstTextBlock* tblockp) { setOp1p(tblockp); }
AstTextBlock* tblockp() { return VN_AS(op1p(), TextBlock); }
};
@ -9241,7 +9241,7 @@ public:
}
ASTNODE_NODE_FUNCS(CReturn)
virtual int instrCount() const override { return widthInstrs(); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
//
AstNode* lhsp() const { return op1p(); }
};
@ -9272,7 +9272,7 @@ public:
virtual bool cleanOut() const override { return m_cleanOut; }
virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); }
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
void addBodysp(AstNode* nodep) { addNOp1p(nodep); }
AstNode* bodysp() const { return op1p(); } // op1 = expressions to print
bool pure() const { return m_pure; }
@ -9289,7 +9289,7 @@ public:
ASTNODE_NODE_FUNCS(CReset)
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
AstVarRef* varrefp() const { return VN_AS(op1p(), VarRef); } // op1 = varref to reset
};
@ -9307,7 +9307,7 @@ public:
ASTNODE_NODE_FUNCS(CStmt)
virtual bool isGateOptimizable() const override { return false; }
virtual bool isPredictOptimizable() const override { return false; }
virtual bool same(const AstNode* samep) const override { return true; }
virtual bool same(const AstNode* /*samep*/) const override { return true; }
void addBodysp(AstNode* nodep) { addNOp1p(nodep); }
AstNode* bodysp() const { return op1p(); } // op1 = expressions to print
};
@ -9403,7 +9403,7 @@ class AstTypeTable final : public AstNode {
AstEmptyQueueDType* m_emptyQueuep = nullptr;
AstQueueDType* m_queueIndexp = nullptr;
AstVoidDType* m_voidp = nullptr;
AstBasicDType* m_basicps[VBasicDTypeKwd::_ENUM_MAX];
AstBasicDType* m_basicps[VBasicDTypeKwd::_ENUM_MAX]{};
//
using DetailedMap = std::map<VBasicTypeKey, AstBasicDType*>;
DetailedMap m_detailedMap;

4
src/V3Dead.cpp
View File

@ -85,7 +85,7 @@ private:
}
if (AstNode* const subnodep = nodep->getChildDTypep()) subnodep->user1Inc();
}
void checkVarRef(AstNodeVarRef* nodep) {
void checkVarRef(AstNodeVarRef* nodep) const {
if (nodep->classOrPackagep() && m_elimCells) nodep->classOrPackagep(nullptr);
}
void checkDType(AstNodeDType* nodep) {
@ -316,7 +316,7 @@ private:
}
}
}
bool mightElimVar(AstVar* nodep) {
bool mightElimVar(AstVar* nodep) const {
if (nodep->isSigPublic()) return false; // Can't elim publics!
if (nodep->isIO() || nodep->isClassMember()) return false;
if (nodep->isTemp() && !nodep->isTrace()) return true;

5
src/V3DupFinder.h
View File

@ -44,7 +44,7 @@ class V3DupFinder final : private std::multimap<V3Hash, AstNode*> {
using Super = std::multimap<V3Hash, AstNode*>;
// MEMBERS
const V3Hasher* const m_hasherp; // Pointer to owned hasher
const V3Hasher* const m_hasherp = nullptr; // Pointer to owned hasher
const V3Hasher& m_hasher; // Reference to hasher
public:
@ -53,8 +53,7 @@ public:
: m_hasherp{new V3Hasher}
, m_hasher{*m_hasherp} {}
explicit V3DupFinder(const V3Hasher& hasher)
: m_hasherp{nullptr}
, m_hasher{hasher} {}
: m_hasher{hasher} {}
~V3DupFinder() {
if (m_hasherp) delete m_hasherp;
}

2
src/V3FileLine.cpp
View File

@ -126,7 +126,7 @@ string VFileContent::getLine(int lineno) const {
return "";
}
}
const string text = m_lines[lineno];
string text = m_lines[lineno];
UINFO(9, "Get Stream[ct" << m_id << "+" << lineno << "]: " << text);
return text;
}

4
src/V3FileLine.h
View File

@ -162,7 +162,7 @@ public:
m_firstColumn = firstColumn;
m_lastColumn = lastColumn;
}
void language(V3LangCode lang) { singleton().numberToLang(filenameno(), lang); }
void language(V3LangCode lang) const { singleton().numberToLang(filenameno(), lang); }
void filename(const string& name) { m_filenameno = singleton().nameToNumber(name); }
void parent(FileLine* fileline) { m_parent = fileline; }
void lineDirective(const char* textp, int& enterExitRef);
@ -213,7 +213,7 @@ public:
void warnStyleOff(bool flag);
void warnStateFrom(const FileLine& from) { m_warnOn = from.m_warnOn; }
void warnResetDefault() { warnStateFrom(defaultFileLine()); }
bool lastWarnWaived() { return m_waive; }
bool lastWarnWaived() const { return m_waive; }
// Specific flag ACCESSORS/METHODS
bool celldefineOn() const { return m_warnOn.test(V3ErrorCode::I_CELLDEFINE); }

2
src/V3HierBlock.cpp
View File

@ -201,7 +201,7 @@ string V3HierBlock::hierGenerated(bool withDir) const {
}
string V3HierBlock::vFileIfNecessary() const {
const string filename = V3Os::filenameRealPath(m_modp->fileline()->filename());
string filename = V3Os::filenameRealPath(m_modp->fileline()->filename());
for (const string& v : v3Global.opt.vFiles()) {
// Already listed in vFiles, so no need to add the file.
if (filename == V3Os::filenameRealPath(v)) return "";

8
src/V3Options.cpp
View File

@ -339,7 +339,7 @@ bool V3Options::hasParameter(const string& name) {
}
string V3Options::parameter(const string& name) {
const string value = m_parameters.find(name)->second;
string value = m_parameters.find(name)->second;
m_parameters.erase(m_parameters.find(name));
return value;
}
@ -477,7 +477,7 @@ string V3Options::fileExists(const string& filename) {
return ""; // Not found
}
// Check if it is a directory, ignore if so
const string filenameOut = V3Os::filenameFromDirBase(dir, basename);
string filenameOut = V3Os::filenameFromDirBase(dir, basename);
if (!fileStatNormal(filenameOut)) return ""; // Directory
return filenameOut;
}
@ -518,11 +518,11 @@ string V3Options::filePath(FileLine* fl, const string& modname, const string& la
// using the incdir and libext's.
// Return "" if not found.
for (const string& dir : m_impp->m_incDirUsers) {
const string exists = filePathCheckOneDir(modname, dir);
string exists = filePathCheckOneDir(modname, dir);
if (exists != "") return exists;
}
for (const string& dir : m_impp->m_incDirFallbacks) {
const string exists = filePathCheckOneDir(modname, dir);
string exists = filePathCheckOneDir(modname, dir);
if (exists != "") return exists;
}

3
src/V3ParseGrammar.cpp
View File

@ -270,7 +270,8 @@ string V3ParseGrammar::deQuote(FileLine* fileline, string text) {
} else if (*cp == 'x' && isxdigit(cp[1])
&& isxdigit(cp[2])) { // SystemVerilog 3.1
#define vl_decodexdigit(c) ((isdigit(c) ? ((c) - '0') : (tolower((c)) - 'a' + 10)))
newtext += (char)(16 * vl_decodexdigit(cp[1]) + vl_decodexdigit(cp[2]));
newtext
+= static_cast<char>(16 * vl_decodexdigit(cp[1]) + vl_decodexdigit(cp[2]));
cp += 2;
} else if (isalnum(*cp)) {
fileline->v3error("Unknown escape sequence: \\" << *cp);

5
src/V3ParseImp.h
View File

@ -173,9 +173,10 @@ public:
}
static int debug() {
static int level = -1;
if (VL_UNLIKELY(level < 0))
if (VL_UNLIKELY(level < 0)) {
level = std::max(std::max(debugBison(), debugFlex()),
v3Global.opt.debugSrcLevel("V3ParseImp"));
}
return level;
}
@ -273,7 +274,7 @@ public:
//==== Symbol tables
V3ParseSym* symp() { return m_symp; }
AstPackage* unitPackage(FileLine* fl) {
AstPackage* unitPackage(FileLine* /*fl*/) {
// Find one made earlier?
const VSymEnt* const rootSymp
= symp()->symRootp()->findIdFlat(AstPackage::dollarUnitName());

4
src/V3PartitionGraph.h
View File

@ -30,7 +30,7 @@
class AbstractMTask VL_NOT_FINAL : public V3GraphVertex {
public:
AbstractMTask(V3Graph* graphp)
explicit AbstractMTask(V3Graph* graphp)
: V3GraphVertex{graphp} {}
virtual ~AbstractMTask() override = default;
virtual uint32_t id() const = 0;
@ -42,7 +42,7 @@ public:
// TYPES
using VxList = std::list<MTaskMoveVertex*>;
// CONSTRUCTORS
AbstractLogicMTask(V3Graph* graphp)
explicit AbstractLogicMTask(V3Graph* graphp)
: AbstractMTask{graphp} {}
virtual ~AbstractLogicMTask() override = default;
// METHODS

2
src/V3PreProc.cpp
View File

@ -1612,7 +1612,7 @@ string V3PreProcImp::getline() {
// Make new string with data up to the newline.
const int len = rtnp - m_lineChars.c_str() + 1;
const string theLine(m_lineChars, 0, len);
string theLine(m_lineChars, 0, len);
m_lineChars = m_lineChars.erase(0, len); // Remove returned characters
if (debug() >= 4) {
const string lncln = V3PreLex::cleanDbgStrg(theLine);

7
src/V3Simulate.h
View File

@ -183,7 +183,7 @@ public:
}
m_whyNotOptimizable = why;
std::ostringstream stack;
for (auto& callstack : vlstd::reverse_view(m_callStack)) {
for (const auto& callstack : vlstd::reverse_view(m_callStack)) {
AstFuncRef* const funcp = callstack->m_funcp;
stack << "\n " << funcp->fileline() << "... Called from "
<< funcp->prettyName() << "() with parameters:";
@ -193,9 +193,10 @@ public:
AstVar* const portp = conIt->first;
AstNode* const pinp = conIt->second->exprp();
AstNodeDType* const dtypep = pinp->dtypep();
if (AstConst* const valp = fetchConstNull(pinp))
if (AstConst* const valp = fetchConstNull(pinp)) {
stack << "\n " << portp->prettyName() << " = "
<< prettyNumber(&valp->num(), dtypep);
}
}
}
m_whyNotOptimizable += stack.str();
@ -380,7 +381,7 @@ private:
UASSERT_OBJ(vscp, nodep, "Not linked");
return vscp;
}
int unrollCount() {
int unrollCount() const {
return m_params ? v3Global.opt.unrollCount() * 16 : v3Global.opt.unrollCount();
}
bool jumpingOver(AstNode* nodep) {

4
src/V3TraceDecl.cpp
View File

@ -192,7 +192,9 @@ private:
m_subFuncSize += stmtp->nodeCount();
}
std::string getScopeChar(VltTraceScope sct) { return std::string(1, (char)(0x80 + sct)); }
std::string getScopeChar(VltTraceScope sct) {
return std::string(1, static_cast<char>(0x80 + sct));
}
std::string addAboveInterface(const std::string& scopeName) {
std::string out;

2
src/V3Tristate.cpp
View File

@ -360,7 +360,7 @@ class TristateVisitor final : public TristateBaseVisitor {
VDouble0 m_statTriSigs; // stat tracking
// METHODS
string dbgState() {
string dbgState() const {
string o = (m_graphing ? " gr " : " ng ");
if (m_alhs) o += "alhs ";
return o;

2
src/V3Unroll.cpp
View File

@ -58,7 +58,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
bool cantUnroll(AstNode* nodep, const char* reason) {
bool cantUnroll(AstNode* nodep, const char* reason) const {
if (m_generate)
nodep->v3warn(E_UNSUPPORTED, "Unsupported: Can't unroll generate for; " << reason);
UINFO(3, " Can't Unroll: " << reason << " :" << nodep << endl);

10
src/VlcBucket.h
View File

@ -96,20 +96,20 @@ public:
}
uint64_t popCount() const {
uint64_t pop = 0;
for (uint64_t i = 0; i < m_dataSize; i++) {
if (hits(i)) pop++;
for (uint64_t i = 0; i < m_dataSize; ++i) {
if (hits(i)) ++pop;
}
return pop;
}
uint64_t dataPopCount(const VlcBuckets& remaining) {
uint64_t pop = 0;
for (uint64_t i = 0; i < m_dataSize; i++) {
if (hits(i) && remaining.hits(i)) pop++;
for (uint64_t i = 0; i < m_dataSize; ++i) {
if (hits(i) && remaining.hits(i)) ++pop;
}
return pop;
}
void orData(const VlcBuckets& ordata) {
for (uint64_t i = 0; i < m_dataSize; i++) {
for (uint64_t i = 0; i < m_dataSize; ++i) {
if (hits(i) && ordata.hits(i)) clearHits(i);
}
}