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

Internals: Use C++11 const and initializers. No functional change intended.

This commit is contained in:
Wilson Snyder 2021-07-24 08:36:11 -04:00
parent 19875d2e85
commit ab13a2ebdc
16 changed files with 296 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
include/verilated.cpp
View File

@ -173,9 +173,9 @@ void vl_stop_maybe(const char* filename, int linenum, const char* hier, bool may
void VL_FINISH_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE { void VL_FINISH_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE {
#ifdef VL_THREADED #ifdef VL_THREADED
VerilatedThreadMsgQueue::post(VerilatedMsg([=]() { // VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() { //
vl_finish(filename, linenum, hier); vl_finish(filename, linenum, hier);
})); }});
#else #else
vl_finish(filename, linenum, hier); vl_finish(filename, linenum, hier);
#endif #endif
@ -183,9 +183,9 @@ void VL_FINISH_MT(const char* filename, int linenum, const char* hier) VL_MT_SAF
void VL_STOP_MT(const char* filename, int linenum, const char* hier, bool maybe) VL_MT_SAFE { void VL_STOP_MT(const char* filename, int linenum, const char* hier, bool maybe) VL_MT_SAFE {
#ifdef VL_THREADED #ifdef VL_THREADED
VerilatedThreadMsgQueue::post(VerilatedMsg([=]() { // VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() { //
vl_stop_maybe(filename, linenum, hier, maybe); vl_stop_maybe(filename, linenum, hier, maybe);
})); }});
#else #else
vl_stop_maybe(filename, linenum, hier, maybe); vl_stop_maybe(filename, linenum, hier, maybe);
#endif #endif
@ -193,9 +193,9 @@ void VL_STOP_MT(const char* filename, int linenum, const char* hier, bool maybe)
void VL_FATAL_MT(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_SAFE { void VL_FATAL_MT(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_SAFE {
#ifdef VL_THREADED #ifdef VL_THREADED
VerilatedThreadMsgQueue::post(VerilatedMsg([=]() { // VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() { //
vl_fatal(filename, linenum, hier, msg); vl_fatal(filename, linenum, hier, msg);
})); }});
#else #else
vl_fatal(filename, linenum, hier, msg); vl_fatal(filename, linenum, hier, msg);
#endif #endif
@ -208,14 +208,14 @@ void VL_FATAL_MT(const char* filename, int linenum, const char* hier, const char
std::string _vl_string_vprintf(const char* formatp, va_list ap) VL_MT_SAFE { std::string _vl_string_vprintf(const char* formatp, va_list ap) VL_MT_SAFE {
va_list aq; va_list aq;
va_copy(aq, ap); va_copy(aq, ap);
int len = VL_VSNPRINTF(nullptr, 0, formatp, aq); size_t len = VL_VSNPRINTF(nullptr, 0, formatp, aq);
va_end(aq); va_end(aq);
if (VL_UNLIKELY(len < 1)) return ""; if (VL_UNLIKELY(len < 1)) return "";
char* bufp = new char[len + 1]; char* const bufp = new char[len + 1];
VL_VSNPRINTF(bufp, len + 1, formatp, ap); VL_VSNPRINTF(bufp, len + 1, formatp, ap);
const std::string out = std::string(bufp, len); const std::string out{bufp, len};
delete[] bufp; delete[] bufp;
return out; return out;
} }
@ -263,9 +263,9 @@ void VL_PRINTF_MT(const char* formatp, ...) VL_MT_SAFE {
va_start(ap, formatp); va_start(ap, formatp);
const std::string out = _vl_string_vprintf(formatp, ap); const std::string out = _vl_string_vprintf(formatp, ap);
va_end(ap); va_end(ap);
VerilatedThreadMsgQueue::post(VerilatedMsg([=]() { // VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() { //
VL_PRINTF("%s", out.c_str()); VL_PRINTF("%s", out.c_str());
})); }});
} }
#endif #endif
@ -276,7 +276,7 @@ static vluint32_t vl_sys_rand32() VL_MT_UNSAFE {
// Return random 32-bits using system library. // Return random 32-bits using system library.
// Used only to construct seed for Verilator's PNRG. // Used only to construct seed for Verilator's PNRG.
static VerilatedMutex s_mutex; static VerilatedMutex s_mutex;
const VerilatedLockGuard lock(s_mutex); // Otherwise rand is unsafe const VerilatedLockGuard lock{s_mutex}; // Otherwise rand is unsafe
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
// Windows doesn't have lrand48(), although Cygwin does. // Windows doesn't have lrand48(), although Cygwin does.
return (std::rand() << 16) ^ std::rand(); return (std::rand() << 16) ^ std::rand();
@ -742,7 +742,7 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
} else if (!inPct) { // Normal text } else if (!inPct) { // Normal text
// Fast-forward to next escape and add to output // Fast-forward to next escape and add to output
const char* ep = pos; const char* ep = pos;
while (ep[0] && ep[0] != '%') ep++; while (ep[0] && ep[0] != '%') ++ep;
if (ep != pos) { if (ep != pos) {
output.append(pos, ep - pos); output.append(pos, ep - pos);
pos += ep - pos - 1; pos += ep - pos - 1;
@ -776,7 +776,7 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
output += '%'; output += '%';
break; break;
case 'N': { // "C" string with name of module, add . if needed case 'N': { // "C" string with name of module, add . if needed
const char* cstrp = va_arg(ap, const char*); const char* const cstrp = va_arg(ap, const char*);
if (VL_LIKELY(*cstrp)) { if (VL_LIKELY(*cstrp)) {
output += cstrp; output += cstrp;
output += '.'; output += '.';
@ -784,13 +784,13 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
break; break;
} }
case 'S': { // "C" string case 'S': { // "C" string
const char* cstrp = va_arg(ap, const char*); const char* const cstrp = va_arg(ap, const char*);
output += cstrp; output += cstrp;
break; break;
} }
case '@': { // Verilog/C++ string case '@': { // Verilog/C++ string
va_arg(ap, int); // # bits is ignored va_arg(ap, int); // # bits is ignored
const std::string* cstrp = va_arg(ap, const std::string*); const std::string* const cstrp = va_arg(ap, const std::string*);
std::string padding; std::string padding;
if (width > cstrp->size()) padding.append(width - cstrp->size(), ' '); if (width > cstrp->size()) padding.append(width - cstrp->size(), ' ');
output += left ? (*cstrp + padding) : (padding + *cstrp); output += left ? (*cstrp + padding) : (padding + *cstrp);
@ -808,7 +808,8 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
const int timeunit = va_arg(ap, int); const int timeunit = va_arg(ap, int);
output += _vl_vsformat_time(t_tmp, d, timeunit, left, width); output += _vl_vsformat_time(t_tmp, d, timeunit, left, width);
} else { } else {
std::string fmts(pctp, pos - pctp + 1); const size_t len = pos - pctp + 1;
std::string fmts{pctp, len};
VL_SNPRINTF(t_tmp, VL_VALUE_STRING_MAX_WIDTH, fmts.c_str(), d); VL_SNPRINTF(t_tmp, VL_VALUE_STRING_MAX_WIDTH, fmts.c_str(), d);
output += t_tmp; output += t_tmp;
} }
@ -862,7 +863,7 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
if (VL_SIGN_E(lbits, lwp[VL_WORDS_I(lbits) - 1])) { if (VL_SIGN_E(lbits, lwp[VL_WORDS_I(lbits) - 1])) {
VlWide<VL_VALUE_STRING_MAX_WIDTH / 4 + 2> neg; VlWide<VL_VALUE_STRING_MAX_WIDTH / 4 + 2> neg;
VL_NEGATE_W(VL_WORDS_I(lbits), neg, lwp); VL_NEGATE_W(VL_WORDS_I(lbits), neg, lwp);
append = std::string("-") + VL_DECIMAL_NW(lbits, neg); append = std::string{"-"} + VL_DECIMAL_NW(lbits, neg);
} else { } else {
append = VL_DECIMAL_NW(lbits, lwp); append = VL_DECIMAL_NW(lbits, lwp);
} }
@ -957,7 +958,7 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
} }
break; break;
default: { // LCOV_EXCL_START default: { // LCOV_EXCL_START
const std::string msg = std::string("Unknown _vl_vsformat code: ") + pos[0]; const std::string msg = std::string{"Unknown _vl_vsformat code: "} + pos[0];
VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
break; break;
} // LCOV_EXCL_STOP } // LCOV_EXCL_STOP
@ -1217,7 +1218,7 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
case 'u': { case 'u': {
// Read packed 2-value binary data // Read packed 2-value binary data
const int bytes = VL_BYTES_I(obits); const int bytes = VL_BYTES_I(obits);
char* out = reinterpret_cast<char*>(owp); char* const out = reinterpret_cast<char*>(owp);
if (!_vl_vsss_read_bin(fp, floc, fromp, fstr, out, bytes)) goto done; if (!_vl_vsss_read_bin(fp, floc, fromp, fstr, out, bytes)) goto done;
const int last = bytes % 4; const int last = bytes % 4;
if (last != 0 if (last != 0
@ -1242,7 +1243,7 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
break; break;
} }
default: { // LCOV_EXCL_START default: { // LCOV_EXCL_START
const std::string msg = std::string("Unknown _vl_vsscanf code: ") + pos[0]; const std::string msg = std::string{"Unknown _vl_vsscanf code: "} + pos[0];
VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
break; break;
} // LCOV_EXCL_STOP } // LCOV_EXCL_STOP
@ -1253,19 +1254,19 @@ IData _vl_vsscanf(FILE* fp, // If a fscanf
// Reload data if non-wide (if wide, we put it in the right place directly) // Reload data if non-wide (if wide, we put it in the right place directly)
if (obits == 0) { // Due to inIgnore if (obits == 0) { // Due to inIgnore
} else if (obits == -1) { // string } else if (obits == -1) { // string
std::string* p = va_arg(ap, std::string*); std::string* const p = va_arg(ap, std::string*);
*p = t_tmp; *p = t_tmp;
} else if (obits <= VL_BYTESIZE) { } else if (obits <= VL_BYTESIZE) {
CData* p = va_arg(ap, CData*); CData* const p = va_arg(ap, CData*);
*p = owp[0]; *p = owp[0];
} else if (obits <= VL_SHORTSIZE) { } else if (obits <= VL_SHORTSIZE) {
SData* p = va_arg(ap, SData*); SData* const p = va_arg(ap, SData*);
*p = owp[0]; *p = owp[0];
} else if (obits <= VL_IDATASIZE) { } else if (obits <= VL_IDATASIZE) {
IData* p = va_arg(ap, IData*); IData* const p = va_arg(ap, IData*);
*p = owp[0]; *p = owp[0];
} else if (obits <= VL_QUADSIZE) { } else if (obits <= VL_QUADSIZE) {
QData* p = va_arg(ap, QData*); QData* const p = va_arg(ap, QData*);
*p = VL_SET_QW(owp); *p = VL_SET_QW(owp);
} }
} }
@ -1354,7 +1355,7 @@ IData VL_FGETS_NI(std::string& dest, IData fpi) VL_MT_SAFE {
IData VL_FERROR_IN(IData, std::string& outputr) VL_MT_SAFE { IData VL_FERROR_IN(IData, std::string& outputr) VL_MT_SAFE {
// We ignore lhs/fpi - IEEE says "most recent error" so probably good enough // We ignore lhs/fpi - IEEE says "most recent error" so probably good enough
const IData ret = errno; const IData ret = errno;
outputr = std::string(::std::strerror(ret)); outputr = std::string{::std::strerror(ret)};
return ret; return ret;
} }
@ -1541,19 +1542,19 @@ IData VL_FREAD_I(int width, int array_lsb, int array_size, void* memp, IData fpi
// Shift value in // Shift value in
IData entry = read_elements + start - array_lsb; IData entry = read_elements + start - array_lsb;
if (width <= 8) { if (width <= 8) {
CData* datap = &(reinterpret_cast<CData*>(memp))[entry]; CData* const datap = &(reinterpret_cast<CData*>(memp))[entry];
if (shift == start_shift) *datap = 0; if (shift == start_shift) *datap = 0;
*datap |= (c << shift) & VL_MASK_I(width); *datap |= (c << shift) & VL_MASK_I(width);
} else if (width <= 16) { } else if (width <= 16) {
SData* datap = &(reinterpret_cast<SData*>(memp))[entry]; SData* const datap = &(reinterpret_cast<SData*>(memp))[entry];
if (shift == start_shift) *datap = 0; if (shift == start_shift) *datap = 0;
*datap |= (c << shift) & VL_MASK_I(width); *datap |= (c << shift) & VL_MASK_I(width);
} else if (width <= VL_IDATASIZE) { } else if (width <= VL_IDATASIZE) {
IData* datap = &(reinterpret_cast<IData*>(memp))[entry]; IData* const datap = &(reinterpret_cast<IData*>(memp))[entry];
if (shift == start_shift) *datap = 0; if (shift == start_shift) *datap = 0;
*datap |= (c << shift) & VL_MASK_I(width); *datap |= (c << shift) & VL_MASK_I(width);
} else if (width <= VL_QUADSIZE) { } else if (width <= VL_QUADSIZE) {
QData* datap = &(reinterpret_cast<QData*>(memp))[entry]; QData* const datap = &(reinterpret_cast<QData*>(memp))[entry];
if (shift == start_shift) *datap = 0; if (shift == start_shift) *datap = 0;
*datap |= ((static_cast<QData>(c) << static_cast<QData>(shift)) & VL_MASK_Q(width)); *datap |= ((static_cast<QData>(c) << static_cast<QData>(shift)) & VL_MASK_Q(width));
} else { } else {
@ -1615,7 +1616,7 @@ IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_M
} }
const std::string& match = Verilated::threadContextp()->impp()->argPlusMatch(prefix.c_str()); const std::string& match = Verilated::threadContextp()->impp()->argPlusMatch(prefix.c_str());
const char* dp = match.c_str() + 1 /*leading + */ + prefix.length(); const char* const dp = match.c_str() + 1 /*leading + */ + prefix.length();
if (match.empty()) return 0; if (match.empty()) return 0;
VL_ZERO_RESET_W(rbits, rwp); VL_ZERO_RESET_W(rbits, rwp);
@ -1684,9 +1685,9 @@ IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_S
} }
} }
const std::string& match = Verilated::threadContextp()->impp()->argPlusMatch(prefix.c_str()); const std::string& match = Verilated::threadContextp()->impp()->argPlusMatch(prefix.c_str());
const char* dp = match.c_str() + 1 /*leading + */ + prefix.length(); const char* const dp = match.c_str() + 1 /*leading + */ + prefix.length();
if (match.empty()) return 0; if (match.empty()) return 0;
rdr = std::string(dp); rdr = std::string{dp};
return 1; return 1;
} }
@ -1731,17 +1732,17 @@ std::string VL_CVT_PACK_STR_NW(int lwords, const WDataInP lwp) VL_MT_SAFE {
int lsb = obits - 1; int lsb = obits - 1;
bool start = true; bool start = true;
char* destp = destout; char* destp = destout;
int len = 0; size_t len = 0;
for (; lsb >= 0; --lsb) { for (; lsb >= 0; --lsb) {
lsb = (lsb / 8) * 8; // Next digit lsb = (lsb / 8) * 8; // Next digit
IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff; IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
if (!start || charval) { if (!start || charval) {
*destp++ = (charval == 0) ? ' ' : charval; *destp++ = (charval == 0) ? ' ' : charval;
len++; ++len;
start = false; // Drop leading 0s start = false; // Drop leading 0s
} }
} }
return std::string(destout, len); return std::string{destout, len};
} }
std::string VL_PUTC_N(const std::string& lhs, IData rhs, CData ths) VL_PURE { std::string VL_PUTC_N(const std::string& lhs, IData rhs, CData ths) VL_PURE {
@ -1924,19 +1925,19 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
const int value const int value
= (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0')); = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
if (m_bits <= 8) { if (m_bits <= 8) {
CData* datap = reinterpret_cast<CData*>(valuep); CData* const datap = reinterpret_cast<CData*>(valuep);
if (!innum) *datap = 0; if (!innum) *datap = 0;
*datap = ((*datap << shift) + value) & VL_MASK_I(m_bits); *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
} else if (m_bits <= 16) { } else if (m_bits <= 16) {
SData* datap = reinterpret_cast<SData*>(valuep); SData* const datap = reinterpret_cast<SData*>(valuep);
if (!innum) *datap = 0; if (!innum) *datap = 0;
*datap = ((*datap << shift) + value) & VL_MASK_I(m_bits); *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
} else if (m_bits <= VL_IDATASIZE) { } else if (m_bits <= VL_IDATASIZE) {
IData* datap = reinterpret_cast<IData*>(valuep); IData* const datap = reinterpret_cast<IData*>(valuep);
if (!innum) *datap = 0; if (!innum) *datap = 0;
*datap = ((*datap << shift) + value) & VL_MASK_I(m_bits); *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
} else if (m_bits <= VL_QUADSIZE) { } else if (m_bits <= VL_QUADSIZE) {
QData* datap = reinterpret_cast<QData*>(valuep); QData* const datap = reinterpret_cast<QData*>(valuep);
if (!innum) *datap = 0; if (!innum) *datap = 0;
*datap = ((*datap << static_cast<QData>(shift)) + static_cast<QData>(value)) *datap = ((*datap << static_cast<QData>(shift)) + static_cast<QData>(value))
& VL_MASK_Q(m_bits); & VL_MASK_Q(m_bits);
@ -1979,7 +1980,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
} }
m_addr = addr + 1; m_addr = addr + 1;
if (m_bits <= 8) { if (m_bits <= 8) {
const CData* datap = reinterpret_cast<const CData*>(valuep); const CData* const datap = reinterpret_cast<const CData*>(valuep);
if (m_hex) { if (m_hex) {
fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap); fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
fprintf(m_fp, "\n"); fprintf(m_fp, "\n");
@ -1987,7 +1988,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap)); fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap));
} }
} else if (m_bits <= 16) { } else if (m_bits <= 16) {
const SData* datap = reinterpret_cast<const SData*>(valuep); const SData* const datap = reinterpret_cast<const SData*>(valuep);
if (m_hex) { if (m_hex) {
fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap); fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
fprintf(m_fp, "\n"); fprintf(m_fp, "\n");
@ -1995,7 +1996,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap)); fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap));
} }
} else if (m_bits <= 32) { } else if (m_bits <= 32) {
const IData* datap = reinterpret_cast<const IData*>(valuep); const IData* const datap = reinterpret_cast<const IData*>(valuep);
if (m_hex) { if (m_hex) {
fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap); fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
fprintf(m_fp, "\n"); fprintf(m_fp, "\n");
@ -2003,7 +2004,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap)); fprintf(m_fp, "%s\n", formatBinary(m_bits, *datap));
} }
} else if (m_bits <= 64) { } else if (m_bits <= 64) {
const QData* datap = reinterpret_cast<const QData*>(valuep); const QData* const datap = reinterpret_cast<const QData*>(valuep);
const vluint64_t value = VL_MASK_Q(m_bits) & *datap; const vluint64_t value = VL_MASK_Q(m_bits) & *datap;
const vluint32_t lo = value & 0xffffffff; const vluint32_t lo = value & 0xffffffff;
const vluint32_t hi = value >> 32; const vluint32_t hi = value >> 32;
@ -2038,7 +2039,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
fprintf(m_fp, "%s", formatBinary(32, data)); fprintf(m_fp, "%s", formatBinary(32, data));
} }
} }
word_idx--; --word_idx;
first = false; first = false;
} }
fprintf(m_fp, "\n"); fprintf(m_fp, "\n");
@ -2057,7 +2058,7 @@ void VL_READMEM_N(bool hex, // Hex format, else binary
) VL_MT_SAFE { ) VL_MT_SAFE {
if (start < static_cast<QData>(array_lsb)) start = array_lsb; if (start < static_cast<QData>(array_lsb)) start = array_lsb;
VlReadMem rmem(hex, bits, filename, start, end); VlReadMem rmem{hex, bits, filename, start, end};
if (VL_UNLIKELY(!rmem.isOpen())) return; if (VL_UNLIKELY(!rmem.isOpen())) return;
while (true) { while (true) {
QData addr = 0; QData addr = 0;
@ -2070,16 +2071,16 @@ void VL_READMEM_N(bool hex, // Hex format, else binary
} else { } else {
QData entry = addr - array_lsb; QData entry = addr - array_lsb;
if (bits <= 8) { if (bits <= 8) {
CData* datap = &(reinterpret_cast<CData*>(memp))[entry]; CData* const datap = &(reinterpret_cast<CData*>(memp))[entry];
rmem.setData(datap, value); rmem.setData(datap, value);
} else if (bits <= 16) { } else if (bits <= 16) {
SData* datap = &(reinterpret_cast<SData*>(memp))[entry]; SData* const datap = &(reinterpret_cast<SData*>(memp))[entry];
rmem.setData(datap, value); rmem.setData(datap, value);
} else if (bits <= VL_IDATASIZE) { } else if (bits <= VL_IDATASIZE) {
IData* datap = &(reinterpret_cast<IData*>(memp))[entry]; IData* const datap = &(reinterpret_cast<IData*>(memp))[entry];
rmem.setData(datap, value); rmem.setData(datap, value);
} else if (bits <= VL_QUADSIZE) { } else if (bits <= VL_QUADSIZE) {
QData* datap = &(reinterpret_cast<QData*>(memp))[entry]; QData* const datap = &(reinterpret_cast<QData*>(memp))[entry];
rmem.setData(datap, value); rmem.setData(datap, value);
} else { } else {
WDataOutP datap WDataOutP datap
@ -2107,22 +2108,22 @@ void VL_WRITEMEM_N(bool hex, // Hex format, else binary
if (start < static_cast<QData>(array_lsb)) start = array_lsb; if (start < static_cast<QData>(array_lsb)) start = array_lsb;
if (end > addr_max) end = addr_max; if (end > addr_max) end = addr_max;
VlWriteMem wmem(hex, bits, filename, start, end); VlWriteMem wmem{hex, bits, filename, start, end};
if (VL_UNLIKELY(!wmem.isOpen())) return; if (VL_UNLIKELY(!wmem.isOpen())) return;
for (QData addr = start; addr <= end; ++addr) { for (QData addr = start; addr <= end; ++addr) {
const QData row_offset = addr - array_lsb; const QData row_offset = addr - array_lsb;
if (bits <= 8) { if (bits <= 8) {
const CData* datap = &(reinterpret_cast<const CData*>(memp))[row_offset]; const CData* const datap = &(reinterpret_cast<const CData*>(memp))[row_offset];
wmem.print(addr, false, datap); wmem.print(addr, false, datap);
} else if (bits <= 16) { } else if (bits <= 16) {
const SData* datap = &(reinterpret_cast<const SData*>(memp))[row_offset]; const SData* const datap = &(reinterpret_cast<const SData*>(memp))[row_offset];
wmem.print(addr, false, datap); wmem.print(addr, false, datap);
} else if (bits <= 32) { } else if (bits <= 32) {
const IData* datap = &(reinterpret_cast<const IData*>(memp))[row_offset]; const IData* const datap = &(reinterpret_cast<const IData*>(memp))[row_offset];
wmem.print(addr, false, datap); wmem.print(addr, false, datap);
} else if (bits <= 64) { } else if (bits <= 64) {
const QData* datap = &(reinterpret_cast<const QData*>(memp))[row_offset]; const QData* const datap = &(reinterpret_cast<const QData*>(memp))[row_offset];
wmem.print(addr, false, datap); wmem.print(addr, false, datap);
} else { } else {
const WDataInP memDatap = reinterpret_cast<WDataInP>(memp); const WDataInP memDatap = reinterpret_cast<WDataInP>(memp);
@ -2142,8 +2143,8 @@ int VL_TIME_STR_CONVERT(const char* strp) VL_PURE {
if (!strp) return 0; if (!strp) return 0;
if (*strp++ != '1') return 0; if (*strp++ != '1') return 0;
while (*strp == '0') { while (*strp == '0') {
scale++; ++scale;
strp++; ++strp;
} }
switch (*strp++) { switch (*strp++) {
case 's': break; case 's': break;
@ -2273,19 +2274,19 @@ VerilatedContext::Serialized::Serialized() {
} }
void VerilatedContext::assertOn(bool flag) VL_MT_SAFE { void VerilatedContext::assertOn(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_assertOn = flag; m_s.m_assertOn = flag;
} }
void VerilatedContext::calcUnusedSigs(bool flag) VL_MT_SAFE { void VerilatedContext::calcUnusedSigs(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_calcUnusedSigs = flag; m_s.m_calcUnusedSigs = flag;
} }
void VerilatedContext::dumpfile(const std::string& flag) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) { void VerilatedContext::dumpfile(const std::string& flag) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
const VerilatedLockGuard lock(m_timeDumpMutex); const VerilatedLockGuard lock{m_timeDumpMutex};
m_dumpfile = flag; m_dumpfile = flag;
} }
std::string VerilatedContext::dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) { std::string VerilatedContext::dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
const VerilatedLockGuard lock(m_timeDumpMutex); const VerilatedLockGuard lock{m_timeDumpMutex};
return m_dumpfile; return m_dumpfile;
} }
std::string VerilatedContext::dumpfileCheck() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) { std::string VerilatedContext::dumpfileCheck() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
@ -2297,61 +2298,61 @@ std::string VerilatedContext::dumpfileCheck() const VL_MT_SAFE_EXCLUDES(m_timeDu
return out; return out;
} }
void VerilatedContext::errorCount(int val) VL_MT_SAFE { void VerilatedContext::errorCount(int val) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_errorCount = val; m_s.m_errorCount = val;
} }
void VerilatedContext::errorCountInc() VL_MT_SAFE { void VerilatedContext::errorCountInc() VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
++m_s.m_errorCount; ++m_s.m_errorCount;
} }
void VerilatedContext::errorLimit(int val) VL_MT_SAFE { void VerilatedContext::errorLimit(int val) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_errorLimit = val; m_s.m_errorLimit = val;
} }
void VerilatedContext::fatalOnError(bool flag) VL_MT_SAFE { void VerilatedContext::fatalOnError(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_fatalOnError = flag; m_s.m_fatalOnError = flag;
} }
void VerilatedContext::fatalOnVpiError(bool flag) VL_MT_SAFE { void VerilatedContext::fatalOnVpiError(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_fatalOnVpiError = flag; m_s.m_fatalOnVpiError = flag;
} }
void VerilatedContext::gotError(bool flag) VL_MT_SAFE { void VerilatedContext::gotError(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_gotError = flag; m_s.m_gotError = flag;
} }
void VerilatedContext::gotFinish(bool flag) VL_MT_SAFE { void VerilatedContext::gotFinish(bool flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_gotFinish = flag; m_s.m_gotFinish = flag;
} }
void VerilatedContext::profThreadsStart(vluint64_t flag) VL_MT_SAFE { void VerilatedContext::profThreadsStart(vluint64_t flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_ns.m_profThreadsStart = flag; m_ns.m_profThreadsStart = flag;
} }
void VerilatedContext::profThreadsWindow(vluint64_t flag) VL_MT_SAFE { void VerilatedContext::profThreadsWindow(vluint64_t flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_ns.m_profThreadsWindow = flag; m_ns.m_profThreadsWindow = flag;
} }
void VerilatedContext::profThreadsFilename(const std::string& flag) VL_MT_SAFE { void VerilatedContext::profThreadsFilename(const std::string& flag) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_ns.m_profThreadsFilename = flag; m_ns.m_profThreadsFilename = flag;
} }
std::string VerilatedContext::profThreadsFilename() const VL_MT_SAFE { std::string VerilatedContext::profThreadsFilename() const VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
return m_ns.m_profThreadsFilename; return m_ns.m_profThreadsFilename;
} }
void VerilatedContext::randReset(int val) VL_MT_SAFE { void VerilatedContext::randReset(int val) VL_MT_SAFE {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_randReset = val; m_s.m_randReset = val;
} }
void VerilatedContext::timeunit(int value) VL_MT_SAFE { void VerilatedContext::timeunit(int value) VL_MT_SAFE {
if (value < 0) value = -value; // Stored as 0..15 if (value < 0) value = -value; // Stored as 0..15
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_timeunit = value; m_s.m_timeunit = value;
} }
void VerilatedContext::timeprecision(int value) VL_MT_SAFE { void VerilatedContext::timeprecision(int value) VL_MT_SAFE {
if (value < 0) value = -value; // Stored as 0..15 if (value < 0) value = -value; // Stored as 0..15
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_s.m_timeprecision = value; m_s.m_timeprecision = value;
#ifdef SYSTEMC_VERSION #ifdef SYSTEMC_VERSION
const sc_time sc_res = sc_get_time_resolution(); const sc_time sc_res = sc_get_time_resolution();
@ -2387,13 +2388,13 @@ const char* VerilatedContext::timeprecisionString() const VL_MT_SAFE {
} }
void VerilatedContext::commandArgs(int argc, const char** argv) VL_MT_SAFE_EXCLUDES(m_argMutex) { void VerilatedContext::commandArgs(int argc, const char** argv) VL_MT_SAFE_EXCLUDES(m_argMutex) {
const VerilatedLockGuard lock(m_argMutex); const VerilatedLockGuard lock{m_argMutex};
m_args.m_argVec.clear(); // Empty first, then add m_args.m_argVec.clear(); // Empty first, then add
impp()->commandArgsAddGuts(argc, argv); impp()->commandArgsAddGuts(argc, argv);
} }
void VerilatedContext::commandArgsAdd(int argc, const char** argv) void VerilatedContext::commandArgsAdd(int argc, const char** argv)
VL_MT_SAFE_EXCLUDES(m_argMutex) { VL_MT_SAFE_EXCLUDES(m_argMutex) {
const VerilatedLockGuard lock(m_argMutex); const VerilatedLockGuard lock{m_argMutex};
impp()->commandArgsAddGuts(argc, argv); impp()->commandArgsAddGuts(argc, argv);
} }
const char* VerilatedContext::commandArgsPlusMatch(const char* prefixp) const char* VerilatedContext::commandArgsPlusMatch(const char* prefixp)
@ -2428,14 +2429,14 @@ void VerilatedContextImp::commandArgsAddGuts(int argc, const char** argv) VL_REQ
m_args.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok m_args.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
} }
void VerilatedContextImp::commandArgDump() const VL_MT_SAFE_EXCLUDES(m_argMutex) { void VerilatedContextImp::commandArgDump() const VL_MT_SAFE_EXCLUDES(m_argMutex) {
const VerilatedLockGuard lock(m_argMutex); const VerilatedLockGuard lock{m_argMutex};
VL_PRINTF_MT(" Argv:"); VL_PRINTF_MT(" Argv:");
for (const auto& i : m_args.m_argVec) VL_PRINTF_MT(" %s", i.c_str()); for (const auto& i : m_args.m_argVec) VL_PRINTF_MT(" %s", i.c_str());
VL_PRINTF_MT("\n"); VL_PRINTF_MT("\n");
} }
std::string VerilatedContextImp::argPlusMatch(const char* prefixp) std::string VerilatedContextImp::argPlusMatch(const char* prefixp)
VL_MT_SAFE_EXCLUDES(m_argMutex) { VL_MT_SAFE_EXCLUDES(m_argMutex) {
const VerilatedLockGuard lock(m_argMutex); const VerilatedLockGuard lock{m_argMutex};
// Note prefixp does not include the leading "+" // Note prefixp does not include the leading "+"
const size_t len = std::strlen(prefixp); const size_t len = std::strlen(prefixp);
if (VL_UNLIKELY(!m_args.m_argVecLoaded)) { if (VL_UNLIKELY(!m_args.m_argVecLoaded)) {
@ -2454,7 +2455,7 @@ std::string VerilatedContextImp::argPlusMatch(const char* prefixp)
// Return string representing current argv // Return string representing current argv
// Only used by VPI so uses static storage, only supports most recent called context // Only used by VPI so uses static storage, only supports most recent called context
std::pair<int, char**> VerilatedContextImp::argc_argv() VL_MT_SAFE_EXCLUDES(m_argMutex) { std::pair<int, char**> VerilatedContextImp::argc_argv() VL_MT_SAFE_EXCLUDES(m_argMutex) {
const VerilatedLockGuard lock(m_argMutex); const VerilatedLockGuard lock{m_argMutex};
static bool s_loaded = false; static bool s_loaded = false;
static int s_argc = 0; static int s_argc = 0;
static char** s_argvp = nullptr; static char** s_argvp = nullptr;
@ -2529,7 +2530,7 @@ bool VerilatedContextImp::commandArgVlValue(const std::string& arg, const std::s
void VerilatedContext::randSeed(int val) VL_MT_SAFE { void VerilatedContext::randSeed(int val) VL_MT_SAFE {
// As we have per-thread state, the epoch must be static, // As we have per-thread state, the epoch must be static,
// and so the rand seed's mutex must also be static // and so the rand seed's mutex must also be static
const VerilatedLockGuard lock(VerilatedContextImp::s().s_randMutex); const VerilatedLockGuard lock{VerilatedContextImp::s().s_randMutex};
m_s.m_randSeed = val; m_s.m_randSeed = val;
const vluint64_t newEpoch = VerilatedContextImp::s().s_randSeedEpoch + 1; const vluint64_t newEpoch = VerilatedContextImp::s().s_randSeedEpoch + 1;
// Obververs must see new epoch AFTER seed updated // Obververs must see new epoch AFTER seed updated
@ -2552,10 +2553,10 @@ vluint64_t VerilatedContextImp::randSeedDefault64() const VL_MT_SAFE {
// VerilatedContext:: Methods - scopes // VerilatedContext:: Methods - scopes
void VerilatedContext::scopesDump() const VL_MT_SAFE { void VerilatedContext::scopesDump() const VL_MT_SAFE {
const VerilatedLockGuard lock(m_impdatap->m_nameMutex); const VerilatedLockGuard lock{m_impdatap->m_nameMutex};
VL_PRINTF_MT(" scopesDump:\n"); VL_PRINTF_MT(" scopesDump:\n");
for (const auto& i : m_impdatap->m_nameMap) { for (const auto& i : m_impdatap->m_nameMap) {
const VerilatedScope* scopep = i.second; const VerilatedScope* const scopep = i.second;
scopep->scopeDump(); scopep->scopeDump();
} }
VL_PRINTF_MT("\n"); VL_PRINTF_MT("\n");
@ -2563,20 +2564,20 @@ void VerilatedContext::scopesDump() const VL_MT_SAFE {
void VerilatedContextImp::scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE { void VerilatedContextImp::scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope at construction // Slow ok - called once/scope at construction
const VerilatedLockGuard lock(m_impdatap->m_nameMutex); const VerilatedLockGuard lock{m_impdatap->m_nameMutex};
const auto it = m_impdatap->m_nameMap.find(scopep->name()); const auto it = m_impdatap->m_nameMap.find(scopep->name());
if (it == m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.emplace(scopep->name(), scopep); if (it == m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.emplace(scopep->name(), scopep);
} }
void VerilatedContextImp::scopeErase(const VerilatedScope* scopep) VL_MT_SAFE { void VerilatedContextImp::scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope at destruction // Slow ok - called once/scope at destruction
const VerilatedLockGuard lock(m_impdatap->m_nameMutex); const VerilatedLockGuard lock{m_impdatap->m_nameMutex};
VerilatedImp::userEraseScope(scopep); VerilatedImp::userEraseScope(scopep);
const auto it = m_impdatap->m_nameMap.find(scopep->name()); const auto it = m_impdatap->m_nameMap.find(scopep->name());
if (it != m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.erase(it); if (it != m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.erase(it);
} }
const VerilatedScope* VerilatedContext::scopeFind(const char* namep) const VL_MT_SAFE { const VerilatedScope* VerilatedContext::scopeFind(const char* namep) const VL_MT_SAFE {
// Thread save only assuming this is called only after model construction completed // Thread save only assuming this is called only after model construction completed
const VerilatedLockGuard lock(m_impdatap->m_nameMutex); const VerilatedLockGuard lock{m_impdatap->m_nameMutex};
// If too slow, can assume this is only VL_MT_SAFE_POSINIT // If too slow, can assume this is only VL_MT_SAFE_POSINIT
const auto& it = m_impdatap->m_nameMap.find(namep); const auto& it = m_impdatap->m_nameMap.find(namep);
if (VL_UNLIKELY(it == m_impdatap->m_nameMap.end())) return nullptr; if (VL_UNLIKELY(it == m_impdatap->m_nameMap.end())) return nullptr;
@ -2670,11 +2671,11 @@ static void runCallbacks(const VoidPCbList& cbs) VL_MT_SAFE {
} }
void Verilated::addFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE { void Verilated::addFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE {
const VerilatedLockGuard lock(VlCbStatic.s_flushMutex); const VerilatedLockGuard lock{VlCbStatic.s_flushMutex};
addCb(cb, datap, VlCbStatic.s_flushCbs); addCb(cb, datap, VlCbStatic.s_flushCbs);
} }
void Verilated::removeFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE { void Verilated::removeFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE {
const VerilatedLockGuard lock(VlCbStatic.s_flushMutex); const VerilatedLockGuard lock{VlCbStatic.s_flushMutex};
removeCb(cb, datap, VlCbStatic.s_flushCbs); removeCb(cb, datap, VlCbStatic.s_flushCbs);
} }
void Verilated::runFlushCallbacks() VL_MT_SAFE { void Verilated::runFlushCallbacks() VL_MT_SAFE {
@ -2685,7 +2686,7 @@ void Verilated::runFlushCallbacks() VL_MT_SAFE {
static int s_recursing = 0; static int s_recursing = 0;
#endif #endif
if (!s_recursing++) { if (!s_recursing++) {
const VerilatedLockGuard lock(VlCbStatic.s_flushMutex); const VerilatedLockGuard lock{VlCbStatic.s_flushMutex};
runCallbacks(VlCbStatic.s_flushCbs); runCallbacks(VlCbStatic.s_flushCbs);
} }
--s_recursing; --s_recursing;
@ -2698,11 +2699,11 @@ void Verilated::runFlushCallbacks() VL_MT_SAFE {
} }
void Verilated::addExitCb(VoidPCb cb, void* datap) VL_MT_SAFE { void Verilated::addExitCb(VoidPCb cb, void* datap) VL_MT_SAFE {
const VerilatedLockGuard lock(VlCbStatic.s_exitMutex); const VerilatedLockGuard lock{VlCbStatic.s_exitMutex};
addCb(cb, datap, VlCbStatic.s_exitCbs); addCb(cb, datap, VlCbStatic.s_exitCbs);
} }
void Verilated::removeExitCb(VoidPCb cb, void* datap) VL_MT_SAFE { void Verilated::removeExitCb(VoidPCb cb, void* datap) VL_MT_SAFE {
const VerilatedLockGuard lock(VlCbStatic.s_exitMutex); const VerilatedLockGuard lock{VlCbStatic.s_exitMutex};
removeCb(cb, datap, VlCbStatic.s_exitCbs); removeCb(cb, datap, VlCbStatic.s_exitCbs);
} }
void Verilated::runExitCallbacks() VL_MT_SAFE { void Verilated::runExitCallbacks() VL_MT_SAFE {
@ -2712,7 +2713,7 @@ void Verilated::runExitCallbacks() VL_MT_SAFE {
static int s_recursing = 0; static int s_recursing = 0;
#endif #endif
if (!s_recursing++) { if (!s_recursing++) {
const VerilatedLockGuard lock(VlCbStatic.s_exitMutex); const VerilatedLockGuard lock{VlCbStatic.s_exitMutex};
runCallbacks(VlCbStatic.s_exitCbs); runCallbacks(VlCbStatic.s_exitCbs);
} }
--s_recursing; --s_recursing;
@ -2729,7 +2730,7 @@ void Verilated::nullPointerError(const char* filename, int linenum) VL_MT_SAFE {
void Verilated::overWidthError(const char* signame) VL_MT_SAFE { void Verilated::overWidthError(const char* signame) VL_MT_SAFE {
// Slowpath - Called only when signal sets too high of a bit // Slowpath - Called only when signal sets too high of a bit
const std::string msg = (std::string("Testbench C set input '") + signame const std::string msg = (std::string{"Testbench C set input '"} + signame
+ "' to value that overflows what the signal's width can fit"); + "' to value that overflows what the signal's width can fit");
VL_FATAL_MT("unknown", 0, "", msg.c_str()); VL_FATAL_MT("unknown", 0, "", msg.c_str());
VL_UNREACHABLE VL_UNREACHABLE
@ -2846,7 +2847,7 @@ void VerilatedScope::configure(VerilatedSyms* symsp, const char* prefixp, const
m_type = type; m_type = type;
m_timeunit = timeunit; m_timeunit = timeunit;
{ {
char* namep = new char[std::strlen(prefixp) + std::strlen(suffixp) + 2]; char* const namep = new char[std::strlen(prefixp) + std::strlen(suffixp) + 2];
char* dp = namep; char* dp = namep;
for (const char* sp = prefixp; *sp;) *dp++ = *sp++; for (const char* sp = prefixp; *sp;) *dp++ = *sp++;
if (*prefixp && *suffixp) *dp++ = '.'; if (*prefixp && *suffixp) *dp++ = '.';
@ -2886,7 +2887,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
// statically construct from that. // statically construct from that.
if (!finalize) return; if (!finalize) return;
if (!m_varsp) m_varsp = new VerilatedVarNameMap(); if (!m_varsp) m_varsp = new VerilatedVarNameMap;
VerilatedVar var(namep, datap, vltype, static_cast<VerilatedVarFlags>(vlflags), dims, isParam); VerilatedVar var(namep, datap, vltype, static_cast<VerilatedVarFlags>(vlflags), dims, isParam);
va_list ap; va_list ap;
@ -2903,9 +2904,9 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
} else { } else {
// We could have a linked list of ranges, but really this whole thing needs // We could have a linked list of ranges, but really this whole thing needs
// to be generalized to support structs and unions, etc. // to be generalized to support structs and unions, etc.
VL_FATAL_MT( std::string msg
__FILE__, __LINE__, "", = std::string{"Unsupported multi-dimensional public varInsert: "} + namep;
(std::string("Unsupported multi-dimensional public varInsert: ") + namep).c_str()); VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
} }
} }
va_end(ap); va_end(ap);
@ -2925,7 +2926,7 @@ VerilatedVar* VerilatedScope::varFind(const char* namep) const VL_MT_SAFE_POSTIN
void* VerilatedScope::exportFindNullError(int funcnum) VL_MT_SAFE { void* VerilatedScope::exportFindNullError(int funcnum) VL_MT_SAFE {
// Slowpath - Called only when find has failed // Slowpath - Called only when find has failed
const std::string msg const std::string msg
= (std::string("Testbench C called '") + VerilatedImp::exportName(funcnum) = (std::string{"Testbench C called '"} + VerilatedImp::exportName(funcnum)
+ "' but scope wasn't set, perhaps due to dpi import call without " + "' but scope wasn't set, perhaps due to dpi import call without "
+ "'context', or missing svSetScope. See IEEE 1800-2017 35.5.3."); + "'context', or missing svSetScope. See IEEE 1800-2017 35.5.3.");
VL_FATAL_MT("unknown", 0, "", msg.c_str()); VL_FATAL_MT("unknown", 0, "", msg.c_str());
@ -2935,7 +2936,7 @@ void* VerilatedScope::exportFindNullError(int funcnum) VL_MT_SAFE {
void* VerilatedScope::exportFindError(int funcnum) const { void* VerilatedScope::exportFindError(int funcnum) const {
// Slowpath - Called only when find has failed // Slowpath - Called only when find has failed
const std::string msg const std::string msg
= (std::string("Testbench C called '") + VerilatedImp::exportName(funcnum) = (std::string{"Testbench C called '"} + VerilatedImp::exportName(funcnum)
+ "' but this DPI export function exists only in other scopes, not scope '" + name() + "' but this DPI export function exists only in other scopes, not scope '" + name()
+ "'"); + "'");
VL_FATAL_MT("unknown", 0, "", msg.c_str()); VL_FATAL_MT("unknown", 0, "", msg.c_str());
@ -2950,7 +2951,7 @@ void VerilatedScope::scopeDump() const {
VerilatedImp::exportName(i)); VerilatedImp::exportName(i));
} }
} }
if (VerilatedVarNameMap* varsp = this->varsp()) { if (VerilatedVarNameMap* const varsp = this->varsp()) {
for (const auto& i : *varsp) VL_PRINTF_MT(" VAR %p: %s\n", &(i.second), i.first); for (const auto& i : *varsp) VL_PRINTF_MT(" VAR %p: %s\n", &(i.second), i.first);
} }
} }

4
include/verilated.h
View File

@ -1614,14 +1614,14 @@ static inline IData VL_ONEHOT0_W(int words, WDataInP const lwp) VL_MT_SAFE {
static inline IData VL_CLOG2_I(IData lhs) VL_PURE { static inline IData VL_CLOG2_I(IData lhs) VL_PURE {
// There are faster algorithms, or fls GCC4 builtins, but rarely used // There are faster algorithms, or fls GCC4 builtins, but rarely used
if (VL_UNLIKELY(!lhs)) return 0; if (VL_UNLIKELY(!lhs)) return 0;
lhs--; --lhs;
int shifts = 0; int shifts = 0;
for (; lhs != 0; ++shifts) lhs = lhs >> 1; for (; lhs != 0; ++shifts) lhs = lhs >> 1;
return shifts; return shifts;
} }
static inline IData VL_CLOG2_Q(QData lhs) VL_PURE { static inline IData VL_CLOG2_Q(QData lhs) VL_PURE {
if (VL_UNLIKELY(!lhs)) return 0; if (VL_UNLIKELY(!lhs)) return 0;
lhs--; --lhs;
int shifts = 0; int shifts = 0;
for (; lhs != 0; ++shifts) lhs = lhs >> 1ULL; for (; lhs != 0; ++shifts) lhs = lhs >> 1ULL;
return shifts; return shifts;

56
include/verilated_cov.cpp
View File

@ -132,7 +132,7 @@ private:
int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) { int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
const auto iter = m_valueIndexes.find(value); const auto iter = m_valueIndexes.find(value);
if (iter != m_valueIndexes.end()) return iter->second; if (iter != m_valueIndexes.end()) return iter->second;
m_nextIndex++; ++m_nextIndex;
assert(m_nextIndex > 0); // Didn't rollover assert(m_nextIndex > 0); // Didn't rollover
m_valueIndexes.emplace(value, m_nextIndex); m_valueIndexes.emplace(value, m_nextIndex);
m_indexValues.emplace(m_nextIndex, value); m_indexValues.emplace(m_nextIndex, value);
@ -165,11 +165,11 @@ private:
const std::string& value) VL_PURE { const std::string& value) VL_PURE {
std::string name; std::string name;
if (key.length() == 1 && std::isalpha(key[0])) { if (key.length() == 1 && std::isalpha(key[0])) {
name += std::string("\001") + key; name += std::string{"\001"} + key;
} else { } else {
name += std::string("\001") + dequote(key); name += std::string{"\001"} + dequote(key);
} }
name += std::string("\002") + dequote(value); name += std::string{"\002"} + dequote(value);
return name; return name;
} }
static std::string combineHier(const std::string& old, const std::string& add) VL_PURE { static std::string combineHier(const std::string& old, const std::string& add) VL_PURE {
@ -180,31 +180,32 @@ private:
if (old.empty()) return add; if (old.empty()) return add;
if (add.empty()) return old; if (add.empty()) return old;
const char* a = old.c_str(); const char* const a = old.c_str();
const char* b = add.c_str(); const char* const b = add.c_str();
// Scan forward to first mismatch // Scan forward to first mismatch
const char* apre = a; const char* apre = a;
const char* bpre = b; const char* bpre = b;
while (*apre == *bpre) { while (*apre == *bpre) {
apre++; ++apre;
bpre++; ++bpre;
} }
// We used to backup and split on only .'s but it seems better to be verbose // We used to backup and split on only .'s but it seems better to be verbose
// and not assume . is the separator // and not assume . is the separator
const std::string prefix = std::string(a, apre - a); const size_t prefix_len = apre - a;
const std::string prefix = std::string{a, prefix_len};
// Scan backward to last mismatch // Scan backward to last mismatch
const char* apost = a + std::strlen(a) - 1; const char* apost = a + std::strlen(a) - 1;
const char* bpost = b + std::strlen(b) - 1; const char* bpost = b + std::strlen(b) - 1;
while (*apost == *bpost && apost > apre && bpost > bpre) { while (*apost == *bpost && apost > apre && bpost > bpre) {
apost--; --apost;
bpost--; --bpost;
} }
// Forward to . so we have a whole word // Forward to . so we have a whole word
std::string suffix = *bpost ? std::string(bpost + 1) : ""; std::string suffix = *bpost ? std::string{bpost + 1} : "";
std::string out = prefix + "*" + suffix; std::string out = prefix + "*" + suffix;
@ -253,17 +254,17 @@ public:
// PUBLIC METHODS // PUBLIC METHODS
void forcePerInstance(const bool flag) VL_MT_SAFE_EXCLUDES(m_mutex) { void forcePerInstance(const bool flag) VL_MT_SAFE_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_forcePerInstance = flag; m_forcePerInstance = flag;
} }
void clear() VL_MT_SAFE_EXCLUDES(m_mutex) { void clear() VL_MT_SAFE_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
clearGuts(); clearGuts();
} }
void clearNonMatch(const char* const matchp) VL_MT_SAFE_EXCLUDES(m_mutex) { void clearNonMatch(const char* const matchp) VL_MT_SAFE_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
if (matchp && matchp[0]) { if (matchp && matchp[0]) {
ItemList newlist; ItemList newlist;
for (const auto& itemp : m_items) { for (const auto& itemp : m_items) {
@ -278,24 +279,24 @@ public:
} }
void zero() VL_MT_SAFE_EXCLUDES(m_mutex) { void zero() VL_MT_SAFE_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
for (const auto& itemp : m_items) itemp->zero(); for (const auto& itemp : m_items) itemp->zero();
} }
// We assume there's always call to i/f/p in that order // We assume there's always call to i/f/p in that order
void inserti(VerilatedCovImpItem* itemp) VL_MT_SAFE_EXCLUDES(m_mutex) { void inserti(VerilatedCovImpItem* itemp) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
assert(!m_insertp); assert(!m_insertp);
m_insertp = itemp; m_insertp = itemp;
} }
void insertf(const char* const filenamep, const int lineno) VL_MT_SAFE_EXCLUDES(m_mutex) { void insertf(const char* const filenamep, const int lineno) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_insertFilenamep = filenamep; m_insertFilenamep = filenamep;
m_insertLineno = lineno; m_insertLineno = lineno;
} }
void insertp(const char* ckeyps[VerilatedCovConst::MAX_KEYS], void insertp(const char* ckeyps[VerilatedCovConst::MAX_KEYS],
const char* valps[VerilatedCovConst::MAX_KEYS]) VL_MT_SAFE_EXCLUDES(m_mutex) { const char* valps[VerilatedCovConst::MAX_KEYS]) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
assert(m_insertp); assert(m_insertp);
// First two key/vals are filename // First two key/vals are filename
ckeyps[0] = "filename"; ckeyps[0] = "filename";
@ -308,7 +309,8 @@ public:
while (const char* foundp = std::strchr(fnstartp, '/')) fnstartp = foundp + 1; while (const char* foundp = std::strchr(fnstartp, '/')) fnstartp = foundp + 1;
const char* fnendp = fnstartp; const char* fnendp = fnstartp;
for (; *fnendp && *fnendp != '.'; fnendp++) {} for (; *fnendp && *fnendp != '.'; fnendp++) {}
std::string page_default = "sp_user/" + std::string(fnstartp, fnendp - fnstartp); const size_t page_len = fnendp - fnstartp;
const std::string page_default = "sp_user/" + std::string{fnstartp, page_len};
ckeyps[2] = "page"; ckeyps[2] = "page";
valps[2] = page_default.c_str(); valps[2] = page_default.c_str();
@ -337,7 +339,7 @@ public:
// cout<<" "<<__FUNCTION__<<" "<<key<<" = "<<val<<endl; // cout<<" "<<__FUNCTION__<<" "<<key<<" = "<<val<<endl;
m_insertp->m_keys[addKeynum] = valueIndex(key); m_insertp->m_keys[addKeynum] = valueIndex(key);
m_insertp->m_vals[addKeynum] = valueIndex(val); m_insertp->m_vals[addKeynum] = valueIndex(val);
addKeynum++; ++addKeynum;
if (VL_UNCOVERABLE(!legalKey(key))) { if (VL_UNCOVERABLE(!legalKey(key))) {
std::string msg std::string msg
= ("%Error: Coverage keys of one character, or letter+digit are illegal: " = ("%Error: Coverage keys of one character, or letter+digit are illegal: "
@ -353,15 +355,15 @@ public:
void write(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) { void write(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
#ifndef VM_COVERAGE #ifndef VM_COVERAGE
VL_FATAL_MT("", 0, "", "%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n"); VL_FATAL_MT("", 0, "", "%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
#endif #endif
selftest(); selftest();
std::ofstream os(filename); std::ofstream os{filename};
if (os.fail()) { if (os.fail()) {
std::string msg = std::string("%Error: Can't write '") + filename + "'"; std::string msg = std::string{"%Error: Can't write '"} + filename + "'";
VL_FATAL_MT("", 0, "", msg.c_str()); VL_FATAL_MT("", 0, "", msg.c_str());
return; return;
} }
@ -435,10 +437,10 @@ void VerilatedCovContext::clearNonMatch(const char* matchp) VL_MT_SAFE {
void VerilatedCovContext::zero() VL_MT_SAFE { impp()->zero(); } void VerilatedCovContext::zero() VL_MT_SAFE { impp()->zero(); }
void VerilatedCovContext::write(const char* filenamep) VL_MT_SAFE { impp()->write(filenamep); } void VerilatedCovContext::write(const char* filenamep) VL_MT_SAFE { impp()->write(filenamep); }
void VerilatedCovContext::_inserti(vluint32_t* itemp) VL_MT_SAFE { void VerilatedCovContext::_inserti(vluint32_t* itemp) VL_MT_SAFE {
impp()->inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp)); impp()->inserti(new VerilatedCoverItemSpec<vluint32_t>{itemp});
} }
void VerilatedCovContext::_inserti(vluint64_t* itemp) VL_MT_SAFE { void VerilatedCovContext::_inserti(vluint64_t* itemp) VL_MT_SAFE {
impp()->inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp)); impp()->inserti(new VerilatedCoverItemSpec<vluint64_t>{itemp});
} }
void VerilatedCovContext::_insertf(const char* filename, int lineno) VL_MT_SAFE { void VerilatedCovContext::_insertf(const char* filename, int lineno) VL_MT_SAFE {
impp()->insertf(filename, lineno); impp()->insertf(filename, lineno);
@ -511,7 +513,7 @@ VerilatedCovContext* VerilatedCov::threadCovp() VL_MT_SAFE {
VerilatedCovContext* VerilatedContext::coveragep() VL_MT_SAFE { VerilatedCovContext* VerilatedContext::coveragep() VL_MT_SAFE {
static VerilatedMutex s_mutex; static VerilatedMutex s_mutex;
if (VL_UNLIKELY(!m_coveragep)) { if (VL_UNLIKELY(!m_coveragep)) {
const VerilatedLockGuard lock(s_mutex); const VerilatedLockGuard lock{s_mutex};
if (VL_LIKELY(!m_coveragep)) { // Not redundant, prevents race if (VL_LIKELY(!m_coveragep)) { // Not redundant, prevents race
m_coveragep.reset(new VerilatedCovImp); m_coveragep.reset(new VerilatedCovImp);
} }

56
include/verilated_dpi.cpp
View File

@ -184,7 +184,7 @@ static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHa
VL_FATAL_MT(__FILE__, __LINE__, "", VL_FATAL_MT(__FILE__, __LINE__, "",
"%%Error: DPI svOpenArrayHandle function called with nullptr handle"); "%%Error: DPI svOpenArrayHandle function called with nullptr handle");
} }
const VerilatedDpiOpenVar* varp = reinterpret_cast<const VerilatedDpiOpenVar*>(h); const VerilatedDpiOpenVar* const varp = reinterpret_cast<const VerilatedDpiOpenVar*>(h);
if (VL_UNLIKELY(!varp->magicOk())) { if (VL_UNLIKELY(!varp->magicOk())) {
VL_FATAL_MT(__FILE__, __LINE__, "", VL_FATAL_MT(__FILE__, __LINE__, "",
"%%Error: DPI svOpenArrayHandle function called with non-Verilator handle"); "%%Error: DPI svOpenArrayHandle function called with non-Verilator handle");
@ -205,13 +205,13 @@ int svDimensions(const svOpenArrayHandle h) { return _vl_openhandle_varp(h)->udi
// Return pointer to open array data, or nullptr if not in IEEE standard C layout // Return pointer to open array data, or nullptr if not in IEEE standard C layout
void* svGetArrayPtr(const svOpenArrayHandle h) { void* svGetArrayPtr(const svOpenArrayHandle h) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(h);
if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr; if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr;
return varp->datap(); return varp->datap();
} }
// Return size of open array, or 0 if not in IEEE standard C layout // Return size of open array, or 0 if not in IEEE standard C layout
int svSizeOfArray(const svOpenArrayHandle h) { int svSizeOfArray(const svOpenArrayHandle h) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(h);
if (VL_UNLIKELY(!varp->isDpiStdLayout())) return 0; if (VL_UNLIKELY(!varp->isDpiStdLayout())) return 0;
// Truncate 64 bits to int; DPI is limited to 4GB // Truncate 64 bits to int; DPI is limited to 4GB
return static_cast<int>(varp->totalSize()); return static_cast<int>(varp->totalSize());
@ -264,15 +264,15 @@ static void* _vl_svGetArrElemPtr(const svOpenArrayHandle h, int nargs, int indx1
int indx3) VL_MT_SAFE { int indx3) VL_MT_SAFE {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h); const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr; if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr;
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
return datap; return datap;
} }
// Copy to user bit array from simulator open array // Copy to user bit array from simulator open array
static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int nargs, static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int nargs,
int indx1, int indx2, int indx3) VL_MT_SAFE { int indx1, int indx2, int indx3) VL_MT_SAFE {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return; if (VL_UNLIKELY(!datap)) return;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: d[0] = *(reinterpret_cast<CData*>(datap)); return; case VLVT_UINT8: d[0] = *(reinterpret_cast<CData*>(datap)); return;
@ -299,8 +299,8 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
// Copy to user logic array from simulator open array // Copy to user logic array from simulator open array
static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int nargs, static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int nargs,
int indx1, int indx2, int indx3) VL_MT_SAFE { int indx1, int indx2, int indx3) VL_MT_SAFE {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return; if (VL_UNLIKELY(!datap)) return;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: case VLVT_UINT8:
@ -342,8 +342,8 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
// Copy to simulator open array from from user bit array // Copy to simulator open array from from user bit array
static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int nargs, static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int nargs,
int indx1, int indx2, int indx3) VL_MT_SAFE { int indx1, int indx2, int indx3) VL_MT_SAFE {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return; if (VL_UNLIKELY(!datap)) return;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0]; return; case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0]; return;
@ -364,8 +364,8 @@ static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecV
// Copy to simulator open array from from user logic array // Copy to simulator open array from from user logic array
static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s, static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE { int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return; if (VL_UNLIKELY(!datap)) return;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0].aval; return; case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0].aval; return;
@ -388,8 +388,8 @@ static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogic
static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s, int nargs, int indx1, int indx2, static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s, int nargs, int indx1, int indx2,
int indx3, int indx4) VL_MT_SAFE { int indx3, int indx4) VL_MT_SAFE {
// One extra index supported, as need bit number // One extra index supported, as need bit number
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return 0; if (VL_UNLIKELY(!datap)) return 0;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: return (*(reinterpret_cast<CData*>(datap))) & 1; case VLVT_UINT8: return (*(reinterpret_cast<CData*>(datap))) & 1;
@ -404,8 +404,8 @@ static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value, int narg
int indx2, int indx3, int indx4) VL_MT_SAFE { int indx2, int indx3, int indx4) VL_MT_SAFE {
// One extra index supported, as need bit number // One extra index supported, as need bit number
value &= 1; // Make sure clean value &= 1; // Make sure clean
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3); void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
if (VL_UNLIKELY(!datap)) return; if (VL_UNLIKELY(!datap)) return;
switch (varp->vltype()) { // LCOV_EXCL_BR_LINE switch (varp->vltype()) { // LCOV_EXCL_BR_LINE
case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = value; return; case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = value; return;
@ -420,7 +420,7 @@ static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value, int narg
// DPI accessors that simply call above functions // DPI accessors that simply call above functions
void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) { void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(h);
void* datap; void* datap;
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
@ -454,7 +454,7 @@ void* svGetArrElemPtr3(const svOpenArrayHandle h, int indx1, int indx2, int indx
} }
void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1, ...) { void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -486,7 +486,7 @@ void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s, int
_vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
} }
void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1, ...) { void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -522,7 +522,7 @@ void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
// From simulator storage into user space // From simulator storage into user space
void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1, ...) { void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -553,7 +553,7 @@ void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1
_vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
} }
void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1, ...) { void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -585,7 +585,7 @@ void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s, int i
} }
svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) { svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
svBit out; svBit out;
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
@ -618,7 +618,7 @@ svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int indx
} }
svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) { svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
// Verilator doesn't support X/Z so can just call Bit version // Verilator doesn't support X/Z so can just call Bit version
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
svBit out; svBit out;
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
@ -654,7 +654,7 @@ svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int
} }
void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) { void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -685,7 +685,7 @@ void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1, int ind
} }
void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...) { void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...) {
// Verilator doesn't support X/Z so can just call Bit version // Verilator doesn't support X/Z so can just call Bit version
const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d); const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
va_list ap; va_list ap;
va_start(ap, indx1); va_start(ap, indx1);
switch (varp->udims()) { switch (varp->udims()) {
@ -732,15 +732,15 @@ svScope svGetScope() {
} }
svScope svSetScope(const svScope scope) { svScope svSetScope(const svScope scope) {
const VerilatedScope* prevScopep = Verilated::dpiScope(); const VerilatedScope* const prevScopep = Verilated::dpiScope();
const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope); const VerilatedScope* const vscopep = reinterpret_cast<const VerilatedScope*>(scope);
Verilated::dpiScope(vscopep); Verilated::dpiScope(vscopep);
// NOLINTNEXTLINE(google-readability-casting) // NOLINTNEXTLINE(google-readability-casting)
return (svScope)(prevScopep); return (svScope)(prevScopep);
} }
const char* svGetNameFromScope(const svScope scope) { const char* svGetNameFromScope(const svScope scope) {
const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope); const VerilatedScope* const vscopep = reinterpret_cast<const VerilatedScope*>(scope);
return vscopep->name(); return vscopep->name();
} }

10
include/verilated_fst_c.cpp
View File

@ -98,7 +98,7 @@ VerilatedFst::~VerilatedFst() {
} }
void VerilatedFst::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedFst::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_fst = fstWriterCreate(filename, 1); m_fst = fstWriterCreate(filename, 1);
fstWriterSetPackType(m_fst, FST_WR_PT_LZ4); fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
fstWriterSetTimescaleFromString(m_fst, timeResStr().c_str()); // lintok-begin-on-ref fstWriterSetTimescaleFromString(m_fst, timeResStr().c_str()); // lintok-begin-on-ref
@ -130,14 +130,14 @@ void VerilatedFst::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
} }
void VerilatedFst::close() VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedFst::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
VerilatedTrace<VerilatedFst>::closeBase(); VerilatedTrace<VerilatedFst>::closeBase();
fstWriterClose(m_fst); fstWriterClose(m_fst);
m_fst = nullptr; m_fst = nullptr;
} }
void VerilatedFst::flush() VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedFst::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
VerilatedTrace<VerilatedFst>::flushBase(); VerilatedTrace<VerilatedFst>::flushBase();
fstWriterFlushContext(m_fst); fstWriterFlushContext(m_fst);
} }
@ -161,11 +161,11 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
VerilatedTrace<VerilatedFst>::declCode(code, bits, false); VerilatedTrace<VerilatedFst>::declCode(code, bits, false);
std::istringstream nameiss(name); std::istringstream nameiss{name};
std::istream_iterator<std::string> beg(nameiss); std::istream_iterator<std::string> beg(nameiss);
std::istream_iterator<std::string> end; std::istream_iterator<std::string> end;
std::list<std::string> tokens(beg, end); // Split name std::list<std::string> tokens(beg, end); // Split name
std::string symbol_name(tokens.back()); std::string symbol_name{tokens.back()};
tokens.pop_back(); // Remove symbol name from hierarchy tokens.pop_back(); // Remove symbol name from hierarchy
tokens.insert(tokens.begin(), moduleName()); // Add current module to the hierarchy tokens.insert(tokens.begin(), moduleName()); // Add current module to the hierarchy
std::string tmpModName; std::string tmpModName;

10
include/verilated_heavy.h
View File

@ -316,7 +316,7 @@ public:
}); });
} }
void reverse() { std::reverse(m_deque.begin(), m_deque.end()); } void reverse() { std::reverse(m_deque.begin(), m_deque.end()); }
void shuffle() { std::shuffle(m_deque.begin(), m_deque.end(), VlURNG()); } void shuffle() { std::shuffle(m_deque.begin(), m_deque.end(), VlURNG{}); }
VlQueue unique() const { VlQueue unique() const {
VlQueue out; VlQueue out;
std::unordered_set<T_Value> saw; std::unordered_set<T_Value> saw;
@ -397,12 +397,12 @@ public:
// Reduction operators // Reduction operators
VlQueue min() const { VlQueue min() const {
if (m_deque.empty()) return VlQueue(); if (m_deque.empty()) return VlQueue{};
const auto it = std::min_element(m_deque.begin(), m_deque.end()); const auto it = std::min_element(m_deque.begin(), m_deque.end());
return VlQueue::cons(*it); return VlQueue::cons(*it);
} }
VlQueue max() const { VlQueue max() const {
if (m_deque.empty()) return VlQueue(); if (m_deque.empty()) return VlQueue{};
const auto it = std::max_element(m_deque.begin(), m_deque.end()); const auto it = std::max_element(m_deque.begin(), m_deque.end());
return VlQueue::cons(*it); return VlQueue::cons(*it);
} }
@ -774,7 +774,7 @@ std::string VL_TO_STRING(const VlAssocArray<T_Key, T_Value>& obj) {
template <class T_Key, class T_Value> template <class T_Key, class T_Value>
void VL_READMEM_N(bool hex, int bits, const std::string& filename, void VL_READMEM_N(bool hex, int bits, const std::string& filename,
VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE { VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
VlReadMem rmem(hex, bits, filename, start, end); VlReadMem rmem{hex, bits, filename, start, end};
if (VL_UNLIKELY(!rmem.isOpen())) return; if (VL_UNLIKELY(!rmem.isOpen())) return;
while (true) { while (true) {
QData addr; QData addr;
@ -790,7 +790,7 @@ void VL_READMEM_N(bool hex, int bits, const std::string& filename,
template <class T_Key, class T_Value> template <class T_Key, class T_Value>
void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename, void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE { const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
VlWriteMem wmem(hex, bits, filename, start, end); VlWriteMem wmem{hex, bits, filename, start, end};
if (VL_UNLIKELY(!wmem.isOpen())) return; if (VL_UNLIKELY(!wmem.isOpen())) return;
for (const auto& i : obj) { for (const auto& i : obj) {
const QData addr = i.first; const QData addr = i.first;

48
include/verilated_imp.h
View File

@ -104,7 +104,7 @@ public:
// METHODS // METHODS
// Add message to queue (called by producer) // Add message to queue (called by producer)
void post(const VerilatedMsg& msg) VL_MT_SAFE_EXCLUDES(m_mutex) { void post(const VerilatedMsg& msg) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_queue.insert(msg); // Pass by value to copy the message into queue m_queue.insert(msg); // Pass by value to copy the message into queue
++m_depth; ++m_depth;
} }
@ -124,7 +124,7 @@ public:
const VerilatedMsg msg = *(it); const VerilatedMsg msg = *(it);
m_queue.erase(it); m_queue.erase(it);
m_mutex.unlock(); m_mutex.unlock();
m_depth--; // Ok if outside critical section as only this code checks the value --m_depth; // Ok if outside critical section as only this code checks the value
{ {
VL_DEBUG_IF(VL_DBG_MSGF("Executing callback from mtaskId=%d\n", msg.mtaskId());); VL_DEBUG_IF(VL_DBG_MSGF("Executing callback from mtaskId=%d\n", msg.mtaskId()););
msg.run(); msg.run();
@ -256,11 +256,11 @@ public: // But only for verilated*.cpp
int timeFormatWidth() const VL_MT_SAFE { return m_s.m_timeFormatWidth; } int timeFormatWidth() const VL_MT_SAFE { return m_s.m_timeFormatWidth; }
void timeFormatWidth(int value) VL_MT_SAFE { m_s.m_timeFormatWidth = value; } void timeFormatWidth(int value) VL_MT_SAFE { m_s.m_timeFormatWidth = value; }
std::string timeFormatSuffix() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) { std::string timeFormatSuffix() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
const VerilatedLockGuard lock(m_timeDumpMutex); const VerilatedLockGuard lock{m_timeDumpMutex};
return m_timeFormatSuffix; return m_timeFormatSuffix;
} }
void timeFormatSuffix(const std::string& value) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) { void timeFormatSuffix(const std::string& value) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
const VerilatedLockGuard lock(m_timeDumpMutex); const VerilatedLockGuard lock{m_timeDumpMutex};
m_timeFormatSuffix = value; m_timeFormatSuffix = value;
} }
@ -276,7 +276,7 @@ public: // But only for verilated*.cpp
public: // But only for verilated*.cpp public: // But only for verilated*.cpp
// METHODS - file IO // METHODS - file IO
IData fdNewMcd(const char* filenamep) VL_MT_SAFE_EXCLUDES(m_fdMutex) { IData fdNewMcd(const char* filenamep) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
if (m_fdFreeMct.empty()) return 0; if (m_fdFreeMct.empty()) return 0;
IData idx = m_fdFreeMct.back(); IData idx = m_fdFreeMct.back();
m_fdFreeMct.pop_back(); m_fdFreeMct.pop_back();
@ -285,10 +285,10 @@ public: // But only for verilated*.cpp
return (1 << idx); return (1 << idx);
} }
IData fdNew(const char* filenamep, const char* modep) VL_MT_SAFE_EXCLUDES(m_fdMutex) { IData fdNew(const char* filenamep, const char* modep) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
FILE* fp = std::fopen(filenamep, modep); FILE* const fp = std::fopen(filenamep, modep);
if (VL_UNLIKELY(!fp)) return 0; if (VL_UNLIKELY(!fp)) return 0;
// Bit 31 indicates it's a descriptor not a MCD // Bit 31 indicates it's a descriptor not a MCD
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
if (m_fdFree.empty()) { if (m_fdFree.empty()) {
// Need to create more space in m_fdps and m_fdFree // Need to create more space in m_fdps and m_fdFree
const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, m_fdps.size()); const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, m_fdps.size());
@ -306,25 +306,25 @@ public: // But only for verilated*.cpp
return (idx | (1UL << 31)); // bit 31 indicates not MCD return (idx | (1UL << 31)); // bit 31 indicates not MCD
} }
void fdFlush(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) { void fdFlush(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
for (const auto& i : fdlist) std::fflush(i); for (const auto& i : fdlist) std::fflush(i);
} }
IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE_EXCLUDES(m_fdMutex) { IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
if (VL_UNLIKELY(fdlist.size() != 1)) return 0; if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
return static_cast<IData>( return static_cast<IData>(
std::fseek(*fdlist.begin(), static_cast<long>(offset), static_cast<int>(origin))); std::fseek(*fdlist.begin(), static_cast<long>(offset), static_cast<int>(origin)));
} }
IData fdTell(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) { IData fdTell(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
if (VL_UNLIKELY(fdlist.size() != 1)) return 0; if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
return static_cast<IData>(std::ftell(*fdlist.begin())); return static_cast<IData>(std::ftell(*fdlist.begin()));
} }
void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE_EXCLUDES(m_fdMutex) { void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
for (const auto& i : fdlist) { for (const auto& i : fdlist) {
if (VL_UNLIKELY(!i)) continue; if (VL_UNLIKELY(!i)) continue;
@ -332,7 +332,7 @@ public: // But only for verilated*.cpp
} }
} }
void fdClose(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) { void fdClose(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
if (VL_BITISSET_I(fdi, 31)) { if (VL_BITISSET_I(fdi, 31)) {
// Non-MCD case // Non-MCD case
IData idx = VL_MASK_I(31) & fdi; IData idx = VL_MASK_I(31) & fdi;
@ -356,7 +356,7 @@ public: // But only for verilated*.cpp
} }
} }
inline FILE* fdToFp(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) { inline FILE* fdToFp(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
const VerilatedLockGuard lock(m_fdMutex); const VerilatedLockGuard lock{m_fdMutex};
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr; if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr;
return *fdlist.begin(); return *fdlist.begin();
@ -463,7 +463,7 @@ public:
// per map overhead * N scopes would take much more space and cache thrashing. // per map overhead * N scopes would take much more space and cache thrashing.
// As scopep's are pointers, this implicitly handles multiple Context's // As scopep's are pointers, this implicitly handles multiple Context's
static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE { static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
const VerilatedLockGuard lock(s().m_userMapMutex); const VerilatedLockGuard lock{s().m_userMapMutex};
const auto it = s().m_userMap.find(std::make_pair(scopep, userKey)); const auto it = s().m_userMap.find(std::make_pair(scopep, userKey));
if (it != s().m_userMap.end()) { if (it != s().m_userMap.end()) {
it->second = userData; it->second = userData;
@ -472,7 +472,7 @@ public:
} }
} }
static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE { static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
const VerilatedLockGuard lock(s().m_userMapMutex); const VerilatedLockGuard lock{s().m_userMapMutex};
const auto& it = vlstd::as_const(s().m_userMap).find(std::make_pair(scopep, userKey)); const auto& it = vlstd::as_const(s().m_userMap).find(std::make_pair(scopep, userKey));
if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr; if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr;
return it->second; return it->second;
@ -482,7 +482,7 @@ public: // But only for verilated.cpp
// Symbol table destruction cleans up the entries for each scope. // Symbol table destruction cleans up the entries for each scope.
static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE { static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope on destruction, so we simply iterate. // Slow ok - called once/scope on destruction, so we simply iterate.
const VerilatedLockGuard lock(s().m_userMapMutex); const VerilatedLockGuard lock{s().m_userMapMutex};
for (auto it = s().m_userMap.begin(); it != s().m_userMap.end();) { for (auto it = s().m_userMap.begin(); it != s().m_userMap.end();) {
if (it->first.first == scopep) { if (it->first.first == scopep) {
s().m_userMap.erase(it++); s().m_userMap.erase(it++);
@ -492,7 +492,7 @@ public: // But only for verilated.cpp
} }
} }
static void userDump() VL_MT_SAFE { static void userDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s().m_userMapMutex); // Avoid it changing in middle of dump const VerilatedLockGuard lock{s().m_userMapMutex}; // Avoid it changing in middle of dump
bool first = true; bool first = true;
for (const auto& i : s().m_userMap) { for (const auto& i : s().m_userMap) {
if (first) { if (first) {
@ -508,13 +508,13 @@ public: // But only for verilated*.cpp
// METHODS - hierarchy // METHODS - hierarchy
static void hierarchyAdd(const VerilatedScope* fromp, const VerilatedScope* top) VL_MT_SAFE { static void hierarchyAdd(const VerilatedScope* fromp, const VerilatedScope* top) VL_MT_SAFE {
// Slow ok - called at construction for VPI accessible elements // Slow ok - called at construction for VPI accessible elements
const VerilatedLockGuard lock(s().m_hierMapMutex); const VerilatedLockGuard lock{s().m_hierMapMutex};
s().m_hierMap[fromp].push_back(top); s().m_hierMap[fromp].push_back(top);
} }
static void hierarchyRemove(const VerilatedScope* fromp, static void hierarchyRemove(const VerilatedScope* fromp,
const VerilatedScope* top) VL_MT_SAFE { const VerilatedScope* top) VL_MT_SAFE {
// Slow ok - called at destruction for VPI accessible elements // Slow ok - called at destruction for VPI accessible elements
const VerilatedLockGuard lock(s().m_hierMapMutex); const VerilatedLockGuard lock{s().m_hierMapMutex};
VerilatedHierarchyMap& map = s().m_hierMap; VerilatedHierarchyMap& map = s().m_hierMap;
if (map.find(fromp) == map.end()) return; if (map.find(fromp) == map.end()) return;
auto& scopes = map[fromp]; auto& scopes = map[fromp];
@ -537,7 +537,7 @@ public: // But only for verilated*.cpp
// miss at the cost of a multiply, and all lookups move to slowpath. // miss at the cost of a multiply, and all lookups move to slowpath.
static int exportInsert(const char* namep) VL_MT_SAFE { static int exportInsert(const char* namep) VL_MT_SAFE {
// Slow ok - called once/function at creation // Slow ok - called once/function at creation
const VerilatedLockGuard lock(s().m_exportMutex); const VerilatedLockGuard lock{s().m_exportMutex};
const auto it = s().m_exportMap.find(namep); const auto it = s().m_exportMap.find(namep);
if (it == s().m_exportMap.end()) { if (it == s().m_exportMap.end()) {
s().m_exportMap.emplace(namep, s().m_exportNext++); s().m_exportMap.emplace(namep, s().m_exportNext++);
@ -547,24 +547,24 @@ public: // But only for verilated*.cpp
} }
} }
static int exportFind(const char* namep) VL_MT_SAFE { static int exportFind(const char* namep) VL_MT_SAFE {
const VerilatedLockGuard lock(s().m_exportMutex); const VerilatedLockGuard lock{s().m_exportMutex};
const auto& it = s().m_exportMap.find(namep); const auto& it = s().m_exportMap.find(namep);
if (VL_LIKELY(it != s().m_exportMap.end())) return it->second; if (VL_LIKELY(it != s().m_exportMap.end())) return it->second;
std::string msg = (std::string("%Error: Testbench C called ") + namep std::string msg = (std::string{"%Error: Testbench C called "} + namep
+ " but no such DPI export function name exists in ANY model"); + " but no such DPI export function name exists in ANY model");
VL_FATAL_MT("unknown", 0, "", msg.c_str()); VL_FATAL_MT("unknown", 0, "", msg.c_str());
return -1; return -1;
} }
static const char* exportName(int funcnum) VL_MT_SAFE { static const char* exportName(int funcnum) VL_MT_SAFE {
// Slowpath; find name for given export; errors only so no map to reverse-map it // Slowpath; find name for given export; errors only so no map to reverse-map it
const VerilatedLockGuard lock(s().m_exportMutex); const VerilatedLockGuard lock{s().m_exportMutex};
for (const auto& i : s().m_exportMap) { for (const auto& i : s().m_exportMap) {
if (i.second == funcnum) return i.first; if (i.second == funcnum) return i.first;
} }
return "*UNKNOWN*"; return "*UNKNOWN*";
} }
static void exportsDump() VL_MT_SAFE { static void exportsDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s().m_exportMutex); const VerilatedLockGuard lock{s().m_exportMutex};
bool first = true; bool first = true;
for (const auto& i : s().m_exportMap) { for (const auto& i : s().m_exportMap) {
if (first) { if (first) {

10
include/verilated_save.cpp
View File

@ -93,8 +93,8 @@ void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, std::strlen(VLTSAVE_HEADER_STR)))) { if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, std::strlen(VLTSAVE_HEADER_STR)))) {
const std::string fn = filename(); const std::string fn = filename();
const std::string msg const std::string msg
= std::string( = std::
"Can't deserialize; file has wrong header signature, or file not found: ") string{"Can't deserialize; file has wrong header signature, or file not found: "}
+ filename(); + filename();
VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str()); VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
// Die before we close() as close would infinite loop // Die before we close() as close would infinite loop
@ -112,7 +112,7 @@ void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, std::strlen(VLTSAVE_TRAILER_STR)))) { if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, std::strlen(VLTSAVE_TRAILER_STR)))) {
const std::string fn = filename(); const std::string fn = filename();
const std::string msg const std::string msg
= std::string("Can't deserialize; file has wrong end-of-file signature: ") = std::string{"Can't deserialize; file has wrong end-of-file signature: "}
+ filename(); + filename();
VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str()); VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
// Die before we close() as close would infinite loop // Die before we close() as close would infinite loop
@ -204,7 +204,7 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) { if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
// LCOV_EXCL_START // LCOV_EXCL_START
// write failed, presume error (perhaps out of disk space) // write failed, presume error (perhaps out of disk space)
std::string msg = std::string(__FUNCTION__) + ": " + std::strerror(errno); std::string msg = std::string{__FUNCTION__} + ": " + std::strerror(errno);
VL_FATAL_MT("", 0, "", msg.c_str()); VL_FATAL_MT("", 0, "", msg.c_str());
close(); close();
break; break;
@ -235,7 +235,7 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) { if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
// LCOV_EXCL_START // LCOV_EXCL_START
// write failed, presume error (perhaps out of disk space) // write failed, presume error (perhaps out of disk space)
const std::string msg = std::string(__FUNCTION__) + ": " + std::strerror(errno); const std::string msg = std::string{__FUNCTION__} + ": " + std::strerror(errno);
VL_FATAL_MT("", 0, "", msg.c_str()); VL_FATAL_MT("", 0, "", msg.c_str());
close(); close();
break; break;

8
include/verilated_threads.cpp
View File

@ -104,7 +104,7 @@ VlThreadPool::VlThreadPool(VerilatedContext* contextp, int nThreads, bool profil
} }
// Create'em // Create'em
for (int i = 0; i < nThreads; ++i) { for (int i = 0; i < nThreads; ++i) {
m_workers.push_back(new VlWorkerThread(this, contextp, profiling)); m_workers.push_back(new VlWorkerThread{this, contextp, profiling});
} }
// Set up a profile buffer for the current thread too -- on the // Set up a profile buffer for the current thread too -- on the
// assumption that it's the same thread that calls eval and may be // assumption that it's the same thread that calls eval and may be
@ -131,13 +131,13 @@ void VlThreadPool::setupProfilingClientThread() VL_MT_SAFE_EXCLUDES(m_mutex) {
// try not to malloc while collecting profiling. // try not to malloc while collecting profiling.
t_profilep->reserve(4096); t_profilep->reserve(4096);
{ {
const VerilatedLockGuard lk(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_allProfiles.insert(t_profilep); m_allProfiles.insert(t_profilep);
} }
} }
void VlThreadPool::profileAppendAll(const VlProfileRec& rec) VL_MT_SAFE_EXCLUDES(m_mutex) { void VlThreadPool::profileAppendAll(const VlProfileRec& rec) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lk(m_mutex); const VerilatedLockGuard lock{m_mutex};
for (const auto& profilep : m_allProfiles) { for (const auto& profilep : m_allProfiles) {
// Every thread's profile trace gets a copy of rec. // Every thread's profile trace gets a copy of rec.
profilep->emplace_back(rec); profilep->emplace_back(rec);
@ -146,7 +146,7 @@ void VlThreadPool::profileAppendAll(const VlProfileRec& rec) VL_MT_SAFE_EXCLUDES
void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed)
VL_MT_SAFE_EXCLUDES(m_mutex) { VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lk(m_mutex); const VerilatedLockGuard lock{m_mutex};
VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep);); VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep););
FILE* const fp = std::fopen(filenamep, "w"); FILE* const fp = std::fopen(filenamep, "w");

6
include/verilated_threads.h
View File

@ -225,10 +225,10 @@ public:
} }
VL_CPU_RELAX(); VL_CPU_RELAX();
} }
VerilatedLockGuard lk(m_mutex); VerilatedLockGuard lock{m_mutex};
while (m_ready.empty()) { while (m_ready.empty()) {
m_waiting = true; m_waiting = true;
m_cv.wait(lk); m_cv.wait(lock);
} }
m_waiting = false; m_waiting = false;
// As noted above this is inefficient if our ready list is ever // As noted above this is inefficient if our ready list is ever
@ -242,7 +242,7 @@ public:
VL_MT_SAFE_EXCLUDES(m_mutex) { VL_MT_SAFE_EXCLUDES(m_mutex) {
bool notify; bool notify;
{ {
const VerilatedLockGuard lk(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_ready.emplace_back(fnp, selfp, evenCycle); m_ready.emplace_back(fnp, selfp, evenCycle);
m_ready_size.fetch_add(1, std::memory_order_relaxed); m_ready_size.fetch_add(1, std::memory_order_relaxed);
notify = m_waiting; notify = m_waiting;

8
include/verilated_trace.h
View File

@ -52,21 +52,21 @@ private:
public: public:
// Put an element at the back of the queue // Put an element at the back of the queue
void put(T value) VL_MT_SAFE_EXCLUDES(m_mutex) { void put(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_queue.push_back(value); m_queue.push_back(value);
m_cv.notify_one(); m_cv.notify_one();
} }
// Put an element at the front of the queue // Put an element at the front of the queue
void put_front(T value) VL_MT_SAFE_EXCLUDES(m_mutex) { void put_front(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
m_queue.push_front(value); m_queue.push_front(value);
m_cv.notify_one(); m_cv.notify_one();
} }
// Get an element from the front of the queue. Blocks if none available // Get an element from the front of the queue. Blocks if none available
T get() VL_MT_SAFE_EXCLUDES(m_mutex) { T get() VL_MT_SAFE_EXCLUDES(m_mutex) {
VerilatedLockGuard lock(m_mutex); VerilatedLockGuard lock{m_mutex};
m_cv.wait(lock, [this]() VL_REQUIRES(m_mutex) { return !m_queue.empty(); }); m_cv.wait(lock, [this]() VL_REQUIRES(m_mutex) { return !m_queue.empty(); });
assert(!m_queue.empty()); assert(!m_queue.empty());
T value = m_queue.front(); T value = m_queue.front();
@ -76,7 +76,7 @@ public:
// Non blocking get // Non blocking get
bool tryGet(T& result) VL_MT_SAFE_EXCLUDES(m_mutex) { bool tryGet(T& result) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lockGuard(m_mutex); const VerilatedLockGuard lockGuard{m_mutex};
if (m_queue.empty()) return false; if (m_queue.empty()) return false;
result = m_queue.front(); result = m_queue.front();
m_queue.pop_front(); m_queue.pop_front();

18
include/verilated_trace_imp.cpp
View File

@ -246,7 +246,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::closeBase() {
shutdownWorker(); shutdownWorker();
while (m_numTraceBuffers) { while (m_numTraceBuffers) {
delete[] m_buffersFromWorker.get(); delete[] m_buffersFromWorker.get();
m_numTraceBuffers--; --m_numTraceBuffers;
} }
#endif #endif
} }
@ -351,7 +351,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
m_traceBufferSize = nextCode() + numSignals() * 2 + 4; m_traceBufferSize = nextCode() + numSignals() * 2 + 4;
// Start the worker thread // Start the worker thread
m_workerThread.reset(new std::thread(&VerilatedTrace<VL_DERIVED_T>::workerThreadMain, this)); m_workerThread.reset(new std::thread{&VerilatedTrace<VL_DERIVED_T>::workerThreadMain, this});
#endif #endif
} }
@ -398,7 +398,7 @@ void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) VL_MT_SAFE_EXCLUDES(m
// Not really VL_MT_SAFE but more VL_MT_UNSAFE_ONE. // Not really VL_MT_SAFE but more VL_MT_UNSAFE_ONE.
// This does get the mutex, but if multiple threads are trying to dump // This does get the mutex, but if multiple threads are trying to dump
// chances are the data being dumped will have other problems // chances are the data being dumped will have other problems
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
if (VL_UNCOVERABLE(m_timeLastDump && timeui <= m_timeLastDump)) { // LCOV_EXCL_START if (VL_UNCOVERABLE(m_timeLastDump && timeui <= m_timeLastDump)) { // LCOV_EXCL_START
VL_PRINTF_MT("%%Warning: previous dump at t=%" VL_PRI64 "u, requesting t=%" VL_PRI64 VL_PRINTF_MT("%%Warning: previous dump at t=%" VL_PRI64 "u, requesting t=%" VL_PRI64
"u, dump call ignored\n", "u, dump call ignored\n",
@ -479,9 +479,9 @@ template <>
void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>& cbVec, void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>& cbVec,
CallbackRecord& cbRec) CallbackRecord& cbRec)
VL_MT_SAFE_EXCLUDES(m_mutex) { VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
if (VL_UNCOVERABLE(timeLastDump() != 0)) { // LCOV_EXCL_START if (VL_UNCOVERABLE(timeLastDump() != 0)) { // LCOV_EXCL_START
std::string msg = (std::string("Internal: ") + __FILE__ + "::" + __FUNCTION__ std::string msg = (std::string{"Internal: "} + __FILE__ + "::" + __FUNCTION__
+ " called with already open file"); + " called with already open file");
VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
} // LCOV_EXCL_STOP } // LCOV_EXCL_STOP
@ -489,19 +489,19 @@ void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>
} }
template <> void VerilatedTrace<VL_DERIVED_T>::addInitCb(initCb_t cb, void* userp) VL_MT_SAFE { template <> void VerilatedTrace<VL_DERIVED_T>::addInitCb(initCb_t cb, void* userp) VL_MT_SAFE {
CallbackRecord cbr(cb, userp); CallbackRecord cbr{cb, userp};
addCallbackRecord(m_initCbs, cbr); addCallbackRecord(m_initCbs, cbr);
} }
template <> void VerilatedTrace<VL_DERIVED_T>::addFullCb(dumpCb_t cb, void* userp) VL_MT_SAFE { template <> void VerilatedTrace<VL_DERIVED_T>::addFullCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
CallbackRecord cbr(cb, userp); CallbackRecord cbr{cb, userp};
addCallbackRecord(m_fullCbs, cbr); addCallbackRecord(m_fullCbs, cbr);
} }
template <> void VerilatedTrace<VL_DERIVED_T>::addChgCb(dumpCb_t cb, void* userp) VL_MT_SAFE { template <> void VerilatedTrace<VL_DERIVED_T>::addChgCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
CallbackRecord cbr(cb, userp); CallbackRecord cbr{cb, userp};
addCallbackRecord(m_chgCbs, cbr); addCallbackRecord(m_chgCbs, cbr);
} }
template <> void VerilatedTrace<VL_DERIVED_T>::addCleanupCb(dumpCb_t cb, void* userp) VL_MT_SAFE { template <> void VerilatedTrace<VL_DERIVED_T>::addCleanupCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
CallbackRecord cbr(cb, userp); CallbackRecord cbr{cb, userp};
addCallbackRecord(m_cleanupCbs, cbr); addCallbackRecord(m_cleanupCbs, cbr);
} }
template <> void VerilatedTrace<VL_DERIVED_T>::module(const std::string& name) VL_MT_UNSAFE { template <> void VerilatedTrace<VL_DERIVED_T>::module(const std::string& name) VL_MT_UNSAFE {

26
include/verilated_vcd_c.cpp
View File

@ -102,7 +102,7 @@ VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep) {
} }
void VerilatedVcd::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedVcd::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
if (isOpen()) return; if (isOpen()) return;
// Set member variables // Set member variables
@ -120,7 +120,7 @@ void VerilatedVcd::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
void VerilatedVcd::openNext(bool incFilename) VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedVcd::openNext(bool incFilename) VL_MT_SAFE_EXCLUDES(m_mutex) {
// Open next filename in concat sequence, mangle filename if // Open next filename in concat sequence, mangle filename if
// incFilename is true. // incFilename is true.
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
openNextImp(incFilename); openNextImp(incFilename);
} }
@ -195,11 +195,11 @@ void VerilatedVcd::makeNameMap() {
if (!hiername.empty() && hiername[0] == '\t') nullScope = true; if (!hiername.empty() && hiername[0] == '\t') nullScope = true;
} }
if (nullScope) { if (nullScope) {
NameMap* newmapp = new NameMap; NameMap* const newmapp = new NameMap;
for (const auto& i : *m_namemapp) { for (const auto& i : *m_namemapp) {
const std::string& hiername = i.first; const std::string& hiername = i.first;
const std::string& decl = i.second; const std::string& decl = i.second;
std::string newname = std::string("top"); std::string newname{"top"};
if (hiername[0] != '\t') newname += ' '; if (hiername[0] != '\t') newname += ' ';
newname += hiername; newname += hiername;
newmapp->emplace(newname, decl); newmapp->emplace(newname, decl);
@ -243,7 +243,7 @@ void VerilatedVcd::closeErr() {
void VerilatedVcd::close() VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedVcd::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
// This function is on the flush() call path // This function is on the flush() call path
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
if (!isOpen()) return; if (!isOpen()) return;
if (m_evcd) { if (m_evcd) {
printStr("$vcdclose "); printStr("$vcdclose ");
@ -257,7 +257,7 @@ void VerilatedVcd::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
} }
void VerilatedVcd::flush() VL_MT_SAFE_EXCLUDES(m_mutex) { void VerilatedVcd::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock{m_mutex};
VerilatedTrace<VerilatedVcd>::flushBase(); VerilatedTrace<VerilatedVcd>::flushBase();
bufferFlush(); bufferFlush();
} }
@ -311,7 +311,7 @@ void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
// LCOV_EXCL_START // LCOV_EXCL_START
// write failed, presume error (perhaps out of disk space) // write failed, presume error (perhaps out of disk space)
std::string msg std::string msg
= std::string("VerilatedVcd::bufferFlush: ") + std::strerror(errno); = std::string{"VerilatedVcd::bufferFlush: "} + std::strerror(errno);
VL_FATAL_MT("", 0, "", msg.c_str()); VL_FATAL_MT("", 0, "", msg.c_str());
closeErr(); closeErr();
break; break;
@ -331,7 +331,7 @@ char* VerilatedVcd::writeCode(char* writep, vluint32_t code) {
*writep++ = static_cast<char>('!' + code % 94); *writep++ = static_cast<char>('!' + code % 94);
code /= 94; code /= 94;
while (code) { while (code) {
code--; --code;
*writep++ = static_cast<char>('!' + code % 94); *writep++ = static_cast<char>('!' + code % 94);
code /= 94; code /= 94;
} }
@ -393,8 +393,8 @@ void VerilatedVcd::dumpHeader() {
// Skip common prefix, it must break at a space or tab // Skip common prefix, it must break at a space or tab
for (; *np && (*np == *lp); np++, lp++) {} for (; *np && (*np == *lp); np++, lp++) {}
while (np != hiername && *np && *np != ' ' && *np != '\t') { while (np != hiername && *np && *np != ' ' && *np != '\t') {
np--; --np;
lp--; --lp;
} }
// printf("hier %s\n lp=%s\n np=%s\n",hiername,lp,np); // printf("hier %s\n lp=%s\n np=%s\n",hiername,lp,np);
@ -896,9 +896,9 @@ void vcdTestMain(const char* filenamep) {
VerilatedVcdC* vcdp = new VerilatedVcdC; VerilatedVcdC* vcdp = new VerilatedVcdC;
vcdp->evcd(true); vcdp->evcd(true);
vcdp->set_time_unit("1ms"); vcdp->set_time_unit("1ms");
vcdp->set_time_unit(std::string("1ms")); vcdp->set_time_unit(std::string{"1ms"});
vcdp->set_time_resolution("1ns"); vcdp->set_time_resolution("1ns");
vcdp->set_time_resolution(std::string("1ns")); vcdp->set_time_resolution(std::string{"1ns"});
vcdp->spTrace()->addInitCb(&vcdInit, 0); vcdp->spTrace()->addInitCb(&vcdInit, 0);
vcdp->spTrace()->addFullCb(&vcdFull, 0); vcdp->spTrace()->addFullCb(&vcdFull, 0);
vcdp->spTrace()->addChgCb(&vcdChange, 0); vcdp->spTrace()->addChgCb(&vcdChange, 0);
@ -927,7 +927,7 @@ void vcdTestMain(const char* filenamep) {
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
vcdp->dump(++timestamp); vcdp->dump(++timestamp);
# ifdef VERILATED_VCD_TEST_64BIT # ifdef VERILATED_VCD_TEST_64BIT
vluint64_t bytesPerDump = 15ULL; const vluint64_t bytesPerDump = 15ULL;
for (vluint64_t i = 0; i < ((1ULL << 32) / bytesPerDump); i++) { for (vluint64_t i = 0; i < ((1ULL << 32) / bytesPerDump); i++) {
v1 = i; v1 = i;
vcdp->dump(++timestamp); vcdp->dump(++timestamp);

4
include/verilated_vcd_sc.h
View File

@ -44,9 +44,9 @@ public:
// We want to avoid a depreciated warning, but still be back compatible. // We want to avoid a depreciated warning, but still be back compatible.
// Turning off the message just for this still results in an // Turning off the message just for this still results in an
// annoying "to turn off" message. // annoying "to turn off" message.
const sc_time t1sec(1, SC_SEC); const sc_time t1sec{1, SC_SEC};
if (t1sec.to_default_time_units() != 0) { if (t1sec.to_default_time_units() != 0) {
const sc_time tunits(1.0 / t1sec.to_default_time_units(), SC_SEC); const sc_time tunits{1.0 / t1sec.to_default_time_units(), SC_SEC};
spTrace()->set_time_unit(tunits.to_string()); spTrace()->set_time_unit(tunits.to_string());
} }
spTrace()->set_time_resolution(sc_get_time_resolution().to_string()); spTrace()->set_time_resolution(sc_get_time_resolution().to_string());

113
include/verilated_vpi.cpp
View File

@ -80,7 +80,7 @@ public:
static const size_t chunk = 96; static const size_t chunk = 96;
if (VL_UNCOVERABLE(size > chunk)) VL_FATAL_MT(__FILE__, __LINE__, "", "increase chunk"); if (VL_UNCOVERABLE(size > chunk)) VL_FATAL_MT(__FILE__, __LINE__, "", "increase chunk");
if (VL_LIKELY(t_freeHead)) { if (VL_LIKELY(t_freeHead)) {
vluint8_t* newp = t_freeHead; vluint8_t* const newp = t_freeHead;
t_freeHead = *(reinterpret_cast<vluint8_t**>(newp)); t_freeHead = *(reinterpret_cast<vluint8_t**>(newp));
*(reinterpret_cast<vluint32_t*>(newp)) = activeMagic(); *(reinterpret_cast<vluint32_t*>(newp)) = activeMagic();
return newp + 8; return newp + 8;
@ -91,7 +91,7 @@ public:
return newp + 8; return newp + 8;
} }
static void operator delete(void* obj, size_t /*size*/)VL_MT_SAFE { static void operator delete(void* obj, size_t /*size*/)VL_MT_SAFE {
vluint8_t* oldp = (static_cast<vluint8_t*>(obj)) - 8; vluint8_t* const oldp = (static_cast<vluint8_t*>(obj)) - 8;
if (VL_UNLIKELY(*(reinterpret_cast<vluint32_t*>(oldp)) != activeMagic())) { if (VL_UNLIKELY(*(reinterpret_cast<vluint32_t*>(oldp)) != activeMagic())) {
VL_FATAL_MT(__FILE__, __LINE__, "", VL_FATAL_MT(__FILE__, __LINE__, "",
"vpi_release_handle() called on same object twice, or on non-Verilator " "vpi_release_handle() called on same object twice, or on non-Verilator "
@ -128,7 +128,7 @@ class VerilatedVpioTimedCb final : public VerilatedVpio {
public: public:
VerilatedVpioTimedCb(vluint64_t id, QData time) VerilatedVpioTimedCb(vluint64_t id, QData time)
: m_id(id) : m_id{id}
, m_time{time} {} , m_time{time} {}
virtual ~VerilatedVpioTimedCb() override = default; virtual ~VerilatedVpioTimedCb() override = default;
static VerilatedVpioTimedCb* castp(vpiHandle h) { static VerilatedVpioTimedCb* castp(vpiHandle h) {
@ -147,7 +147,7 @@ class VerilatedVpioReasonCb final : public VerilatedVpio {
public: public:
// cppcheck-suppress uninitVar // m_value // cppcheck-suppress uninitVar // m_value
VerilatedVpioReasonCb(vluint64_t id, PLI_INT32 reason) VerilatedVpioReasonCb(vluint64_t id, PLI_INT32 reason)
: m_id(id) : m_id{id}
, m_reason{reason} {} , m_reason{reason} {}
virtual ~VerilatedVpioReasonCb() override = default; virtual ~VerilatedVpioReasonCb() override = default;
static VerilatedVpioReasonCb* castp(vpiHandle h) { static VerilatedVpioReasonCb* castp(vpiHandle h) {
@ -200,7 +200,7 @@ public:
virtual const char* name() const override { return m_varp->name(); } virtual const char* name() const override { return m_varp->name(); }
virtual const char* fullname() const override { virtual const char* fullname() const override {
static VL_THREAD_LOCAL std::string t_out; static VL_THREAD_LOCAL std::string t_out;
t_out = std::string(m_scopep->name()) + "." + name(); t_out = std::string{m_scopep->name()} + "." + name();
return t_out.c_str(); return t_out.c_str();
} }
}; };
@ -208,7 +208,7 @@ public:
class VerilatedVpioParam final : public VerilatedVpioVarBase { class VerilatedVpioParam final : public VerilatedVpioVarBase {
public: public:
VerilatedVpioParam(const VerilatedVar* varp, const VerilatedScope* scopep) VerilatedVpioParam(const VerilatedVar* varp, const VerilatedScope* scopep)
: VerilatedVpioVarBase(varp, scopep) {} : VerilatedVpioVarBase{varp, scopep} {}
virtual ~VerilatedVpioParam() override = default; virtual ~VerilatedVpioParam() override = default;
static VerilatedVpioParam* castp(vpiHandle h) { static VerilatedVpioParam* castp(vpiHandle h) {
@ -252,7 +252,7 @@ public:
return nullptr; return nullptr;
} }
m_done = true; m_done = true;
return ((new VerilatedVpioRange(m_range))->castVpiHandle()); return ((new VerilatedVpioRange{m_range})->castVpiHandle());
} }
}; };
@ -286,13 +286,13 @@ protected:
public: public:
VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep) VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep)
: VerilatedVpioVarBase(varp, scopep) { : VerilatedVpioVarBase{varp, scopep} {
m_mask.u32 = VL_MASK_I(varp->packed().elements()); m_mask.u32 = VL_MASK_I(varp->packed().elements());
m_entSize = varp->entSize(); m_entSize = varp->entSize();
m_varDatap = varp->datap(); m_varDatap = varp->datap();
} }
explicit VerilatedVpioVar(const VerilatedVpioVar* varp) explicit VerilatedVpioVar(const VerilatedVpioVar* varp)
: VerilatedVpioVarBase(varp) { : VerilatedVpioVarBase{varp} {
if (varp) { if (varp) {
m_mask.u32 = varp->m_mask.u32; m_mask.u32 = varp->m_mask.u32;
m_entSize = varp->m_entSize; m_entSize = varp->m_entSize;
@ -345,7 +345,7 @@ public:
static VL_THREAD_LOCAL std::string t_out; static VL_THREAD_LOCAL std::string t_out;
char num[25]; char num[25];
VL_SNPRINTF(num, 25, "%d", m_index); VL_SNPRINTF(num, 25, "%d", m_index);
t_out = std::string(scopep()->name()) + "." + name() + "[" + num + "]"; t_out = std::string{scopep()->name()} + "." + name() + "[" + num + "]";
return t_out.c_str(); return t_out.c_str();
} }
}; };
@ -379,7 +379,7 @@ public:
delete this; // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle delete this; // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle
return nullptr; return nullptr;
} }
return ((new VerilatedVpioVar(&(m_it->second), m_scopep))->castVpiHandle()); return ((new VerilatedVpioVar{&(m_it->second), m_scopep})->castVpiHandle());
} }
delete this; // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle delete this; // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle
return nullptr; // End of list - only one deep return nullptr; // End of list - only one deep
@ -457,7 +457,7 @@ public:
return nullptr; return nullptr;
} }
const VerilatedScope* modp = *m_it++; const VerilatedScope* modp = *m_it++;
return (new VerilatedVpioModule(modp))->castVpiHandle(); return (new VerilatedVpioModule{modp})->castVpiHandle();
} }
}; };
@ -475,9 +475,9 @@ class VerilatedVpiCbHolder final {
public: public:
// cppcheck-suppress uninitVar // m_value // cppcheck-suppress uninitVar // m_value
VerilatedVpiCbHolder(vluint64_t id, const s_cb_data* cbDatap, const VerilatedVpioVar* varop) VerilatedVpiCbHolder(vluint64_t id, const s_cb_data* cbDatap, const VerilatedVpioVar* varop)
: m_id(id) : m_id{id}
, m_cbData(*cbDatap) , m_cbData{*cbDatap}
, m_varo(varop) { , m_varo{varop} {
m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal; m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal;
m_cbData.value = &m_value; m_cbData.value = &m_value;
if (varop) { if (varop) {
@ -626,9 +626,10 @@ public:
continue; continue;
} }
VerilatedVpiCbHolder& ho = *it++; VerilatedVpiCbHolder& ho = *it++;
if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(ho.cb_datap()->obj)) { if (VerilatedVpioVar* const varop = VerilatedVpioVar::castp(ho.cb_datap()->obj)) {
void* newDatap = varop->varDatap(); void* const newDatap = varop->varDatap();
void* prevDatap = varop->prevDatap(); // Was malloced when we added the callback void* const prevDatap
= varop->prevDatap(); // Was malloced when we added the callback
VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_test %s v[0]=%d/%d %p %p\n", VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_test %s v[0]=%d/%d %p %p\n",
varop->fullname(), *((CData*)newDatap), varop->fullname(), *((CData*)newDatap),
*((CData*)prevDatap), newDatap, prevDatap);); *((CData*)prevDatap), newDatap, prevDatap););
@ -758,7 +759,7 @@ PLI_INT32 VerilatedVpioReasonCb::dovpi_remove_cb() {
VerilatedVpiError* VerilatedVpiImp::error_info() VL_MT_UNSAFE_ONE { VerilatedVpiError* VerilatedVpiImp::error_info() VL_MT_UNSAFE_ONE {
VerilatedVpiImp::assertOneCheck(); VerilatedVpiImp::assertOneCheck();
if (VL_UNLIKELY(!s().m_errorInfop)) s().m_errorInfop = new VerilatedVpiError(); if (VL_UNLIKELY(!s().m_errorInfop)) s().m_errorInfop = new VerilatedVpiError;
return s().m_errorInfop; return s().m_errorInfop;
} }
@ -1108,13 +1109,13 @@ const char* VerilatedVpiError::strFromVpiProp(PLI_INT32 vpiVal) VL_MT_SAFE {
#define SELF_CHECK_RESULT_CSTR(got, exp) \ #define SELF_CHECK_RESULT_CSTR(got, exp) \
if (0 != std::strcmp((got), (exp))) { \ if (0 != std::strcmp((got), (exp))) { \
std::string msg \ std::string msg \
= std::string("%Error: ") + "GOT = '" + got + "'" + " EXP = '" + exp + "'"; \ = std::string{"%Error: "} + "GOT = '" + got + "'" + " EXP = '" + exp + "'"; \
VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); \ VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); \
} }
#define SELF_CHECK_ENUM_STR(fn, enumn) \ #define SELF_CHECK_ENUM_STR(fn, enumn) \
do { \ do { \
const char* strVal = VerilatedVpiError::fn(enumn); \ const char* const strVal = VerilatedVpiError::fn(enumn); \
SELF_CHECK_RESULT_CSTR(strVal, #enumn); \ SELF_CHECK_RESULT_CSTR(strVal, #enumn); \
} while (0) } while (0)
@ -1358,7 +1359,7 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
const VerilatedVpioScope* const voScopep = VerilatedVpioScope::castp(scope); const VerilatedVpioScope* const voScopep = VerilatedVpioScope::castp(scope);
std::string scopeAndName = namep; std::string scopeAndName = namep;
if (voScopep) { if (voScopep) {
scopeAndName = std::string(voScopep->fullname()) + "." + namep; scopeAndName = std::string{voScopep->fullname()} + "." + namep;
namep = const_cast<PLI_BYTE8*>(scopeAndName.c_str()); namep = const_cast<PLI_BYTE8*>(scopeAndName.c_str());
} }
{ {
@ -1366,9 +1367,9 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
scopep = Verilated::threadContextp()->scopeFind(namep); scopep = Verilated::threadContextp()->scopeFind(namep);
if (scopep) { // Whole thing found as a scope if (scopep) { // Whole thing found as a scope
if (scopep->type() == VerilatedScope::SCOPE_MODULE) { if (scopep->type() == VerilatedScope::SCOPE_MODULE) {
return (new VerilatedVpioModule(scopep))->castVpiHandle(); return (new VerilatedVpioModule{scopep})->castVpiHandle();
} else { } else {
return (new VerilatedVpioScope(scopep))->castVpiHandle(); return (new VerilatedVpioScope{scopep})->castVpiHandle();
} }
} }
const char* baseNamep = scopeAndName.c_str(); const char* baseNamep = scopeAndName.c_str();
@ -1376,7 +1377,8 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
const char* const dotp = std::strrchr(namep, '.'); const char* const dotp = std::strrchr(namep, '.');
if (VL_LIKELY(dotp)) { if (VL_LIKELY(dotp)) {
baseNamep = dotp + 1; baseNamep = dotp + 1;
scopename = std::string(namep, dotp - namep); const size_t len = dotp - namep;
scopename = std::string{namep, len};
} }
if (scopename.find('.') == std::string::npos) { if (scopename.find('.') == std::string::npos) {
@ -1393,9 +1395,9 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
if (!varp) return nullptr; if (!varp) return nullptr;
if (varp->isParam()) { if (varp->isParam()) {
return (new VerilatedVpioParam(varp, scopep))->castVpiHandle(); return (new VerilatedVpioParam{varp, scopep})->castVpiHandle();
} else { } else {
return (new VerilatedVpioVar(varp, scopep))->castVpiHandle(); return (new VerilatedVpioVar{varp, scopep})->castVpiHandle();
} }
} }
@ -1405,7 +1407,7 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
VerilatedVpiImp::assertOneCheck(); VerilatedVpiImp::assertOneCheck();
VL_VPI_ERROR_RESET_(); VL_VPI_ERROR_RESET_();
// Memory words are not indexable // Memory words are not indexable
VerilatedVpioMemoryWord* vop = VerilatedVpioMemoryWord::castp(object); VerilatedVpioMemoryWord* const vop = VerilatedVpioMemoryWord::castp(object);
if (VL_UNLIKELY(vop)) return nullptr; if (VL_UNLIKELY(vop)) return nullptr;
const VerilatedVpioVar* const varop = VerilatedVpioVar::castp(object); const VerilatedVpioVar* const varop = VerilatedVpioVar::castp(object);
if (VL_LIKELY(varop)) { if (VL_LIKELY(varop)) {
@ -1414,15 +1416,15 @@ vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
if (VL_UNLIKELY(indx > varop->varp()->unpacked().left() if (VL_UNLIKELY(indx > varop->varp()->unpacked().left()
|| indx < varop->varp()->unpacked().right())) || indx < varop->varp()->unpacked().right()))
return nullptr; return nullptr;
return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx, return (new VerilatedVpioMemoryWord{varop->varp(), varop->scopep(), indx,
indx - varop->varp()->unpacked().right())) indx - varop->varp()->unpacked().right()})
->castVpiHandle(); ->castVpiHandle();
} }
if (VL_UNLIKELY(indx < varop->varp()->unpacked().left() if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
|| indx > varop->varp()->unpacked().right())) || indx > varop->varp()->unpacked().right()))
return nullptr; return nullptr;
return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx, return (new VerilatedVpioMemoryWord{varop->varp(), varop->scopep(), indx,
indx - varop->varp()->unpacked().left())) indx - varop->varp()->unpacked().left()})
->castVpiHandle(); ->castVpiHandle();
} }
VL_VPI_INTERNAL_(__FILE__, __LINE__, "%s : can't resolve handle", __func__); VL_VPI_INTERNAL_(__FILE__, __LINE__, "%s : can't resolve handle", __func__);
@ -1437,12 +1439,12 @@ vpiHandle vpi_handle(PLI_INT32 type, vpiHandle object) {
VL_VPI_ERROR_RESET_(); VL_VPI_ERROR_RESET_();
switch (type) { switch (type) {
case vpiLeftRange: { case vpiLeftRange: {
if (VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object)) { if (VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object)) {
if (VL_UNLIKELY(!vop->rangep())) return nullptr; if (VL_UNLIKELY(!vop->rangep())) return nullptr;
return (new VerilatedVpioConst(vop->rangep()->left()))->castVpiHandle(); return (new VerilatedVpioConst{vop->rangep()->left()})->castVpiHandle();
} else if (VerilatedVpioRange* vop = VerilatedVpioRange::castp(object)) { } else if (VerilatedVpioRange* const vop = VerilatedVpioRange::castp(object)) {
if (VL_UNLIKELY(!vop->rangep())) return nullptr; if (VL_UNLIKELY(!vop->rangep())) return nullptr;
return (new VerilatedVpioConst(vop->rangep()->left()))->castVpiHandle(); return (new VerilatedVpioConst{vop->rangep()->left()})->castVpiHandle();
} }
VL_VPI_WARNING_(__FILE__, __LINE__, VL_VPI_WARNING_(__FILE__, __LINE__,
"%s: Unsupported vpiHandle (%p) for type %s, nothing will be returned", "%s: Unsupported vpiHandle (%p) for type %s, nothing will be returned",
@ -1450,12 +1452,12 @@ vpiHandle vpi_handle(PLI_INT32 type, vpiHandle object) {
return nullptr; return nullptr;
} }
case vpiRightRange: { case vpiRightRange: {
if (VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object)) { if (VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object)) {
if (VL_UNLIKELY(!vop->rangep())) return nullptr; if (VL_UNLIKELY(!vop->rangep())) return nullptr;
return (new VerilatedVpioConst(vop->rangep()->right()))->castVpiHandle(); return (new VerilatedVpioConst{vop->rangep()->right()})->castVpiHandle();
} else if (VerilatedVpioRange* vop = VerilatedVpioRange::castp(object)) { } else if (VerilatedVpioRange* const vop = VerilatedVpioRange::castp(object)) {
if (VL_UNLIKELY(!vop->rangep())) return nullptr; if (VL_UNLIKELY(!vop->rangep())) return nullptr;
return (new VerilatedVpioConst(vop->rangep()->right()))->castVpiHandle(); return (new VerilatedVpioConst{vop->rangep()->right()})->castVpiHandle();
} }
VL_VPI_WARNING_(__FILE__, __LINE__, VL_VPI_WARNING_(__FILE__, __LINE__,
"%s: Unsupported vpiHandle (%p) for type %s, nothing will be returned", "%s: Unsupported vpiHandle (%p) for type %s, nothing will be returned",
@ -1463,19 +1465,20 @@ vpiHandle vpi_handle(PLI_INT32 type, vpiHandle object) {
return nullptr; return nullptr;
} }
case vpiIndex: { case vpiIndex: {
VerilatedVpioVar* vop = VerilatedVpioVar::castp(object); VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object);
if (VL_UNLIKELY(!vop)) return nullptr; if (VL_UNLIKELY(!vop)) return nullptr;
return (new VerilatedVpioConst(vop->index()))->castVpiHandle(); const vlsint32_t val = vop->index();
return (new VerilatedVpioConst{val})->castVpiHandle();
} }
case vpiScope: { case vpiScope: {
VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object); VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object);
if (VL_UNLIKELY(!vop)) return nullptr; if (VL_UNLIKELY(!vop)) return nullptr;
return (new VerilatedVpioScope(vop->scopep()))->castVpiHandle(); return (new VerilatedVpioScope{vop->scopep()})->castVpiHandle();
} }
case vpiParent: { case vpiParent: {
VerilatedVpioMemoryWord* vop = VerilatedVpioMemoryWord::castp(object); VerilatedVpioMemoryWord* const vop = VerilatedVpioMemoryWord::castp(object);
if (VL_UNLIKELY(!vop)) return nullptr; if (VL_UNLIKELY(!vop)) return nullptr;
return (new VerilatedVpioVar(vop->varp(), vop->scopep()))->castVpiHandle(); return (new VerilatedVpioVar{vop->varp(), vop->scopep()})->castVpiHandle();
} }
default: default:
VL_VPI_WARNING_(__FILE__, __LINE__, "%s: Unsupported type %s, nothing will be returned", VL_VPI_WARNING_(__FILE__, __LINE__, "%s: Unsupported type %s, nothing will be returned",
@ -1505,7 +1508,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
VerilatedVpiError::strFromVpiMethod(type), vop->fullname(), VerilatedVpiError::strFromVpiMethod(type), vop->fullname(),
vop->varp()->dims()); vop->varp()->dims());
} }
return (new VerilatedVpioMemoryWordIter(object, vop->varp()))->castVpiHandle(); return (new VerilatedVpioMemoryWordIter{object, vop->varp()})->castVpiHandle();
} }
case vpiRange: { case vpiRange: {
const VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object); const VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object);
@ -1518,12 +1521,12 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
VerilatedVpiError::strFromVpiMethod(type), vop->fullname(), VerilatedVpiError::strFromVpiMethod(type), vop->fullname(),
vop->varp()->dims()); vop->varp()->dims());
} }
return ((new VerilatedVpioRangeIter(vop->rangep()))->castVpiHandle()); return ((new VerilatedVpioRangeIter{vop->rangep()})->castVpiHandle());
} }
case vpiReg: { case vpiReg: {
const VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object); const VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object);
if (VL_UNLIKELY(!vop)) return nullptr; if (VL_UNLIKELY(!vop)) return nullptr;
return ((new VerilatedVpioVarIter(vop->scopep()))->castVpiHandle()); return ((new VerilatedVpioVarIter{vop->scopep()})->castVpiHandle());
} }
case vpiModule: { case vpiModule: {
const VerilatedVpioModule* const vop = VerilatedVpioModule::castp(object); const VerilatedVpioModule* const vop = VerilatedVpioModule::castp(object);
@ -1531,7 +1534,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
const VerilatedScope* const modp = vop ? vop->scopep() : nullptr; const VerilatedScope* const modp = vop ? vop->scopep() : nullptr;
const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(modp)); const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(modp));
if (it == map->end()) return nullptr; if (it == map->end()) return nullptr;
return ((new VerilatedVpioModuleIter(it->second))->castVpiHandle()); return ((new VerilatedVpioModuleIter{it->second})->castVpiHandle());
} }
default: default:
VL_VPI_WARNING_(__FILE__, __LINE__, "%s: Unsupported type %s, nothing will be returned", VL_VPI_WARNING_(__FILE__, __LINE__, "%s: Unsupported type %s, nothing will be returned",
@ -1543,7 +1546,7 @@ vpiHandle vpi_scan(vpiHandle object) {
VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_scan %p\n", object);); VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_scan %p\n", object););
VerilatedVpiImp::assertOneCheck(); VerilatedVpiImp::assertOneCheck();
VL_VPI_ERROR_RESET_(); VL_VPI_ERROR_RESET_();
VerilatedVpio* vop = VerilatedVpio::castp(object); VerilatedVpio* const vop = VerilatedVpio::castp(object);
if (VL_UNLIKELY(!vop)) return nullptr; if (VL_UNLIKELY(!vop)) return nullptr;
return vop->dovpi_scan(); return vop->dovpi_scan();
} }
@ -1893,13 +1896,13 @@ void vpi_get_value(vpiHandle object, p_vpi_value valuep) {
VL_VPI_ERROR_RESET_(); VL_VPI_ERROR_RESET_();
if (VL_UNLIKELY(!valuep)) return; if (VL_UNLIKELY(!valuep)) return;
if (VerilatedVpioVar* vop = VerilatedVpioVar::castp(object)) { if (VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object)) {
vl_get_value(vop->varp(), vop->varDatap(), valuep, vop->fullname()); vl_get_value(vop->varp(), vop->varDatap(), valuep, vop->fullname());
return; return;
} else if (const VerilatedVpioParam* const vop = VerilatedVpioParam::castp(object)) { } else if (const VerilatedVpioParam* const vop = VerilatedVpioParam::castp(object)) {
vl_get_value(vop->varp(), vop->varDatap(), valuep, vop->fullname()); vl_get_value(vop->varp(), vop->varDatap(), valuep, vop->fullname());
return; return;
} else if (VerilatedVpioConst* vop = VerilatedVpioConst::castp(object)) { } else if (VerilatedVpioConst* const vop = VerilatedVpioConst::castp(object)) {
if (valuep->format == vpiIntVal) { if (valuep->format == vpiIntVal) {
valuep->value.integer = vop->num(); valuep->value.integer = vop->num();
return; return;
@ -2161,7 +2164,7 @@ void vpi_get_time(vpiHandle object, p_vpi_time time_p) {
return; return;
} else if (time_p->type == vpiScaledRealTime) { } else if (time_p->type == vpiScaledRealTime) {
double dtime = VL_TIME_D(); double dtime = VL_TIME_D();
if (VerilatedVpioScope* vop = VerilatedVpioScope::castp(object)) { if (VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object)) {
const int scalePow10 const int scalePow10
= Verilated::threadContextp()->timeprecision() - vop->scopep()->timeunit(); = Verilated::threadContextp()->timeprecision() - vop->scopep()->timeunit();
const double scale = vl_time_multiplier(scalePow10); // e.g. 0.0001 const double scale = vl_time_multiplier(scalePow10); // e.g. 0.0001
@ -2271,7 +2274,7 @@ PLI_INT32 vpi_free_object(vpiHandle object) {
PLI_INT32 vpi_release_handle(vpiHandle object) { PLI_INT32 vpi_release_handle(vpiHandle object) {
VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_release_handle %p\n", object);); VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_release_handle %p\n", object););
VerilatedVpiImp::assertOneCheck(); VerilatedVpiImp::assertOneCheck();
VerilatedVpio* vop = VerilatedVpio::castp(object); VerilatedVpio* const vop = VerilatedVpio::castp(object);
VL_VPI_ERROR_RESET_(); VL_VPI_ERROR_RESET_();
if (VL_UNLIKELY(!vop)) return 0; if (VL_UNLIKELY(!vop)) return 0;
VL_DO_DANGLING(delete vop, vop); VL_DO_DANGLING(delete vop, vop);

4
nodist/dot_importer
View File

@ -66,11 +66,11 @@ def cwrite(filename):
fh.write(" auto* gp = &m_graph;\n") fh.write(" auto* gp = &m_graph;\n")
for ver in sorted(Vertexes, key=lambda ver: ver['num']): for ver in sorted(Vertexes, key=lambda ver: ver['num']):
fh.write( fh.write(
" auto* %s = new V3GraphTestVertex(gp, \"%s\"); if (%s) {}\n" " auto* %s = new V3GraphTestVertex{gp, \"%s\"}; if (%s) {}\n"
% (ver['name'], ver['name'], ver['name'])) % (ver['name'], ver['name'], ver['name']))
fh.write("\n") fh.write("\n")
for edge in Edges: for edge in Edges:
fh.write(" new V3GraphEdge(gp, %s, %s, %s, %s);\n" % fh.write(" new V3GraphEdge{gp, %s, %s, %s, %s};\n" %
(edge['from'], edge['to'], edge['weight'], (edge['from'], edge['to'], edge['weight'],
"true" if edge['cutable'] else "false")) "true" if edge['cutable'] else "false"))
fh.write("}\n") fh.write("}\n")