From ab13a2ebdc37775cccddbe66a2ef3467cfea8a82 Mon Sep 17 00:00:00 2001
From: Wilson Snyder <wsnyder@wsnyder.org>
Date: Sat, 24 Jul 2021 08:36:11 -0400
Subject: [PATCH] Internals: Use C++11 const and initializers. No functional
 change intended.

---
 include/verilated.cpp           | 205 ++++++++++++++++----------------
 include/verilated.h             |   4 +-
 include/verilated_cov.cpp       |  56 ++++-----
 include/verilated_dpi.cpp       |  56 ++++-----
 include/verilated_fst_c.cpp     |  10 +-
 include/verilated_heavy.h       |  10 +-
 include/verilated_imp.h         |  48 ++++----
 include/verilated_save.cpp      |  10 +-
 include/verilated_threads.cpp   |   8 +-
 include/verilated_threads.h     |   6 +-
 include/verilated_trace.h       |   8 +-
 include/verilated_trace_imp.cpp |  18 +--
 include/verilated_vcd_c.cpp     |  26 ++--
 include/verilated_vcd_sc.h      |   4 +-
 include/verilated_vpi.cpp       | 113 +++++++++---------
 nodist/dot_importer             |   4 +-
 16 files changed, 296 insertions(+), 290 deletions(-)

diff --git a/include/verilated.cpp b/include/verilated.cpp
index 01d31413f..375647d2d 100644
--- a/include/verilated.cpp
+++ b/include/verilated.cpp
@@ -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 {
 #ifdef VL_THREADED
-    VerilatedThreadMsgQueue::post(VerilatedMsg([=]() {  //
+    VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() {  //
         vl_finish(filename, linenum, hier);
-    }));
+    }});
 #else
     vl_finish(filename, linenum, hier);
 #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 {
 #ifdef VL_THREADED
-    VerilatedThreadMsgQueue::post(VerilatedMsg([=]() {  //
+    VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() {  //
         vl_stop_maybe(filename, linenum, hier, maybe);
-    }));
+    }});
 #else
     vl_stop_maybe(filename, linenum, hier, maybe);
 #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 {
 #ifdef VL_THREADED
-    VerilatedThreadMsgQueue::post(VerilatedMsg([=]() {  //
+    VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() {  //
         vl_fatal(filename, linenum, hier, msg);
-    }));
+    }});
 #else
     vl_fatal(filename, linenum, hier, msg);
 #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 {
     va_list aq;
     va_copy(aq, ap);
-    int len = VL_VSNPRINTF(nullptr, 0, formatp, aq);
+    size_t len = VL_VSNPRINTF(nullptr, 0, formatp, aq);
     va_end(aq);
     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);
 
-    const std::string out = std::string(bufp, len);
+    const std::string out{bufp, len};
     delete[] bufp;
     return out;
 }
@@ -263,9 +263,9 @@ void VL_PRINTF_MT(const char* formatp, ...) VL_MT_SAFE {
     va_start(ap, formatp);
     const std::string out = _vl_string_vprintf(formatp, ap);
     va_end(ap);
-    VerilatedThreadMsgQueue::post(VerilatedMsg([=]() {  //
+    VerilatedThreadMsgQueue::post(VerilatedMsg{[=]() {  //
         VL_PRINTF("%s", out.c_str());
-    }));
+    }});
 }
 #endif
 
@@ -276,7 +276,7 @@ static vluint32_t vl_sys_rand32() VL_MT_UNSAFE {
     // Return random 32-bits using system library.
     // Used only to construct seed for Verilator's PNRG.
     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__)
     // Windows doesn't have lrand48(), although Cygwin does.
     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
             // Fast-forward to next escape and add to output
             const char* ep = pos;
-            while (ep[0] && ep[0] != '%') ep++;
+            while (ep[0] && ep[0] != '%') ++ep;
             if (ep != pos) {
                 output.append(pos, ep - pos);
                 pos += ep - pos - 1;
@@ -776,7 +776,7 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
                 output += '%';
                 break;
             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)) {
                     output += cstrp;
                     output += '.';
@@ -784,13 +784,13 @@ void _vl_vsformat(std::string& output, const char* formatp, va_list ap) VL_MT_SA
                 break;
             }
             case 'S': {  // "C" string
-                const char* cstrp = va_arg(ap, const char*);
+                const char* const cstrp = va_arg(ap, const char*);
                 output += cstrp;
                 break;
             }
             case '@': {  // Verilog/C++ string
                 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;
                 if (width > cstrp->size()) padding.append(width - cstrp->size(), ' ');
                 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);
                     output += _vl_vsformat_time(t_tmp, d, timeunit, left, width);
                 } 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);
                     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])) {
                             VlWide<VL_VALUE_STRING_MAX_WIDTH / 4 + 2> neg;
                             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 {
                             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;
                 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());
                     break;
                 }  // LCOV_EXCL_STOP
@@ -1217,7 +1218,7 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
                 case 'u': {
                     // Read packed 2-value binary data
                     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;
                     const int last = bytes % 4;
                     if (last != 0
@@ -1242,7 +1243,7 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
                     break;
                 }
                 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());
                     break;
                 }  // 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)
                 if (obits == 0) {  // Due to inIgnore
                 } 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;
                 } else if (obits <= VL_BYTESIZE) {
-                    CData* p = va_arg(ap, CData*);
+                    CData* const p = va_arg(ap, CData*);
                     *p = owp[0];
                 } else if (obits <= VL_SHORTSIZE) {
-                    SData* p = va_arg(ap, SData*);
+                    SData* const p = va_arg(ap, SData*);
                     *p = owp[0];
                 } else if (obits <= VL_IDATASIZE) {
-                    IData* p = va_arg(ap, IData*);
+                    IData* const p = va_arg(ap, IData*);
                     *p = owp[0];
                 } else if (obits <= VL_QUADSIZE) {
-                    QData* p = va_arg(ap, QData*);
+                    QData* const p = va_arg(ap, QData*);
                     *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 {
     // We ignore lhs/fpi - IEEE says "most recent error" so probably good enough
     const IData ret = errno;
-    outputr = std::string(::std::strerror(ret));
+    outputr = std::string{::std::strerror(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
         IData entry = read_elements + start - array_lsb;
         if (width <= 8) {
-            CData* datap = &(reinterpret_cast<CData*>(memp))[entry];
+            CData* const datap = &(reinterpret_cast<CData*>(memp))[entry];
             if (shift == start_shift) *datap = 0;
             *datap |= (c << shift) & VL_MASK_I(width);
         } 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;
             *datap |= (c << shift) & VL_MASK_I(width);
         } 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;
             *datap |= (c << shift) & VL_MASK_I(width);
         } 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;
             *datap |= ((static_cast<QData>(c) << static_cast<QData>(shift)) & VL_MASK_Q(width));
         } 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 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;
 
     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 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;
-    rdr = std::string(dp);
+    rdr = std::string{dp};
     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;
     bool start = true;
     char* destp = destout;
-    int len = 0;
+    size_t len = 0;
     for (; lsb >= 0; --lsb) {
         lsb = (lsb / 8) * 8;  // Next digit
         IData charval = VL_BITRSHIFT_W(lwp, lsb) & 0xff;
         if (!start || charval) {
             *destp++ = (charval == 0) ? ' ' : charval;
-            len++;
+            ++len;
             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 {
@@ -1924,19 +1925,19 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
         const int value
             = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
         if (m_bits <= 8) {
-            CData* datap = reinterpret_cast<CData*>(valuep);
+            CData* const datap = reinterpret_cast<CData*>(valuep);
             if (!innum) *datap = 0;
             *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
         } else if (m_bits <= 16) {
-            SData* datap = reinterpret_cast<SData*>(valuep);
+            SData* const datap = reinterpret_cast<SData*>(valuep);
             if (!innum) *datap = 0;
             *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
         } else if (m_bits <= VL_IDATASIZE) {
-            IData* datap = reinterpret_cast<IData*>(valuep);
+            IData* const datap = reinterpret_cast<IData*>(valuep);
             if (!innum) *datap = 0;
             *datap = ((*datap << shift) + value) & VL_MASK_I(m_bits);
         } else if (m_bits <= VL_QUADSIZE) {
-            QData* datap = reinterpret_cast<QData*>(valuep);
+            QData* const datap = reinterpret_cast<QData*>(valuep);
             if (!innum) *datap = 0;
             *datap = ((*datap << static_cast<QData>(shift)) + static_cast<QData>(value))
                      & VL_MASK_Q(m_bits);
@@ -1979,7 +1980,7 @@ void VlWriteMem::print(QData addr, bool addrstamp, const void* valuep) {
     }
     m_addr = addr + 1;
     if (m_bits <= 8) {
-        const CData* datap = reinterpret_cast<const CData*>(valuep);
+        const CData* const datap = reinterpret_cast<const CData*>(valuep);
         if (m_hex) {
             fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
             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));
         }
     } 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) {
             fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
             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));
         }
     } 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) {
             fprintf(m_fp, memhFormat(m_bits), VL_MASK_I(m_bits) & *datap);
             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));
         }
     } 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 vluint32_t lo = value & 0xffffffff;
         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));
                 }
             }
-            word_idx--;
+            --word_idx;
             first = false;
         }
         fprintf(m_fp, "\n");
@@ -2057,7 +2058,7 @@ void VL_READMEM_N(bool hex,  // Hex format, else binary
                   ) VL_MT_SAFE {
     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;
     while (true) {
         QData addr = 0;
@@ -2070,16 +2071,16 @@ void VL_READMEM_N(bool hex,  // Hex format, else binary
             } else {
                 QData entry = addr - array_lsb;
                 if (bits <= 8) {
-                    CData* datap = &(reinterpret_cast<CData*>(memp))[entry];
+                    CData* const datap = &(reinterpret_cast<CData*>(memp))[entry];
                     rmem.setData(datap, value);
                 } else if (bits <= 16) {
-                    SData* datap = &(reinterpret_cast<SData*>(memp))[entry];
+                    SData* const datap = &(reinterpret_cast<SData*>(memp))[entry];
                     rmem.setData(datap, value);
                 } else if (bits <= VL_IDATASIZE) {
-                    IData* datap = &(reinterpret_cast<IData*>(memp))[entry];
+                    IData* const datap = &(reinterpret_cast<IData*>(memp))[entry];
                     rmem.setData(datap, value);
                 } else if (bits <= VL_QUADSIZE) {
-                    QData* datap = &(reinterpret_cast<QData*>(memp))[entry];
+                    QData* const datap = &(reinterpret_cast<QData*>(memp))[entry];
                     rmem.setData(datap, value);
                 } else {
                     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 (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;
 
     for (QData addr = start; addr <= end; ++addr) {
         const QData row_offset = addr - array_lsb;
         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);
         } 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);
         } 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);
         } 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);
         } else {
             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++ != '1') return 0;
     while (*strp == '0') {
-        scale++;
-        strp++;
+        ++scale;
+        ++strp;
     }
     switch (*strp++) {
     case 's': break;
@@ -2273,19 +2274,19 @@ VerilatedContext::Serialized::Serialized() {
 }
 
 void VerilatedContext::assertOn(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_assertOn = flag;
 }
 void VerilatedContext::calcUnusedSigs(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_calcUnusedSigs = flag;
 }
 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;
 }
 std::string VerilatedContext::dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
-    const VerilatedLockGuard lock(m_timeDumpMutex);
+    const VerilatedLockGuard lock{m_timeDumpMutex};
     return m_dumpfile;
 }
 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;
 }
 void VerilatedContext::errorCount(int val) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_errorCount = val;
 }
 void VerilatedContext::errorCountInc() VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     ++m_s.m_errorCount;
 }
 void VerilatedContext::errorLimit(int val) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_errorLimit = val;
 }
 void VerilatedContext::fatalOnError(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_fatalOnError = flag;
 }
 void VerilatedContext::fatalOnVpiError(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_fatalOnVpiError = flag;
 }
 void VerilatedContext::gotError(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_gotError = flag;
 }
 void VerilatedContext::gotFinish(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_gotFinish = flag;
 }
 void VerilatedContext::profThreadsStart(vluint64_t flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_ns.m_profThreadsStart = flag;
 }
 void VerilatedContext::profThreadsWindow(vluint64_t flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_ns.m_profThreadsWindow = flag;
 }
 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;
 }
 std::string VerilatedContext::profThreadsFilename() const VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     return m_ns.m_profThreadsFilename;
 }
 void VerilatedContext::randReset(int val) VL_MT_SAFE {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_randReset = val;
 }
 void VerilatedContext::timeunit(int value) VL_MT_SAFE {
     if (value < 0) value = -value;  // Stored as 0..15
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_timeunit = value;
 }
 void VerilatedContext::timeprecision(int value) VL_MT_SAFE {
     if (value < 0) value = -value;  // Stored as 0..15
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     m_s.m_timeprecision = value;
 #ifdef SYSTEMC_VERSION
     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) {
-    const VerilatedLockGuard lock(m_argMutex);
+    const VerilatedLockGuard lock{m_argMutex};
     m_args.m_argVec.clear();  // Empty first, then add
     impp()->commandArgsAddGuts(argc, argv);
 }
 void VerilatedContext::commandArgsAdd(int argc, const char** argv)
     VL_MT_SAFE_EXCLUDES(m_argMutex) {
-    const VerilatedLockGuard lock(m_argMutex);
+    const VerilatedLockGuard lock{m_argMutex};
     impp()->commandArgsAddGuts(argc, argv);
 }
 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
 }
 void VerilatedContextImp::commandArgDump() const VL_MT_SAFE_EXCLUDES(m_argMutex) {
-    const VerilatedLockGuard lock(m_argMutex);
+    const VerilatedLockGuard lock{m_argMutex};
     VL_PRINTF_MT("  Argv:");
     for (const auto& i : m_args.m_argVec) VL_PRINTF_MT(" %s", i.c_str());
     VL_PRINTF_MT("\n");
 }
 std::string VerilatedContextImp::argPlusMatch(const char* prefixp)
     VL_MT_SAFE_EXCLUDES(m_argMutex) {
-    const VerilatedLockGuard lock(m_argMutex);
+    const VerilatedLockGuard lock{m_argMutex};
     // Note prefixp does not include the leading "+"
     const size_t len = std::strlen(prefixp);
     if (VL_UNLIKELY(!m_args.m_argVecLoaded)) {
@@ -2454,7 +2455,7 @@ std::string VerilatedContextImp::argPlusMatch(const char* prefixp)
 // Return string representing current argv
 // 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) {
-    const VerilatedLockGuard lock(m_argMutex);
+    const VerilatedLockGuard lock{m_argMutex};
     static bool s_loaded = false;
     static int s_argc = 0;
     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 {
     // As we have per-thread state, the epoch must 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;
     const vluint64_t newEpoch = VerilatedContextImp::s().s_randSeedEpoch + 1;
     // Obververs must see new epoch AFTER seed updated
@@ -2552,10 +2553,10 @@ vluint64_t VerilatedContextImp::randSeedDefault64() const VL_MT_SAFE {
 // VerilatedContext:: Methods - scopes
 
 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");
     for (const auto& i : m_impdatap->m_nameMap) {
-        const VerilatedScope* scopep = i.second;
+        const VerilatedScope* const scopep = i.second;
         scopep->scopeDump();
     }
     VL_PRINTF_MT("\n");
@@ -2563,20 +2564,20 @@ void VerilatedContext::scopesDump() const VL_MT_SAFE {
 
 void VerilatedContextImp::scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
     // 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());
     if (it == m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.emplace(scopep->name(), scopep);
 }
 void VerilatedContextImp::scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
     // Slow ok - called once/scope at destruction
-    const VerilatedLockGuard lock(m_impdatap->m_nameMutex);
+    const VerilatedLockGuard lock{m_impdatap->m_nameMutex};
     VerilatedImp::userEraseScope(scopep);
     const auto it = m_impdatap->m_nameMap.find(scopep->name());
     if (it != m_impdatap->m_nameMap.end()) m_impdatap->m_nameMap.erase(it);
 }
 const VerilatedScope* VerilatedContext::scopeFind(const char* namep) const VL_MT_SAFE {
     // 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
     const auto& it = m_impdatap->m_nameMap.find(namep);
     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 {
-    const VerilatedLockGuard lock(VlCbStatic.s_flushMutex);
+    const VerilatedLockGuard lock{VlCbStatic.s_flushMutex};
     addCb(cb, datap, VlCbStatic.s_flushCbs);
 }
 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);
 }
 void Verilated::runFlushCallbacks() VL_MT_SAFE {
@@ -2685,7 +2686,7 @@ void Verilated::runFlushCallbacks() VL_MT_SAFE {
     static int s_recursing = 0;
 #endif
     if (!s_recursing++) {
-        const VerilatedLockGuard lock(VlCbStatic.s_flushMutex);
+        const VerilatedLockGuard lock{VlCbStatic.s_flushMutex};
         runCallbacks(VlCbStatic.s_flushCbs);
     }
     --s_recursing;
@@ -2698,11 +2699,11 @@ void Verilated::runFlushCallbacks() 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);
 }
 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);
 }
 void Verilated::runExitCallbacks() VL_MT_SAFE {
@@ -2712,7 +2713,7 @@ void Verilated::runExitCallbacks() VL_MT_SAFE {
     static int s_recursing = 0;
 #endif
     if (!s_recursing++) {
-        const VerilatedLockGuard lock(VlCbStatic.s_exitMutex);
+        const VerilatedLockGuard lock{VlCbStatic.s_exitMutex};
         runCallbacks(VlCbStatic.s_exitCbs);
     }
     --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 {
     // 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");
     VL_FATAL_MT("unknown", 0, "", msg.c_str());
     VL_UNREACHABLE
@@ -2846,7 +2847,7 @@ void VerilatedScope::configure(VerilatedSyms* symsp, const char* prefixp, const
     m_type = type;
     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;
         for (const char* sp = prefixp; *sp;) *dp++ = *sp++;
         if (*prefixp && *suffixp) *dp++ = '.';
@@ -2886,7 +2887,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
     // statically construct from that.
     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);
 
     va_list ap;
@@ -2903,9 +2904,9 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
         } else {
             // We could have a linked list of ranges, but really this whole thing needs
             // to be generalized to support structs and unions, etc.
-            VL_FATAL_MT(
-                __FILE__, __LINE__, "",
-                (std::string("Unsupported multi-dimensional public varInsert: ") + namep).c_str());
+            std::string msg
+                = std::string{"Unsupported multi-dimensional public varInsert: "} + namep;
+            VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
         }
     }
     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 {
     // Slowpath - Called only when find has failed
     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 "
            + "'context', or missing svSetScope. See IEEE 1800-2017 35.5.3.");
     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 {
     // Slowpath - Called only when find has failed
     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()
            + "'");
     VL_FATAL_MT("unknown", 0, "", msg.c_str());
@@ -2950,7 +2951,7 @@ void VerilatedScope::scopeDump() const {
                          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);
     }
 }
diff --git a/include/verilated.h b/include/verilated.h
index cb375d27c..f71f13308 100644
--- a/include/verilated.h
+++ b/include/verilated.h
@@ -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 {
     // There are faster algorithms, or fls GCC4 builtins, but rarely used
     if (VL_UNLIKELY(!lhs)) return 0;
-    lhs--;
+    --lhs;
     int shifts = 0;
     for (; lhs != 0; ++shifts) lhs = lhs >> 1;
     return shifts;
 }
 static inline IData VL_CLOG2_Q(QData lhs) VL_PURE {
     if (VL_UNLIKELY(!lhs)) return 0;
-    lhs--;
+    --lhs;
     int shifts = 0;
     for (; lhs != 0; ++shifts) lhs = lhs >> 1ULL;
     return shifts;
diff --git a/include/verilated_cov.cpp b/include/verilated_cov.cpp
index 1fe14ba8d..78757fc4a 100644
--- a/include/verilated_cov.cpp
+++ b/include/verilated_cov.cpp
@@ -132,7 +132,7 @@ private:
     int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
         const auto iter = m_valueIndexes.find(value);
         if (iter != m_valueIndexes.end()) return iter->second;
-        m_nextIndex++;
+        ++m_nextIndex;
         assert(m_nextIndex > 0);  // Didn't rollover
         m_valueIndexes.emplace(value, m_nextIndex);
         m_indexValues.emplace(m_nextIndex, value);
@@ -165,11 +165,11 @@ private:
                                          const std::string& value) VL_PURE {
         std::string name;
         if (key.length() == 1 && std::isalpha(key[0])) {
-            name += std::string("\001") + key;
+            name += std::string{"\001"} + key;
         } 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;
     }
     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 (add.empty()) return old;
 
-        const char* a = old.c_str();
-        const char* b = add.c_str();
+        const char* const a = old.c_str();
+        const char* const b = add.c_str();
 
         // Scan forward to first mismatch
         const char* apre = a;
         const char* bpre = b;
         while (*apre == *bpre) {
-            apre++;
-            bpre++;
+            ++apre;
+            ++bpre;
         }
 
         // We used to backup and split on only .'s but it seems better to be verbose
         // 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
         const char* apost = a + std::strlen(a) - 1;
         const char* bpost = b + std::strlen(b) - 1;
         while (*apost == *bpost && apost > apre && bpost > bpre) {
-            apost--;
-            bpost--;
+            --apost;
+            --bpost;
         }
 
         // 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;
 
@@ -253,17 +254,17 @@ public:
     // PUBLIC METHODS
     void forcePerInstance(const bool flag) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         m_forcePerInstance = flag;
     }
     void clear() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         clearGuts();
     }
     void clearNonMatch(const char* const matchp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         if (matchp && matchp[0]) {
             ItemList newlist;
             for (const auto& itemp : m_items) {
@@ -278,24 +279,24 @@ public:
     }
     void zero() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         for (const auto& itemp : m_items) itemp->zero();
     }
 
     // We assume there's always call to i/f/p in that order
     void inserti(VerilatedCovImpItem* itemp) VL_MT_SAFE_EXCLUDES(m_mutex) {
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         assert(!m_insertp);
         m_insertp = itemp;
     }
     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_insertLineno = lineno;
     }
     void insertp(const char* ckeyps[VerilatedCovConst::MAX_KEYS],
                  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);
         // First two key/vals are filename
         ckeyps[0] = "filename";
@@ -308,7 +309,8 @@ public:
         while (const char* foundp = std::strchr(fnstartp, '/')) fnstartp = foundp + 1;
         const char* fnendp = fnstartp;
         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";
         valps[2] = page_default.c_str();
 
@@ -337,7 +339,7 @@ public:
                 // cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
                 m_insertp->m_keys[addKeynum] = valueIndex(key);
                 m_insertp->m_vals[addKeynum] = valueIndex(val);
-                addKeynum++;
+                ++addKeynum;
                 if (VL_UNCOVERABLE(!legalKey(key))) {
                     std::string msg
                         = ("%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) {
         Verilated::quiesce();
-        const VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
 #ifndef VM_COVERAGE
         VL_FATAL_MT("", 0, "", "%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
 #endif
         selftest();
 
-        std::ofstream os(filename);
+        std::ofstream os{filename};
         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());
             return;
         }
@@ -435,10 +437,10 @@ void VerilatedCovContext::clearNonMatch(const char* matchp) VL_MT_SAFE {
 void VerilatedCovContext::zero() VL_MT_SAFE { impp()->zero(); }
 void VerilatedCovContext::write(const char* filenamep) VL_MT_SAFE { impp()->write(filenamep); }
 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 {
-    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 {
     impp()->insertf(filename, lineno);
@@ -511,7 +513,7 @@ VerilatedCovContext* VerilatedCov::threadCovp() VL_MT_SAFE {
 VerilatedCovContext* VerilatedContext::coveragep() VL_MT_SAFE {
     static VerilatedMutex s_mutex;
     if (VL_UNLIKELY(!m_coveragep)) {
-        const VerilatedLockGuard lock(s_mutex);
+        const VerilatedLockGuard lock{s_mutex};
         if (VL_LIKELY(!m_coveragep)) {  // Not redundant, prevents race
             m_coveragep.reset(new VerilatedCovImp);
         }
diff --git a/include/verilated_dpi.cpp b/include/verilated_dpi.cpp
index 8ec3fc457..986de1453 100644
--- a/include/verilated_dpi.cpp
+++ b/include/verilated_dpi.cpp
@@ -184,7 +184,7 @@ static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHa
         VL_FATAL_MT(__FILE__, __LINE__, "",
                     "%%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())) {
         VL_FATAL_MT(__FILE__, __LINE__, "",
                     "%%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
 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;
     return varp->datap();
 }
 // Return size of open array, or 0 if not in IEEE standard C layout
 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;
     // Truncate 64 bits to int; DPI is limited to 4GB
     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 {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
     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;
 }
 
 // Copy to user bit array from simulator open array
 static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int nargs,
                                       int indx1, int indx2, int indx3) VL_MT_SAFE {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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
 static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int nargs,
                                         int indx1, int indx2, int indx3) VL_MT_SAFE {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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
 static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int nargs,
                                       int indx1, int indx2, int indx3) VL_MT_SAFE {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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
 static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
                                         int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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,
                                  int indx3, int indx4) VL_MT_SAFE {
     // One extra index supported, as need bit number
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return 0;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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 {
     // One extra index supported, as need bit number
     value &= 1;  // Make sure clean
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
-    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
+    void* const datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
     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
 
 void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(h);
     void* datap;
     va_list ap;
     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, ...) {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
     va_list ap;
     va_start(ap, indx1);
     switch (varp->udims()) {
@@ -486,7 +486,7 @@ void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s, int
     _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 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_start(ap, indx1);
     switch (varp->udims()) {
@@ -522,7 +522,7 @@ void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
 // From simulator storage into user space
 
 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_start(ap, indx1);
     switch (varp->udims()) {
@@ -553,7 +553,7 @@ void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1
     _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 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_start(ap, indx1);
     switch (varp->udims()) {
@@ -585,7 +585,7 @@ void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s, int i
 }
 
 svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(s);
     svBit out;
     va_list ap;
     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, ...) {
     // 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;
     va_list ap;
     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, ...) {
-    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
+    const VerilatedDpiOpenVar* const varp = _vl_openhandle_varp(d);
     va_list ap;
     va_start(ap, indx1);
     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, ...) {
     // 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_start(ap, indx1);
     switch (varp->udims()) {
@@ -732,15 +732,15 @@ svScope svGetScope() {
 }
 
 svScope svSetScope(const svScope scope) {
-    const VerilatedScope* prevScopep = Verilated::dpiScope();
-    const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
+    const VerilatedScope* const prevScopep = Verilated::dpiScope();
+    const VerilatedScope* const vscopep = reinterpret_cast<const VerilatedScope*>(scope);
     Verilated::dpiScope(vscopep);
     // NOLINTNEXTLINE(google-readability-casting)
     return (svScope)(prevScopep);
 }
 
 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();
 }
 
diff --git a/include/verilated_fst_c.cpp b/include/verilated_fst_c.cpp
index 9d91029de..4aea35c20 100644
--- a/include/verilated_fst_c.cpp
+++ b/include/verilated_fst_c.cpp
@@ -98,7 +98,7 @@ VerilatedFst::~VerilatedFst() {
 }
 
 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);
     fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
     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) {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     VerilatedTrace<VerilatedFst>::closeBase();
     fstWriterClose(m_fst);
     m_fst = nullptr;
 }
 
 void VerilatedFst::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     VerilatedTrace<VerilatedFst>::flushBase();
     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);
 
-    std::istringstream nameiss(name);
+    std::istringstream nameiss{name};
     std::istream_iterator<std::string> beg(nameiss);
     std::istream_iterator<std::string> end;
     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.insert(tokens.begin(), moduleName());  // Add current module to the hierarchy
     std::string tmpModName;
diff --git a/include/verilated_heavy.h b/include/verilated_heavy.h
index 150991a19..598a99400 100644
--- a/include/verilated_heavy.h
+++ b/include/verilated_heavy.h
@@ -316,7 +316,7 @@ public:
         });
     }
     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 out;
         std::unordered_set<T_Value> saw;
@@ -397,12 +397,12 @@ public:
 
     // Reduction operators
     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());
         return VlQueue::cons(*it);
     }
     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());
         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>
 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 {
-    VlReadMem rmem(hex, bits, filename, start, end);
+    VlReadMem rmem{hex, bits, filename, start, end};
     if (VL_UNLIKELY(!rmem.isOpen())) return;
     while (true) {
         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>
 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 {
-    VlWriteMem wmem(hex, bits, filename, start, end);
+    VlWriteMem wmem{hex, bits, filename, start, end};
     if (VL_UNLIKELY(!wmem.isOpen())) return;
     for (const auto& i : obj) {
         const QData addr = i.first;
diff --git a/include/verilated_imp.h b/include/verilated_imp.h
index b4d13e0e0..fef103f7b 100644
--- a/include/verilated_imp.h
+++ b/include/verilated_imp.h
@@ -104,7 +104,7 @@ public:
     // METHODS
     // Add message to queue (called by producer)
     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_depth;
     }
@@ -124,7 +124,7 @@ public:
             const VerilatedMsg msg = *(it);
             m_queue.erase(it);
             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()););
                 msg.run();
@@ -256,11 +256,11 @@ public:  // But only for verilated*.cpp
     int timeFormatWidth() const VL_MT_SAFE { return m_s.m_timeFormatWidth; }
     void timeFormatWidth(int value) VL_MT_SAFE { m_s.m_timeFormatWidth = value; }
     std::string timeFormatSuffix() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
-        const VerilatedLockGuard lock(m_timeDumpMutex);
+        const VerilatedLockGuard lock{m_timeDumpMutex};
         return m_timeFormatSuffix;
     }
     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;
     }
 
@@ -276,7 +276,7 @@ public:  // But only for verilated*.cpp
 public:  // But only for verilated*.cpp
     // METHODS - file IO
     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;
         IData idx = m_fdFreeMct.back();
         m_fdFreeMct.pop_back();
@@ -285,10 +285,10 @@ public:  // But only for verilated*.cpp
         return (1 << idx);
     }
     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;
         // Bit 31 indicates it's a descriptor not a MCD
-        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedLockGuard lock{m_fdMutex};
         if (m_fdFree.empty()) {
             // 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());
@@ -306,25 +306,25 @@ public:  // But only for verilated*.cpp
         return (idx | (1UL << 31));  // bit 31 indicates not MCD
     }
     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);
         for (const auto& i : fdlist) std::fflush(i);
     }
     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);
         if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
         return static_cast<IData>(
             std::fseek(*fdlist.begin(), static_cast<long>(offset), static_cast<int>(origin)));
     }
     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);
         if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
         return static_cast<IData>(std::ftell(*fdlist.begin()));
     }
     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);
         for (const auto& i : fdlist) {
             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) {
-        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedLockGuard lock{m_fdMutex};
         if (VL_BITISSET_I(fdi, 31)) {
             // Non-MCD case
             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) {
-        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedLockGuard lock{m_fdMutex};
         const VerilatedFpList fdlist = fdToFpList(fdi);
         if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr;
         return *fdlist.begin();
@@ -463,7 +463,7 @@ public:
     // per map overhead * N scopes would take much more space and cache thrashing.
     // 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 {
-        const VerilatedLockGuard lock(s().m_userMapMutex);
+        const VerilatedLockGuard lock{s().m_userMapMutex};
         const auto it = s().m_userMap.find(std::make_pair(scopep, userKey));
         if (it != s().m_userMap.end()) {
             it->second = userData;
@@ -472,7 +472,7 @@ public:
         }
     }
     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));
         if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr;
         return it->second;
@@ -482,7 +482,7 @@ public:  // But only for verilated.cpp
     // Symbol table destruction cleans up the entries for each scope.
     static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
         // Slow ok - called once/scope on destruction, so we 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();) {
             if (it->first.first == scopep) {
                 s().m_userMap.erase(it++);
@@ -492,7 +492,7 @@ public:  // But only for verilated.cpp
         }
     }
     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;
         for (const auto& i : s().m_userMap) {
             if (first) {
@@ -508,13 +508,13 @@ public:  // But only for verilated*.cpp
     // METHODS - hierarchy
     static void hierarchyAdd(const VerilatedScope* fromp, const VerilatedScope* top) VL_MT_SAFE {
         // Slow ok - called at construction for VPI accessible elements
-        const VerilatedLockGuard lock(s().m_hierMapMutex);
+        const VerilatedLockGuard lock{s().m_hierMapMutex};
         s().m_hierMap[fromp].push_back(top);
     }
     static void hierarchyRemove(const VerilatedScope* fromp,
                                 const VerilatedScope* top) VL_MT_SAFE {
         // 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;
         if (map.find(fromp) == map.end()) return;
         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.
     static int exportInsert(const char* namep) VL_MT_SAFE {
         // 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);
         if (it == s().m_exportMap.end()) {
             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 {
-        const VerilatedLockGuard lock(s().m_exportMutex);
+        const VerilatedLockGuard lock{s().m_exportMutex};
         const auto& it = s().m_exportMap.find(namep);
         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");
         VL_FATAL_MT("unknown", 0, "", msg.c_str());
         return -1;
     }
     static const char* exportName(int funcnum) VL_MT_SAFE {
         // 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) {
             if (i.second == funcnum) return i.first;
         }
         return "*UNKNOWN*";
     }
     static void exportsDump() VL_MT_SAFE {
-        const VerilatedLockGuard lock(s().m_exportMutex);
+        const VerilatedLockGuard lock{s().m_exportMutex};
         bool first = true;
         for (const auto& i : s().m_exportMap) {
             if (first) {
diff --git a/include/verilated_save.cpp b/include/verilated_save.cpp
index 0c07022ea..2fec9808d 100644
--- a/include/verilated_save.cpp
+++ b/include/verilated_save.cpp
@@ -93,8 +93,8 @@ void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, std::strlen(VLTSAVE_HEADER_STR)))) {
         const std::string fn = filename();
         const std::string msg
-            = std::string(
-                  "Can't deserialize; file has wrong header signature, or file not found: ")
+            = std::
+                  string{"Can't deserialize; file has wrong header signature, or file not found: "}
               + filename();
         VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
         // 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)))) {
         const std::string fn = filename();
         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();
         VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
         // 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)) {
                 // LCOV_EXCL_START
                 // 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());
                 close();
                 break;
@@ -235,7 +235,7 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
             if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
                 // LCOV_EXCL_START
                 // 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());
                 close();
                 break;
diff --git a/include/verilated_threads.cpp b/include/verilated_threads.cpp
index 8d3480540..99e59e444 100644
--- a/include/verilated_threads.cpp
+++ b/include/verilated_threads.cpp
@@ -104,7 +104,7 @@ VlThreadPool::VlThreadPool(VerilatedContext* contextp, int nThreads, bool profil
     }
     // Create'em
     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
     // 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.
     t_profilep->reserve(4096);
     {
-        const VerilatedLockGuard lk(m_mutex);
+        const VerilatedLockGuard lock{m_mutex};
         m_allProfiles.insert(t_profilep);
     }
 }
 
 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) {
         // Every thread's profile trace gets a copy of 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)
     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););
 
     FILE* const fp = std::fopen(filenamep, "w");
diff --git a/include/verilated_threads.h b/include/verilated_threads.h
index b6163477b..150168f80 100644
--- a/include/verilated_threads.h
+++ b/include/verilated_threads.h
@@ -225,10 +225,10 @@ public:
             }
             VL_CPU_RELAX();
         }
-        VerilatedLockGuard lk(m_mutex);
+        VerilatedLockGuard lock{m_mutex};
         while (m_ready.empty()) {
             m_waiting = true;
-            m_cv.wait(lk);
+            m_cv.wait(lock);
         }
         m_waiting = false;
         // As noted above this is inefficient if our ready list is ever
@@ -242,7 +242,7 @@ public:
         VL_MT_SAFE_EXCLUDES(m_mutex) {
         bool notify;
         {
-            const VerilatedLockGuard lk(m_mutex);
+            const VerilatedLockGuard lock{m_mutex};
             m_ready.emplace_back(fnp, selfp, evenCycle);
             m_ready_size.fetch_add(1, std::memory_order_relaxed);
             notify = m_waiting;
diff --git a/include/verilated_trace.h b/include/verilated_trace.h
index db3b71efc..6e7d6c59e 100644
--- a/include/verilated_trace.h
+++ b/include/verilated_trace.h
@@ -52,21 +52,21 @@ private:
 public:
     // Put an element at the back of the queue
     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_cv.notify_one();
     }
 
     // Put an element at the front of the queue
     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_cv.notify_one();
     }
 
     // Get an element from the front of the queue. Blocks if none available
     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(); });
         assert(!m_queue.empty());
         T value = m_queue.front();
@@ -76,7 +76,7 @@ public:
 
     // Non blocking get
     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;
         result = m_queue.front();
         m_queue.pop_front();
diff --git a/include/verilated_trace_imp.cpp b/include/verilated_trace_imp.cpp
index 6a31b6cd0..07e60f7a3 100644
--- a/include/verilated_trace_imp.cpp
+++ b/include/verilated_trace_imp.cpp
@@ -246,7 +246,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::closeBase() {
     shutdownWorker();
     while (m_numTraceBuffers) {
         delete[] m_buffersFromWorker.get();
-        m_numTraceBuffers--;
+        --m_numTraceBuffers;
     }
 #endif
 }
@@ -351,7 +351,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
     m_traceBufferSize = nextCode() + numSignals() * 2 + 4;
 
     // 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
 }
 
@@ -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.
     // This does get the mutex, but if multiple threads are trying to dump
     // 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
         VL_PRINTF_MT("%%Warning: previous dump at t=%" VL_PRI64 "u, requesting t=%" VL_PRI64
                      "u, dump call ignored\n",
@@ -479,9 +479,9 @@ template <>
 void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>& cbVec,
                                                      CallbackRecord& cbRec)
     VL_MT_SAFE_EXCLUDES(m_mutex) {
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     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");
         VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
     }  // 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 {
-    CallbackRecord cbr(cb, userp);
+    CallbackRecord cbr{cb, userp};
     addCallbackRecord(m_initCbs, cbr);
 }
 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);
 }
 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);
 }
 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);
 }
 template <> void VerilatedTrace<VL_DERIVED_T>::module(const std::string& name) VL_MT_UNSAFE {
diff --git a/include/verilated_vcd_c.cpp b/include/verilated_vcd_c.cpp
index 798618643..de7433498 100644
--- a/include/verilated_vcd_c.cpp
+++ b/include/verilated_vcd_c.cpp
@@ -102,7 +102,7 @@ VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep) {
 }
 
 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;
 
     // 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) {
     // Open next filename in concat sequence, mangle filename if
     // incFilename is true.
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     openNextImp(incFilename);
 }
 
@@ -195,11 +195,11 @@ void VerilatedVcd::makeNameMap() {
         if (!hiername.empty() && hiername[0] == '\t') nullScope = true;
     }
     if (nullScope) {
-        NameMap* newmapp = new NameMap;
+        NameMap* const newmapp = new NameMap;
         for (const auto& i : *m_namemapp) {
             const std::string& hiername = i.first;
             const std::string& decl = i.second;
-            std::string newname = std::string("top");
+            std::string newname{"top"};
             if (hiername[0] != '\t') newname += ' ';
             newname += hiername;
             newmapp->emplace(newname, decl);
@@ -243,7 +243,7 @@ void VerilatedVcd::closeErr() {
 
 void VerilatedVcd::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
     // This function is on the flush() call path
-    const VerilatedLockGuard lock(m_mutex);
+    const VerilatedLockGuard lock{m_mutex};
     if (!isOpen()) return;
     if (m_evcd) {
         printStr("$vcdclose ");
@@ -257,7 +257,7 @@ void VerilatedVcd::close() 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();
     bufferFlush();
 }
@@ -311,7 +311,7 @@ void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
                 // LCOV_EXCL_START
                 // write failed, presume error (perhaps out of disk space)
                 std::string msg
-                    = std::string("VerilatedVcd::bufferFlush: ") + std::strerror(errno);
+                    = std::string{"VerilatedVcd::bufferFlush: "} + std::strerror(errno);
                 VL_FATAL_MT("", 0, "", msg.c_str());
                 closeErr();
                 break;
@@ -331,7 +331,7 @@ char* VerilatedVcd::writeCode(char* writep, vluint32_t code) {
     *writep++ = static_cast<char>('!' + code % 94);
     code /= 94;
     while (code) {
-        code--;
+        --code;
         *writep++ = static_cast<char>('!' + code % 94);
         code /= 94;
     }
@@ -393,8 +393,8 @@ void VerilatedVcd::dumpHeader() {
         // Skip common prefix, it must break at a space or tab
         for (; *np && (*np == *lp); np++, lp++) {}
         while (np != hiername && *np && *np != ' ' && *np != '\t') {
-            np--;
-            lp--;
+            --np;
+            --lp;
         }
         // 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;
         vcdp->evcd(true);
         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(std::string("1ns"));
+        vcdp->set_time_resolution(std::string{"1ns"});
         vcdp->spTrace()->addInitCb(&vcdInit, 0);
         vcdp->spTrace()->addFullCb(&vcdFull, 0);
         vcdp->spTrace()->addChgCb(&vcdChange, 0);
@@ -927,7 +927,7 @@ void vcdTestMain(const char* filenamep) {
         vcdp->dump(++timestamp);
         vcdp->dump(++timestamp);
 # ifdef VERILATED_VCD_TEST_64BIT
-        vluint64_t bytesPerDump = 15ULL;
+        const vluint64_t bytesPerDump = 15ULL;
         for (vluint64_t i = 0; i < ((1ULL << 32) / bytesPerDump); i++) {
             v1 = i;
             vcdp->dump(++timestamp);
diff --git a/include/verilated_vcd_sc.h b/include/verilated_vcd_sc.h
index de6e6d943..a79a9c61a 100644
--- a/include/verilated_vcd_sc.h
+++ b/include/verilated_vcd_sc.h
@@ -44,9 +44,9 @@ public:
         // We want to avoid a depreciated warning, but still be back compatible.
         // Turning off the message just for this still results in an
         // 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) {
-            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_resolution(sc_get_time_resolution().to_string());
diff --git a/include/verilated_vpi.cpp b/include/verilated_vpi.cpp
index eb9e254a3..c354d89f1 100644
--- a/include/verilated_vpi.cpp
+++ b/include/verilated_vpi.cpp
@@ -80,7 +80,7 @@ public:
         static const size_t chunk = 96;
         if (VL_UNCOVERABLE(size > chunk)) VL_FATAL_MT(__FILE__, __LINE__, "", "increase chunk");
         if (VL_LIKELY(t_freeHead)) {
-            vluint8_t* newp = t_freeHead;
+            vluint8_t* const newp = t_freeHead;
             t_freeHead = *(reinterpret_cast<vluint8_t**>(newp));
             *(reinterpret_cast<vluint32_t*>(newp)) = activeMagic();
             return newp + 8;
@@ -91,7 +91,7 @@ public:
         return newp + 8;
     }
     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())) {
             VL_FATAL_MT(__FILE__, __LINE__, "",
                         "vpi_release_handle() called on same object twice, or on non-Verilator "
@@ -128,7 +128,7 @@ class VerilatedVpioTimedCb final : public VerilatedVpio {
 
 public:
     VerilatedVpioTimedCb(vluint64_t id, QData time)
-        : m_id(id)
+        : m_id{id}
         , m_time{time} {}
     virtual ~VerilatedVpioTimedCb() override = default;
     static VerilatedVpioTimedCb* castp(vpiHandle h) {
@@ -147,7 +147,7 @@ class VerilatedVpioReasonCb final : public VerilatedVpio {
 public:
     // cppcheck-suppress uninitVar  // m_value
     VerilatedVpioReasonCb(vluint64_t id, PLI_INT32 reason)
-        : m_id(id)
+        : m_id{id}
         , m_reason{reason} {}
     virtual ~VerilatedVpioReasonCb() override = default;
     static VerilatedVpioReasonCb* castp(vpiHandle h) {
@@ -200,7 +200,7 @@ public:
     virtual const char* name() const override { return m_varp->name(); }
     virtual const char* fullname() const override {
         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();
     }
 };
@@ -208,7 +208,7 @@ public:
 class VerilatedVpioParam final : public VerilatedVpioVarBase {
 public:
     VerilatedVpioParam(const VerilatedVar* varp, const VerilatedScope* scopep)
-        : VerilatedVpioVarBase(varp, scopep) {}
+        : VerilatedVpioVarBase{varp, scopep} {}
     virtual ~VerilatedVpioParam() override = default;
 
     static VerilatedVpioParam* castp(vpiHandle h) {
@@ -252,7 +252,7 @@ public:
             return nullptr;
         }
         m_done = true;
-        return ((new VerilatedVpioRange(m_range))->castVpiHandle());
+        return ((new VerilatedVpioRange{m_range})->castVpiHandle());
     }
 };
 
@@ -286,13 +286,13 @@ protected:
 
 public:
     VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep)
-        : VerilatedVpioVarBase(varp, scopep) {
+        : VerilatedVpioVarBase{varp, scopep} {
         m_mask.u32 = VL_MASK_I(varp->packed().elements());
         m_entSize = varp->entSize();
         m_varDatap = varp->datap();
     }
     explicit VerilatedVpioVar(const VerilatedVpioVar* varp)
-        : VerilatedVpioVarBase(varp) {
+        : VerilatedVpioVarBase{varp} {
         if (varp) {
             m_mask.u32 = varp->m_mask.u32;
             m_entSize = varp->m_entSize;
@@ -345,7 +345,7 @@ public:
         static VL_THREAD_LOCAL std::string t_out;
         char num[25];
         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();
     }
 };
@@ -379,7 +379,7 @@ public:
                 delete this;  // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle
                 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
         return nullptr;  // End of list - only one deep
@@ -457,7 +457,7 @@ public:
             return nullptr;
         }
         const VerilatedScope* modp = *m_it++;
-        return (new VerilatedVpioModule(modp))->castVpiHandle();
+        return (new VerilatedVpioModule{modp})->castVpiHandle();
     }
 };
 
@@ -475,9 +475,9 @@ class VerilatedVpiCbHolder final {
 public:
     // cppcheck-suppress uninitVar  // m_value
     VerilatedVpiCbHolder(vluint64_t id, const s_cb_data* cbDatap, const VerilatedVpioVar* varop)
-        : m_id(id)
-        , m_cbData(*cbDatap)
-        , m_varo(varop) {
+        : m_id{id}
+        , m_cbData{*cbDatap}
+        , m_varo{varop} {
         m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal;
         m_cbData.value = &m_value;
         if (varop) {
@@ -626,9 +626,10 @@ public:
                 continue;
             }
             VerilatedVpiCbHolder& ho = *it++;
-            if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(ho.cb_datap()->obj)) {
-                void* newDatap = varop->varDatap();
-                void* prevDatap = varop->prevDatap();  // Was malloced when we added the callback
+            if (VerilatedVpioVar* const varop = VerilatedVpioVar::castp(ho.cb_datap()->obj)) {
+                void* const newDatap = varop->varDatap();
+                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",
                                             varop->fullname(), *((CData*)newDatap),
                                             *((CData*)prevDatap), newDatap, prevDatap););
@@ -758,7 +759,7 @@ PLI_INT32 VerilatedVpioReasonCb::dovpi_remove_cb() {
 
 VerilatedVpiError* VerilatedVpiImp::error_info() VL_MT_UNSAFE_ONE {
     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;
 }
 
@@ -1108,13 +1109,13 @@ const char* VerilatedVpiError::strFromVpiProp(PLI_INT32 vpiVal) VL_MT_SAFE {
 #define SELF_CHECK_RESULT_CSTR(got, exp) \
     if (0 != std::strcmp((got), (exp))) { \
         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()); \
     }
 
 #define SELF_CHECK_ENUM_STR(fn, enumn) \
     do { \
-        const char* strVal = VerilatedVpiError::fn(enumn); \
+        const char* const strVal = VerilatedVpiError::fn(enumn); \
         SELF_CHECK_RESULT_CSTR(strVal, #enumn); \
     } while (0)
 
@@ -1358,7 +1359,7 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
     const VerilatedVpioScope* const voScopep = VerilatedVpioScope::castp(scope);
     std::string scopeAndName = namep;
     if (voScopep) {
-        scopeAndName = std::string(voScopep->fullname()) + "." + namep;
+        scopeAndName = std::string{voScopep->fullname()} + "." + namep;
         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);
         if (scopep) {  // Whole thing found as a scope
             if (scopep->type() == VerilatedScope::SCOPE_MODULE) {
-                return (new VerilatedVpioModule(scopep))->castVpiHandle();
+                return (new VerilatedVpioModule{scopep})->castVpiHandle();
             } else {
-                return (new VerilatedVpioScope(scopep))->castVpiHandle();
+                return (new VerilatedVpioScope{scopep})->castVpiHandle();
             }
         }
         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, '.');
         if (VL_LIKELY(dotp)) {
             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) {
@@ -1393,9 +1395,9 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
     if (!varp) return nullptr;
 
     if (varp->isParam()) {
-        return (new VerilatedVpioParam(varp, scopep))->castVpiHandle();
+        return (new VerilatedVpioParam{varp, scopep})->castVpiHandle();
     } 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();
     VL_VPI_ERROR_RESET_();
     // Memory words are not indexable
-    VerilatedVpioMemoryWord* vop = VerilatedVpioMemoryWord::castp(object);
+    VerilatedVpioMemoryWord* const vop = VerilatedVpioMemoryWord::castp(object);
     if (VL_UNLIKELY(vop)) return nullptr;
     const VerilatedVpioVar* const varop = VerilatedVpioVar::castp(object);
     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()
                             || indx < varop->varp()->unpacked().right()))
                 return nullptr;
-            return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
-                                                indx - varop->varp()->unpacked().right()))
+            return (new VerilatedVpioMemoryWord{varop->varp(), varop->scopep(), indx,
+                                                indx - varop->varp()->unpacked().right()})
                 ->castVpiHandle();
         }
         if (VL_UNLIKELY(indx < varop->varp()->unpacked().left()
                         || indx > varop->varp()->unpacked().right()))
             return nullptr;
-        return (new VerilatedVpioMemoryWord(varop->varp(), varop->scopep(), indx,
-                                            indx - varop->varp()->unpacked().left()))
+        return (new VerilatedVpioMemoryWord{varop->varp(), varop->scopep(), indx,
+                                            indx - varop->varp()->unpacked().left()})
             ->castVpiHandle();
     }
     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_();
     switch (type) {
     case vpiLeftRange: {
-        if (VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object)) {
+        if (VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object)) {
             if (VL_UNLIKELY(!vop->rangep())) return nullptr;
-            return (new VerilatedVpioConst(vop->rangep()->left()))->castVpiHandle();
-        } else if (VerilatedVpioRange* vop = VerilatedVpioRange::castp(object)) {
+            return (new VerilatedVpioConst{vop->rangep()->left()})->castVpiHandle();
+        } else if (VerilatedVpioRange* const vop = VerilatedVpioRange::castp(object)) {
             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__,
                         "%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;
     }
     case vpiRightRange: {
-        if (VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object)) {
+        if (VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object)) {
             if (VL_UNLIKELY(!vop->rangep())) return nullptr;
-            return (new VerilatedVpioConst(vop->rangep()->right()))->castVpiHandle();
-        } else if (VerilatedVpioRange* vop = VerilatedVpioRange::castp(object)) {
+            return (new VerilatedVpioConst{vop->rangep()->right()})->castVpiHandle();
+        } else if (VerilatedVpioRange* const vop = VerilatedVpioRange::castp(object)) {
             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__,
                         "%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;
     }
     case vpiIndex: {
-        VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
+        VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object);
         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: {
-        VerilatedVpioVarBase* vop = VerilatedVpioVarBase::castp(object);
+        VerilatedVpioVarBase* const vop = VerilatedVpioVarBase::castp(object);
         if (VL_UNLIKELY(!vop)) return nullptr;
-        return (new VerilatedVpioScope(vop->scopep()))->castVpiHandle();
+        return (new VerilatedVpioScope{vop->scopep()})->castVpiHandle();
     }
     case vpiParent: {
-        VerilatedVpioMemoryWord* vop = VerilatedVpioMemoryWord::castp(object);
+        VerilatedVpioMemoryWord* const vop = VerilatedVpioMemoryWord::castp(object);
         if (VL_UNLIKELY(!vop)) return nullptr;
-        return (new VerilatedVpioVar(vop->varp(), vop->scopep()))->castVpiHandle();
+        return (new VerilatedVpioVar{vop->varp(), vop->scopep()})->castVpiHandle();
     }
     default:
         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(),
                             vop->varp()->dims());
         }
-        return (new VerilatedVpioMemoryWordIter(object, vop->varp()))->castVpiHandle();
+        return (new VerilatedVpioMemoryWordIter{object, vop->varp()})->castVpiHandle();
     }
     case vpiRange: {
         const VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object);
@@ -1518,12 +1521,12 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
                             VerilatedVpiError::strFromVpiMethod(type), vop->fullname(),
                             vop->varp()->dims());
         }
-        return ((new VerilatedVpioRangeIter(vop->rangep()))->castVpiHandle());
+        return ((new VerilatedVpioRangeIter{vop->rangep()})->castVpiHandle());
     }
     case vpiReg: {
         const VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object);
         if (VL_UNLIKELY(!vop)) return nullptr;
-        return ((new VerilatedVpioVarIter(vop->scopep()))->castVpiHandle());
+        return ((new VerilatedVpioVarIter{vop->scopep()})->castVpiHandle());
     }
     case vpiModule: {
         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 auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(modp));
         if (it == map->end()) return nullptr;
-        return ((new VerilatedVpioModuleIter(it->second))->castVpiHandle());
+        return ((new VerilatedVpioModuleIter{it->second})->castVpiHandle());
     }
     default:
         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););
     VerilatedVpiImp::assertOneCheck();
     VL_VPI_ERROR_RESET_();
-    VerilatedVpio* vop = VerilatedVpio::castp(object);
+    VerilatedVpio* const vop = VerilatedVpio::castp(object);
     if (VL_UNLIKELY(!vop)) return nullptr;
     return vop->dovpi_scan();
 }
@@ -1893,13 +1896,13 @@ void vpi_get_value(vpiHandle object, p_vpi_value valuep) {
     VL_VPI_ERROR_RESET_();
     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());
         return;
     } else if (const VerilatedVpioParam* const vop = VerilatedVpioParam::castp(object)) {
         vl_get_value(vop->varp(), vop->varDatap(), valuep, vop->fullname());
         return;
-    } else if (VerilatedVpioConst* vop = VerilatedVpioConst::castp(object)) {
+    } else if (VerilatedVpioConst* const vop = VerilatedVpioConst::castp(object)) {
         if (valuep->format == vpiIntVal) {
             valuep->value.integer = vop->num();
             return;
@@ -2161,7 +2164,7 @@ void vpi_get_time(vpiHandle object, p_vpi_time time_p) {
         return;
     } else if (time_p->type == vpiScaledRealTime) {
         double dtime = VL_TIME_D();
-        if (VerilatedVpioScope* vop = VerilatedVpioScope::castp(object)) {
+        if (VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object)) {
             const int scalePow10
                 = Verilated::threadContextp()->timeprecision() - vop->scopep()->timeunit();
             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) {
     VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_release_handle %p\n", object););
     VerilatedVpiImp::assertOneCheck();
-    VerilatedVpio* vop = VerilatedVpio::castp(object);
+    VerilatedVpio* const vop = VerilatedVpio::castp(object);
     VL_VPI_ERROR_RESET_();
     if (VL_UNLIKELY(!vop)) return 0;
     VL_DO_DANGLING(delete vop, vop);
diff --git a/nodist/dot_importer b/nodist/dot_importer
index fb6d6661a..cc9520a27 100755
--- a/nodist/dot_importer
+++ b/nodist/dot_importer
@@ -66,11 +66,11 @@ def cwrite(filename):
         fh.write("    auto* gp = &m_graph;\n")
         for ver in sorted(Vertexes, key=lambda ver: ver['num']):
             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']))
         fh.write("\n")
         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'],
                       "true" if edge['cutable'] else "false"))
         fh.write("}\n")