VeniVidiVici
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

This commit is contained in:
Wilson Snyder 2018-10-14 18:39:33 -04:00
parent 5ae1ce90ad
commit 304a24d03a
95 changed files with 724 additions and 634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.clang-tidy Normal file
View File

@ -0,0 +1,9 @@
Checks: 'clang-diagnostic-*,clang-analyzer-*,*,-modernize*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-default-arguments,-fuchsia-overloaded-operator,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
WarningsAsErrors: ''
HeaderFilterRegex: ''
FormatStyle: none
CheckOptions:
- key: google-readability-braces-around-statements.ShortStatementLines
value: '2'
- key: google-readability-namespace-comments.SpacesBeforeComments
value: '2'

1
.gitignore vendored
View File

@ -1,6 +1,7 @@
\#*
.#*
*~
*.tidy
*.old
*.gz
*.gz.uu

4
MANIFEST.SKIP
View File

@ -1,5 +1,4 @@
^CVS/
/CVS/
\.clang-tidy
\.git/
\.svn/
\.(bak|old)/
@ -9,6 +8,7 @@
.*\.log
\..*\.swp
.*\.tmp
.*\.tidy
.*\.tex
.*\.key
.*\.vcd

21
Makefile.in
View File

@ -427,14 +427,16 @@ endif
endif
# Use --xml flag to see the cppcheck code to use for suppression
CPPCHECK_CPP = $(wildcard \
$(srcdir)/include/*.cpp \
$(srcdir)/src/*.cpp )
CPPCHECK_H = $(wildcard \
$(srcdir)/include/*.h \
$(srcdir)/src/*.h )
CPPCHECK = src/cppcheck_filtered
CPPCHECK_FLAGS = --enable=all --inline-suppr \
--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList
CPPCHECK_FLAGS += --xml
CPPCHECK_CPP = $(wildcard \
$(srcdir)/include/*.cpp \
$(srcdir)/include/gtkwave/*.cpp \
$(srcdir)/src/*.cpp)
CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
@ -442,6 +444,17 @@ cppcheck: $(CPPCHECK_DEP)
%.cppcheck: %.cpp
$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $<
CLANGTIDY = clang-tidy
CLANGTIDY_FLAGS = -config=''
CLANGTIDY_DEP = $(subst .h,.h.tidy,$(CPPCHECK_H)) \
$(subst .cpp,.cpp.tidy,$(CPPCHECK_CPP))
clangtidy: $(CLANGTIDY_DEP)
%.cpp.tidy: %.cpp
$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
%.h.tidy: %.h
$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
analyzer-src:
-rm -rf src/obj_dbg
scan-build $(MAKE) -k verilator_coverage_bin_dbg verilator_bin_dbg

92
include/verilated.cpp
View File

@ -135,13 +135,11 @@ std::string _vl_string_vprintf(const char* formatp, va_list ap) VL_MT_SAFE {
int len = VL_VSNPRINTF(NULL, 0, formatp, aq);
va_end(aq);
if (VL_UNLIKELY(len < 1)) {
va_end(ap);
return "";
}
char* bufp = new char[len+1];
VL_VSNPRINTF(bufp, len+1, formatp, ap);
va_end(ap);
std::string out = std::string(bufp, len);
delete[] bufp;
@ -240,10 +238,10 @@ vluint64_t vl_rand64() VL_MT_SAFE {
t_seeded = true;
{
VerilatedLockGuard lock(s_mutex);
t_state[0] = (((vluint64_t)vl_sys_rand32())<<32
^ ((vluint64_t)vl_sys_rand32()));
t_state[1] = (((vluint64_t)vl_sys_rand32())<<32
^ ((vluint64_t)vl_sys_rand32()));
t_state[0] = ((static_cast<vluint64_t>(vl_sys_rand32()) << 32)
^ (static_cast<vluint64_t>(vl_sys_rand32())));
t_state[1] = ((static_cast<vluint64_t>(vl_sys_rand32()) << 32)
^ (static_cast<vluint64_t>(vl_sys_rand32())));
// Fix state as algorithm is slow to randomize if many zeros
// This causes a loss of ~ 1 bit of seed entropy, no big deal
if (VL_COUNTONES_I(t_state[0]) < 10) t_state[0] = ~t_state[0];
@ -1245,19 +1243,19 @@ IData VL_SSCANF_INX(int, const std::string& ld, const char* formatp, ...) VL_MT_
}
void VL_WRITEMEM_Q(bool hex, int width, int depth, int array_lsb, int,
QData ofilename, const void* memp, IData start,
QData filename, const void* memp, IData start,
IData end) VL_MT_SAFE {
WData fnw[2]; VL_SET_WQ(fnw, ofilename);
return VL_WRITEMEM_W(hex, width,depth,array_lsb,2,fnw,memp,start,end);
WData fnw[2]; VL_SET_WQ(fnw, filename);
return VL_WRITEMEM_W(hex, width, depth, array_lsb,2, fnw, memp, start, end);
}
void VL_WRITEMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
WDataInP ofilenamep, const void* memp, IData start,
WDataInP filenamep, const void* memp, IData start,
IData end) VL_MT_SAFE {
char ofilenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
_VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, ofilenamez, ofilenamep);
std::string ofilenames(ofilenamez);
return VL_WRITEMEM_N(hex, width,depth,array_lsb,ofilenames,memp,start,end);
char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
_VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, filenamez, filenamep);
std::string filenames(filenamez);
return VL_WRITEMEM_N(hex, width, depth, array_lsb, filenames, memp, start, end);
}
const char* memhFormat(int nBits) {
@ -1284,19 +1282,19 @@ void VL_WRITEMEM_N(
int depth, // Number of rows
int array_lsb, // Index of first row. Valid row addresses
// // range from array_lsb up to (array_lsb + depth - 1)
const std::string& ofilenamep, // Output file name
const std::string& filename, // Output file name
const void* memp, // Array state
IData start, // First array row address to write
IData end // Last address to write
) VL_MT_SAFE {
if (VL_UNLIKELY(!hex)) {
VL_FATAL_MT(ofilenamep.c_str(), 0, "",
VL_FATAL_MT(filename.c_str(), 0, "",
"VL_WRITEMEM_N only supports hex format for now, sorry!");
return;
}
FILE* fp = fopen(ofilenamep.c_str(), "w");
FILE* fp = fopen(filename.c_str(), "w");
if (VL_UNLIKELY(!fp)) {
VL_FATAL_MT(ofilenamep.c_str(), 0, "", "$writemem file not found");
VL_FATAL_MT(filename.c_str(), 0, "", "$writemem file not found");
return;
}
@ -1305,7 +1303,7 @@ void VL_WRITEMEM_N(
|| (row_addr > array_lsb + depth - 1)) {
vluint32_t endmax = ~0;
if (end != endmax) {
VL_FATAL_MT(ofilenamep.c_str(), 0, "",
VL_FATAL_MT(filename.c_str(), 0, "",
"$writemem specified address out-of-bounds");
}
// else, it's not an error to overflow due to end == endmax,
@ -1369,17 +1367,17 @@ void VL_WRITEMEM_N(
}
void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int,
QData ofilename, void* memp, IData start, IData end) VL_MT_SAFE {
WData fnw[2]; VL_SET_WQ(fnw, ofilename);
return VL_READMEM_W(hex,width,depth,array_lsb,2,fnw,memp,start,end);
QData filename, void* memp, IData start, IData end) VL_MT_SAFE {
WData fnw[2]; VL_SET_WQ(fnw, filename);
return VL_READMEM_W(hex, width, depth, array_lsb, 2, fnw, memp, start, end);
}
void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
WDataInP ofilenamep, void* memp, IData start, IData end) VL_MT_SAFE {
char ofilenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
_VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, ofilenamez, ofilenamep);
std::string ofilenames(ofilenamez);
return VL_READMEM_N(hex,width,depth,array_lsb,ofilenames,memp,start,end);
WDataInP filenamep, void* memp, IData start, IData end) VL_MT_SAFE {
char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
_VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, filenamez, filenamep);
std::string filenames(filenamez);
return VL_READMEM_N(hex, width, depth, array_lsb, filenames, memp, start, end);
}
void VL_READMEM_N(
@ -1388,15 +1386,15 @@ void VL_READMEM_N(
int depth, // Number of rows
int array_lsb, // Index of first row. Valid row addresses
// // range from array_lsb up to (array_lsb + depth - 1)
const std::string& ofilenamep, // Input file name
const std::string& filename, // Input file name
void* memp, // Array state
IData start, // First array row address to read
IData end // Last row address to read
) VL_MT_SAFE {
FILE* fp = fopen(ofilenamep.c_str(), "r");
FILE* fp = fopen(filename.c_str(), "r");
if (VL_UNLIKELY(!fp)) {
// We don't report the Verilog source filename as it slow to have to pass it down
VL_FATAL_MT(ofilenamep.c_str(), 0, "", "$readmem file not found");
VL_FATAL_MT(filename.c_str(), 0, "", "$readmem file not found");
return;
}
// Prep for reading
@ -1443,7 +1441,7 @@ void VL_READMEM_N(
//printf(" Value width=%d @%x = %c\n", width, addr, c);
if (VL_UNLIKELY(addr >= static_cast<IData>(depth+array_lsb)
|| addr < static_cast<IData>(array_lsb))) {
VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
VL_FATAL_MT(filename.c_str(), linenum, "",
"$readmem file address beyond bounds of array");
} else {
int entry = addr - array_lsb;
@ -1473,7 +1471,7 @@ void VL_READMEM_N(
datap[0] |= value;
}
if (VL_UNLIKELY(value>=(1<<shift))) {
VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
VL_FATAL_MT(filename.c_str(), linenum, "",
"$readmemb (binary) file contains hex characters");
}
}
@ -1481,7 +1479,7 @@ void VL_READMEM_N(
innum = true;
}
else {
VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file syntax error");
VL_FATAL_MT(filename.c_str(), linenum, "", "$readmem file syntax error");
}
}
lastc = c;
@ -1491,7 +1489,8 @@ void VL_READMEM_N(
// Final checks
fclose(fp);
if (VL_UNLIKELY(end != VL_UL(0xffffffff) && addr != (end+1))) {
VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file ended before specified ending-address");
VL_FATAL_MT(filename.c_str(), linenum, "",
"$readmem file ended before specified ending-address");
}
}
@ -1499,16 +1498,16 @@ IData VL_SYSTEM_IQ(QData lhs) VL_MT_SAFE {
WData lhsw[2]; VL_SET_WQ(lhsw, lhs);
return VL_SYSTEM_IW(2, lhsw);
}
IData VL_SYSTEM_IW(int lhswords, WDataInP filenamep) VL_MT_SAFE {
IData VL_SYSTEM_IW(int lhswords, WDataInP lhsp) VL_MT_SAFE {
char filenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
_VL_VINT_TO_STRING(lhswords*VL_WORDSIZE, filenamez, filenamep);
_VL_VINT_TO_STRING(lhswords*VL_WORDSIZE, filenamez, lhsp);
int code = system(filenamez); // Yes, system() is threadsafe
return code >> 8; // Want exit status
}
IData VL_TESTPLUSARGS_I(const char* formatp) VL_MT_SAFE {
const std::string& match = VerilatedImp::argPlusMatch(formatp);
if (match == "") return 0;
if (match.empty()) return 0;
else return 1;
}
@ -1538,7 +1537,7 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_M
const std::string& match = VerilatedImp::argPlusMatch(prefix.c_str());
const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
if (match == "") return 0;
if (match.empty()) return 0;
VL_ZERO_RESET_W(rbits, rwp);
switch (tolower(fmt)) {
@ -1594,7 +1593,7 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
}
const std::string& match = VerilatedImp::argPlusMatch(prefix.c_str());
const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
if (match == "") return 0;
if (match.empty()) return 0;
rdr = std::string(dp);
return 1;
}
@ -1602,7 +1601,7 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
const char* vl_mc_scan_plusargs(const char* prefixp) VL_MT_SAFE {
const std::string& match = VerilatedImp::argPlusMatch(prefixp);
static VL_THREAD_LOCAL char outstr[VL_VALUE_STRING_MAX_WIDTH];
if (match == "") return NULL;
if (match.empty()) return NULL;
strncpy(outstr, match.c_str()+strlen(prefixp)+1, // +1 to skip the "+"
VL_VALUE_STRING_MAX_WIDTH);
outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
@ -1646,10 +1645,10 @@ Verilated::ThreadLocal::ThreadLocal()
Verilated::ThreadLocal::~ThreadLocal() {
}
void Verilated::debug(int val) VL_MT_SAFE {
void Verilated::debug(int level) VL_MT_SAFE {
VerilatedLockGuard lock(m_mutex);
s_s.s_debug = val;
if (val) {
s_s.s_debug = level;
if (level) {
#ifdef VL_DEBUG
VL_DEBUG_IF(VL_DBG_MSGF("- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.\n"););
#else
@ -1743,7 +1742,7 @@ void Verilated::commandArgs(int argc, const char** argv) VL_MT_SAFE {
const char* Verilated::commandArgsPlusMatch(const char* prefixp) VL_MT_SAFE {
const std::string& match = VerilatedImp::argPlusMatch(prefixp);
static VL_THREAD_LOCAL char outstr[VL_VALUE_STRING_MAX_WIDTH];
if (match == "") return "";
if (match.empty()) return "";
strncpy(outstr, match.c_str(), VL_VALUE_STRING_MAX_WIDTH);
outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
return outstr;
@ -1917,7 +1916,8 @@ VerilatedModule::VerilatedModule(const char* namep)
VerilatedModule::~VerilatedModule() {
// Memory cleanup - not called during normal operation
if (m_namep) { free((void*)m_namep); m_namep=NULL; }
// NOLINTNEXTLINE(google-readability-casting)
if (m_namep) { free((void*)(m_namep)); m_namep=NULL; }
}
//======================================================================
@ -2017,7 +2017,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap,
if (!finalize) return;
if (!m_varsp) m_varsp = new VerilatedVarNameMap();
VerilatedVar var(namep, datap, vltype, (VerilatedVarFlags)vlflags, dims);
VerilatedVar var(namep, datap, vltype, static_cast<VerilatedVarFlags>(vlflags), dims);
va_list ap;
va_start(ap,dims);

155
include/verilated.h
View File

@ -583,29 +583,29 @@ extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP r
/// File I/O
extern IData VL_FGETS_IXI(int obits, void* destp, IData fpi);
extern IData VL_FOPEN_S(const char* filenamep, const char* mode);
extern IData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
extern IData VL_FOPEN_QI(QData ofilename, IData mode);
inline IData VL_FOPEN_II(IData ofilename, IData mode) VL_MT_SAFE {
return VL_FOPEN_QI(ofilename,mode); }
extern IData VL_FOPEN_S(const char* filenamep, const char* modep);
extern IData VL_FOPEN_WI(int fnwords, WDataInP filenamep, IData mode);
extern IData VL_FOPEN_QI(QData filename, IData mode);
inline IData VL_FOPEN_II(IData filename, IData mode) VL_MT_SAFE {
return VL_FOPEN_QI(filename,mode); }
extern void VL_FCLOSE_I(IData fdi);
extern void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
WDataInP ofilename, void* memp, IData start, IData end);
WDataInP filenamep, void* memp, IData start, IData end);
extern void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int fnwords,
QData ofilename, void* memp, IData start, IData end);
QData filename, void* memp, IData start, IData end);
inline void VL_READMEM_I(bool hex, int width, int depth, int array_lsb, int fnwords,
IData ofilename, void* memp, IData start, IData end) VL_MT_SAFE {
VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
IData filename, void* memp, IData start, IData end) VL_MT_SAFE {
VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, filename,memp,start,end); }
extern void VL_WRITEMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
WDataInP ofilename, const void* memp, IData start, IData end);
WDataInP filenamep, const void* memp, IData start, IData end);
extern void VL_WRITEMEM_Q(bool hex, int width, int depth, int array_lsb, int fnwords,
QData ofilename, const void* memp, IData start, IData end);
QData filename, const void* memp, IData start, IData end);
inline void VL_WRITEMEM_I(bool hex, int width, int depth, int array_lsb, int fnwords,
IData ofilename, const void* memp, IData start, IData end) VL_MT_SAFE {
VL_WRITEMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
IData filename, const void* memp, IData start, IData end) VL_MT_SAFE {
VL_WRITEMEM_Q(hex, width,depth,array_lsb,fnwords, filename,memp,start,end); }
extern void VL_WRITEF(const char* formatp, ...);
extern void VL_FWRITEF(IData fpi, const char* formatp, ...);
@ -621,7 +621,7 @@ extern void VL_SFORMAT_X(int obits, IData& destr, const char* formatp, ...);
extern void VL_SFORMAT_X(int obits, QData& destr, const char* formatp, ...);
extern void VL_SFORMAT_X(int obits, void* destp, const char* formatp, ...);
extern IData VL_SYSTEM_IW(int lhsnwords, WDataInP lhs);
extern IData VL_SYSTEM_IW(int lhswords, WDataInP lhsp);
extern IData VL_SYSTEM_IQ(QData lhs);
inline IData VL_SYSTEM_II(IData lhs) VL_MT_SAFE { return VL_SYSTEM_IQ(lhs); }
@ -632,24 +632,24 @@ extern const char* vl_mc_scan_plusargs(const char* prefixp); // PLIish
// Base macros
/// Return true if data[bit] set; not 0/1 return, but 0/non-zero return.
#define VL_BITISSET_I(data,bit) (data & (VL_UL(1)<<VL_BITBIT_I(bit)))
#define VL_BITISSET_Q(data,bit) (data & (VL_ULL(1)<<VL_BITBIT_Q(bit)))
#define VL_BITISSET_W(data,bit) (data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
#define VL_BITISSET_I(data,bit) ((data) & (VL_UL(1) << VL_BITBIT_I(bit)))
#define VL_BITISSET_Q(data,bit) ((data) & (VL_ULL(1) << VL_BITBIT_Q(bit)))
#define VL_BITISSET_W(data,bit) ((data)[VL_BITWORD_I(bit)] & (VL_UL(1) << VL_BITBIT_I(bit)))
#define VL_BITISSETLIMIT_W(data,width,bit) \
(((bit)<(width)) && data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
(((bit)<(width)) && (data)[VL_BITWORD_I(bit)] & (VL_UL(1) << VL_BITBIT_I(bit)))
/// Shift appropriate word by bit. Does not account for wrapping between two words
#define VL_BITRSHIFT_W(data,bit) (data[VL_BITWORD_I(bit)] >> VL_BITBIT_I(bit))
#define VL_BITRSHIFT_W(data,bit) ((data)[VL_BITWORD_I(bit)] >> VL_BITBIT_I(bit))
/// Create two 32-bit words from quadword
/// WData is always at least 2 words; does not clean upper bits
#define VL_SET_WQ(owp,data) { owp[0]=static_cast<IData>(data); \
owp[1]=static_cast<IData>((data)>>VL_WORDSIZE); }
#define VL_SET_WI(owp,data) { owp[0]=static_cast<IData>(data); owp[1]=0; }
#define VL_SET_WQ(owp,data) { (owp)[0] = static_cast<IData>(data); \
(owp)[1] = static_cast<IData>((data)>>VL_WORDSIZE); }
#define VL_SET_WI(owp,data) { (owp)[0] = static_cast<IData>(data); (owp)[1] = 0; }
#define VL_SET_QW(lwp) \
( (static_cast<QData>(lwp[0])) \
| (static_cast<QData>(lwp[1])<<(static_cast<QData>(VL_WORDSIZE)) ))
#define _VL_SET_QII(ld,rd) ( (static_cast<QData>(ld)<<VL_ULL(32)) | static_cast<QData>(rd) )
( (static_cast<QData>((lwp)[0])) \
| (static_cast<QData>((lwp)[1]) << (static_cast<QData>(VL_WORDSIZE)) ))
#define _VL_SET_QII(ld,rd) ((static_cast<QData>(ld)<<VL_ULL(32)) | static_cast<QData>(rd))
/// Return FILE* from IData
extern FILE* VL_CVT_I_FP(IData lhs);
@ -698,7 +698,7 @@ extern void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp);
// Pli macros
#ifndef VL_TIME_PRECISION
# define VL_TIME_PRECISION -12 ///< Timescale units only for for VPI return - picoseconds
# define VL_TIME_PRECISION (-12) ///< Timescale units only for for VPI return - picoseconds
#endif
#ifndef VL_TIME_MULTIPLIER
# define VL_TIME_MULTIPLIER 1
@ -828,31 +828,32 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAF
#define VL_ASSIGN_ISI(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read()); }
#define VL_ASSIGN_QSQ(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read()); }
#define VL_ASSIGN_ISW(obits,od,svar) { \
od = (svar.read().get_word(0)) & VL_MASK_I(obits); \
}
#define VL_ASSIGN_QSW(obits,od,svar) { \
od = ((static_cast<QData>(svar.read().get_word(1)))<<VL_WORDSIZE | svar.read().get_word(0)) \
& VL_MASK_Q(obits); \
}
#define VL_ASSIGN_WSW(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \
for (int i=0; i < words; ++i) owp[i] = svar.read().get_word(i); \
owp[words-1] &= VL_MASK_I(obits); \
}
#define VL_ASSIGN_ISW(obits,od,svar) { \
(od) = ((svar).read().get_word(0)) & VL_MASK_I(obits); \
}
#define VL_ASSIGN_QSW(obits,od,svar) { \
(od) = ((static_cast<QData>((svar).read().get_word(1)))<<VL_WORDSIZE \
| (svar).read().get_word(0)) \
& VL_MASK_Q(obits); \
}
#define VL_ASSIGN_WSW(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \
for (int i=0; i < words; ++i) (owp)[i] = (svar).read().get_word(i); \
(owp)[words-1] &= VL_MASK_I(obits); \
}
#define VL_ASSIGN_ISU(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read().to_uint()); }
#define VL_ASSIGN_QSU(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read().to_uint64()); }
#define VL_ASSIGN_WSB(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \
sc_biguint<obits> _butemp = (svar).read(); \
for (int i=0; i < words; ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= obits) ? (obits-1) : msb; \
owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint(); \
} \
owp[words-1] &= VL_MASK_I(obits); \
}
#define VL_ASSIGN_WSB(obits,owp,svar) { \
int words = VL_WORDS_I(obits); \
sc_biguint<(obits)> _butemp = (svar).read(); \
for (int i=0; i < words; ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= (obits)) ? ((obits)-1) : msb; \
(owp)[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint(); \
} \
(owp)[words-1] &= VL_MASK_I(obits); \
}
// Copying verilog format from systemc integers and bit vectors.
// Set a SystemC variable
@ -860,36 +861,36 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) VL_MT_SAF
#define VL_ASSIGN_SII(obits,svar,vvar) { (svar).write(vvar); }
#define VL_ASSIGN_SQQ(obits,svar,vvar) { (svar).write(vvar); }
#define VL_ASSIGN_SWI(obits,svar,rd) { \
sc_bv<obits> _bvtemp; \
_bvtemp.set_word(0,(rd)); \
svar.write(_bvtemp); \
}
#define VL_ASSIGN_SWQ(obits,svar,rd) { \
sc_bv<obits> _bvtemp; \
_bvtemp.set_word(0, static_cast<IData>(rd)); \
_bvtemp.set_word(1, static_cast<IData>((rd)>>VL_WORDSIZE)); \
svar.write(_bvtemp); \
}
#define VL_ASSIGN_SWW(obits,svar,rwp) { \
sc_bv<obits> _bvtemp; \
for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i,rwp[i]); \
svar.write(_bvtemp); \
}
#define VL_ASSIGN_SWI(obits,svar,rd) { \
sc_bv<(obits)> _bvtemp; \
_bvtemp.set_word(0, (rd)); \
(svar).write(_bvtemp); \
}
#define VL_ASSIGN_SWQ(obits,svar,rd) { \
sc_bv<(obits)> _bvtemp; \
_bvtemp.set_word(0, static_cast<IData>(rd)); \
_bvtemp.set_word(1, static_cast<IData>((rd)>>VL_WORDSIZE)); \
(svar).write(_bvtemp); \
}
#define VL_ASSIGN_SWW(obits,svar,rwp) { \
sc_bv<(obits)> _bvtemp; \
for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i, (rwp)[i]); \
(svar).write(_bvtemp); \
}
#define VL_ASSIGN_SUI(obits,svar,rd) { (svar).write(rd); }
#define VL_ASSIGN_SUQ(obits,svar,rd) { (svar).write(rd); }
#define VL_ASSIGN_SBI(obits,svar,rd) { (svar).write(rd); }
#define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); }
#define VL_ASSIGN_SBW(obits,svar,rwp) { \
sc_biguint<obits> _butemp; \
for (int i=0; i < VL_WORDS_I(obits); ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= obits) ? (obits-1) : msb; \
_butemp.range(msb,i*VL_WORDSIZE) = rwp[i]; \
} \
svar.write(_butemp); \
}
#define VL_ASSIGN_SBW(obits,svar,rwp) { \
sc_biguint<(obits)> _butemp; \
for (int i=0; i < VL_WORDS_I(obits); ++i) { \
int msb = ((i+1)*VL_WORDSIZE) - 1; \
msb = (msb >= (obits)) ? ((obits)-1) : msb; \
_butemp.range(msb, i*VL_WORDSIZE) = (rwp)[i]; \
} \
(svar).write(_butemp); \
}
//===================================================================
// Extending sizes
@ -957,8 +958,8 @@ static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WData
// REDUCTION OPERATORS
// EMIT_RULE: VL_REDAND: oclean=clean; lclean==clean; obits=1;
#define VL_REDAND_II(obits,lbits,lhs) (lhs == VL_MASK_I(lbits))
#define VL_REDAND_IQ(obits,lbits,lhs) (lhs == VL_MASK_Q(lbits))
#define VL_REDAND_II(obits,lbits,lhs) ((lhs) == VL_MASK_I(lbits))
#define VL_REDAND_IQ(obits,lbits,lhs) ((lhs) == VL_MASK_Q(lbits))
static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) VL_MT_SAFE {
int words = VL_WORDS_I(lbits);
IData combine=lwp[0];
@ -968,8 +969,8 @@ static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) VL_MT_SAFE {
}
// EMIT_RULE: VL_REDOR: oclean=clean; lclean==clean; obits=1;
#define VL_REDOR_I(lhs) (lhs!=0)
#define VL_REDOR_Q(lhs) (lhs!=0)
#define VL_REDOR_I(lhs) ((lhs)!=0)
#define VL_REDOR_Q(lhs) ((lhs)!=0)
static inline IData VL_REDOR_W(int words, WDataInP lwp) VL_MT_SAFE {
IData equal=0;
for (int i=0; i < words; ++i) equal |= lwp[i];

24
include/verilated_cov.cpp
View File

@ -77,7 +77,7 @@ public:
virtual void zero() const { *m_countp = 0; }
// CONSTRUCTORS
// cppcheck-suppress noExplicitConstructor
VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
virtual ~VerilatedCoverItemSpec() {}
};
@ -167,8 +167,8 @@ private:
// (foo.a.x, foo.b.y) => foo.*
// (foo.a.x, foo.b) => foo.*
if (old == add) return add;
if (old == "") return add;
if (add == "") return old;
if (old.empty()) return add;
if (add.empty()) return old;
const char* a = old.c_str();
const char* b = add.c_str();
@ -296,7 +296,7 @@ public:
}
// Ignore empty keys
for (int i=0; i<MAX_KEYS; ++i) {
if (keys[i]!="") {
if (!keys[i].empty()) {
for (int j=i+1; j<MAX_KEYS; ++j) {
if (keys[i] == keys[j]) { // Duplicate key. Keep the last one
keys[i] = "";
@ -309,7 +309,7 @@ public:
int addKeynum=0;
for (int i=0; i<MAX_KEYS; ++i) {
const std::string key = keys[i];
if (keys[i]!="") {
if (!keys[i].empty()) {
const std::string val = valps[i];
//cout<<" "<<__FUNCTION__<<" "<<key<<" = "<<val<<endl;
m_insertp->m_keys[addKeynum] = valueIndex(key);
@ -391,7 +391,7 @@ public:
for (EventMap::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
os<<"C '"<<std::dec;
os<<it->first;
if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
if (!it->second.first.empty()) os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
os<<"' "<<it->second.second;
os<<std::endl;
}
@ -424,9 +424,9 @@ void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
}
#define K(n) const char* key ## n
#define A(n) const char* key ## n, const char* val ## n // Argument list
#define C(n) key ## n, val ## n // Calling argument list
#define N(n) "","" // Null argument list
#define A(n) const char* key ## n, const char* valp ## n // Argument list
#define C(n) key ## n, valp ## n // Calling argument list
#define N(n) "","" // Null argument list
void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
@ -437,9 +437,9 @@ void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
key20,key21,key22,key23,key24,key25,key26,key27,key28,key29};
const char* valps[VerilatedCovImpBase::MAX_KEYS]
= {NULL,NULL,NULL, // filename,lineno,page
val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,
val10,val11,val12,val13,val14,val15,val16,val17,val18,val19,
val20,val21,val22,val23,val24,val25,val26,val27,val28,val29};
valp0,valp1,valp2,valp3,valp4,valp5,valp6,valp7,valp8,valp9,
valp10,valp11,valp12,valp13,valp14,valp15,valp16,valp17,valp18,valp19,
valp20,valp21,valp22,valp23,valp24,valp25,valp26,valp27,valp28,valp29};
VerilatedCovImp::imp().insertp(keyps, valps);
}

9
include/verilated_dpi.cpp
View File

@ -721,14 +721,16 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int
svScope svGetScope() {
if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return NULL; }
return (svScope)Verilated::dpiScope();
// NOLINTNEXTLINE(google-readability-casting)
return (svScope)(Verilated::dpiScope());
}
svScope svSetScope(const svScope scope) {
const VerilatedScope* prevScopep = Verilated::dpiScope();
const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
Verilated::dpiScope(vscopep);
return (svScope)prevScopep;
// NOLINTNEXTLINE(google-readability-casting)
return (svScope)(prevScopep);
}
const char* svGetNameFromScope(const svScope scope) {
@ -737,7 +739,8 @@ const char* svGetNameFromScope(const svScope scope) {
}
svScope svGetScopeFromName(const char* scopeName) {
return (svScope)VerilatedImp::scopeFind(scopeName);
// NOLINTNEXTLINE(google-readability-casting)
return (svScope)(VerilatedImp::scopeFind(scopeName));
}
int svPutUserData(const svScope scope, void* userKey, void* userData) {

2
include/verilated_fst_c.cpp
View File

@ -107,7 +107,7 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name,
int dtypenum, fstVarDir vardir, fstVarType vartype,
int arraynum, vluint32_t len) {
std::pair<Code2SymbolType::iterator, bool> p
= m_code2symbol.insert(std::make_pair(code, (fstHandle)(0)));
= m_code2symbol.insert(std::make_pair(code, static_cast<fstHandle>(NULL)));
std::istringstream nameiss(name);
std::istream_iterator<std::string> beg(nameiss), end;
std::list<std::string> tokens(beg, end); // Split name

8
include/verilated_fst_c.h
View File

@ -77,10 +77,10 @@ public:
fstWriterClose(m_fst);
m_fst = NULL;
}
// void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
// void set_time_unit(const char* unitp); ///< Set time units (s/ms, defaults to ns)
// void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
// void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
// void set_time_resolution(const char* unitp); ///< Set time resolution (s/ms, defaults to ns)
// void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
// double timescaleToDouble(const char* unitp);
@ -93,8 +93,8 @@ public:
/// Inside dumping routines, called each cycle to make the dump
void dump(vluint64_t timeui);
/// Inside dumping routines, declare callbacks for tracings
void addCallback(VerilatedFstCallback_t init, VerilatedFstCallback_t full,
VerilatedFstCallback_t change,
void addCallback(VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
VerilatedFstCallback_t changecb,
void* userthis) VL_MT_UNSAFE_ONE;
/// Inside dumping routines, declare a module

6
include/verilated_heavy.h
View File

@ -65,15 +65,15 @@ inline IData VL_LEN_IN(const std::string& ld) { return ld.length(); }
extern IData VL_FOPEN_NI(const std::string& filename, IData mode) VL_MT_SAFE;
extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb,
const std::string& ofilename,
const std::string& filename,
void* memp, IData start, IData end) VL_MT_SAFE;
extern void VL_WRITEMEM_N(bool hex, int width, int depth, int array_lsb,
const std::string& ofilename,
const std::string& filename,
const void* memp, IData start, IData end) VL_MT_SAFE;
extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp, ...) VL_MT_SAFE;
extern void VL_SFORMAT_X(int obits_ignored, std::string& output, const char* formatp, ...) VL_MT_SAFE;
extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rdp) VL_MT_SAFE;
extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE;
inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
WData rwp[2]; // WData must always be at least 2
IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);

8
include/verilated_lxt2_c.h
View File

@ -70,10 +70,10 @@ public:
lxt2_wr_close(m_lxt2);
m_lxt2 = NULL;
}
// void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
// void set_time_unit(const char* unitp); ///< Set time units (s/ms, defaults to ns)
// void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
// void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
// void set_time_resolution(const char* unitp); ///< Set time resolution (s/ms, defaults to ns)
// void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
// double timescaleToDouble(const char* unitp);
@ -86,8 +86,8 @@ public:
/// Inside dumping routines, called each cycle to make the dump
void dump(vluint64_t timeui);
/// Inside dumping routines, declare callbacks for tracings
void addCallback(VerilatedLxt2Callback_t init, VerilatedLxt2Callback_t full,
VerilatedLxt2Callback_t change,
void addCallback(VerilatedLxt2Callback_t initcb, VerilatedLxt2Callback_t fullcb,
VerilatedLxt2Callback_t changecb,
void* userthis) VL_MT_UNSAFE_ONE;
/// Inside dumping routines, declare a module

9
include/verilated_save.cpp
View File

@ -38,6 +38,9 @@
#ifndef O_NONBLOCK
# define O_NONBLOCK 0
#endif
#ifndef O_CLOEXEC
# define O_CLOEXEC 0
#endif
// CONSTANTS
static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n"; ///< Value of first bytes of each file
@ -50,7 +53,7 @@ static const char* const VLTSAVE_TRAILER_STR = "vltsaved"; ///< Value of last by
bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
bufferCheck();
const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
const vluint8_t* __restrict dp = static_cast<const vluint8_t* __restrict>(datap);
vluint8_t miss = 0;
while (size--) {
miss |= (*dp++ ^ *m_cp++);
@ -119,7 +122,7 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
assert(0); // Not supported yet.
} else {
// cppcheck-suppress duplicateExpression
m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC
, 0666);
if (m_fd<0) {
// User code can check isOpen()
@ -142,7 +145,7 @@ void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
assert(0); // Not supported yet.
} else {
// cppcheck-suppress duplicateExpression
m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE|O_CLOEXEC
, 0666);
if (m_fd<0) {
// User code can check isOpen()

13
include/verilated_vcd_c.cpp
View File

@ -44,6 +44,9 @@
#ifndef O_NONBLOCK
# define O_NONBLOCK 0
#endif
#ifndef O_CLOEXEC
# define O_CLOEXEC 0
#endif
//=============================================================================
// VerilatedVcdImp
@ -109,7 +112,7 @@ protected:
// VerilatedVcdFile
bool VerilatedVcdFile::open(const std::string& name) VL_MT_UNSAFE {
m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK|O_CLOEXEC, 0666);
return (m_fd>=0);
}
@ -237,7 +240,7 @@ void VerilatedVcd::makeNameMap() {
bool nullScope = false;
for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
const std::string& hiername = it->first;
if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
if (!hiername.empty() && hiername[0] == '\t') nullScope=true;
}
if (nullScope) {
NameMap* newmapp = new NameMap;
@ -546,13 +549,15 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
// Tab sorts before spaces, so signals nicely will print before scopes
// Note the hiername may be nothing, if so we'll add "\t{name}"
std::string nameasstr = name;
if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; } // Optional ->module prefix
if (!m_modName.empty()) {
nameasstr = m_modName+m_scopeEscape+nameasstr; // Optional ->module prefix
}
std::string hiername;
std::string basename;
for (const char* cp=nameasstr.c_str(); *cp; cp++) {
if (isScopeEscape(*cp)) {
// Ahh, we've just read a scope, not a basename
if (hiername!="") hiername += " ";
if (!hiername.empty()) hiername += " ";
hiername += basename;
basename = "";
} else {

10
include/verilated_vcd_c.h
View File

@ -121,7 +121,7 @@ private:
void openNext();
void makeNameMap();
void deleteNameMap();
void printIndent(int levelchange);
void printIndent(int level_change);
void printStr(const char* str);
void printQuad(vluint64_t n);
void printTime(vluint64_t timeui);
@ -172,10 +172,10 @@ public:
/// Flush any remaining data from all files
static void flush_all() VL_MT_UNSAFE_ONE;
void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
void set_time_unit(const char* unitp); ///< Set time units (s/ms, defaults to ns)
void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
void set_time_resolution(const char* unitp); ///< Set time resolution (s/ms, defaults to ns)
void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
double timescaleToDouble(const char* unitp);
@ -187,8 +187,8 @@ public:
void dumpSeconds(double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }
/// Inside dumping routines, declare callbacks for tracings
void addCallback(VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
VerilatedVcdCallback_t change,
void addCallback(VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb,
VerilatedVcdCallback_t changecb,
void* userthis) VL_MT_UNSAFE_ONE;
/// Inside dumping routines, declare a module

32
include/verilated_vpi.cpp
View File

@ -79,11 +79,10 @@ public:
vluint8_t* newp = t_freeHead;
t_freeHead = *((vluint8_t**)newp);
return newp+8;
} else {
// +8: 8 bytes for next
vluint8_t* newp = reinterpret_cast<vluint8_t*>(::operator new(chunk+8));
return newp+8;
}
// +8: 8 bytes for next
vluint8_t* newp = reinterpret_cast<vluint8_t*>(::operator new(chunk+8));
return newp+8;
}
inline static void operator delete(void* obj, size_t size) VL_MT_SAFE {
vluint8_t* oldp = ((vluint8_t*)obj)-8;
@ -156,9 +155,8 @@ public:
VerilatedVpioRange* nextp = new VerilatedVpioRange(*this);
nextp->iterationInc();
return ((nextp)->castVpiHandle());
} else {
return 0; // End of list - only one deep
}
return 0; // End of list - only one deep
}
};
@ -275,9 +273,8 @@ public:
if (m_it == varsp->end()) return 0;
return ((new VerilatedVpioVar(&(m_it->second), m_scopep))
->castVpiHandle());
} else {
return 0; // End of list - only one deep
}
return 0; // End of list - only one deep
}
};
@ -388,9 +385,8 @@ public:
VpioTimedCbs::const_iterator it=s_s.m_timedCbs.begin();
if (VL_LIKELY(it!=s_s.m_timedCbs.end())) {
return it->first;
} else {
return ~VL_ULL(0); // maxquad
}
return ~VL_ULL(0); // maxquad
}
static void callCbs(vluint32_t reason) {
VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
@ -1037,17 +1033,15 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
indx - varop->varp()->unpacked().right()))
->castVpiHandle();
} else {
if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
|| indx > varop->varp()->unpacked().right())) return 0;
return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
indx - varop->varp()->unpacked().left()))
->castVpiHandle();
}
} else {
_VL_VPI_INTERNAL(__FILE__, __LINE__, "%s : can't resolve handle", VL_FUNC);
return 0;
if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
|| indx > varop->varp()->unpacked().right())) return 0;
return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
indx - varop->varp()->unpacked().left()))
->castVpiHandle();
}
_VL_VPI_INTERNAL(__FILE__, __LINE__, "%s : can't resolve handle", VL_FUNC);
return 0;
}
// for traversing relationships

2
include/verilatedos.h
View File

@ -40,7 +40,7 @@
# ifdef _WIN32
# define VL_ATTR_PRINTF(fmtArgNum) // GCC with MS runtime will fool the print arg checker
# else
# define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
# define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, (fmtArgNum), (fmtArgNum)+1)))
# endif
# define VL_ATTR_PURE __attribute__ ((pure))
# define VL_ATTR_UNUSED __attribute__ ((unused))

7
src/V3Assert.cpp
View File

@ -75,13 +75,14 @@ private:
AstNode* newIfAssertOn(AstNode* nodep) {
// Add a internal if to check assertions are on.
// Don't make this a AND term, as it's unlikely to need to test this.
FileLine* fl = nodep->fileline();
AstNode* newp
= new AstIf(nodep->fileline(),
= new AstIf(fl,
// If assertions are off, have constant propagation rip them out later
// This allows syntax errors and such to be detected normally.
(v3Global.opt.assertOn()
? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
: (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
? static_cast<AstNode*>(new AstCMath(fl, "Verilated::assertOn()", 1))
: static_cast<AstNode*>(new AstConst(fl, AstConst::LogicFalse()))),
nodep, NULL);
newp->user1(true); // Don't assert/cover this if
return newp;

22
src/V3Ast.cpp
View File

@ -419,8 +419,8 @@ void AstNode::replaceWith(AstNode* newp) {
}
void AstNRelinker::dump(std::ostream& str) const {
str<<" BK="<<(uint32_t*)m_backp;
str<<" ITER="<<(uint32_t*)m_iterpp;
str<<" BK="<<reinterpret_cast<uint32_t*>(m_backp);
str<<" ITER="<<reinterpret_cast<uint32_t*>(m_iterpp);
str<<" CHG="<<(m_chg==RELINK_NEXT?"[NEXT] ":"");
str<<(m_chg==RELINK_OP1?"[OP1] ":"");
str<<(m_chg==RELINK_OP2?"[OP2] ":"");
@ -670,13 +670,13 @@ void AstNode::deleteNode() {
UASSERT(!m_backp, "Delete called on node with backlink still set");
editCountInc();
// Change links of old node so we coredump if used
this->m_nextp = (AstNode*)1;
this->m_backp = (AstNode*)1;
this->m_headtailp = (AstNode*)1;
this->m_op1p = (AstNode*)1;
this->m_op2p = (AstNode*)1;
this->m_op3p = (AstNode*)1;
this->m_op4p = (AstNode*)1;
this->m_nextp = reinterpret_cast<AstNode*>(0x1);
this->m_backp = reinterpret_cast<AstNode*>(0x1);
this->m_headtailp = reinterpret_cast<AstNode*>(0x1);
this->m_op1p = reinterpret_cast<AstNode*>(0x1);
this->m_op2p = reinterpret_cast<AstNode*>(0x1);
this->m_op3p = reinterpret_cast<AstNode*>(0x1);
this->m_op4p = reinterpret_cast<AstNode*>(0x1);
if (
#if !defined(VL_DEBUG) || defined(VL_LEAK_CHECKS)
1
@ -1077,7 +1077,9 @@ void AstNode::v3errorEnd(std::ostringstream& str) const {
nsstr<<str.str();
if (debug()) {
nsstr<<endl;
nsstr<<"-node: "; ((AstNode*)this)->dump(nsstr); nsstr<<endl;
nsstr<<"-node: ";
const_cast<AstNode*>(this)->dump(nsstr);
nsstr<<endl;
}
m_fileline->v3errorEnd(nsstr);
}

22
src/V3Ast.h
View File

@ -1027,7 +1027,7 @@ std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);
// Prefetch a node.
// The if() makes it faster, even though prefetch won't fault on null pointers
#define ASTNODE_PREFETCH(nodep) \
{ if (nodep) { VL_PREFETCH_RD(&(nodep->m_nextp)); VL_PREFETCH_RD(&(nodep->m_iterpp)); }}
{ if (nodep) { VL_PREFETCH_RD(&((nodep)->m_nextp)); VL_PREFETCH_RD(&((nodep)->m_iterpp)); }}
class AstNode {
// v ASTNODE_PREFETCH depends on below ordering of members
@ -1171,8 +1171,8 @@ public:
static string dedotName(const string& namein); // Name with dots removed
static string prettyName(const string& namein); // Name for printing out to the user
static string encodeName(const string& namein); // Encode user name into internal C representation
static string encodeNumber(vlsint64_t numin); // Encode number into internal C representation
static string vcdName(const string& namein); // Name for printing out to vcd files
static string encodeNumber(vlsint64_t num); // Encode number into internal C representation
static string vcdName(const string& namein); // Name for printing out to vcd files
string prettyName() const { return prettyName(name()); }
string prettyTypeName() const; // "VARREF" for error messages
virtual string prettyOperatorName() const { return "operator "+prettyTypeName(); }
@ -1347,13 +1347,13 @@ public:
void checkTree(); // User Interface version
void checkIter() const;
void clearIter() { m_iterpp=NULL; }
void dumpPtrs(std::ostream& str=std::cout) const;
void dumpTree(std::ostream& str=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
void dumpTreeGdb(); // For GDB only
void dumpTreeAndNext(std::ostream& str=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
static void dumpTreeFileGdb(const char* filenamep=NULL);
void dumpPtrs(std::ostream& os=std::cout) const;
void dumpTree(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
void dumpTreeGdb(); // For GDB only
void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
static void dumpTreeFileGdb(const char* filenamep=NULL);
// METHODS - queries
virtual bool isPure() const { return true; } // Else a $display, etc, that must be ordered with other displays
@ -1798,7 +1798,7 @@ public:
bool widthSized() const { return !m_widthMin || m_widthMin==m_width; }
bool generic() const { return m_generic; }
void generic(bool flag) { m_generic = flag; }
AstNodeDType* dtypeDimensionp(int depth);
AstNodeDType* dtypeDimensionp(int dimension);
std::pair<uint32_t,uint32_t> dimensions(bool includeBasic);
uint32_t arrayUnpackedElements(); // 1, or total multiplication of all dimensions
static int uniqueNumInc() { return ++s_uniqueNum; }

10
src/V3AstNodes.cpp
View File

@ -577,7 +577,9 @@ const char* AstScope::broken() const {
void AstScope::cloneRelink() {
if (m_aboveScopep && m_aboveScopep->clonep()) m_aboveScopep->clonep();
if (m_aboveCellp && m_aboveCellp->clonep()) m_aboveCellp->clonep();
if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep();
if (m_modp && static_cast<AstNode*>(m_modp)->clonep()) {
static_cast<AstNode*>(m_modp)->clonep();
}
}
string AstScope::nameDotless() const {
@ -651,7 +653,7 @@ bool AstSenTree::hasCombo() const {
void AstTypeTable::clearCache() {
// When we mass-change widthMin in V3WidthCommit, we need to correct the table.
// Just clear out the maps; the search functions will be used to rebuild the map
for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
m_basicps[i] = NULL;
}
for (int isbit=0; isbit<_IDX0_MAX; ++isbit) {
@ -701,7 +703,7 @@ AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kw
else if (kwd == AstBasicDTypeKwd::BIT) idx = IDX0_BIT;
else fl->v3fatalSrc("Bad kwd for findLogicBitDType");
std::pair<int,int> widths = make_pair(width,widthMin);
LogicMap& mapr = m_logicMap[idx][(int)numeric];
LogicMap& mapr = m_logicMap[idx][static_cast<int>(numeric)];
LogicMap::const_iterator it = mapr.find(widths);
if (it != mapr.end()) return it->second;
//
@ -991,7 +993,7 @@ void AstMTaskBody::dump(std::ostream& str) {
}
void AstTypeTable::dump(std::ostream& str) {
this->AstNode::dump(str);
for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
if (AstBasicDType* subnodep=m_basicps[i]) {
str<<endl; // Newline from caller, so newline first
str<<"\t\t"<<std::setw(8)<<AstBasicDTypeKwd(i).ascii();

4
src/V3AstNodes.h
View File

@ -3501,8 +3501,8 @@ class AstScopeName : public AstNodeMath {
// Children: TEXT
private:
bool m_dpiExport; // Is for dpiExport
string scopeNameFormatter(AstText* textp) const;
string scopePrettyNameFormatter(AstText* textp) const;
string scopeNameFormatter(AstText* scopeTextp) const;
string scopePrettyNameFormatter(AstText* scopeTextp) const;
public:
explicit AstScopeName(FileLine* fl) : AstNodeMath(fl), m_dpiExport(false) {
dtypeSetUInt64(); }

4
src/V3Branch.cpp
View File

@ -134,7 +134,7 @@ public:
//######################################################################
// Branch class functions
void V3Branch::branchAll(AstNetlist* rootp) {
void V3Branch::branchAll(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
BranchVisitor visitor (rootp);
BranchVisitor visitor (nodep);
}

2
src/V3Branch.h
View File

@ -32,7 +32,7 @@
class V3Branch {
public:
// CONSTRUCTORS
static void branchAll(AstNetlist* rootp);
static void branchAll(AstNetlist* nodep);
};
#endif // Guard

7
src/V3Broken.cpp
View File

@ -61,7 +61,8 @@ public:
if (debug()>=9) cout<<"-nodeDel: "<<cvtToHex(nodep)<<endl;
NodeMap::iterator iter = s_nodes.find(nodep);
if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
reinterpret_cast<const AstNode*>(nodep)
->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
}
if (iter!=s_nodes.end()) s_nodes.erase(iter);
}
@ -155,7 +156,9 @@ public:
// may be varp() and other cross links that are bad.
if (v3Global.opt.debugCheck()) {
std::cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
((AstNode*)(it->first))->AstNode::dump(std::cerr);
AstNode* rawp = const_cast<AstNode*>
(static_cast<const AstNode*>(it->first));
rawp->AstNode::dump(std::cerr);
std::cerr<<endl;
V3Error::incErrors();
}

18
src/V3Cdc.cpp
View File

@ -193,7 +193,7 @@ public:
width += 1; // The :
width += cvtToStr(m_maxLineno).length();
width += 1; // Final :
return (int)width;
return static_cast<int>(width);
}
};
@ -248,7 +248,7 @@ private:
}
CdcVarVertex* makeVarVertex(AstVarScope* varscp) {
CdcVarVertex* vertexp = (CdcVarVertex*)(varscp->user1p());
CdcVarVertex* vertexp = reinterpret_cast<CdcVarVertex*>(varscp->user1p());
if (!vertexp) {
UINFO(6,"New vertex "<<varscp<<endl);
vertexp = new CdcVarVertex(&m_graph, m_scopep, varscp);
@ -376,7 +376,7 @@ private:
if (vvertexp->varScp()->varp()->isPrimaryIn()) {
// Show the source "input" statement if it exists
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
eFromVertexp->asyncPath(true);
}
return NULL;
@ -384,7 +384,7 @@ private:
// Also ok if from flop, but partially trace the flop so more obvious to users
if (vvertexp->fromFlop()) {
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
eFromVertexp->asyncPath(true);
}
return NULL;
@ -392,7 +392,7 @@ private:
}
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
CdcEitherVertex* submarkp = traceAsyncRecurse(eFromVertexp, mark);
if (submarkp && !mark_outp) mark_outp = submarkp;
}
@ -407,7 +407,7 @@ private:
*m_ofp<<"\n";
CdcEitherVertex* targetp = vertexp; // One example destination flop (of possibly many)
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
CdcEitherVertex* eToVertexp = static_cast<CdcEitherVertex*>(edgep->top());
if (!eToVertexp) targetp = eToVertexp;
if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(eToVertexp)) {
if (vvertexp->isFlop() // IE the target flop that is upsetting us
@ -434,7 +434,7 @@ private:
string cont = prefix+sep;
string nextsep = " ";
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
if (dumpAsyncRecurse(eFromVertexp, cont, nextsep, level+1)) {
nextsep = " | ";
}
@ -553,13 +553,13 @@ private:
// Now combine domains of sources/dests
if (traceDests) {
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
CdcEitherVertex* eToVertexp = static_cast<CdcEitherVertex*>(edgep->top());
edgeDomainRecurse(eToVertexp, traceDests, level+1);
if (eToVertexp->dstDomainp()) senouts.insert(eToVertexp->dstDomainp());
}
} else {
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
CdcEitherVertex* eFromVertexp = static_cast<CdcEitherVertex*>(edgep->fromp());
edgeDomainRecurse(eFromVertexp, traceDests, level+1);
if (eFromVertexp->srcDomainp()) senouts.insert(eFromVertexp->srcDomainp());
}

2
src/V3Clean.cpp
View File

@ -98,7 +98,7 @@ private:
nodep->user1(clean);
}
CleanState getCleanState(AstNode* nodep) {
return ((CleanState)nodep->user1());
return static_cast<CleanState>(nodep->user1());
}
bool isClean(AstNode* nodep) {
CleanState clstate = getCleanState(nodep);

8
src/V3ClkGater.cpp
View File

@ -376,7 +376,7 @@ class GaterVisitor : public GaterBaseVisitor {
m_pliVertexp = new GaterPliVertex(&m_graph);
}
if (m_stmtVscp) { // Already saw a variable, be sure to mark it!
GaterVarVertex* varVtxp = (GaterVarVertex*)(m_stmtVscp->user1p());
GaterVarVertex* varVtxp = reinterpret_cast<GaterVarVertex*>(m_stmtVscp->user1p());
new GaterEdge(&m_graph, m_pliVertexp, varVtxp, VU_PLI);
}
m_stmtInPli = true; // Mark all followon variables too
@ -689,9 +689,9 @@ class GaterVisitor : public GaterBaseVisitor {
nodep->addNextHere(alwp);
// Blow moved statements from old body
GaterBodyVisitor(nodep,exprp,true);
{ GaterBodyVisitor vis(nodep,exprp,true); }
// Blow old statements from new body
GaterBodyVisitor(alwp,exprp,false);
{ GaterBodyVisitor vis(alwp,exprp,false); }
++m_statGaters;
if (debug()>=9) alwp->dumpTree(cout," new: ");
@ -764,7 +764,7 @@ class GaterVisitor : public GaterBaseVisitor {
}
m_stmtVscp = vscp;
// Find, or make new Vertex
GaterVarVertex* vertexp = (GaterVarVertex*)(vscp->user1p());
GaterVarVertex* vertexp = reinterpret_cast<GaterVarVertex*>(vscp->user1p());
if (!vertexp) {
vertexp = new GaterVarVertex(&m_graph, vscp);
vscp->user1p(vertexp);

2
src/V3Clock.cpp
View File

@ -71,7 +71,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
AstVarScope* getCreateLastClk(AstVarScope* vscp) {
if (vscp->user1p()) return ((AstVarScope*)vscp->user1p());
if (vscp->user1p()) return static_cast<AstVarScope*>(vscp->user1p());
AstVar* varp = vscp->varp();
if (!varp->width1()) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
string newvarname = (string("__Vclklast__")+vscp->scopep()->nameDotless()+"__"+varp->name());

2
src/V3Combine.cpp
View File

@ -69,7 +69,7 @@ protected:
// Also repair it for DPI functions; when make __common need to insure proper
// flags get inherited from the old to new AstCFunc, and that AstText doesn't
// get split between functions causing the text to have a danginling reference.
bool statementCombine() { return false && duplicateFunctionCombine(); }
bool statementCombine() { return false; } // duplicateFunctionCombine();
};
//######################################################################

22
src/V3Const.cpp
View File

@ -242,13 +242,15 @@ private:
bool operandHugeShiftL(const AstNodeBiop* nodep) {
return (VN_IS(nodep->rhsp(), Const)
&& !VN_CAST_CONST(nodep->rhsp(), Const)->num().isFourState()
&& VN_CAST_CONST(nodep->rhsp(), Const)->toUInt() >= (uint32_t)(nodep->width())
&& (VN_CAST_CONST(nodep->rhsp(), Const)->toUInt()
>= static_cast<uint32_t>(nodep->width()))
&& isTPure(nodep->lhsp()));
}
bool operandHugeShiftR(const AstNodeBiop* nodep) {
return (VN_IS(nodep->rhsp(), Const)
&& !VN_CAST_CONST(nodep->rhsp(), Const)->num().isFourState()
&& VN_CAST_CONST(nodep->rhsp(), Const)->toUInt() >= (uint32_t)(nodep->lhsp()->width())
&& (VN_CAST_CONST(nodep->rhsp(), Const)->toUInt()
>= static_cast<uint32_t>(nodep->lhsp()->width()))
&& isTPure(nodep->lhsp()));
}
bool operandIsTwo(const AstNode* nodep) {
@ -294,14 +296,14 @@ private:
return (VN_IS(nodep->rhsp(), Const)
&& VN_IS(nodep->fromp(), NodeVarRef)
&& !VN_CAST_CONST(nodep->fromp(), NodeVarRef)->lvalue()
&& ((int)(VN_CAST_CONST(nodep->rhsp(), Const)->toUInt())
&& (static_cast<int>(VN_CAST_CONST(nodep->rhsp(), Const)->toUInt())
>= VN_CAST(nodep->fromp(), NodeVarRef)->varp()->widthWords()));
}
bool operandSelFull(const AstSel* nodep) {
return (VN_IS(nodep->lsbp(), Const)
&& VN_IS(nodep->widthp(), Const)
&& nodep->lsbConst()==0
&& (int)nodep->widthConst()==nodep->fromp()->width());
&& static_cast<int>(nodep->widthConst()) == nodep->fromp()->width());
}
bool operandSelExtend(AstSel* nodep) {
// A pattern created by []'s after offsets have been removed
@ -313,7 +315,7 @@ private:
&& VN_IS(nodep->lsbp(), Const)
&& VN_IS(nodep->widthp(), Const)
&& nodep->lsbConst()==0
&& (int)nodep->widthConst()==extendp->lhsp()->width()
&& static_cast<int>(nodep->widthConst()) == extendp->lhsp()->width()
)) return false;
replaceWChild(nodep, extendp->lhsp()); VL_DANGLING(nodep);
return true;
@ -512,8 +514,7 @@ private:
const AstConst* rwidth = VN_CAST_CONST(rhsp->widthp(), Const);
if (!lstart || !rstart || !lwidth || !rwidth) return false; // too complicated
int rend = (rstart->toSInt() + rwidth->toSInt());
if (rend == lstart->toSInt()) return true;
return false;
return (rend == lstart->toSInt());
}
bool ifMergeAdjacent(AstNode* lhsp, AstNode* rhsp) {
// called by concatmergeable to determine if {lhsp, rhsp} make sense
@ -1184,7 +1185,8 @@ private:
if (!VN_IS(VN_CAST_CONST(nodep, And)->rhsp(), ShiftR)) return false;
const AstShiftR* shiftp = VN_CAST(VN_CAST_CONST(nodep, And)->rhsp(), ShiftR);
if (!VN_IS(shiftp->rhsp(), Const)) return false;
if ((uint32_t)(nodep->width()) <= VN_CAST_CONST(shiftp->rhsp(), Const)->toUInt()) return false;
if (static_cast<uint32_t>(nodep->width())
<= VN_CAST_CONST(shiftp->rhsp(), Const)->toUInt()) return false;
return true;
}
void replaceBoolShift(AstNode* nodep) {
@ -1366,7 +1368,7 @@ private:
AstConcat* conp = VN_CAST(nodep->fromp(), Concat);
AstNode* conLhsp = conp->lhsp();
AstNode* conRhsp = conp->rhsp();
if ((int)nodep->lsbConst() >= conRhsp->width()) {
if (static_cast<int>(nodep->lsbConst()) >= conRhsp->width()) {
conLhsp->unlinkFrBack();
AstSel* newp = new AstSel(nodep->fileline(),
conLhsp,
@ -1374,7 +1376,7 @@ private:
nodep->widthConst());
nodep->replaceWith(newp);
}
else if ((int)nodep->msbConst() < conRhsp->width()) {
else if (static_cast<int>(nodep->msbConst()) < conRhsp->width()) {
conRhsp->unlinkFrBack();
AstSel* newp = new AstSel(nodep->fileline(),
conRhsp,

12
src/V3Coverage.cpp
View File

@ -180,9 +180,7 @@ private:
}
}
void toggleVarBottom(AstNodeDType* dtypep, int depth, // per-iteration
const ToggleEnt& above,
AstVar* varp, AstVar* chgVarp) { // Constant
void toggleVarBottom(const ToggleEnt& above, const AstVar* varp) {
AstCoverToggle* newp
= new AstCoverToggle(varp->fileline(),
newCoverInc(varp->fileline(), "", "v_toggle",
@ -202,15 +200,11 @@ private:
ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
new AstSel(varp->fileline(), above.m_varRefp->cloneTree(true), index_code, 1),
new AstSel(varp->fileline(), above.m_chgRefp->cloneTree(true), index_code, 1));
toggleVarBottom(dtypep, depth+1,
newent,
varp, chgVarp);
toggleVarBottom(newent, varp);
newent.cleanup();
}
} else {
toggleVarBottom(dtypep, depth+1,
above,
varp, chgVarp);
toggleVarBottom(above, varp);
}
}
else if (AstUnpackArrayDType* adtypep = VN_CAST(dtypep, UnpackArrayDType)) {

23
src/V3EmitC.cpp
View File

@ -585,8 +585,8 @@ public:
}
virtual void visit(AstReplicate* nodep) {
if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
if (((int)VN_CAST(nodep->rhsp(), Const)->toUInt()
* nodep->lhsp()->widthMin()) != nodep->widthMin())
if ((static_cast<int>(VN_CAST(nodep->rhsp(), Const)->toUInt())
* nodep->lhsp()->widthMin()) != nodep->widthMin())
nodep->v3fatalSrc("Replicate non-constant or width miscomputed");
puts("VL_REPLICATE_");
emitIQW(nodep);
@ -687,7 +687,9 @@ public:
}
for (int word=VL_WORDS_I(upWidth)-1; word>=0; word--) {
// Only 32 bits - llx + long long here just to appease CPP format warning
ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
ofp()->printf(",0x%08" VL_PRI64 "x",
static_cast<vluint64_t>(nodep->num().dataWord
(word+chunks*EMITC_NUM_CONSTW)));
}
puts(")");
}
@ -708,7 +710,9 @@ public:
}
for (int word=EMITC_NUM_CONSTW-1; word>=0; word--) {
// Only 32 bits - llx + long long here just to appease CPP format warning
ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
ofp()->printf(",0x%08" VL_PRI64 "x",
static_cast<vluint64_t>(nodep->num().dataWord
(word+chunks*EMITC_NUM_CONSTW)));
}
puts(")");
}
@ -730,7 +734,7 @@ public:
uint32_t num = nodep->toUInt();
// Only 32 bits - llx + long long here just to appease CPP format warning
if (num<10) puts(cvtToStr(num));
else ofp()->printf("0x%" VL_PRI64 "x", (vluint64_t)num);
else ofp()->printf("0x%" VL_PRI64 "x", static_cast<vluint64_t>(num));
// If signed, we'll do our own functions
// But must be here, or <= comparisons etc may end up signed
puts("U");
@ -1164,7 +1168,7 @@ class EmitCImp : EmitCStmts {
// METHODS
// Low level
void emitVarReset(AstVar* modp);
void emitVarReset(AstVar* varp);
void emitCellCtors(AstNodeModule* modp);
void emitSensitives();
// Medium level
@ -1336,7 +1340,7 @@ void EmitCStmts::emitOpName(AstNode* nodep, const string& format,
// , Commas suppressed if the previous field is suppressed
string nextComma;
bool needComma = false;
#define COMMA { if (nextComma!="") { puts(nextComma); nextComma=""; } }
#define COMMA { if (!nextComma.empty()) { puts(nextComma); nextComma=""; } }
putbs("");
for (string::const_iterator pos = format.begin(); pos != format.end(); ++pos) {
@ -1675,7 +1679,8 @@ void EmitCImp::emitVarReset(AstVar* varp) {
}
bool zeroit = (varp->attrFileDescr() // Zero it out, so we don't core dump if never call $fopen
|| (varp->basicp() && varp->basicp()->isZeroInit())
|| (varp->name().size()>=1 && varp->name()[0]=='_' && v3Global.opt.underlineZero())
|| (v3Global.opt.underlineZero()
&& !varp->name().empty() && varp->name()[0]=='_')
|| (v3Global.opt.xInitial() == "fast" || v3Global.opt.xInitial() == "0"));
if (varp->isWide()) {
// DOCUMENT: We randomize everything. If the user wants a _var to be zero,
@ -1877,7 +1882,7 @@ void EmitCImp::emitSavableImp(AstNodeModule* modp) {
}
}
ofp()->printf( "vluint64_t __Vcheckval = VL_ULL(0x%" VL_PRI64 "x);\n",
(vluint64_t)hash.digestUInt64());
static_cast<vluint64_t>(hash.digestUInt64()));
if (de) {
puts("os.readAssert(__Vcheckval);\n");
} else {

4
src/V3EmitV.cpp
View File

@ -550,9 +550,9 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
// Terminals
virtual void visit(AstVarRef* nodep) {
if (nodep->varScopep())
if (nodep->varScopep()) {
putfs(nodep,nodep->varScopep()->prettyName());
else {
} else {
putfs(nodep,nodep->hiername());
puts(nodep->varp()->prettyName());
}

2
src/V3EmitV.h
View File

@ -34,7 +34,7 @@ public:
static void emitv();
static void verilogForTree(AstNode* nodep, std::ostream& os=std::cout);
static void verilogPrefixedTree(AstNode* nodep, std::ostream& os, const string& prefix, int flWidth,
AstSenTree* domainp, bool user3percent);
AstSenTree* domainp, bool user3mark);
};
#endif // Guard

6
src/V3EmitXml.cpp
View File

@ -115,11 +115,11 @@ class EmitXmlFileVisitor : public AstNVisitor {
virtual void visit(AstPin* nodep) {
// What we call a pin in verilator is a port in the IEEE spec.
outputTag(nodep, "port"); // IEEE: vpiPort
if (nodep->modVarp()->isInOnly())
if (nodep->modVarp()->isInOnly()) {
puts(" direction=\"in\"");
else if (nodep->modVarp()->isOutOnly())
} else if (nodep->modVarp()->isOutOnly()) {
puts(" direction=\"out\"");
else puts(" direction=\"inout\"");
} else puts(" direction=\"inout\"");
puts(" portIndex=\""+cvtToStr(nodep->pinNum())+"\""); // IEEE: vpiPortIndex
// Children includes vpiHighConn and vpiLowConn; we don't support port bits (yet?)
outputChildrenEnd(nodep, "port");

2
src/V3Error.cpp
View File

@ -56,7 +56,7 @@ v3errorIniter v3errorInit;
V3ErrorCode::V3ErrorCode(const char* msgp) {
// Return error encoding for given string, or ERROR, which is a bad code
for (int codei=V3ErrorCode::EC_MIN; codei<V3ErrorCode::_ENUM_MAX; codei++) {
V3ErrorCode code = (V3ErrorCode)codei;
V3ErrorCode code = V3ErrorCode(codei);
if (0==strcasecmp(msgp,code.ascii())) {
m_e = code; return;
}

34
src/V3Expand.cpp
View File

@ -348,7 +348,7 @@ private:
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
// Remember, Sel's may have non-integer rhs, so need to optimize for that!
if (nodep->widthMin()!=(int)nodep->widthConst()) nodep->v3fatalSrc("Width mismatch");
if (nodep->widthMin() != nodep->widthConst()) nodep->v3fatalSrc("Width mismatch");
if (VN_IS(nodep->backp(), NodeAssign) && nodep==VN_CAST(nodep->backp(), NodeAssign)->lhsp()) {
// Sel is an LHS assignment select
} else if (nodep->isWide()) {
@ -456,7 +456,7 @@ private:
}
bool expandWide(AstNodeAssign* nodep, AstSel* rhsp) {
if (nodep->widthMin()!=(int)rhsp->widthConst()) nodep->v3fatalSrc("Width mismatch");
if (nodep->widthMin() != rhsp->widthConst()) nodep->v3fatalSrc("Width mismatch");
if (VN_IS(rhsp->lsbp(), Const) && VL_BITBIT_I(rhsp->lsbConst())==0) {
int lsb = rhsp->lsbConst();
UINFO(8," Wordize ASSIGN(SEL,align) "<<nodep<<endl);
@ -527,9 +527,12 @@ private:
// else we would just be setting it to the same exact value
AstNode* oldvalp = newAstWordSelClone(destp, w);
fixCloneLvalue(oldvalp);
if (!ones) oldvalp = new AstAnd(lhsp->fileline(),
new AstConst(lhsp->fileline(), maskold.dataWord(w)),
oldvalp);
if (!ones) {
oldvalp = new AstAnd(lhsp->fileline(),
new AstConst(lhsp->fileline(),
maskold.dataWord(w)),
oldvalp);
}
addWordAssign(nodep, w,
destp,
new AstOr(lhsp->fileline(),
@ -542,12 +545,16 @@ private:
destp->deleteTree(); VL_DANGLING(destp);
} else {
UINFO(8," ASSIGNSEL(const,narrow) "<<nodep<<endl);
if (destp->isQuad() && !rhsp->isQuad()) rhsp = new AstCCast(nodep->fileline(), rhsp, nodep);
if (destp->isQuad() && !rhsp->isQuad()) {
rhsp = new AstCCast(nodep->fileline(), rhsp, nodep);
}
AstNode* oldvalp = destp->cloneTree(true);
fixCloneLvalue(oldvalp);
if (!ones) oldvalp = new AstAnd(lhsp->fileline(),
new AstConst(lhsp->fileline(), maskold),
oldvalp);
if (!ones) {
oldvalp = new AstAnd(lhsp->fileline(),
new AstConst(lhsp->fileline(), maskold),
oldvalp);
}
AstNode* newp
= new AstOr(lhsp->fileline(),
oldvalp,
@ -569,7 +576,7 @@ private:
destp->cloneTree(true),
newSelBitWord(lhsp->lsbp(), 0));
fixCloneLvalue(oldvalp);
if (!ones)
if (!ones) {
oldvalp = new AstAnd(lhsp->fileline(),
new AstNot(lhsp->fileline(),
new AstShiftL(lhsp->fileline(),
@ -580,7 +587,7 @@ private:
newSelBitBit(lhsp->lsbp()),
VL_WORDSIZE)),
oldvalp);
}
// Restrict the shift amount to 0-31, see bug804.
AstNode* shiftp = new AstAnd(nodep->fileline(), lhsp->lsbp()->cloneTree(true),
new AstConst(nodep->fileline(), VL_WORDSIZE-1));
@ -618,10 +625,10 @@ private:
fixCloneLvalue(oldvalp);
V3Number maskwidth (nodep->fileline(), destp->widthMin());
for (int bit=0; bit<(int)lhsp->widthConst(); bit++) maskwidth.setBit(bit,1);
for (int bit=0; bit < lhsp->widthConst(); bit++) maskwidth.setBit(bit,1);
if (destp->isQuad() && !rhsp->isQuad()) rhsp = new AstCCast(nodep->fileline(), rhsp, nodep);
if (!ones)
if (!ones) {
oldvalp = new AstAnd(lhsp->fileline(),
new AstNot(lhsp->fileline(),
new AstShiftL(lhsp->fileline(),
@ -630,6 +637,7 @@ private:
lhsp->lsbp()->cloneTree(true),
destp->width())),
oldvalp);
}
AstNode* newp
= new AstOr(lhsp->fileline(),
oldvalp,

23
src/V3File.cpp
View File

@ -54,8 +54,8 @@
// If change this code, run a test with the below size set very small
//#define INFILTER_IPC_BUFSIZ 16
#define INFILTER_IPC_BUFSIZ 64*1024 // For debug, try this as a small number
#define INFILTER_CACHE_MAX 64*1024 // Maximum bytes to cache if same file read twice
#define INFILTER_IPC_BUFSIZ (64*1024) // For debug, try this as a small number
#define INFILTER_CACHE_MAX (64*1024) // Maximum bytes to cache if same file read twice
//######################################################################
// V3File Internal state
@ -124,8 +124,8 @@ public:
}
}
void writeDepend(const string& filename);
void writeTimes(const string& filename, const string& cmdline);
bool checkTimes(const string& filename, const string& cmdline);
void writeTimes(const string& filename, const string& cmdlineIn);
bool checkTimes(const string& filename, const string& cmdlineIn);
};
V3FileDependImp dependImp; // Depend implementation class
@ -180,7 +180,7 @@ inline void V3FileDependImp::writeTimes(const string& filename, const string& cm
for (std::set<DependFile>::iterator iter=m_filenameList.begin();
iter!=m_filenameList.end(); ++iter) {
// Read stats of files we create after we're done making them (execpt for this file, of course)
DependFile* dfp = (DependFile*)&(*iter);
DependFile* dfp = const_cast<DependFile*>(&(*iter));
V3Options::fileNfsFlush(dfp->filename());
dfp->loadStats();
off_t showSize = iter->size();
@ -232,6 +232,7 @@ inline bool V3FileDependImp::checkTimes(const string& filename, const string& cm
string chkFilename; getline(*ifp, chkFilename, '"');
V3Options::fileNfsFlush(chkFilename);
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct stat chkStat;
int err = stat(chkFilename.c_str(), &chkStat);
if (err!=0) {
@ -280,11 +281,11 @@ void V3File::addTgtDepend(const string& filename) {
void V3File::writeDepend(const string& filename) {
dependImp.writeDepend(filename);
}
void V3File::writeTimes(const string& filename, const string& cmdline) {
dependImp.writeTimes(filename, cmdline);
void V3File::writeTimes(const string& filename, const string& cmdlineIn) {
dependImp.writeTimes(filename, cmdlineIn);
}
bool V3File::checkTimes(const string& filename, const string& cmdline) {
return dependImp.checkTimes(filename, cmdline);
bool V3File::checkTimes(const string& filename, const string& cmdlineIn) {
return dependImp.checkTimes(filename, cmdlineIn);
}
void V3File::createMakeDir() {
@ -463,7 +464,7 @@ private:
dup2(fd_stdout[P_WR], 1);
// And stderr comes from parent
execl("/bin/sh", "sh", "-c", command.c_str(), (char*)NULL);
execl("/bin/sh", "sh", "-c", command.c_str(), static_cast<char*>(NULL));
// Don't use v3fatal, we don't share the common structures any more
fprintf(stderr,"--pipe-filter: exec failed: %s\n",strerror(errno));
_exit(10);
@ -858,7 +859,7 @@ void V3OutFormatter::printf(const char *fmt...) {
V3OutFile::V3OutFile(const string& filename, V3OutFormatter::Language lang)
: V3OutFormatter(filename, lang) {
if ((m_fp = V3File::new_fopen_w(filename.c_str())) == NULL) {
if ((m_fp = V3File::new_fopen_w(filename)) == NULL) {
v3fatal("Cannot write "<<filename);
}
}

8
src/V3File.h
View File

@ -65,8 +65,8 @@ public:
static void addSrcDepend(const string& filename);
static void addTgtDepend(const string& filename);
static void writeDepend(const string& filename);
static void writeTimes(const string& filename, const string& cmdline);
static bool checkTimes(const string& filename, const string& cmdline);
static void writeTimes(const string& filename, const string& cmdlineIn);
static bool checkTimes(const string& filename, const string& cmdlineIn);
// Directory utilities
static void createMakeDir();
@ -129,7 +129,7 @@ private:
int m_bracketLevel; // Intenting = { block, indicates number of {'s seen.
int endLevels(const char* strg);
const char* indentStr(int levels);
const char* indentStr(int num);
void putcNoTracking(char chr);
public:
@ -160,7 +160,7 @@ public:
void blockInc() { m_parenVec.push(m_indentLevel + m_blockIndent); }
void blockDec() { if (!m_parenVec.empty()) m_parenVec.pop(); }
// STATIC METHODS
static const string indentSpaces(int levels);
static const string indentSpaces(int num);
// CALLBACKS - MUST OVERRIDE
virtual void putcOutput(char chr) = 0;

26
src/V3FileLine.cpp
View File

@ -36,15 +36,15 @@
//######################################################################
// FileLineSingleton class functions
const string FileLineSingleton::filenameLetters(int no) {
const string FileLineSingleton::filenameLetters(int fileno) {
const int size = 1 + (64 / 4); // Each letter retires more than 4 bits of a > 64 bit number
char out[size];
char* op = out+size-1;
*--op = '\0'; // We build backwards
int num = no;
int num = fileno;
do {
*--op = 'a'+num%26;
num /= 26;
*--op = 'a'+num%26;
num /= 26;
} while (num);
return op;
}
@ -90,8 +90,8 @@ FileLine::FileLine(FileLine::EmptySecret) {
m_warnOn=0;
for (int codei=V3ErrorCode::EC_MIN; codei<V3ErrorCode::_ENUM_MAX; codei++) {
V3ErrorCode code = (V3ErrorCode)codei;
warnOff(code, code.defaultsOff());
V3ErrorCode code = V3ErrorCode(codei);
warnOff(code, code.defaultsOff());
}
}
@ -205,15 +205,15 @@ bool FileLine::warnOff(const string& msg, bool flag) {
void FileLine::warnLintOff(bool flag) {
for (int codei=V3ErrorCode::EC_MIN; codei<V3ErrorCode::_ENUM_MAX; codei++) {
V3ErrorCode code = (V3ErrorCode)codei;
if (code.lintError()) warnOff(code, flag);
V3ErrorCode code = V3ErrorCode(codei);
if (code.lintError()) warnOff(code, flag);
}
}
void FileLine::warnStyleOff(bool flag) {
for (int codei=V3ErrorCode::EC_MIN; codei<V3ErrorCode::_ENUM_MAX; codei++) {
V3ErrorCode code = (V3ErrorCode)codei;
if (code.styleError()) warnOff(code, flag);
V3ErrorCode code = V3ErrorCode(codei);
if (code.styleError()) warnOff(code, flag);
}
}
@ -229,10 +229,8 @@ bool FileLine::warnIsOff(V3ErrorCode code) const {
void FileLine::modifyStateInherit(const FileLine* fromp) {
// Any warnings that are off in "from", become off in "this".
for (int codei=V3ErrorCode::EC_MIN; codei<V3ErrorCode::_ENUM_MAX; codei++) {
V3ErrorCode code = (V3ErrorCode)codei;
if (fromp->warnIsOff(code)) {
warnOff(code, true);
}
V3ErrorCode code = V3ErrorCode(codei);
if (fromp->warnIsOff(code)) { warnOff(code, true); }
}
}

4
src/V3FileLine.h
View File

@ -123,10 +123,10 @@ public:
const string filebasenameNoExt() const;
const string profileFuncname() const;
const string xml() const { return "fl=\""+filenameLetters()+cvtToStr(lineno())+"\""; }
string lineDirectiveStrg(int enter_exit_level) const;
string lineDirectiveStrg(int enterExit) const;
void warnOn(V3ErrorCode code, bool flag) { m_warnOn.set(code,flag); } // Turn on/off warning messages on this line.
void warnOff(V3ErrorCode code, bool flag) { warnOn(code,!flag); }
bool warnOff(const string& code, bool flag); // Returns 1 if ok
bool warnOff(const string& msg, bool flag); // Returns 1 if ok
bool warnIsOff(V3ErrorCode code) const;
void warnLintOff(bool flag);
void warnStyleOff(bool flag);

40
src/V3Gate.cpp
View File

@ -230,9 +230,11 @@ private:
}
virtual void visit(AstNodeAssign* nodep) {
m_substTreep = nodep->rhsp();
if (!VN_IS(nodep->lhsp(), NodeVarRef))
clearSimple("ASSIGN(non-VARREF)");
else iterateChildren(nodep);
if (!VN_IS(nodep->lhsp(), NodeVarRef)) {
clearSimple("ASSIGN(non-VARREF)");
} else {
iterateChildren(nodep);
}
// We don't push logic other then assignments/NOTs into SenItems
// This avoids a mess in computing what exactly a POSEDGE is
// V3Const cleans up any NOTs by flipping the edges for us
@ -345,7 +347,7 @@ private:
}
GateVarVertex* makeVarVertex(AstVarScope* varscp) {
GateVarVertex* vertexp = (GateVarVertex*)(varscp->user1p());
GateVarVertex* vertexp = reinterpret_cast<GateVarVertex*>(varscp->user1p());
if (!vertexp) {
UINFO(6,"New vertex "<<varscp<<endl);
vertexp = new GateVarVertex(&m_graph, m_scopep, varscp);
@ -368,7 +370,7 @@ private:
void optimizeSignals(bool allowMultiIn);
bool elimLogicOkOutputs(GateLogicVertex* consumeVertexp, const GateOkVisitor& okVisitor);
void optimizeElimVar(AstVarScope* varscp, AstNode* logicp, AstNode* consumerp);
void optimizeElimVar(AstVarScope* varscp, AstNode* substp, AstNode* consumerp);
void warnSignals();
void consumedMark();
void consumedMarkRecurse(GateEitherVertex* vertexp);
@ -738,7 +740,7 @@ void GateVisitor::consumedMark() {
// Propagate consumed signals backwards to all producers into a consumed node
m_graph.userClearVertices();
for (V3GraphVertex* vertexp = m_graph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
GateEitherVertex* evertexp = (GateEitherVertex*)vertexp;
GateEitherVertex* evertexp = static_cast<GateEitherVertex*>(vertexp);
if (!evertexp->user() && evertexp->consumed()) {
consumedMarkRecurse(evertexp);
}
@ -751,7 +753,7 @@ void GateVisitor::consumedMarkRecurse(GateEitherVertex* vertexp) {
if (!vertexp->consumed()) vertexp->setConsumed("propagated");
// Walk sources and mark them too
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
GateEitherVertex* eFromVertexp = (GateEitherVertex*)edgep->fromp();
GateEitherVertex* eFromVertexp = static_cast<GateEitherVertex*>(edgep->fromp());
consumedMarkRecurse(eFromVertexp);
}
}
@ -1016,7 +1018,7 @@ public:
if (AstNodeVarRef* lhsVarRefp = VN_CAST(lhsp, NodeVarRef)) {
if (lhsVarRefp->varScopep() != consumerVarScopep) consumerVarScopep->v3fatalSrc("Consumer doesn't match lhs of assign");
if (AstNodeAssign* dup = m_hash.hashAndFindDupe(m_assignp,activep,m_ifCondp)) {
return (AstNodeVarRef*) dup->lhsp();
return static_cast<AstNodeVarRef*>(dup->lhsp());
}
}
}
@ -1044,16 +1046,17 @@ private:
m_depth++;
if (vvertexp->inSize1()) {
AstNodeVarRef* dupVarRefp = (AstNodeVarRef*) vvertexp->iterateInEdges(*this, VNUser(vvertexp)).toNodep();
AstNodeVarRef* dupVarRefp = static_cast<AstNodeVarRef*>
(vvertexp->iterateInEdges(*this, VNUser(vvertexp)).toNodep());
if (dupVarRefp) {
V3GraphEdge* edgep = vvertexp->inBeginp();
GateLogicVertex* lvertexp = (GateLogicVertex*)edgep->fromp();
GateLogicVertex* lvertexp = static_cast<GateLogicVertex*>(edgep->fromp());
if (!vvertexp->dedupable()) vvertexp->varScp()->v3fatalSrc("GateLogicVertex* visit should have returned NULL if consumer var vertex is not dedupable.");
GateOkVisitor okVisitor(lvertexp->nodep(), false, true);
if (okVisitor.isSimple()) {
AstVarScope* dupVarScopep = dupVarRefp->varScopep();
GateVarVertex* dupVvertexp = (GateVarVertex*) (dupVarScopep->user1p());
GateVarVertex* dupVvertexp
= reinterpret_cast<GateVarVertex*>(dupVarScopep->user1p());
UINFO(4,"replacing " << vvertexp << " with " << dupVvertexp << endl);
++m_numDeduped;
// Replace all of this varvertex's consumers with dupVarRefp
@ -1089,7 +1092,7 @@ private:
virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) {
lvertexp->iterateInEdges(*this);
GateVarVertex* consumerVvertexpp = (GateVarVertex*) vu.toGraphVertex();
GateVarVertex* consumerVvertexpp = static_cast<GateVarVertex*>(vu.toGraphVertex());
if (lvertexp->dedupable() && consumerVvertexpp->dedupable()) {
AstNode* nodep = lvertexp->nodep();
AstVarScope* consumerVarScopep = consumerVvertexpp->varScp();
@ -1161,9 +1164,10 @@ private:
const AstConst* cstart = VN_CAST(cur->lsbp(), Const);
const AstConst* cwidth = VN_CAST(cur->widthp(), Const);
if (!pstart || !pwidth || !cstart || !cwidth) return NULL; // too complicated
if (cur->lsbConst()+cur->widthConst() == pre->lsbConst())
return new AstSel(curVarRefp->fileline(), curVarRefp->cloneTree(false), cur->lsbConst(), pre->widthConst()+cur->widthConst());
else return NULL;
if (cur->lsbConst()+cur->widthConst() == pre->lsbConst()) {
return new AstSel(curVarRefp->fileline(), curVarRefp->cloneTree(false),
cur->lsbConst(), pre->widthConst()+cur->widthConst());
} else return NULL;
}
virtual VNUser visit(GateVarVertex *vvertexp, VNUser) {
@ -1353,7 +1357,7 @@ private:
m_seen_clk_vectors++;
m_total_seen_clk_vectors++;
}
GateClkDecompState* currState = (GateClkDecompState*) vu.c();
GateClkDecompState* currState = reinterpret_cast<GateClkDecompState*>(vu.c());
GateClkDecompState nextState(currState->m_offset, vsp);
vvertexp->iterateCurrentOutEdges(*this, VNUser(&nextState));
if (vsp->varp()->width() > 1) {
@ -1364,7 +1368,7 @@ private:
}
virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) {
GateClkDecompState* currState = (GateClkDecompState*) vu.c();
GateClkDecompState* currState = reinterpret_cast<GateClkDecompState*>(vu.c());
int clk_offset = currState->m_offset;
if (const AstAssignW* assignp = VN_CAST(lvertexp->nodep(), AssignW)) {
UINFO(9,"CLK DECOMP Logic (off = "<<clk_offset<<") - "<<lvertexp<<" : "<<m_clk_vsp<<endl);

35
src/V3GraphAcyc.cpp
View File

@ -65,7 +65,7 @@ class GraphAcycEdge : public V3GraphEdge {
private:
typedef std::list<V3GraphEdge*> OrigEdgeList; // List of orig edges, see also GraphAcyc's decl
V3GraphEdge* origEdgep() const {
OrigEdgeList* oEListp = ((OrigEdgeList*)userp());
OrigEdgeList* oEListp = static_cast<OrigEdgeList*>(userp());
if (!oEListp) v3fatalSrc("No original edge associated with acyc edge "<<this<<endl);
return (oEListp->front());
}
@ -114,12 +114,12 @@ private:
void buildGraph(V3Graph* origGraphp);
void buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* avertexp);
void simplify(bool allowCut);
void simplifyNone(GraphAcycVertex* vertexp);
void simplifyOne(GraphAcycVertex* vertexp);
void simplifyOut(GraphAcycVertex* vertexp);
void simplifyDup(GraphAcycVertex* vertexp);
void cutBasic(GraphAcycVertex* vertexp);
void cutBackward(GraphAcycVertex* vertexp);
void simplifyNone(GraphAcycVertex* avertexp);
void simplifyOne(GraphAcycVertex* avertexp);
void simplifyOut(GraphAcycVertex* avertexp);
void simplifyDup(GraphAcycVertex* avertexp);
void cutBasic(GraphAcycVertex* avertexp);
void cutBackward(GraphAcycVertex* avertexp);
void deleteMarked();
void place();
void placeTryEdge(V3GraphEdge* edgep);
@ -144,8 +144,8 @@ private:
m_origEdgeDelp.push_back(oep);
toEdgep->userp(oep);
}
OrigEdgeList* oEListp = (OrigEdgeList*)(toEdgep->userp());
if (OrigEdgeList* addListp = (OrigEdgeList*)(addEdgep->userp())) {
OrigEdgeList* oEListp = static_cast<OrigEdgeList*>(toEdgep->userp());
if (OrigEdgeList* addListp = static_cast<OrigEdgeList*>(addEdgep->userp())) {
for (OrigEdgeList::iterator it = addListp->begin(); it != addListp->end(); ++it) {
oEListp->push_back(*it);
}
@ -158,7 +158,7 @@ private:
// From the break edge, cut edges in original graph it represents
UINFO(8,why<<" CUT "<<breakEdgep->fromp()<<endl);
breakEdgep->cut();
OrigEdgeList* oEListp = (OrigEdgeList*)(breakEdgep->userp());
OrigEdgeList* oEListp = static_cast<OrigEdgeList*>(breakEdgep->userp());
if (!oEListp) v3fatalSrc("No original edge associated with cutting edge "<<breakEdgep<<endl);
// The breakGraph edge may represent multiple real edges; cut them all
for (OrigEdgeList::iterator it = oEListp->begin(); it != oEListp->end(); ++it) {
@ -169,7 +169,7 @@ private:
}
// Work Que
void workPush(V3GraphVertex* vertexp) {
GraphAcycVertex* avertexp = (GraphAcycVertex*)vertexp;
GraphAcycVertex* avertexp = static_cast<GraphAcycVertex*>(vertexp);
// Add vertex to list of nodes needing further optimization trials
if (!avertexp->m_onWorkList) {
avertexp->m_onWorkList = true;
@ -216,7 +216,7 @@ void GraphAcyc::buildGraph(V3Graph* origGraphp) {
// Build edges between logic vertices
for (V3GraphVertex* overtexp = origGraphp->verticesBeginp(); overtexp; overtexp=overtexp->verticesNextp()) {
if (overtexp->color()) {
GraphAcycVertex* avertexp = (GraphAcycVertex*)(overtexp->userp());
GraphAcycVertex* avertexp = static_cast<GraphAcycVertex*>(overtexp->userp());
buildGraphIterate(overtexp, avertexp);
}
}
@ -228,7 +228,7 @@ void GraphAcyc::buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* aver
if (origFollowEdge(edgep)) { // not cut
V3GraphVertex* toVertexp = edgep->top();
if (toVertexp->color()) {
GraphAcycVertex* toAVertexp = (GraphAcycVertex*)(toVertexp->userp());
GraphAcycVertex* toAVertexp = static_cast<GraphAcycVertex*>(toVertexp->userp());
// Replicate the old edge into the new graph
// There may be multiple edges between same pairs of vertices
V3GraphEdge* breakEdgep = new GraphAcycEdge
@ -267,7 +267,7 @@ void GraphAcyc::deleteMarked() {
// Delete nodes marked for removal
for (V3GraphVertex* nextp, *vertexp = m_breakGraph.verticesBeginp(); vertexp; vertexp=nextp) {
nextp = vertexp->verticesNextp();
GraphAcycVertex* avertexp = (GraphAcycVertex*)vertexp;
GraphAcycVertex* avertexp = static_cast<GraphAcycVertex*>(vertexp);
if (avertexp->isDelete()) {
avertexp->unlinkDelete(&m_breakGraph); VL_DANGLING(avertexp);
}
@ -377,7 +377,7 @@ void GraphAcyc::simplifyDup(GraphAcycVertex* avertexp) {
for (V3GraphEdge* nextp, *edgep = avertexp->outBeginp(); edgep; edgep=nextp) {
nextp = edgep->outNextp();
V3GraphVertex* outVertexp = edgep->top();
V3GraphEdge* prevEdgep = (V3GraphEdge*)outVertexp->userp();
V3GraphEdge* prevEdgep = static_cast<V3GraphEdge*>(outVertexp->userp());
if (prevEdgep) {
if (!prevEdgep->cutable()) {
// !cutable duplicates prev !cutable: we can ignore it, redundant
@ -484,7 +484,8 @@ void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) {
// Vertex::m_user begin: number indicates this edge was completed
// Try to assign ranks, presuming this edge is in place
// If we come across user()==placestep, we've detected a loop and must back out
bool loop=placeIterate((GraphAcycVertex*)edgep->top(), edgep->fromp()->rank()+1);
bool loop = placeIterate(static_cast<GraphAcycVertex*>(edgep->top()),
edgep->fromp()->rank()+1);
if (!loop) {
// No loop, we can keep it as uncutable
// Commit the new ranks we calculated
@ -523,7 +524,7 @@ bool GraphAcyc::placeIterate(GraphAcycVertex* vertexp, uint32_t currentRank) {
// Follow all edges and increase their ranks
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
if (edgep->weight() && !edgep->cutable()) {
if (placeIterate((GraphAcycVertex*)edgep->top(), currentRank+1)) {
if (placeIterate(static_cast<GraphAcycVertex*>(edgep->top()), currentRank+1)) {
// We don't need to reset user(); we'll use a different placeStep for the next edge
return true; // Loop detected
}

6
src/V3GraphAlg.cpp
View File

@ -92,7 +92,7 @@ private:
nextp = edgep->outNextp();
if (followEdge(edgep)) {
V3GraphVertex* outVertexp = edgep->top();
V3GraphEdge* prevEdgep = (V3GraphEdge*)outVertexp->userp();
V3GraphEdge* prevEdgep = static_cast<V3GraphEdge*>(outVertexp->userp());
if (!prevEdgep) { // No previous assignment
outVertexp->userp(edgep);
} else { // Duplicate
@ -427,7 +427,7 @@ private:
//! Iterate through all connected nodes of a graph with a loop or loops.
V3GraphVertex* vertexIterateAll(V3GraphVertex* vertexp) {
if (V3GraphVertex* newVertexp = (V3GraphVertex*)vertexp->userp()) {
if (V3GraphVertex* newVertexp = static_cast<V3GraphVertex*>(vertexp->userp())) {
return newVertexp;
} else {
newVertexp = vertexp->clone(m_loopGraphp);
@ -436,7 +436,7 @@ private:
for (V3GraphEdge* edgep = vertexp->outBeginp();
edgep; edgep=edgep->outNextp()) {
if (followEdge(edgep)) {
V3GraphEdge* newEdgep = (V3GraphEdge*)edgep->userp();
V3GraphEdge* newEdgep = static_cast<V3GraphEdge*>(edgep->userp());
if (!newEdgep) {
V3GraphVertex* newTop = vertexIterateAll(edgep->top());
newEdgep = edgep->clone(m_loopGraphp, newVertexp,

4
src/V3GraphDfa.cpp
View File

@ -159,9 +159,7 @@ private:
}
// If we saw all of the nodes, then they have the same number of hits
// (Else something in dfa1p that wasn't in dfa2p)
if (num1s != num2s) return false;
// Match
return true;
return (num1s == num2s);
}
void insertDfaOrigins(DfaVertex* dfaStatep) {

2
src/V3GraphPathChecker.h
View File

@ -58,7 +58,7 @@ class GraphPathChecker : GraphAlg<const V3Graph> {
bool pathExistsInternal(const V3GraphVertex* ap,
const V3GraphVertex* bp,
unsigned* costp = NULL);
void initHalfCriticalPaths(GraphWay w, bool checkOnly);
void initHalfCriticalPaths(GraphWay way, bool checkOnly);
void incGeneration() { ++m_generation; }
VL_DEBUG_FUNC; // Declare debug()

2
src/V3GraphTest.cpp
View File

@ -334,7 +334,7 @@ public:
virtual string name() { return "import"; }
virtual void runTest() {
DfaGraph* gp = &m_graph;
if (V3GraphTest::debug()) gp->debug(9);
if (V3GraphTest::debug()) DfaGraph::debug(9);
dotImport();
dump();
gp->acyclic(&V3GraphEdge::followAlwaysTrue);

4
src/V3Inst.h
View File

@ -33,8 +33,8 @@ class V3Inst {
public:
static void instAll(AstNetlist* nodep);
static void dearrayAll(AstNetlist* nodep);
static AstAssignW* pinReconnectSimple(AstPin* nodep, AstCell* cellp,
bool forTristate, bool alwaysCvt=false);
static AstAssignW* pinReconnectSimple(AstPin* pinp, AstCell* cellp,
bool forTristate, bool alwaysCvt=false);
};
#endif // Guard

4
src/V3LifePost.cpp
View File

@ -60,7 +60,7 @@ private:
virtual void visit(AstVarRef* nodep) {
AstVarScope* vscp = nodep->varScopep();
if (!vscp) nodep->v3fatalSrc("Scope not assigned");
if (AstVarScope* newvscp = (AstVarScope*)vscp->user4p()) {
if (AstVarScope* newvscp = reinterpret_cast<AstVarScope*>(vscp->user4p())) {
UINFO(9, " Replace "<<nodep<<" to "<<newvscp<<endl);
AstVarRef* newrefp = new AstVarRef(nodep->fileline(), newvscp, nodep->lvalue());
nodep->replaceWith(newrefp);
@ -222,7 +222,7 @@ private:
const std::set<LifeLocation>& dlyVarAssigns = m_writes[dlyVarp];
// Proof (1)
const std::set<LifeLocation>& dlyVarReads = m_reads[dlyVarp];
if (dlyVarReads.size() > 0) {
if (!dlyVarReads.empty()) {
continue; // do not scrunch, go to next LifePostLocation
}

10
src/V3LinkCells.cpp
View File

@ -459,14 +459,14 @@ private:
public:
// CONSTUCTORS
LinkCellsVisitor(AstNetlist* rootp, V3InFilter* filterp, V3ParseSym* parseSymp)
: m_mods(rootp) {
LinkCellsVisitor(AstNetlist* nodep, V3InFilter* filterp, V3ParseSym* parseSymp)
: m_mods(nodep) {
m_filterp = filterp;
m_parseSymp = parseSymp;
m_modp = NULL;
m_libVertexp = NULL;
m_topVertexp = NULL;
iterate(rootp);
iterate(nodep);
}
virtual ~LinkCellsVisitor() {}
};
@ -474,7 +474,7 @@ public:
//######################################################################
// Link class functions
void V3LinkCells::link(AstNetlist* rootp, V3InFilter* filterp, V3ParseSym* parseSymp) {
void V3LinkCells::link(AstNetlist* nodep, V3InFilter* filterp, V3ParseSym* parseSymp) {
UINFO(4,__FUNCTION__<<": "<<endl);
LinkCellsVisitor visitor (rootp, filterp, parseSymp);
LinkCellsVisitor visitor (nodep, filterp, parseSymp);
}

10
src/V3LinkDot.h
View File

@ -34,27 +34,27 @@ enum VLinkDotStep { LDS_PRIMARY, LDS_PARAMED, LDS_ARRAYED, LDS_SCOPED };
class V3LinkDot {
private:
static int debug();
static void linkDotGuts(AstNetlist* nodep, VLinkDotStep step);
static void linkDotGuts(AstNetlist* rootp, VLinkDotStep step);
public:
static void linkDotPrimary(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
linkDotGuts(nodep,LDS_PRIMARY);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
}
static void linkDotParamed(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
linkDotGuts(nodep,LDS_PARAMED);
V3Global::dumpCheckGlobalTree("paramlink", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
V3Global::dumpCheckGlobalTree("paramlink", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
}
static void linkDotArrayed(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
linkDotGuts(nodep,LDS_ARRAYED);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
}
static void linkDotScope(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
linkDotGuts(nodep,LDS_SCOPED);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
}
};

4
src/V3LinkLValue.cpp
View File

@ -271,10 +271,10 @@ public:
//######################################################################
// Link class functions
void V3LinkLValue::linkLValue(AstNetlist* rootp) {
void V3LinkLValue::linkLValue(AstNetlist* nodep) {
UINFO(4,__FUNCTION__<<": "<<endl);
{
LinkLValueVisitor visitor(rootp, false);
LinkLValueVisitor visitor(nodep, false);
} // Destruct before checking
V3Global::dumpCheckGlobalTree("linklvalue", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
}

28
src/V3LinkLevel.cpp
View File

@ -85,30 +85,30 @@ void V3LinkLevel::modSortByLevel() {
//######################################################################
// Wrapping
void V3LinkLevel::wrapTop(AstNetlist* netlistp) {
void V3LinkLevel::wrapTop(AstNetlist* rootp) {
UINFO(2,__FUNCTION__<<": "<<endl);
// We do ONLY the top module
AstNodeModule* oldmodp = netlistp->modulesp();
if (!oldmodp) netlistp->v3fatalSrc("No module found to process");
AstNodeModule* oldmodp = rootp->modulesp();
if (!oldmodp) rootp->v3fatalSrc("No module found to process");
AstNodeModule* newmodp = new AstModule(oldmodp->fileline(), string("TOP_")+oldmodp->name());
// Make the new module first in the list
oldmodp->unlinkFrBackWithNext();
newmodp->addNext(oldmodp);
newmodp->level(1);
newmodp->modPublic(true);
netlistp->addModulep(newmodp);
rootp->addModulep(newmodp);
// TODO the module creation above could be done after linkcells, but
// the rest must be done after data type resolution
wrapTopCell(netlistp);
wrapTopPackages(netlistp);
wrapTopCell(rootp);
wrapTopPackages(rootp);
}
void V3LinkLevel::wrapTopCell(AstNetlist* netlistp) {
AstNodeModule* newmodp = netlistp->modulesp();
if (!newmodp || !newmodp->isTop()) netlistp->v3fatalSrc("No TOP module found to process");
void V3LinkLevel::wrapTopCell(AstNetlist* rootp) {
AstNodeModule* newmodp = rootp->modulesp();
if (!newmodp || !newmodp->isTop()) rootp->v3fatalSrc("No TOP module found to process");
AstNodeModule* oldmodp = VN_CAST(newmodp->nextp(), NodeModule);
if (!oldmodp) netlistp->v3fatalSrc("No module found to process");
if (!oldmodp) rootp->v3fatalSrc("No module found to process");
// Add instance
AstCell* cellp = new AstCell(newmodp->fileline(),
@ -148,12 +148,12 @@ void V3LinkLevel::wrapTopCell(AstNetlist* netlistp) {
}
}
void V3LinkLevel::wrapTopPackages(AstNetlist* netlistp) {
void V3LinkLevel::wrapTopPackages(AstNetlist* rootp) {
// Instantiate all packages under the top wrapper
// This way all later SCOPE based optimizations can ignore packages
AstNodeModule* newmodp = netlistp->modulesp();
if (!newmodp || !newmodp->isTop()) netlistp->v3fatalSrc("No TOP module found to process");
for (AstNodeModule* modp = netlistp->modulesp(); modp; modp=VN_CAST(modp->nextp(), NodeModule)) {
AstNodeModule* newmodp = rootp->modulesp();
if (!newmodp || !newmodp->isTop()) rootp->v3fatalSrc("No TOP module found to process");
for (AstNodeModule* modp = rootp->modulesp(); modp; modp=VN_CAST(modp->nextp(), NodeModule)) {
if (VN_IS(modp, Package)) {
AstCell* cellp = new AstCell(modp->fileline(),
// Could add __03a__03a="::" to prevent conflict

6
src/V3LinkLevel.h
View File

@ -31,11 +31,11 @@
class V3LinkLevel {
private:
static void wrapTopCell(AstNetlist* nodep);
static void wrapTopPackages(AstNetlist* nodep);
static void wrapTopCell(AstNetlist* rootp);
static void wrapTopPackages(AstNetlist* rootp);
public:
static void modSortByLevel();
static void wrapTop(AstNetlist* nodep);
static void wrapTop(AstNetlist* rootp);
};
#endif // Guard

2
src/V3LinkParse.h
View File

@ -31,7 +31,7 @@
class V3LinkParse {
public:
static void linkParse(AstNetlist* nodep);
static void linkParse(AstNetlist* rootp);
};
#endif // Guard

2
src/V3LinkResolve.h
View File

@ -31,7 +31,7 @@
class V3LinkResolve {
public:
static void linkResolve(AstNetlist* nodep);
static void linkResolve(AstNetlist* rootp);
};
#endif // Guard

4
src/V3Localize.cpp
View File

@ -63,7 +63,7 @@ protected:
};
// cppcheck-suppress unusedStructMember
uint32_t m_flags;
VarFlags(AstNode* nodep) { m_flags = nodep->user2(); }
explicit VarFlags(AstNode* nodep) { m_flags = nodep->user2(); }
void setNodeFlags(AstNode* nodep) { nodep->user2(m_flags); }
};
};
@ -215,7 +215,7 @@ private:
clearOptimizable(nodep->varp(),"BVmultiF");
}
// First varref in function must be assignment found earlier
AstVarRef* firstasn = (AstVarRef*)(nodep->varp()->user4p());
AstVarRef* firstasn = static_cast<AstVarRef*>(nodep->varp()->user4p());
if (firstasn && nodep!=firstasn) {
clearStdOptimizable(nodep->varp(),"notFirstAsn");
nodep->varp()->user4p(NULL);

96
src/V3Number.cpp
View File

@ -490,7 +490,7 @@ string V3Number::displayed(FileLine*fl, const string& vformat) const {
while ((bit%3)!=2) bit++;
for (; bit>0; bit -= 3) {
int v = bitsValue(bit-2, 3);
str += (char)('0'+v);
str += static_cast<char>('0' + v);
}
return str;
}
@ -501,8 +501,8 @@ string V3Number::displayed(FileLine*fl, const string& vformat) const {
while ((bit%4)!=3) bit++;
for (; bit>0; bit -= 4) {
int v = bitsValue(bit-3, 4);
if (v>=10) str += (char)('a'+v-10);
else str += (char)('0'+v);
if (v>=10) str += static_cast<char>('a' + v - 10);
else str += static_cast<char>('0' + v);
}
return str;
}
@ -521,8 +521,8 @@ string V3Number::displayed(FileLine*fl, const string& vformat) const {
for (; bit>=0; bit -= 8) {
int v = bitsValue(bit-7, 8);
if (!start || v) {
str += (char)((v==0)?' ':v);
start = false; // Drop leading 0s
str += static_cast<char>((v==0) ? ' ' : v);
start = false; // Drop leading 0s
} else {
if (fmtsize != "0") str += ' ';
}
@ -555,7 +555,7 @@ string V3Number::displayed(FileLine*fl, const string& vformat) const {
}
int intfmtsize = atoi(fmtsize.c_str());
bool zeropad = fmtsize.length()>0 && fmtsize[0]=='0';
while ((int)(str.length()) < intfmtsize) {
while (static_cast<int>(str.length()) < intfmtsize) {
if (zeropad) str.insert(0, "0");
else str.insert(0, " ");
}
@ -572,23 +572,23 @@ string V3Number::displayed(FileLine*fl, const string& vformat) const {
// 'p' // Packed - converted to another code by V3Width
case 'u': { // Packed 2-state
for (int i=0; i<words(); i++) {
str += (char)((m_value[i] >> 0) & 0xff);
str += (char)((m_value[i] >> 8) & 0xff);
str += (char)((m_value[i] >> 16) & 0xff);
str += (char)((m_value[i] >> 24) & 0xff);
str += static_cast<char>((m_value[i] >> 0) & 0xff);
str += static_cast<char>((m_value[i] >> 8) & 0xff);
str += static_cast<char>((m_value[i] >> 16) & 0xff);
str += static_cast<char>((m_value[i] >> 24) & 0xff);
}
return str;
}
case 'z': { // Packed 4-state
for (int i=0; i<words(); i++) {
str += (char)((m_value[i] >> 0) & 0xff);
str += (char)((m_value[i] >> 8) & 0xff);
str += (char)((m_value[i] >> 16) & 0xff);
str += (char)((m_value[i] >> 24) & 0xff);
str += (char)((m_valueX[i] >> 0) & 0xff);
str += (char)((m_valueX[i] >> 8) & 0xff);
str += (char)((m_valueX[i] >> 16) & 0xff);
str += (char)((m_valueX[i] >> 24) & 0xff);
str += static_cast<char>((m_value[i] >> 0) & 0xff);
str += static_cast<char>((m_value[i] >> 8) & 0xff);
str += static_cast<char>((m_value[i] >> 16) & 0xff);
str += static_cast<char>((m_value[i] >> 24) & 0xff);
str += static_cast<char>((m_valueX[i] >> 0) & 0xff);
str += static_cast<char>((m_valueX[i] >> 8) & 0xff);
str += static_cast<char>((m_valueX[i] >> 16) & 0xff);
str += static_cast<char>((m_valueX[i] >> 24) & 0xff);
}
return str;
}
@ -691,11 +691,11 @@ vlsint32_t V3Number::toSInt() const {
uint32_t v = toUInt();
uint32_t signExtend = (-(v & (1UL<<(width()-1))));
uint32_t extended = v | signExtend;
return (vlsint32_t)(extended);
return static_cast<vlsint32_t>(extended);
} else {
// Where we use this (widths, etc) and care about signedness,
// we can reasonably assume the MSB isn't set on unsigned numbers.
return (vlsint32_t)toUInt();
return static_cast<vlsint32_t>(toUInt());
}
}
@ -705,15 +705,16 @@ vluint64_t V3Number::toUQuad() const {
for (int i=2; i<words(); ++i) {
UASSERT(!m_value[i], "Value too wide for 64-bits expected in this context "<<*this);
}
if (width()<=32) return ((vluint64_t)(toUInt()));
return ((vluint64_t)m_value[1]<<VL_ULL(32)) | ((vluint64_t)m_value[0]);
if (width()<=32) return (static_cast<vluint64_t>(toUInt()));
return ((static_cast<vluint64_t>(m_value[1])<<VL_ULL(32))
| (static_cast<vluint64_t>(m_value[0])));
}
vlsint64_t V3Number::toSQuad() const {
vluint64_t v = toUQuad();
vluint64_t signExtend = (-(v & (VL_ULL(1)<<(width()-1))));
vluint64_t extended = v | signExtend;
return (vlsint64_t)(extended);
return static_cast<vlsint64_t>(extended);
}
string V3Number::toString() const {
@ -727,8 +728,8 @@ string V3Number::toString() const {
for (; bit>=0; bit -= 8) {
int v = bitsValue(bit-7, 8);
if (!start || v) {
str += (char)((v==0)?' ':v);
start = false; // Drop leading 0s
str += static_cast<char>((v==0) ? ' ' : v);
start = false; // Drop leading 0s
}
}
return str;
@ -1069,7 +1070,7 @@ V3Number& V3Number::opStreamL(const V3Number& lhs, const V3Number& rhs) {
m_fileline->v3warn(WIDTHCONCAT,"Unsized numbers/parameters not allowed in streams.");
}
// Slice size should never exceed the lhs width
int ssize = std::min(rhs.toUInt(), (unsigned)lhs.width());
int ssize = std::min(rhs.toUInt(), static_cast<unsigned>(lhs.width()));
for (int istart=0; istart<lhs.width(); istart+=ssize) {
int ostart = std::max(0, lhs.width()-ssize-istart);
for (int bit=0; bit<ssize && bit<lhs.width()-istart; bit++) {
@ -1273,7 +1274,7 @@ V3Number& V3Number::opRotL(const V3Number& lhs, const V3Number& rhs) {
setZero();
uint32_t rhsval = rhs.toUInt();
for (int bit=0; bit<this->width(); bit++) {
if (bit >= (int)rhsval) {
if (bit >= static_cast<int>(rhsval)) {
setBit(bit,lhs.bitIs((bit - rhsval) % this->width()));
}
}
@ -1288,7 +1289,7 @@ V3Number& V3Number::opShiftR(const V3Number& lhs, const V3Number& rhs) {
if (rhs.bitIs1(bit)) return *this; // shift of over 2^32 must be zero
}
uint32_t rhsval = rhs.toUInt();
if (rhsval < (uint32_t)lhs.width()) {
if (rhsval < static_cast<uint32_t>(lhs.width())) {
for (int bit=0; bit<this->width(); bit++) {
setBit(bit,lhs.bitIs(bit + rhsval));
}
@ -1310,7 +1311,7 @@ V3Number& V3Number::opShiftRS(const V3Number& lhs, const V3Number& rhs, uint32_t
return *this; // shift of over 2^32 must be -1/0
}
uint32_t rhsval = rhs.toUInt();
if (rhsval < (uint32_t)lhs.width()) {
if (rhsval < static_cast<uint32_t>(lhs.width())) {
for (int bit=0; bit<this->width(); bit++) {
setBit(bit,lhs.bitIsExtend(bit + rhsval, lbits));
}
@ -1331,8 +1332,8 @@ V3Number& V3Number::opShiftL(const V3Number& lhs, const V3Number& rhs) {
}
uint32_t rhsval = rhs.toUInt();
for (int bit=0; bit<this->width(); bit++) {
if (bit >= (int)rhsval) {
setBit(bit,lhs.bitIs(bit - rhsval));
if (bit >= static_cast<int>(rhsval)) {
setBit(bit, lhs.bitIs(bit - rhsval));
}
}
return *this;
@ -1391,7 +1392,8 @@ V3Number& V3Number::opMul(const V3Number& lhs, const V3Number& rhs) {
} else {
for (int lword=0; lword<lhs.words(); lword++) {
for (int rword=0; rword<rhs.words(); rword++) {
vluint64_t mul = (vluint64_t)(lhs.m_value[lword]) * (vluint64_t)(rhs.m_value[rword]);
vluint64_t mul = static_cast<vluint64_t>(lhs.m_value[lword])
* static_cast<vluint64_t>(rhs.m_value[rword]);
for (int qword=lword+rword; qword<this->words(); qword++) {
mul += (vluint64_t)(m_value[qword]);
m_value[qword] = (mul & VL_ULL(0xffffffff));
@ -1494,9 +1496,10 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
if (vw == 1) { // Single divisor word breaks rest of algorithm
vluint64_t k = 0;
for (int j = uw-1; j >= 0; j--) {
vluint64_t unw64 = ((k<<VL_ULL(32)) + (vluint64_t)(lhs.m_value[j]));
m_value[j] = unw64 / (vluint64_t)(rhs.m_value[0]);
k = unw64 - (vluint64_t)(m_value[j])*(vluint64_t)(rhs.m_value[0]);
vluint64_t unw64 = ((k<<VL_ULL(32)) + static_cast<vluint64_t>(lhs.m_value[j]));
m_value[j] = unw64 / static_cast<vluint64_t>(rhs.m_value[0]);
k = unw64 - (static_cast<vluint64_t>(m_value[j])
* static_cast<vluint64_t>(rhs.m_value[0]));
}
UINFO(9, " opmoddiv-1w "<<lhs<<" "<<rhs<<" q="<<*this<<" rem=0x"<<std::hex<<k<<std::dec<<endl);
if (is_modulus) { setZero(); m_value[0] = k; }
@ -1536,9 +1539,10 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
// Main loop
for (int j = uw - vw; j >= 0; j--) {
// Estimate
vluint64_t unw64 = ((vluint64_t)(un[j+vw])<<VL_ULL(32) | (vluint64_t)(un[j+vw-1]));
vluint64_t qhat = unw64 / (vluint64_t)(vn[vw-1]);
vluint64_t rhat = unw64 - qhat*(vluint64_t)(vn[vw-1]);
vluint64_t unw64 = (static_cast<vluint64_t>(un[j+vw])<<VL_ULL(32)
| static_cast<vluint64_t>(un[j+vw-1]));
vluint64_t qhat = unw64 / static_cast<vluint64_t>(vn[vw-1]);
vluint64_t rhat = unw64 - qhat*static_cast<vluint64_t>(vn[vw-1]);
again:
if (qhat >= VL_ULL(0x100000000)
@ -1565,7 +1569,7 @@ V3Number& V3Number::opModDivGuts(const V3Number& lhs, const V3Number& rhs, bool
this->m_value[j]--;
k = 0;
for (int i=0; i<vw; i++) {
t = (vluint64_t)(un[i+j]) + (vluint64_t)(vn[i]) + k;
t = static_cast<vluint64_t>(un[i+j]) + static_cast<vluint64_t>(vn[i]) + k;
un[i+j] = t;
k = t >> VL_ULL(32);
}
@ -1684,15 +1688,15 @@ V3Number& V3Number::opSel(const V3Number& lhs, const V3Number& msb, const V3Numb
V3Number& V3Number::opSel(const V3Number& lhs, uint32_t msbval, uint32_t lsbval) {
setZero();
int ibit=lsbval;
int ibit = lsbval;
for(int bit=0; bit<this->width(); bit++) {
if (ibit>=0 && ibit<lhs.width()
&& ibit<=(int)msbval) {
setBit(bit,lhs.bitIs(ibit));
&& ibit <= static_cast<int>(msbval)) {
setBit(bit, lhs.bitIs(ibit));
} else {
setBit(bit,'x');
setBit(bit, 'x');
}
ibit++;
++ibit;
}
//UINFO(0,"RANGE "<<lhs<<" "<<msb<<" "<<lsb<<" = "<<*this<<endl);
return *this;
@ -1743,12 +1747,12 @@ V3Number& V3Number::opIToRD(const V3Number& lhs) {
}
V3Number& V3Number::opRToIS(const V3Number& lhs) {
double v = VL_TRUNC(lhs.toDouble());
vlsint32_t i = (vlsint32_t)v; // C converts from double to vlsint32
vlsint32_t i = static_cast<vlsint32_t>(v); // C converts from double to vlsint32
return setLongS(i);
}
V3Number& V3Number::opRToIRoundS(const V3Number& lhs) {
double v = VL_ROUND(lhs.toDouble());
vlsint32_t i = (vlsint32_t)v; // C converts from double to vlsint32
vlsint32_t i = static_cast<vlsint32_t>(v); // C converts from double to vlsint32
return setLongS(i);
}
V3Number& V3Number::opRealToBits(const V3Number& lhs) {

28
src/V3Number.h
View File

@ -134,9 +134,9 @@ public:
explicit V3Number(FileLine* fileline) { init(fileline, 1); }
V3Number(FileLine* fileline, int width) { init(fileline, width); } // 0=unsized
V3Number(FileLine* fileline, int width, uint32_t value) { init(fileline, width); m_value[0]=value; opCleanThis(); }
V3Number(FileLine* fileline, const char* source); // Create from a verilog 32'hxxxx number.
class VerilogStringLiteral {}; // for creator type-overload selection
V3Number(VerilogStringLiteral, FileLine* fileline, const string& vvalue);
V3Number(FileLine* fileline, const char* sourcep); // Create from a verilog 32'hxxxx number.
class VerilogStringLiteral {}; // For creator type-overload selection
V3Number(VerilogStringLiteral, FileLine* fileline, const string& str);
class String {};
V3Number(String, FileLine* fileline, const string& value) { init(fileline, 0); setString(value); }
@ -173,7 +173,7 @@ public:
// ACCESSORS
string ascii(bool prefixed=true, bool cleanVerilog=false) const;
static string quoteNameControls(const string& namein); // Add backslash quotes to strings
string displayed(FileLine* fl, const string& format) const;
string displayed(FileLine* fl, const string& vformat) const;
static bool displayedFmtLegal(char format); // Is this a valid format letter?
int width() const { return m_width; }
int widthMin() const; // Minimum width that can represent this number (~== log2(num)+1)
@ -194,9 +194,9 @@ public:
bool isBitsZero(int msb, int lsb) const;
bool isEqOne() const;
bool isEqAllOnes(int optwidth=0) const;
bool isCaseEq(const V3Number& rhsp) const; // operator==
bool isLt(const V3Number& rhsp) const; // operator<
bool isLtXZ(const V3Number& rhsp) const; // operator< with XZ compared
bool isCaseEq(const V3Number& rhs) const; // operator==
bool isLt(const V3Number& rhs) const; // operator<
bool isLtXZ(const V3Number& rhs) const; // operator< with XZ compared
void isSigned(bool ssigned) { m_signed=ssigned; }
bool isUnknown() const;
uint32_t toUInt() const;
@ -246,18 +246,18 @@ public:
V3Number& opConcat (const V3Number& lhs, const V3Number& rhs);
V3Number& opLenN (const V3Number& lhs);
V3Number& opRepl (const V3Number& lhs, const V3Number& rhs);
V3Number& opRepl (const V3Number& lhs, uint32_t rhs);
V3Number& opRepl (const V3Number& lhs, uint32_t rhsval);
V3Number& opStreamL (const V3Number& lhs, const V3Number& rhs);
V3Number& opSel (const V3Number& lhs, const V3Number& rhs, const V3Number& ths);
V3Number& opSel (const V3Number& lhs, uint32_t rhs, uint32_t ths);
V3Number& opSel (const V3Number& lhs, const V3Number& msb, const V3Number& lsb);
V3Number& opSel (const V3Number& lhs, uint32_t msbval, uint32_t lsbval);
V3Number& opSelInto (const V3Number& lhs, const V3Number& lsb, int width);
V3Number& opSelInto (const V3Number& lhs, int lsb, int width);
V3Number& opCond (const V3Number& lhs, const V3Number& rhs, const V3Number& ths);
V3Number& opSelInto (const V3Number& lhs, int lsbval, int width);
V3Number& opCond (const V3Number& lhs, const V3Number& if1s, const V3Number& if0s);
V3Number& opCaseEq (const V3Number& lhs, const V3Number& rhs);
V3Number& opCaseNeq (const V3Number& lhs, const V3Number& rhs);
V3Number& opWildEq (const V3Number& lhs, const V3Number& rhs);
V3Number& opWildNeq (const V3Number& lhs, const V3Number& rhs);
V3Number& opBufIf1 (const V3Number& lhs, const V3Number& rhs);
V3Number& opBufIf1 (const V3Number& ens, const V3Number& if1s);
// "standard" math
V3Number& opNot (const V3Number& lhs);
V3Number& opLogNot (const V3Number& lhs);
@ -324,7 +324,7 @@ public:
// "N" - string operations
V3Number& opConcatN (const V3Number& lhs, const V3Number& rhs);
V3Number& opReplN (const V3Number& lhs, const V3Number& rhs);
V3Number& opReplN (const V3Number& lhs, uint32_t rhs);
V3Number& opReplN (const V3Number& lhs, uint32_t rhsval);
V3Number& opEqN (const V3Number& lhs, const V3Number& rhs);
V3Number& opNeqN (const V3Number& lhs, const V3Number& rhs);
V3Number& opGtN (const V3Number& lhs, const V3Number& rhs);

4
src/V3Number_test.cpp
View File

@ -87,6 +87,10 @@ void test(const string& lhss, const string& op, const string& rhss, const string
if (ok.toUInt()!=1) {
v3fatalSrc("%Error:Test FAILED");
}
free(l1);
free(r1);
free(e1);
}
int main() {

11
src/V3Options.cpp
View File

@ -248,7 +248,7 @@ string V3Options::allArgsString() {
V3LangCode::V3LangCode(const char* textp) {
// Return code for given string, or ERROR, which is a bad code
for (int codei=V3LangCode::L_ERROR; codei<V3LangCode::_ENUM_END; ++codei) {
V3LangCode code = (V3LangCode)codei;
V3LangCode code = V3LangCode(codei);
if (0==strcasecmp(textp,code.ascii())) {
m_e = code; return;
}
@ -260,7 +260,8 @@ V3LangCode::V3LangCode(const char* textp) {
// File searching
bool V3Options::fileStatDir(const string& filename) {
struct stat sstat; // Stat information
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct stat sstat; // Stat information
int err = stat(filename.c_str(), &sstat);
if (err!=0) return false;
if (!S_ISDIR(sstat.st_mode)) return false;
@ -268,7 +269,8 @@ bool V3Options::fileStatDir(const string& filename) {
}
bool V3Options::fileStatNormal(const string& filename) {
struct stat sstat; // Stat information
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct stat sstat; // Stat information
int err = stat(filename.c_str(), &sstat);
if (err!=0) return false;
if (S_ISDIR(sstat.st_mode)) return false;
@ -450,6 +452,7 @@ string V3Options::getenvSYSTEMC_ARCH() {
string sysname = "WIN32";
var = "win32";
#else
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
struct utsname uts;
uname(&uts);
string sysname = VString::downcase(uts.sysname); // aka 'uname -s'
@ -1164,7 +1167,7 @@ void V3Options::parseOptsFile(FileLine* fl, const string& filename, bool rel) {
// Convert to argv style arg list and parse them
char* argv [args.size()+1];
for (unsigned i=0; i<args.size(); ++i) {
argv[i] = (char*)args[i].c_str();
argv[i] = const_cast<char*>(args[i].c_str());
}
parseOptsList(fl, optdir, args.size(), argv);
}

10
src/V3Options.h
View File

@ -27,10 +27,10 @@
#include "V3Global.h"
#include "V3LangCode.h"
#include <string>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <vector>
class V3OptionsImp;
class FileLine;
@ -214,7 +214,7 @@ class V3Options {
private:
// METHODS
void addArg(const string& flag);
void addArg(const string& arg);
void addDefine(const string& defline, bool allowPlus);
void addFuture(const string& flag);
void addIncDirUser(const string& incdir); // User requested
@ -238,9 +238,9 @@ class V3Options {
~V3Options();
void setDebugMode(int level);
void setDebugSrcLevel(const string& srcfile, int level);
int debugSrcLevel(const string& srcfile, int default_level=V3Error::debugDefault());
int debugSrcLevel(const string& srcfile_path, int default_level=V3Error::debugDefault());
void setDumpTreeLevel(const string& srcfile, int level);
int dumpTreeLevel(const string& srcfile);
int dumpTreeLevel(const string& srcfile_path);
// METHODS
void addCppFile(const string& filename);

19
src/V3Order.cpp
View File

@ -749,7 +749,7 @@ private:
m_orderUserps.push_back(newup);
varscp->user1p(newup);
}
OrderUser* up = (OrderUser*)(varscp->user1p());
OrderUser* up = reinterpret_cast<OrderUser*>(varscp->user1p());
OrderVarVertex* varVxp = up->newVarUserVertex(&m_graph, m_scopep, varscp, type, createdp);
return varVxp;
}
@ -1059,7 +1059,8 @@ private:
// clock_enable attribute: user's worring about it for us
con = false;
}
if (m_inClkAss && (varscp->varp()->attrClocker()) != AstVarAttrClocker::CLOCKER_YES) {
if (m_inClkAss && (varscp->varp()->attrClocker()
!= AstVarAttrClocker::CLOCKER_YES)) {
con = false;
UINFO(4, "nodep used as clock_enable "<<varscp<<" in "<<m_logicVxp->nodep()<<endl);
}
@ -1087,10 +1088,12 @@ private:
} else {
// If the lhs is a clocker, avoid marking that as circular by
// putting a hard edge instead of normal cuttable
if (varscp->varp()->attrClocker() == AstVarAttrClocker::CLOCKER_YES)
if (varscp->varp()->attrClocker()
== AstVarAttrClocker::CLOCKER_YES) {
new OrderEdge(&m_graph, m_logicVxp, varVxp, WEIGHT_NORMAL);
else
} else {
new OrderComboCutEdge(&m_graph, m_logicVxp, varVxp);
}
}
// For m_inPost:
// Add edge consumed_var_POST->logic_vertex
@ -1354,7 +1357,7 @@ void OrderVisitor::processInputsInIterate(OrderEitherVertex* vertexp, VertexVec&
// Also, determine if this vertex is an input
int inonly = 1; // 0=no, 1=maybe, 2=yes until a no
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep=edgep->inNextp()) {
OrderEitherVertex* frVertexp = (OrderEitherVertex*)edgep->fromp();
OrderEitherVertex* frVertexp = static_cast<OrderEitherVertex*>(edgep->fromp());
processInputsInIterate(frVertexp, todoVec);
if (frVertexp->isFromInput()) {
if (inonly==1) inonly = 2;
@ -1393,7 +1396,7 @@ void OrderVisitor::processInputsOutIterate(OrderEitherVertex* vertexp, VertexVec
{
// Propagate PrimaryIn through simple assignments, followint target of vertex
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
OrderEitherVertex* toVertexp = (OrderEitherVertex*)edgep->top();
OrderEitherVertex* toVertexp = static_cast<OrderEitherVertex*>(edgep->top());
if (OrderVarStdVertex* vvertexp = dynamic_cast<OrderVarStdVertex*>(toVertexp)) {
processInputsInIterate(vvertexp, todoVec);
}
@ -1506,7 +1509,7 @@ void OrderVisitor::processDomainsIterate(OrderEitherVertex* vertexp) {
}
if (!domainp) {
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
OrderEitherVertex* fromVertexp = (OrderEitherVertex*)edgep->fromp();
OrderEitherVertex* fromVertexp = static_cast<OrderEitherVertex*>(edgep->fromp());
if (edgep->weight()
&& fromVertexp->domainMatters()
) {
@ -1721,7 +1724,7 @@ void OrderVisitor::processMoveDoneOne(OrderMoveVertex* vertexp) {
// Mark our outputs as one closer to ready
for (V3GraphEdge* edgep = vertexp->outBeginp(), *nextp; edgep; edgep=nextp) {
nextp = edgep->outNextp();
OrderMoveVertex* toVertexp = (OrderMoveVertex*)edgep->top();
OrderMoveVertex* toVertexp = static_cast<OrderMoveVertex*>(edgep->top());
UINFO(9," Clear to "<<(toVertexp->inEmpty()?"[EMP] ":" ")
<<toVertexp<<endl);
// Delete this edge

1
src/V3Os.cpp
View File

@ -208,6 +208,7 @@ uint64_t V3Os::timeUsecs() {
#if defined(_WIN32) || defined(__MINGW32__)
return 0;
#else
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
timeval tv;
if (gettimeofday(&tv, NULL) < 0) return 0;
return static_cast<uint64_t>(tv.tv_sec)*1000000 + tv.tv_usec;

2
src/V3Os.h
View File

@ -43,7 +43,7 @@ public:
return filenameNonExt(filenameNonDir(filename)); }
static string filenameDir(const string& filename); ///< Return directory part of filename
static string filenameSubstitute(const string& filename); ///< Return filename with env vars removed
static string filenameRealPath(const string& fn); ///< Return realpath of filename
static string filenameRealPath(const string& filename); ///< Return realpath of filename
static bool filenameIsRel(const string& filename); ///< True if relative
// METHODS (directory utilities)

33
src/V3Param.cpp
View File

@ -618,25 +618,26 @@ void ParamVisitor::visitCell(AstCell* nodep) {
&& VN_IS(exprp, VarRef)
&& VN_CAST(exprp, VarRef)->varp()
&& VN_CAST(exprp, VarRef)->varp()->subDTypep()
&& VN_IS(VN_CAST(exprp, VarRef)->varp()->subDTypep(), IfaceRefDType))
&& VN_IS(VN_CAST(exprp, VarRef)->varp()->subDTypep(), IfaceRefDType)) {
pinIrefp = VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), IfaceRefDType);
else if (exprp
&& exprp->op1p()
&& VN_IS(exprp->op1p(), VarRef)
&& VN_CAST(exprp->op1p(), VarRef)->varp()
&& VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep()
&& VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)
&& VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep()
&& VN_CAST(VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType))
} else if (exprp
&& exprp->op1p()
&& VN_IS(exprp->op1p(), VarRef)
&& VN_CAST(exprp->op1p(), VarRef)->varp()
&& VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep()
&& VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)
&& VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep()
&& VN_CAST(VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType)) {
pinIrefp = VN_CAST(VN_CAST(VN_CAST(exprp->op1p(), VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType);
else if (exprp
&& VN_IS(exprp, VarRef)
&& VN_CAST(exprp, VarRef)->varp()
&& VN_CAST(exprp, VarRef)->varp()->subDTypep()
&& VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)
&& VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep()
&& VN_CAST(VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType))
} else if (exprp
&& VN_IS(exprp, VarRef)
&& VN_CAST(exprp, VarRef)->varp()
&& VN_CAST(exprp, VarRef)->varp()->subDTypep()
&& VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)
&& VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep()
&& VN_CAST(VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType)) {
pinIrefp = VN_CAST(VN_CAST(VN_CAST(exprp, VarRef)->varp()->subDTypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType);
}
UINFO(9," portIfaceRef "<<portIrefp<<endl);

2
src/V3ParseImp.cpp
View File

@ -164,7 +164,7 @@ void V3ParseImp::lexFile(const string& modname) {
s_parsep = this;
fileline()->warnResetDefault(); // Reenable warnings on each file
lexDestroy(); // Restart from clean slate.
lexNew(debugFlex()>=9);
lexNew();
// Lex it
if (bisonParse()) v3fatal("Cannot continue\n");

2
src/V3ParseImp.h
View File

@ -200,7 +200,7 @@ public:
int bisonParse();
// Interactions with lexer
void lexNew(int debug);
void lexNew();
void lexDestroy();
void statePop(); // Parser -> lexer communication
static int stateVerilogRecent(); // Parser -> lexer communication

23
src/V3ParseLex.cpp
View File

@ -47,19 +47,22 @@ public:
~V3Lexer() {}
// METHODS
void statePop() {
yy_pop_state();
yy_pop_state();
}
void unputString(const char* textp, size_t length) {
// Add characters to input stream in back-to-front order
const char* cp = textp;
for (cp += length - 1; length--; cp--) {
unput(*cp);
}
// Add characters to input stream in back-to-front order
const char* cp = textp;
for (cp += length - 1; length--; cp--) {
unput(*cp);
}
}
};
void V3ParseImp::statePop() { parsep()->m_lexerp->statePop(); }
void V3ParseImp::unputString(const char* textp, size_t length) { parsep()->m_lexerp->unputString(textp, length); }
void V3ParseImp::statePop() { parsep()->m_lexerp->statePop(); }
void V3ParseImp::unputString(const char* textp, size_t length) {
parsep()->m_lexerp->unputString(textp, length);
}
int V3ParseImp::yylexReadTok() {
// Call yylex() remembering last non-whitespace token
@ -71,8 +74,8 @@ int V3ParseImp::yylexReadTok() {
//######################################################################
// Read class functions
void V3ParseImp::lexNew(int debug) {
if (m_lexerp) delete m_lexerp; // Restart from clean slate.
void V3ParseImp::lexNew() {
if (m_lexerp) delete m_lexerp; // Restart from clean slate.
m_lexerp = new V3Lexer();
if (debugFlex()>=9) { m_lexerp->set_debug(~0); }
}

15
src/V3Partition.cpp
View File

@ -551,7 +551,7 @@ public:
logcost = ceil(logcost);
logcost = logcost / 20.0;
uint32_t stepCost = (uint32_t)(exp(logcost));
uint32_t stepCost = static_cast<uint32_t>(exp(logcost));
UASSERT_STATIC(stepCost >= cost, "stepped cost error exceeded");
UASSERT_STATIC(stepCost <= ((cost * 11 / 10)), "stepped cost error exceeded");
return stepCost;
@ -822,8 +822,7 @@ class MTaskEdge : public V3GraphEdge, public MergeCandidate {
public:
// CONSTRUCTORS
MTaskEdge(V3Graph* graphp, LogicMTask* fromp, LogicMTask* top, int weight)
: V3GraphEdge(graphp, fromp, top, weight),
MergeCandidate() {
: V3GraphEdge(graphp, fromp, top, weight) {
fromp->addRelative(GraphWay::FORWARD, top);
top->addRelative(GraphWay::REVERSE, fromp);
}
@ -2204,10 +2203,10 @@ private:
public:
// CONSTRUCTORS
PartPackMTasks(V3Graph* mtasksp,
uint32_t nThreads = v3Global.opt.threads(),
unsigned sandbagNumerator = 30,
unsigned sandbagDenom = 100)
explicit PartPackMTasks(V3Graph* mtasksp,
uint32_t nThreads = v3Global.opt.threads(),
unsigned sandbagNumerator = 30,
unsigned sandbagDenom = 100)
: m_mtasksp(mtasksp)
, m_nThreads(nThreads)
, m_sandbagNumerator(sandbagNumerator)
@ -2296,6 +2295,7 @@ public:
<<" on thread "<<th<<endl);
if ((timeBegin < bestTime)
|| ((timeBegin == bestTime)
&& bestMtaskp // Redundant, but appeases static analysis tools
&& (taskp->priority() > bestMtaskp->priority()))) {
bestTime = timeBegin;
bestTh = th;
@ -2304,6 +2304,7 @@ public:
}
}
if (!bestMtaskp) v3fatalSrc("Should have found some task");
UINFO(6, "Will schedule "<<bestMtaskp->name()
<<" onto thread "<<bestTh<<endl);
uint32_t bestEndTime = bestTime + bestMtaskp->cost();

2
src/V3Partition.h
View File

@ -60,7 +60,7 @@ public:
static void hashGraphDebug(const V3Graph* graphp, const char* debugName);
// Print debug stats about graphp whose nodes must be AbstractMTask's.
static void debugMTaskGraphStats(const V3Graph* graphp, const string& name);
static void debugMTaskGraphStats(const V3Graph* graphp, const string& stage);
// Operate on the final ExecMTask graph, immediately prior to code
// generation time.

37
src/V3PreProc.cpp
View File

@ -230,11 +230,11 @@ public:
string getline();
void insertUnreadback(const string& text) { m_lineCmt += text; }
void insertUnreadbackAtBol(const string& text);
void addLineComment(int enter_exit_level);
void addLineComment(int enterExit);
// METHODS, callbacks
virtual void comment(const string& cmt); // Comment detected (if keepComments==2)
virtual void include(const string& filename); // Request a include file be processed
virtual void comment(const string& text); // Comment detected (if keepComments==2)
virtual void include(const string& filename); // Request a include file be processed
virtual void undef(const string& name);
virtual void undefineall();
virtual void define(FileLine* fl, const string& name, const string& value,
@ -242,7 +242,7 @@ public:
virtual string removeDefines(const string& text); // Remove defines in a text string
// CONSTRUCTORS
V3PreProcImp() : V3PreProc() {
V3PreProcImp() {
m_debug = 0;
m_states.push(ps_TOP);
m_off = 0;
@ -299,8 +299,7 @@ void V3PreProcImp::undefineall() {
}
bool V3PreProcImp::defExists(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
if (iter == m_defines.end()) return false;
return true;
return (iter != m_defines.end());
}
string V3PreProcImp::defValue(const string& name) {
DefinesMap::iterator iter = m_defines.find(name);
@ -338,9 +337,9 @@ void V3PreProcImp::define(FileLine* fl, const string& name, const string& value,
m_defines.insert(make_pair(name, V3Define(fl, value, params, cmdline)));
}
string V3PreProcImp::removeDefines(const string& sym) {
string V3PreProcImp::removeDefines(const string& text) {
string val = "0_never_match";
string rtnsym = sym;
string rtnsym = text;
for (int loopprevent=0; loopprevent<100; loopprevent++) {
string xsym = rtnsym;
if (xsym.substr(0,1)=="`") xsym.replace(0,1,"");
@ -793,9 +792,9 @@ void V3PreProcImp::insertUnreadbackAtBol(const string& text) {
insertUnreadback(text);
}
void V3PreProcImp::addLineComment(int enter_exit_level) {
void V3PreProcImp::addLineComment(int enterExit) {
if (lineDirectives()) {
insertUnreadbackAtBol(m_lexp->curFilelinep()->lineDirectiveStrg(enter_exit_level));
insertUnreadbackAtBol(m_lexp->curFilelinep()->lineDirectiveStrg(enterExit));
}
}
@ -854,7 +853,8 @@ void V3PreProcImp::debugToken(int tok, const char* cmtp) {
while ((pos = buf.find('\r')) != string::npos) { buf.replace(pos, 1, "\\r"); }
fprintf(stderr, "%d: %s %s %s(%d) dr%d: <%d>%-10s: %s\n",
m_lexp->m_tokFilelinep->lineno(), cmtp, m_off?"of":"on",
procStateName(state()), (int)m_states.size(), (int)m_defRefs.size(),
procStateName(state()), static_cast<int>(m_states.size()),
static_cast<int>(m_defRefs.size()),
m_lexp->currentStartState(), tokenName(tok), buf.c_str());
}
}
@ -889,7 +889,9 @@ int V3PreProcImp::getStateToken() {
// We're off or processed the comment specially. If there are newlines
// in it, we also return the newlines as TEXT so that the linenumber
// count is maintained for downstream tools
for (size_t len=0; len<(size_t)yyourleng(); len++) { if (yyourtext()[len]=='\n') m_lineAdd++; }
for (size_t len=0; len<static_cast<size_t>(yyourleng()); len++) {
if (yyourtext()[len]=='\n') m_lineAdd++;
}
goto next_tok;
}
if (tok==VP_LINE) {
@ -1416,11 +1418,14 @@ int V3PreProcImp::getFinalToken(string& buf) {
if (m_finAtBol && !(tok==VP_TEXT && buf=="\n")
&& m_preprocp->lineDirectives()) {
if (int outBehind = m_lexp->m_tokFilelinep->lineno() - m_finFilelinep->lineno()) {
if (debug()>=5) fprintf(stderr,"%d: FIN: readjust, fin at %d request at %d\n",
m_lexp->m_tokFilelinep->lineno(),
m_finFilelinep->lineno(), m_lexp->m_tokFilelinep->lineno());
if (debug()>=5) {
fprintf(stderr, "%d: FIN: readjust, fin at %d request at %d\n",
m_lexp->m_tokFilelinep->lineno(),
m_finFilelinep->lineno(), m_lexp->m_tokFilelinep->lineno());
}
m_finFilelinep = m_finFilelinep->create(m_lexp->m_tokFilelinep->filename(),m_lexp->m_tokFilelinep->lineno());
if (outBehind > 0 && outBehind <= (int)V3PreProc::NEWLINES_VS_TICKLINE) {
if (outBehind > 0
&& (outBehind <= static_cast<int>(V3PreProc::NEWLINES_VS_TICKLINE))) {
// Output stream is behind, send newlines to get back in sync
// (Most likely because we're completing a disabled `endif)
if (m_preprocp->keepWhitespace()) {

2
src/V3PreProc.h
View File

@ -100,7 +100,7 @@ protected:
};
void configure(FileLine* fl);
public:
static V3PreProc* createPreProc(FileLine* fileline);
static V3PreProc* createPreProc(FileLine* fl);
virtual ~V3PreProc() {}
};

6
src/V3PreShell.h
View File

@ -36,9 +36,9 @@ class V3PreShell {
// Static class for calling preprocessor
public:
static void boot(char** env);
static bool preproc(FileLine* fileline, const string& module, V3InFilter* filterp,
V3ParseImp* parsep, const string& errmsg);
static void preprocInclude(FileLine* fileline, const string& module);
static bool preproc(FileLine* fl, const string& modname, V3InFilter* filterp,
V3ParseImp* parsep, const string& errmsg);
static void preprocInclude(FileLine* fl, const string& modname);
static string dependFiles() { return ""; } // Perl only
static void defineCmdLine(const string& name, const string& value);
static void undef(const string& name);

4
src/V3Scope.cpp
View File

@ -106,7 +106,9 @@ private:
UINFO(4," MOD AT "<<scopename<<" "<<nodep<<endl);
AstNode::user1ClearTree();
m_scopep = new AstScope((m_aboveCellp?(AstNode*)m_aboveCellp:(AstNode*)nodep)->fileline(),
m_scopep = new AstScope((m_aboveCellp ? static_cast<AstNode*>(m_aboveCellp)
: static_cast<AstNode*>(nodep))
->fileline(),
nodep, scopename, m_aboveScopep, m_aboveCellp);
if (VN_IS(nodep, Package)) m_packageScopes.insert(make_pair(VN_CAST(nodep, Package), m_scopep));

8
src/V3Slice.cpp
View File

@ -226,10 +226,10 @@ class SliceVisitor : public AstNVisitor {
public:
// CONSTUCTORS
explicit SliceVisitor(AstNetlist* rootp) {
explicit SliceVisitor(AstNetlist* nodep) {
m_assignp = NULL;
m_assignError = false;
iterate(rootp);
iterate(nodep);
}
virtual ~SliceVisitor() {}
};
@ -237,10 +237,10 @@ public:
//######################################################################
// Link class functions
void V3Slice::sliceAll(AstNetlist* rootp) {
void V3Slice::sliceAll(AstNetlist* nodep) {
UINFO(2,__FUNCTION__<<": "<<endl);
{
SliceVisitor visitor(rootp);
SliceVisitor visitor(nodep);
} // Destruct before checking
V3Global::dumpCheckGlobalTree("slice", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
}

39
src/V3Split.cpp
View File

@ -183,8 +183,7 @@ public:
static bool followCyclic(const V3GraphEdge* edgep) {
const SplitEdge* oedgep = dynamic_cast<const SplitEdge*>(edgep);
if (!oedgep) v3fatalSrc("Following edge of non-SplitEdge type");
if (oedgep->ignoreThisStep()) return false;
return true;
return (!oedgep->ignoreThisStep());
}
virtual string dotStyle() const {
return ignoreThisStep() ? "dotted" : V3GraphEdge::dotStyle();
@ -335,7 +334,7 @@ protected:
if (!vertexp->outBeginp()
&& dynamic_cast<SplitVarStdVertex*>(vertexp)) {
if (debug() >= 9) {
SplitVarStdVertex* stdp = (SplitVarStdVertex*)(vertexp);
SplitVarStdVertex* stdp = static_cast<SplitVarStdVertex*>(vertexp);
UINFO(0, "Will prune deps on var "<<stdp->nodep()<<endl);
stdp->nodep()->dumpTree(cout, "- ");
}
@ -388,10 +387,10 @@ protected:
// Create vertexes for variable
if (!vscp->user1p()) {
SplitVarStdVertex* vstdp = new SplitVarStdVertex(&m_graph, vscp);
SplitVarStdVertex* vstdp = new SplitVarStdVertex(&m_graph, vscp);
vscp->user1p(vstdp);
}
SplitVarStdVertex* vstdp = (SplitVarStdVertex*) vscp->user1p();
SplitVarStdVertex* vstdp = reinterpret_cast<SplitVarStdVertex*>(vscp->user1p());
// SPEEDUP: We add duplicate edges, that should be fixed
if (m_inDly && nodep->lvalue()) {
@ -402,7 +401,8 @@ protected:
vscp->user2p(vpostp);
new SplitPostEdge(&m_graph, vstdp, vpostp);
}
SplitVarPostVertex* vpostp = (SplitVarPostVertex*)vscp->user2p();
SplitVarPostVertex* vpostp
= reinterpret_cast<SplitVarPostVertex*>(vscp->user2p());
// Add edges
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); ++it) {
new SplitLVEdge(&m_graph, vpostp, *it);
@ -451,11 +451,9 @@ private:
class ReorderVisitor : public SplitReorderBaseVisitor {
// CONSTRUCTORS
public:
explicit ReorderVisitor(AstNetlist* nodep)
: SplitReorderBaseVisitor() {
iterate(nodep);
}
explicit ReorderVisitor(AstNetlist* nodep) {
iterate(nodep);
}
virtual ~ReorderVisitor() {}
// METHODS
@ -480,7 +478,7 @@ protected:
// Vertex::m_user begin: true indicates logic for this step
m_graph.userClearVertices();
for (AstNode* nextp=nodep; nextp; nextp=nextp->nextp()) {
SplitLogicVertex* vvertexp = (SplitLogicVertex*)nextp->user3p();
SplitLogicVertex* vvertexp = reinterpret_cast<SplitLogicVertex*>(nextp->user3p());
vvertexp->user(true);
}
@ -513,7 +511,7 @@ protected:
// Add hard orderings between all nodes of same color, in the order they appeared
vl_unordered_map<uint32_t, SplitLogicVertex*> lastOfColor;
for (AstNode* nextp=nodep; nextp; nextp=nextp->nextp()) {
SplitLogicVertex* vvertexp = (SplitLogicVertex*)nextp->user3p();
SplitLogicVertex* vvertexp = reinterpret_cast<SplitLogicVertex*>(nextp->user3p());
uint32_t color = vvertexp->color();
if (!color) nextp->v3fatalSrc("No node color assigned");
if (lastOfColor[color]) {
@ -539,7 +537,7 @@ protected:
RankNodeMap rankMap;
int currOrder = 0; // Existing sequence number of assignment
for (AstNode* nextp=nodep; nextp; nextp=nextp->nextp()) {
SplitLogicVertex* vvertexp = (SplitLogicVertex*)nextp->user3p();
SplitLogicVertex* vvertexp = reinterpret_cast<SplitLogicVertex*>(nextp->user3p());
rankMap.insert(make_pair(vvertexp->rank(), nextp));
nextp->user4(++currOrder); // Record current ordering
}
@ -593,9 +591,11 @@ protected:
cleanupBlockGraph(nodep);
reorderBlock(nodep);
// Delete old vertexes and edges only applying to this block
while (firstp->backp()->nextp()==firstp) firstp = firstp->backp(); // Walk back to first in list
// First, walk back to first in list
while (firstp->backp()->nextp()==firstp) firstp = firstp->backp();
for (AstNode* nextp=firstp; nextp; nextp=nextp->nextp()) {
SplitLogicVertex* vvertexp = (SplitLogicVertex*)nextp->user3p();
SplitLogicVertex* vvertexp
= reinterpret_cast<SplitLogicVertex*>(nextp->user3p());
vvertexp->unlinkDelete(&m_graph);
}
}
@ -662,7 +662,7 @@ protected:
virtual void visit(AstNode* nodep) {
if (nodep->user3p()) {
SplitLogicVertex* vertexp = (SplitLogicVertex*)(nodep->user3p());
SplitLogicVertex* vertexp = reinterpret_cast<SplitLogicVertex*>(nodep->user3p());
uint32_t color = vertexp->color();
m_colors.insert(color);
UINFO(8, " SVL " << vertexp << " has color " << color << "\n");
@ -754,7 +754,7 @@ protected:
if (!nodep->user3p()) nodep->v3fatalSrc("null user3p in V3Split leaf");
// Clone the leaf into its new always block
SplitLogicVertex* vxp = (SplitLogicVertex*)(nodep->user3p());
SplitLogicVertex* vxp = reinterpret_cast<SplitLogicVertex*>(nodep->user3p());
uint32_t color = vxp->color();
AstNode* clonedp = nodep->cloneTree(false);
m_addAfter[color]->addNextHere(clonedp);
@ -846,8 +846,7 @@ private:
// CONSTRUCTORS
public:
explicit SplitVisitor(AstNetlist* nodep)
: SplitReorderBaseVisitor()
, m_curIfConditional(NULL) {
: m_curIfConditional(NULL) {
iterate(nodep);
// Splice newly-split blocks into the tree. Remove placeholders

2
src/V3StatsReport.cpp
View File

@ -48,7 +48,7 @@ class StatsReport {
os<<endl;
os<<"Information:"<<endl;
os<<" "<<v3Global.opt.version()<<endl;
os<<" "<<V3Options::version()<<endl;
os<<" Arguments: "<<v3Global.opt.allArgsString()<<endl;
os<<endl;
}

45
src/V3String.cpp
View File

@ -41,9 +41,11 @@ inline bool VString::wildmatchi(const char* s, const char* p) {
else {
// Trailing star matches everything.
if (!*++p) return true;
while (wildmatch(s, p) == false)
if (*++s == '\0')
return false;
while (!wildmatch(s, p)) {
if (*++s == '\0') {
return false;
}
}
return true;
}
}
@ -59,9 +61,11 @@ bool VString::wildmatch(const char* s, const char* p) {
else {
// Trailing star matches everything.
if (!*++p) return true;
while (wildmatchi(s, p) == false)
if (*++s == '\0')
return false;
while (!wildmatchi(s, p)) {
if (*++s == '\0') {
return false;
}
}
return true;
}
}
@ -149,15 +153,15 @@ void VHashSha1::insert(const void* datap, size_t length) {
int chunkLen;
const uint8_t* chunkp;
if (m_remainder=="") {
chunkLen = length;
chunkp = (const uint8_t*)datap;
chunkLen = length;
chunkp = static_cast<const uint8_t*>(datap);
} else {
// If there are large inserts it would be more efficient to avoid this copy
// by copying bytes in the loop below from either m_remainder or the data
// as appropriate.
tempData = m_remainder + string((const char*)datap,length);
chunkLen = tempData.length();
chunkp = (const uint8_t*)tempData.data();
tempData = m_remainder + string(static_cast<const char*>(datap), length);
chunkLen = tempData.length();
chunkp = reinterpret_cast<const uint8_t*>(tempData.data());
}
// See wikipedia SHA-1 algorithm summary
@ -170,15 +174,15 @@ void VHashSha1::insert(const void* datap, size_t length) {
posEnd = posBegin + 64;
// 64 byte round input data, being careful to swap on big, keep on little
for (int roundByte = 0; posBegin < posEnd; posBegin += 4) {
w[roundByte++] = ((uint32_t) chunkp[posBegin + 3]
| (((uint32_t) chunkp[posBegin + 2]) << 8)
| (((uint32_t) chunkp[posBegin + 1]) << 16)
| (((uint32_t) chunkp[posBegin]) << 24));
w[roundByte++] = (static_cast<uint32_t>(chunkp[posBegin + 3])
| (static_cast<uint32_t>(chunkp[posBegin + 2]) << 8)
| (static_cast<uint32_t>(chunkp[posBegin + 1]) << 16)
| (static_cast<uint32_t>(chunkp[posBegin]) << 24));
}
sha1Block(m_inthash, w);
}
m_remainder = string((const char*)(chunkp+posBegin), chunkLen-posEnd);
m_remainder = string(reinterpret_cast<const char*>(chunkp+posBegin), chunkLen-posEnd);
}
void VHashSha1::finalize() {
@ -192,7 +196,8 @@ void VHashSha1::finalize() {
for (int i=0; i<16; ++i) w[i] = 0;
size_t blockPos = 0;
for (; blockPos < m_remainder.length(); ++blockPos) {
w[blockPos >> 2] |= ((uint32_t) m_remainder[blockPos]) << ((3 - (blockPos & 3)) << 3);
w[blockPos >> 2] |= ((static_cast<uint32_t>(m_remainder[blockPos]))
<< ((3 - (blockPos & 3)) << 3));
}
w[blockPos >> 2] |= 0x80 << ((3 - (blockPos & 3)) << 3);
if (m_remainder.length() >= 56) {
@ -248,9 +253,9 @@ string VHashSha1::digestSymbol() {
for (; pos < (160/8) - 2; pos += 3) {
out += digits[((binhash[pos] >> 2) & 0x3f)];
out += digits[((binhash[pos] & 0x3) << 4)
| ((int) (binhash[pos + 1] & 0xf0) >> 4)];
| (static_cast<int>(binhash[pos + 1] & 0xf0) >> 4)];
out += digits[((binhash[pos + 1] & 0xf) << 2)
| ((int) (binhash[pos + 2] & 0xc0) >> 6)];
| (static_cast<int>(binhash[pos + 2] & 0xc0) >> 6)];
out += digits[((binhash[pos + 2] & 0x3f))];
}
if (0) { // Not needed for 160 bit hash
@ -260,7 +265,7 @@ string VHashSha1::digestSymbol() {
else {
out += digits[((binhash[pos] >> 2) & 0x3f)];
out += digits[((binhash[pos] & 0x3) << 4)
| ((int) (binhash[pos + 1] & 0xf0) >> 4)];
| (static_cast<int>(binhash[pos + 1] & 0xf0) >> 4)];
out += digits[((binhash[pos + 1] & 0xf) << 2)];
}
return out;

15
src/V3Subst.cpp
View File

@ -83,7 +83,6 @@ public:
// CONSTRUCTORS
explicit SubstVarEntry(AstVar* varp) { // Construction for when a var is used
m_varp = varp;
m_whole.m_use = false;
m_wordAssign = false;
m_wordUse = false;
m_words.resize(varp->widthWords());
@ -116,11 +115,11 @@ public:
m_words[word].m_step = step;
}
}
void assignWordComplex(int step, int word) {
void assignWordComplex(int word) {
if (!wordNumOk(word) || getWordAssignp(word) || m_words[word].m_complex) m_whole.m_complex = true;
m_words[word].m_complex = true;
}
void assignComplex(int step) {
void assignComplex() {
m_whole.m_complex = true;
}
void consumeWhole() { //==consumeComplex as we don't know the difference
@ -187,7 +186,7 @@ private:
// METHODS
SubstVarEntry* findEntryp(AstVarRef* nodep) {
return (SubstVarEntry*)(nodep->varp()->user1p()); // Might be NULL
return reinterpret_cast<SubstVarEntry*>(nodep->varp()->user1p()); // Might be NULL
}
// VISITORS
virtual void visit(AstVarRef* nodep) {
@ -249,7 +248,7 @@ private:
nodep->varp()->user1p(entryp);
return entryp;
} else {
SubstVarEntry* entryp = (SubstVarEntry*)(nodep->varp()->user1p());
SubstVarEntry* entryp = reinterpret_cast<SubstVarEntry*>(nodep->varp()->user1p());
return entryp;
}
}
@ -269,7 +268,7 @@ private:
hit = true;
if (m_ops > SUBST_MAX_OPS_SUBST) {
UINFO(8," ASSIGNtooDeep "<<varrefp<<endl);
entryp->assignComplex(m_assignStep);
entryp->assignComplex();
} else {
UINFO(8," ASSIGNwhole "<<varrefp<<endl);
entryp->assignWhole(m_assignStep, nodep);
@ -285,7 +284,7 @@ private:
hit = true;
if (m_ops > SUBST_MAX_OPS_SUBST) {
UINFO(8," ASSIGNtooDeep "<<varrefp<<endl);
entryp->assignWordComplex(m_assignStep, word);
entryp->assignWordComplex(word);
} else {
UINFO(8," ASSIGNword"<<word<<" "<<varrefp<<endl);
entryp->assignWord(m_assignStep, word, nodep);
@ -346,7 +345,7 @@ private:
SubstVarEntry* entryp = getEntryp(nodep);
if (nodep->lvalue()) {
UINFO(8," ASSIGNcpx "<<nodep<<endl);
entryp->assignComplex(m_assignStep);
entryp->assignComplex();
} else if (AstNode* substp = entryp->substWhole(nodep)) {
// Check that the RHS hasn't changed value since we recorded it.
SubstUseVisitor visitor (substp, entryp->getWholeStep());

4
src/V3TSP.cpp
View File

@ -430,7 +430,7 @@ void V3TSP::tspSort(const V3TSP::StateVec& states, V3TSP::StateVec* resultp) {
// Make this TSP implementation work for graphs of size 0 or 1
// which, unfortunately, is a special case as the following
// code assumes >= 2 nodes.
if (states.size() == 0) {
if (states.empty()) {
return;
}
if (states.size() == 1) {
@ -550,7 +550,7 @@ public:
unsigned xabs, yabs;
xabs = diff(otherp->m_xpos, m_xpos);
yabs = diff(otherp->m_ypos, m_ypos);
return (int)(0.5 + sqrt(xabs*xabs + yabs*yabs));
return lround(sqrt(xabs*xabs + yabs*yabs));
}
unsigned xpos() const {
return m_xpos;

11
src/V3Table.cpp
View File

@ -119,8 +119,8 @@ private:
// Calc data storage in bytes
size_t chgWidth = m_outVarps.size(); // Width of one change-it-vector
if (chgWidth<8) chgWidth = 8;
double space = (pow((double)2,((double)(m_inWidth)))
*(double)(m_outWidth+chgWidth));
double space = (pow(static_cast<double>(2.0), static_cast<double>(m_inWidth))
* static_cast<double>(m_outWidth + chgWidth));
// Instruction count bytes (ok, it's space also not time :)
double bytesPerInst = 4;
double time = (chkvis.instrCount()*bytesPerInst + chkvis.dataCount()) + 1; // +1 so won't div by zero
@ -377,9 +377,10 @@ private:
AstNode* arhsp = new AstArraySel(nodep->fileline(),
new AstVarRef(nodep->fileline(), m_tableVarps[outnum], false),
new AstVarRef(nodep->fileline(), indexVscp, false));
AstNode* outasnp = (m_assignDly
? (AstNode*)(new AstAssignDly(nodep->fileline(), alhsp, arhsp))
: (AstNode*)(new AstAssign(nodep->fileline(), alhsp, arhsp)));
AstNode* outasnp
= (m_assignDly
? static_cast<AstNode*>(new AstAssignDly(nodep->fileline(), alhsp, arhsp))
: static_cast<AstNode*>(new AstAssign(nodep->fileline(), alhsp, arhsp)));
AstNode* outsetp = outasnp;
// Is the value set in only some branches of the table?

12
src/V3Task.cpp
View File

@ -767,7 +767,7 @@ private:
string stmt = "return "+rtnvarp->name()+";\n";
dpip->addStmtsp(new AstCStmt(nodep->fileline(), stmt));
}
makePortList(nodep, rtnvarp, dpip);
makePortList(nodep, dpip);
}
void makeDpiImportProto(AstNodeFTask* nodep, AstVar* rtnvarp) {
@ -789,7 +789,7 @@ private:
dpip->dpiImport(true);
// Add DPI reference to top, since it's a global function
m_topScopep->scopep()->addActivep(dpip);
makePortList(nodep, rtnvarp, dpip);
makePortList(nodep, dpip);
}
bool duplicatedDpiProto(AstNodeFTask* nodep, const string& dpiproto) {
@ -811,7 +811,7 @@ private:
}
}
void makePortList(AstNodeFTask* nodep, AstVar* rtnvarp, AstCFunc* dpip) {
void makePortList(AstNodeFTask* nodep, AstCFunc* dpip) {
// Copy nodep's list of function I/O to the new dpip c function
for (AstNode* stmtp = nodep->stmtsp(); stmtp; stmtp=stmtp->nextp()) {
if (AstVar* portp = VN_CAST(stmtp, Var)) {
@ -963,7 +963,7 @@ private:
rtnvarp->user2p(rtnvscp);
}
string prefix = "";
string prefix;
if (nodep->dpiImport()) prefix = "__Vdpiimwrap_";
else if (nodep->dpiExport()) prefix = "__Vdpiexp_";
else if (ftaskNoInline) prefix = "__VnoInFunc_";
@ -1292,7 +1292,7 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
for (AstNode* stmtp = taskStmtsp; stmtp; stmtp=stmtp->nextp()) {
if (AstVar* portp = VN_CAST(stmtp, Var)) {
if (portp->isIO()) {
tconnects.push_back(make_pair(portp, (AstArg*)NULL));
tconnects.push_back(make_pair(portp, static_cast<AstArg*>(NULL)));
nameToIndex.insert(make_pair(portp->name(), tpinnum)); // For name based connections
tpinnum++;
if (portp->attrSFormat()) {
@ -1330,7 +1330,7 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
} else { // By pin number
if (ppinnum >= tpinnum) {
if (sformatp) {
tconnects.push_back(make_pair(sformatp, (AstArg*)NULL));
tconnects.push_back(make_pair(sformatp, static_cast<AstArg*>(NULL)));
tconnects[ppinnum].second = argp;
tpinnum++;
} else {

4
src/V3TraceDecl.cpp
View File

@ -71,7 +71,7 @@ private:
}
else if (!v3Global.opt.traceUnderscore()) {
string prettyName = varp->prettyName();
if (prettyName.size()>=1 && prettyName[0] == '_')
if (!prettyName.empty() && prettyName[0] == '_')
return "Leading underscore";
if (prettyName.find("._") != string::npos)
return "Inlined leading underscore";
@ -192,7 +192,7 @@ private:
virtual void visit(AstUnpackArrayDType* nodep) {
// Note more specific dtypes above
if (m_traVscp) {
if ((int)nodep->arrayUnpackedElements() > v3Global.opt.traceMaxArray()) {
if (static_cast<int>(nodep->arrayUnpackedElements()) > v3Global.opt.traceMaxArray()) {
addIgnore("Wide memory > --trace-max-array ents");
} else if (VN_IS(nodep->subDTypep()->skipRefp(), BasicDType) // Nothing lower than this array
&& m_traVscp->dtypep()->skipRefp() == nodep) { // Nothing above this array

22
src/V3Tristate.cpp
View File

@ -141,7 +141,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
TristateVertex* makeVertex(AstNode* nodep) {
TristateVertex* vertexp = (TristateVertex*)(nodep->user5p());
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
if (!vertexp) {
UINFO(6," New vertex "<<nodep<<endl);
vertexp = new TristateVertex(&m_graph, nodep);
@ -224,10 +224,10 @@ public:
//if (debug()>=9) m_graph.dumpDotFilePrefixed("tri_pre__"+nodep->name());
UINFO(9," Walking "<<nodep<<endl);
for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
graphWalkRecurseFwd((TristateVertex*)itp, 0);
graphWalkRecurseFwd(static_cast<TristateVertex*>(itp), 0);
}
for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
graphWalkRecurseBack((TristateVertex*)itp, 0);
graphWalkRecurseBack(static_cast<TristateVertex*>(itp), 0);
}
if (debug()>=9) m_graph.dumpDotFilePrefixed("tri_pos__"+nodep->name());
}
@ -238,15 +238,15 @@ public:
new V3GraphEdge(&m_graph, makeVertex(fromp), makeVertex(top), 1);
}
bool isTristate(AstNode* nodep) {
TristateVertex* vertexp = (TristateVertex*)(nodep->user5p());
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
return vertexp && vertexp->isTristate();
}
bool feedsTri(AstNode* nodep) {
TristateVertex* vertexp = (TristateVertex*)(nodep->user5p());
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
return vertexp && vertexp->feedsTri();
}
void didProcess(AstNode* nodep) {
TristateVertex* vertexp = (TristateVertex*)(nodep->user5p());
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
if (!vertexp) {
// Not v3errorSrc as no reason to stop the world
nodep->v3error("Unsupported tristate construct (not in propagation graph): "<<nodep->prettyTypeName());
@ -441,7 +441,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
void setPullDirection(AstVar* varp, AstPull* pullp) {
AstPull* oldpullp = (AstPull*)varp->user3p();
AstPull* oldpullp = static_cast<AstPull*>(varp->user3p());
if (!oldpullp) {
varp->user3p(pullp); //save off to indicate the pull direction
} else {
@ -599,7 +599,7 @@ class TristateVisitor : public TristateBaseVisitor {
// This is the final resolution of the tristate, so we apply
// the pull direction to any undriven pins.
V3Number pull(invarp->fileline(), lhsp->width());
AstPull* pullp = (AstPull*)lhsp->user3p();
AstPull* pullp = static_cast<AstPull*>(lhsp->user3p());
if (pullp && pullp->direction() == 1) {
pull.setAllBits1();
UINFO(9,"Has pullup "<<pullp<<endl);
@ -1054,7 +1054,7 @@ class TristateVisitor : public TristateBaseVisitor {
if (nodep->user2() & U2_GRAPHING) return; // This pin is already expanded
nodep->user2(U2_GRAPHING);
// Find child module's new variables.
AstVar* enModVarp = (AstVar*) nodep->modVarp()->user1p();
AstVar* enModVarp = static_cast<AstVar*>(nodep->modVarp()->user1p());
if (!enModVarp) {
if (nodep->exprp()) {
// May have an output only that later connects to a tristate, so simplify now.
@ -1116,7 +1116,7 @@ class TristateVisitor : public TristateBaseVisitor {
// Create new output pin
AstAssignW* outAssignp = NULL; // If reconnected, the related assignment
AstPin* outpinp = NULL;
AstVar* outModVarp = (AstVar*) nodep->modVarp()->user4p();
AstVar* outModVarp = static_cast<AstVar*>(nodep->modVarp()->user4p());
if (!outModVarp) {
// At top, no need for __out as might be input only. Otherwise resolvable.
if (!m_modp->isTop()) nodep->v3fatalSrc("Unlinked");
@ -1176,7 +1176,7 @@ class TristateVisitor : public TristateBaseVisitor {
// Propagate any pullups/pulldowns upwards if necessary
if (exprrefp) {
if (AstPull* pullp = (AstPull*) nodep->modVarp()->user3p()) {
if (AstPull* pullp = static_cast<AstPull*>(nodep->modVarp()->user3p())) {
UINFO(9, "propagate pull on "<<exprrefp<<endl);
setPullDirection(exprrefp->varp(), pullp);
}

6
src/V3Undriven.cpp
View File

@ -70,7 +70,8 @@ public:
private:
// METHODS
inline bool bitNumOk(int bit) const { return bit>=0 && (bit*FLAGS_PER_BIT < (int)m_flags.size()); }
inline bool bitNumOk(int bit) const { return bit>=0
&& (bit*FLAGS_PER_BIT < static_cast<int>(m_flags.size())); }
inline bool usedFlag(int bit) const { return m_usedWhole || m_flags[bit*FLAGS_PER_BIT + FLAG_USED]; }
inline bool drivenFlag(int bit) const { return m_drivenWhole || m_flags[bit*FLAGS_PER_BIT + FLAG_DRIVEN]; }
enum BitNamesWhich { BN_UNUSED, BN_UNDRIVEN, BN_BOTH };
@ -248,7 +249,8 @@ private:
else nodep->v3fatalSrc("Bad case");
return entryp;
} else {
UndrivenVarEntry* entryp = (UndrivenVarEntry*)(which_user==1 ? nodep->user1p() : nodep->user2p());
UndrivenVarEntry* entryp = reinterpret_cast<UndrivenVarEntry*>
(which_user==1 ? nodep->user1p() : nodep->user2p());
return entryp;
}
}

10
src/V3Unknown.cpp
View File

@ -190,9 +190,9 @@ private:
lhsp->deleteTree(); VL_DANGLING(lhsp);
rhsp->deleteTree(); VL_DANGLING(rhsp);
} else {
if (VN_IS(nodep, EqCase))
newp = new AstEq(nodep->fileline(), lhsp, rhsp);
else newp = new AstNeq(nodep->fileline(), lhsp, rhsp);
if (VN_IS(nodep, EqCase)) {
newp = new AstEq(nodep->fileline(), lhsp, rhsp);
} else { newp = new AstNeq(nodep->fileline(), lhsp, rhsp); }
}
nodep->replaceWith(newp);
nodep->deleteTree(); VL_DANGLING(nodep);
@ -225,9 +225,9 @@ private:
AstNode* and1p = new AstAnd(nodep->fileline(), lhsp,
new AstConst(nodep->fileline(), nummask));
AstNode* and2p = new AstConst(nodep->fileline(), numval);
if (VN_IS(nodep, EqWild))
if (VN_IS(nodep, EqWild)) {
newp = new AstEq(nodep->fileline(), and1p, and2p);
else newp = new AstNeq(nodep->fileline(), and1p, and2p);
} else { newp = new AstNeq(nodep->fileline(), and1p, and2p); }
rhsp->deleteTree(); VL_DANGLING(rhsp);
}
nodep->replaceWith(newp);

8
src/V3Width.cpp
View File

@ -86,7 +86,9 @@
//######################################################################
enum Stage { PRELIM=1,FINAL=2,BOTH=3 }; // Numbers are a bitmask <0>=prelim, <1>=final
std::ostream& operator<<(std::ostream& str, const Stage& rhs) { return str<<("-PFB"[(int)rhs]); }
std::ostream& operator<<(std::ostream& str, const Stage& rhs) {
return str<<("-PFB"[static_cast<int>(rhs)]);
}
enum Determ {
SELF, // Self-determined
@ -1644,9 +1646,9 @@ private:
for (int i = 0; i < arrayType->elementsConst(); ++i) {
AstNode* arrayRef = nodep->fromp()->cloneTree(false);
AstNode* selector = new AstArraySel(fl, arrayRef, i);
if (!newp)
if (!newp) {
newp = selector;
else {
} else {
switch (methodId) {
case ARRAY_OR: newp = new AstOr(fl, newp, selector); break;
case ARRAY_AND: newp = new AstAnd(fl, newp, selector); break;

12
src/V3WidthSel.cpp
View File

@ -69,11 +69,11 @@ private:
AstNode* m_errp; // Node that was found, for error reporting if not known type
AstNodeDType* m_dtypep; // Data type for the 'from' slice
VNumRange m_fromRange; // Numeric range bounds for the 'from' slice
FromData(AstNode* errp, AstNodeDType* dtypep, VNumRange fromRange)
FromData(AstNode* errp, AstNodeDType* dtypep, const VNumRange& fromRange)
{ m_errp=errp; m_dtypep=dtypep; m_fromRange=fromRange; }
~FromData() {}
};
FromData fromDataForArray(AstNode* nodep, AstNode* basefromp, bool rangedSelect) {
FromData fromDataForArray(AstNode* nodep, AstNode* basefromp) {
// What is the data type and information for this SEL-ish's from()?
UINFO(9," fromData start ddtypep = "<<basefromp<<endl);
VNumRange fromRange; // constructs to isRanged(false)
@ -198,7 +198,7 @@ private:
AstNode* fromp = nodep->lhsp()->unlinkFrBack();
AstNode* rhsp = nodep->rhsp()->unlinkFrBack(); // bit we're extracting
if (debug()>=9) nodep->dumpTree(cout,"--SELBT2: ");
FromData fromdata = fromDataForArray(nodep, fromp, false);
FromData fromdata = fromDataForArray(nodep, fromp);
AstNodeDType* ddtypep = fromdata.m_dtypep;
VNumRange fromRange = fromdata.m_fromRange;
UINFO(6," ddtypep "<<ddtypep<<endl);
@ -290,7 +290,7 @@ private:
vlsint32_t msb = VN_CAST(msbp, Const)->toSInt();
vlsint32_t lsb = VN_CAST(lsbp, Const)->toSInt();
vlsint32_t elem = (msb>lsb) ? (msb-lsb+1) : (lsb-msb+1);
FromData fromdata = fromDataForArray(nodep, fromp, false);
FromData fromdata = fromDataForArray(nodep, fromp);
AstNodeDType* ddtypep = fromdata.m_dtypep;
VNumRange fromRange = fromdata.m_fromRange;
if (VN_IS(ddtypep, UnpackArrayDType)) {
@ -331,7 +331,7 @@ private:
newp->declElWidth(elwidth);
newp->dtypeFrom(sliceDType(adtypep, msb, lsb));
//if (debug()>=9) newp->dumpTree(cout,"--EXTBTn: ");
if (newp->widthMin()!=(int)newp->widthConst()) nodep->v3fatalSrc("Width mismatch");
if (newp->widthMin() != newp->widthConst()) nodep->v3fatalSrc("Width mismatch");
nodep->replaceWith(newp); pushDeletep(nodep); VL_DANGLING(nodep);
}
else if (VN_IS(ddtypep, BasicDType)) {
@ -402,7 +402,7 @@ private:
int width = VN_CAST(widthp, Const)->toSInt();
if (width > (1<<28)) nodep->v3error("Width of :+ or :- is huge; vector of over 1billion bits: "<<widthp->prettyName());
if (width<0) nodep->v3error("Width of :+ or :- is < 0: "<<widthp->prettyName());
FromData fromdata = fromDataForArray(nodep, fromp, width!=1);
FromData fromdata = fromDataForArray(nodep, fromp);
AstNodeDType* ddtypep = fromdata.m_dtypep;
VNumRange fromRange = fromdata.m_fromRange;
if (VN_IS(ddtypep, BasicDType)

2
src/Verilator.cpp
View File

@ -566,7 +566,7 @@ int main(int argc, char** argv, char** env) {
time_t randseed;
time(&randseed);
srand( (int) randseed);
srand(static_cast<int>(randseed));
// Post-constructor initialization of netlists
v3Global.boot();

4
src/VlcMain.cpp
View File

@ -171,7 +171,7 @@ int main(int argc, char** argv, char** env) {
}
V3Error::abortIfWarnings();
if (top.opt.annotateOut() != "") {
if (!top.opt.annotateOut().empty()) {
top.annotate(top.opt.annotateOut());
}
@ -180,7 +180,7 @@ int main(int argc, char** argv, char** env) {
top.tests().dump(false);
}
if (top.opt.writeFile() != "") {
if (!top.opt.writeFile().empty()) {
top.writeCoverage(top.opt.writeFile());
V3Error::abortIfWarnings();
if (top.opt.unlink()) {

2
src/VlcOptions.h
View File

@ -26,9 +26,9 @@
#include "config_rev.h"
#include <vector>
#include <map>
#include <set>
#include <vector>
//######################################################################
// V3Options - Command line options

4
src/VlcTop.cpp
View File

@ -150,11 +150,11 @@ void VlcTop::annotateCalc() {
const VlcPoint& point = m_points.pointNumber(it->second);
string filename = point.filename();
int lineno = point.lineno();
if (filename!="" && lineno!=0) {
if (!filename.empty() && lineno!=0) {
int column = point.column();
VlcSource& source = sources().findNewSource(filename);
string threshStr = point.thresh();
unsigned thresh = (threshStr!="") ? atoi(threshStr.c_str()) : opt.annotateMin();
unsigned thresh = (!threshStr.empty()) ? atoi(threshStr.c_str()) : opt.annotateMin();
bool ok = (point.count() >= thresh);
UINFO(9, "AnnoCalc count "<<filename<<" "<<lineno<<" "<<point.count()<<endl);
source.incCount(lineno, column, point.count(), ok);

7
test_regress/t/t_dist_tabs.pl
View File

@ -44,6 +44,13 @@ if (!-r "$root/.git") {
print " Inserts tabs\n" if $Self->{verbose} && !$btab;
$btab = 1;
}
elsif ($line =~ m!^\+(.*)!) {
my $len = length($1);
if ($len >= 100) {
print" Wide $line\n" if $Self->{verbose};
$warns{$file} = "File modification adds a new >100 column line: $file";
}
}
}
}
if (keys %warns) {