diff --git a/src/V3AstAttr.h b/src/V3AstAttr.h
index 44e8b2dc1..729b4c77e 100644
--- a/src/V3AstAttr.h
+++ b/src/V3AstAttr.h
@@ -75,11 +75,11 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {"RD", "WR", "RW", "--"};
+        static constexpr const char* const names[] = {"RD", "WR", "RW", "--"};
         return names[m_e];
     }
     const char* arrow() const {
-        static const char* const names[] = {"[RV] <-", "[LV] =>", "[LRV] <=>", "--"};
+        static constexpr const char* const names[] = {"[RV] <-", "[LV] =>", "[LRV] <=>", "--"};
         return names[m_e];
     }
     VAccess()
@@ -119,7 +119,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"always", "always_ff", "always_latch", "always_comb", "cont_assign"};
         return names[m_e];
     }
@@ -160,18 +160,18 @@ public:
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
         // IEEE 1800-2023 20.11
-        static const char* const names[] = {"",
-                                            "",
-                                            "",
-                                            "$asserton",
-                                            "$assertoff",
-                                            "$assertkill",
-                                            "$assertpasson",
-                                            "$assertpassoff",
-                                            "$assertfailon",
-                                            "$assertfailoff",
-                                            "$assertnonvacuouson",
-                                            "$assertvacuousoff"};
+        static constexpr const char* const names[] = {"",
+                                                      "",
+                                                      "",
+                                                      "$asserton",
+                                                      "$assertoff",
+                                                      "$assertkill",
+                                                      "$assertpasson",
+                                                      "$assertpassoff",
+                                                      "$assertfailon",
+                                                      "$assertfailoff",
+                                                      "$assertnonvacuouson",
+                                                      "$assertvacuousoff"};
         return names[m_e];
     }
 };
@@ -311,7 +311,7 @@ public:
     constexpr VPropStrength(en _e)
         : m_e{_e} {}
     const char* ascii() const {
-        static const char* const names[] = {"default", "weak", "strong"};
+        static constexpr const char* const names[] = {"default", "weak", "strong"};
         return names[m_e];
     }
 };
@@ -379,7 +379,7 @@ public:
     enum en m_e;
     const char* ascii() const {
         // clang-format off
-        static const char* const names[] = {
+        static constexpr const char* const names[] = {
             "%E-AT",
             "DIM_BITS", "DIM_BITS_OR_NUMBER", "DIM_DIMENSIONS",
             "DIM_HIGH", "DIM_INCREMENT", "DIM_LEFT",
@@ -520,69 +520,69 @@ public:
     };
     enum en m_e;
     const char* ascii() const VL_MT_SAFE {
-        static const char* const names[] = {"%E-unk",
-                                            "bit",
-                                            "byte",
-                                            "chandle",
-                                            "void",
-                                            "event",
-                                            "int",
-                                            "integer",
-                                            "logic",
-                                            "longint",
-                                            "real",
-                                            "shortint",
-                                            "time",
-                                            "string",
-                                            "untyped",
-                                            "VerilatedScope*",
-                                            "char*",
-                                            "VlMTaskState",
-                                            "VlDelayScheduler",
-                                            "VlTriggerScheduler",
-                                            "VlDynamicTriggerScheduler",
-                                            "VlFork",
-                                            "VlProcessRef",
-                                            "VlRandomizer",
-                                            "VlStdRandomizer",
-                                            "VlCovInstHandle",
-                                            "IData",
-                                            "QData",
-                                            "LOGIC_IMPLICIT",
-                                            " MAX"};
+        static constexpr const char* const names[] = {"%E-unk",
+                                                      "bit",
+                                                      "byte",
+                                                      "chandle",
+                                                      "void",
+                                                      "event",
+                                                      "int",
+                                                      "integer",
+                                                      "logic",
+                                                      "longint",
+                                                      "real",
+                                                      "shortint",
+                                                      "time",
+                                                      "string",
+                                                      "untyped",
+                                                      "VerilatedScope*",
+                                                      "char*",
+                                                      "VlMTaskState",
+                                                      "VlDelayScheduler",
+                                                      "VlTriggerScheduler",
+                                                      "VlDynamicTriggerScheduler",
+                                                      "VlFork",
+                                                      "VlProcessRef",
+                                                      "VlRandomizer",
+                                                      "VlStdRandomizer",
+                                                      "VlCovInstHandle",
+                                                      "IData",
+                                                      "QData",
+                                                      "LOGIC_IMPLICIT",
+                                                      " MAX"};
         return names[m_e];
     }
     const char* dpiType() const {
-        static const char* const names[] = {"%E-unk",
-                                            "svBit",
-                                            "char",
-                                            "void*",
-                                            "void",
-                                            "char",
-                                            "int",
-                                            "%E-integer",
-                                            "svLogic",
-                                            "long long",
-                                            "double",
-                                            "short",
-                                            "%E-time",
-                                            "const char*",
-                                            "%E-untyped",
-                                            "dpiScope",
-                                            "const char*",
-                                            "%E-mtaskstate",
-                                            "%E-dly-sched",
-                                            "%E-trig-sched",
-                                            "%E-dyn-sched",
-                                            "%E-fork",
-                                            "%E-proc-ref",
-                                            "%E-rand-gen",
-                                            "%E-stdrand-gen",
-                                            "%E-cg-insthandle",
-                                            "IData",
-                                            "QData",
-                                            "%E-logic-implct",
-                                            " MAX"};
+        static constexpr const char* const names[] = {"%E-unk",
+                                                      "svBit",
+                                                      "char",
+                                                      "void*",
+                                                      "void",
+                                                      "char",
+                                                      "int",
+                                                      "%E-integer",
+                                                      "svLogic",
+                                                      "long long",
+                                                      "double",
+                                                      "short",
+                                                      "%E-time",
+                                                      "const char*",
+                                                      "%E-untyped",
+                                                      "dpiScope",
+                                                      "const char*",
+                                                      "%E-mtaskstate",
+                                                      "%E-dly-sched",
+                                                      "%E-trig-sched",
+                                                      "%E-dyn-sched",
+                                                      "%E-fork",
+                                                      "%E-proc-ref",
+                                                      "%E-rand-gen",
+                                                      "%E-stdrand-gen",
+                                                      "%E-cg-insthandle",
+                                                      "IData",
+                                                      "QData",
+                                                      "%E-logic-implct",
+                                                      " MAX"};
         return names[m_e];
     }
     static void selfTest() {
@@ -694,7 +694,7 @@ public:
 
     const char* traceSigType() const {
         // VerilatedTraceSigType to used in trace signal declaration
-        static const char* const lut[] = {
+        static constexpr const char* const lut[] = {
             /* UNKNOWN:                   */ "",  // Should not be traced
             /* BIT:                       */ "BIT",
             /* BYTE:                      */ "BYTE",
@@ -754,7 +754,7 @@ public:
     explicit VBoolOrUnknown(int _e)
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     const char* ascii() const {
-        static const char* const names[] = {"FALSE", "TRUE", "UNK"};
+        static constexpr const char* const names[] = {"FALSE", "TRUE", "UNK"};
         return names[m_e];
     }
     bool isKnown() const { return m_e != BU_UNKNOWN; }
@@ -798,11 +798,11 @@ public:
         return m_e;
     }
     const char* ascii() const {
-        static const char* const names[] = {"", "VL_LIKELY", "VL_UNLIKELY"};
+        static constexpr const char* const names[] = {"", "VL_LIKELY", "VL_UNLIKELY"};
         return names[m_e];
     }
     const char* asciiShort() const {
-        static const char* const names[] = {"", "L", "!L"};
+        static constexpr const char* const names[] = {"", "L", "!L"};
         return names[m_e];
     }
 };
@@ -1018,7 +1018,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const VL_PURE {
-        static const char* const values[] = {
+        static constexpr const char* const values[] = {
 #define VL_CMETHOD_NAME(id, method, pure, args) method,
             FOR_EACH_CMETHOD(VL_CMETHOD_NAME)
 #undef VL_CMETHOD_NAME
@@ -1027,7 +1027,7 @@ public:
         return values[m_e];
     }
     bool isPure() const VL_PURE {
-        static const bool values[] = {
+        static constexpr bool values[] = {
 #define VL_CMETHOD_PURE(id, method, pure, args) pure,
             FOR_EACH_CMETHOD(VL_CMETHOD_PURE)
 #undef VL_CMETHOD_PURE
@@ -1036,7 +1036,7 @@ public:
         return values[m_e];
     }
     const char* args() const VL_PURE {
-        static const char* const values[] = {
+        static constexpr const char* const values[] = {
 #define VL_CMETHOD_ARGS(id, method, pure, args) args,
             FOR_EACH_CMETHOD(VL_CMETHOD_ARGS)
 #undef VL_CMETHOD_ARGS
@@ -1106,7 +1106,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const VL_PURE {
-        static const char* const names[] = {"none", "ctor_var_reset_call"};
+        static constexpr const char* const names[] = {"none", "ctor_var_reset_call"};
         return names[m_e];
     }
     bool isNone() const { return m_e == NONE; }
@@ -1142,7 +1142,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const VL_PURE {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"CASE", "CASEX", "CASEZ", "CASEINSIDE", "CASEMATCHES", "RANDSEQUENCE"};
         return names[m_e];
     }
@@ -1169,7 +1169,7 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"UNSUPPORTED",   "SAMEISH",       "COMPATIBLE",  "ENUM_EXPLICIT",
                "ENUM_IMPLICIT", "DYNAMIC_CLASS", "INCOMPATIBLE"};
         return names[m_e];
@@ -1216,15 +1216,15 @@ public:
         : m_e{_e} {}
     constexpr operator en() const { return m_e; }  // LCOV_EXCL_LINE
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"array",        "auto",       "auto_implicit", "default", "ignore_bins",
                "illegal_bins", "transition", "bins",          "wildcard"};
         return names[m_e];
     }
     // Keyword declaring the bins, without any 'wildcard' prefix
     const char* verilogKwd() const {
-        static const char* const names[] = {"bins",         "bins", "bins", "bins", "ignore_bins",
-                                            "illegal_bins", "bins", "bins", "bins"};
+        static constexpr const char* const names[] = {
+            "bins", "bins", "bins", "bins", "ignore_bins", "illegal_bins", "bins", "bins", "bins"};
         return names[m_e];
     }
     // VlCovBinKind enumerator naming the bin's set
@@ -1278,23 +1278,23 @@ public:
     constexpr VCoverOptionType(en _e)
         : m_e{_e} {}
     const char* ascii() const {
-        static const char* const names[] = {"weight",
-                                            "goal",
-                                            "at_least",
-                                            "auto_bin_max",
-                                            "per_instance",
-                                            "comment",
-                                            "name",
-                                            "cross_num_print_missing",
-                                            "cross_retain_auto_bins",
-                                            "detect_overlap",
-                                            "get_inst_coverage",
-                                            "strobe",
-                                            "merge_instances",
-                                            "distribute_first",
-                                            "real_interval",
-                                            "cross_auto_bin_max",
-                                            "unknown"};
+        static constexpr const char* const names[] = {"weight",
+                                                      "goal",
+                                                      "at_least",
+                                                      "auto_bin_max",
+                                                      "per_instance",
+                                                      "comment",
+                                                      "name",
+                                                      "cross_num_print_missing",
+                                                      "cross_retain_auto_bins",
+                                                      "detect_overlap",
+                                                      "get_inst_coverage",
+                                                      "strobe",
+                                                      "merge_instances",
+                                                      "distribute_first",
+                                                      "real_interval",
+                                                      "cross_auto_bin_max",
+                                                      "unknown"};
         return names[m_e];
     }
 };
@@ -1322,11 +1322,12 @@ public:
         : m_e(static_cast<en>(_e)) {}  // LCOV_EXCL_STOP  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }  // LCOV_EXCL_LINE
     const char* ascii() const {
-        static const char* const names[] = {"", "[*]", "[->]", "[=]"};
+        static constexpr const char* const names[] = {"", "[*]", "[->]", "[=]"};
         return names[m_e];
     }
     const char* asciiJson() const {
-        static const char* const names[] = {"\"none\"", "\"consec\"", "\"goto\"", "\"noncons\""};
+        static constexpr const char* const names[]
+            = {"\"none\"", "\"consec\"", "\"goto\"", "\"noncons\""};
         return names[m_e];
     }
 };
@@ -1346,11 +1347,13 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const VL_MT_SAFE { return m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"NONE", "INPUT", "OUTPUT", "INOUT", "REF", "CONSTREF"};
+        static constexpr const char* const names[]
+            = {"NONE", "INPUT", "OUTPUT", "INOUT", "REF", "CONSTREF"};
         return names[m_e];
     }
     string verilogKwd() const {
-        static const char* const names[] = {"", "input", "output", "inout", "ref", "const ref"};
+        static constexpr const char* const names[]
+            = {"", "input", "output", "inout", "ref", "const ref"};
         return names[m_e];
     }
     string prettyName() const { return verilogKwd(); }
@@ -1426,7 +1429,7 @@ public:
     bool addNewline() const { return m_e != DT_WRITE; }
     bool needScopeTracking() const { return m_e != DT_DISPLAY && m_e != DT_WRITE; }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"display", "write", "monitor", "strobe", "info", "error", "warning", "fatal"};
         return names[m_e];
     }
@@ -1452,8 +1455,9 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"$dumpfile",  "$dumpvars", "$dumpall", "$dumpflush",
-                                            "$dumplimit", "$dumpoff",  "$dumpon"};
+        static constexpr const char* const names[]
+            = {"$dumpfile",  "$dumpvars", "$dumpall", "$dumpflush",
+               "$dumplimit", "$dumpoff",  "$dumpon"};
         return names[m_e];
     }
 };
@@ -1491,7 +1495,7 @@ public:
     };
     enum en m_e;
     bool clockedStmt() const {
-        static const bool clocked[] = {
+        static constexpr bool clocked[] = {
             true,  // ET_CHANGED
             true,  // ET_BOTHEDGE
             true,  // ET_POSEDGE
@@ -1521,13 +1525,13 @@ public:
         }
     }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"CHANGED", "BOTH",       "POS",    "NEG",    "EVENT",   "TRUE",  "ET_INITIAL_NBA",
                "COMBO",   "COMBO_STAR", "HYBRID", "STATIC", "INITIAL", "FINAL", "NEVER"};
         return names[m_e];
     }
     const char* verilogKwd() const {
-        static const char* const names[] = {
+        static constexpr const char* const names[] = {
             "[changed]", "edge", "posedge",  "negedge",  "[event]",   "[true]",  "[initial_nba]",
             "*",         "*",    "[hybrid]", "[static]", "[initial]", "[final]", "[never]"};
         return names[m_e];
@@ -1590,7 +1594,7 @@ public:
     enum en m_e;
 
     const char* ascii() const {
-        static const char* const values[] = {
+        static constexpr const char* const values[] = {
 #define VL_EVAL_NAME(id, iterated, triggers, first, slow) #id,
             FOR_EACH_EVAL(VL_EVAL_NAME)
 #undef VL_EVAL_NAME
@@ -1599,7 +1603,7 @@ public:
         return values[m_e];
     }
     bool isIterated() const {
-        static const bool values[] = {
+        static constexpr bool values[] = {
 #define VL_EVAL_IS_ITERATED(id, iterated, triggers, first, slow) iterated,
             FOR_EACH_EVAL(VL_EVAL_IS_ITERATED)
 #undef VL_EVAL_IS_ITERATED
@@ -1608,7 +1612,7 @@ public:
         return values[m_e];
     }
     bool hasTriggers() const {
-        static const bool values[] = {
+        static constexpr bool values[] = {
 #define VL_EVAL_HAS_TRIGGERS(id, iterated, triggers, first, slow) triggers,
             FOR_EACH_EVAL(VL_EVAL_HAS_TRIGGERS)
 #undef VL_EVAL_HAS_TRIGGERS
@@ -1617,7 +1621,7 @@ public:
         return values[m_e];
     }
     bool firstIteration() const {
-        static const bool values[] = {
+        static constexpr bool values[] = {
 #define VL_EVAL_FIRST(id, iterated, triggers, first, slow) first,
             FOR_EACH_EVAL(VL_EVAL_FIRST)
 #undef VL_EVAL_FIRST
@@ -1626,7 +1630,7 @@ public:
         return values[m_e];
     }
     bool slow() const {
-        static const bool values[] = {
+        static constexpr bool values[] = {
 #define VL_EVAL_SLOW(id, iterated, triggers, first, slow) slow,
             FOR_EACH_EVAL(VL_EVAL_SLOW)
 #undef VL_EVAL_SLOW
@@ -1669,7 +1673,7 @@ public:
     enum en : uint8_t { NONE, ENUM, STRUCT, UNION, CLASS, INTERFACE_CLASS, GENERIC_INTERFACE };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"none", "enum", "struct", "union", "class", "interface class", "generic interface"};
         return names[m_e];
     }
@@ -1739,11 +1743,11 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"JOIN", "JOIN_ANY", "JOIN_NONE"};
+        static constexpr const char* const names[] = {"JOIN", "JOIN_ANY", "JOIN_NONE"};
         return names[m_e];
     }
     const char* verilogKwd() const {
-        static const char* const names[] = {"join", "join_any", "join_none"};
+        static constexpr const char* const names[] = {"join", "join_any", "join_none"};
         return names[m_e];
     }
     bool join() const { return m_e == JOIN; }
@@ -1772,7 +1776,8 @@ public:
     };  // Static propagated from above
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {"NONE", "VAUTOM", "VAUTOMI", "VSTATIC", "VSTATICI"};
+        static constexpr const char* const names[]
+            = {"NONE", "VAUTOM", "VAUTOMI", "VSTATIC", "VSTATICI"};
         return names[m_e];
     }
     VLifetime()
@@ -1892,7 +1897,7 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {
+        static constexpr const char* const names[] = {
             "COVERAGE_BLOCK_OFF",  //
             "HIER_BLOCK",  //
             "HIER_PARAMS",  //
@@ -1940,7 +1945,7 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {"NONE", "RAND", "RANDC", "RAND_INLINE"};
+        static constexpr const char* const names[] = {"NONE", "RAND", "RANDC", "RAND_INLINE"};
         return names[m_e];
     }
     VRandAttr()
@@ -2007,7 +2012,7 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {"UNSIGNED", "SIGNED", "NOSIGN"};
+        static constexpr const char* const names[] = {"UNSIGNED", "SIGNED", "NOSIGN"};
         return names[m_e];
     }
     VSigning()
@@ -2046,7 +2051,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"highz", "small", "medium", "weak", "large", "pull", "strong", "supply"};
         return names[m_e];
     }
@@ -2076,13 +2081,13 @@ public:
     };
     enum en m_e;
     const char* ascii() const {
-        static const char* const names[] = {"`systemc_ctor",  //
-                                            "`systemc_dtor",  //
-                                            "`systemc_header",  //
-                                            "`systemc_header_post",  //
-                                            "`systemc_implementation",  //
-                                            "`systemc_imp_header",  //
-                                            "`systemc_interface"};
+        static constexpr const char* const names[] = {"`systemc_ctor",  //
+                                                      "`systemc_dtor",  //
+                                                      "`systemc_header",  //
+                                                      "`systemc_header_post",  //
+                                                      "`systemc_implementation",  //
+                                                      "`systemc_imp_header",  //
+                                                      "`systemc_interface"};
         return names[m_e];
     }
     // cppcheck-suppress noExplicitConstructor
@@ -2111,7 +2116,7 @@ public:
         : m_e{_e} {}
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"ARRAY_PACKED",  "ARRAY_UNPACKED",  "SCOPE_MODULE", "SCOPE_INTERFACE",
                "STRUCT_PACKED", "STRUCT_UNPACKED", "UNION_PACKED"};
         return names[m_e];
@@ -2149,11 +2154,11 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"CONSTANT", "FULL", "CHANGE"};
+        static constexpr const char* const names[] = {"CONSTANT", "FULL", "CHANGE"};
         return names[m_e];
     }
     const char* func_prefix() const {
-        static const char* const names[] = {"trace_const", "trace_full", "trace_chg"};
+        static constexpr const char* const names[] = {"trace_const", "trace_full", "trace_chg"};
         return names[m_e];
     }
 };
@@ -2186,7 +2191,7 @@ public:
     constexpr operator en() const { return m_e; }
     bool containsAny(VUseType other) const { return m_e & other.m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"INT_FWD", "INT_INC", "INT_FWD_INC"};
+        static constexpr const char* const names[] = {"INT_FWD", "INT_INC", "INT_FWD_INC"};
         return names[m_e - 1];
     }
 };
@@ -2239,7 +2244,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[]
+        static constexpr const char* const names[]
             = {"?",        "GPARAM",  "LPARAM",   "SPECPARAM", "GENVAR",    "VAR",
                "SUPPLY0",  "SUPPLY1", "WIRE",     "WREAL",     "TRIAND",    "TRIOR",
                "TRIWIRE",  "TRI0",    "TRI1",     "PORT",      "BLOCKTEMP", "MODULETEMP",
@@ -2278,7 +2283,7 @@ public:
 
     const char* traceSigKind() const {
         // VerilatedTraceSigKind to used in trace signal declaration
-        static const char* const lut[] = {
+        static constexpr const char* const lut[] = {
             /* UNKNOWN:      */ "",  // Should not be traced
             /* GPARAM:       */ "PARAMETER",
             /* LPARAM:       */ "PARAMETER",
diff --git a/src/V3ExecGraph.cpp b/src/V3ExecGraph.cpp
index bf3d18821..1378c4340 100644
--- a/src/V3ExecGraph.cpp
+++ b/src/V3ExecGraph.cpp
@@ -776,7 +776,7 @@ void normalizeCosts(Costs& costs) {
         if (maxCost < costProfiled) maxCost = costProfiled;
         UINFO(9, "Post uint scale: ce = " << est.second.first << " cp=" << est.second.second);
     }
-    const uint64_t scaleDownTo = 10000000;  // Extra room for future algorithms to add costs
+    constexpr uint64_t scaleDownTo = 10000000;  // Extra room for future algorithms to add costs
     if (maxCost > scaleDownTo) {
         const double scaleup = static_cast<double>(scaleDownTo) / static_cast<double>(maxCost);
         UINFO(5, "Scaling data to within 32-bits by multiply by=" << scaleup
diff --git a/src/V3Graph.h b/src/V3Graph.h
index a8dbe745b..cc78995c2 100644
--- a/src/V3Graph.h
+++ b/src/V3Graph.h
@@ -65,7 +65,7 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const { return m_e; }
     const char* ascii() const {
-        static const char* const names[] = {"FORWARD", "REVERSE"};
+        static constexpr const char* const names[] = {"FORWARD", "REVERSE"};
         return names[m_e];
     }
     // METHODS unique to this class
diff --git a/src/V3Os.cpp b/src/V3Os.cpp
index 5ce4c9791..e5a2bdf57 100644
--- a/src/V3Os.cpp
+++ b/src/V3Os.cpp
@@ -471,7 +471,7 @@ string V3Os::trueRandom(size_t size) VL_MT_SAFE {
 uint64_t V3Os::timeUsecs() {
 #if defined(_WIN32) || defined(__MINGW32__)
     // Microseconds between 1601-01-01 00:00:00 UTC and 1970-01-01 00:00:00 UTC
-    static const uint64_t EPOCH_DIFFERENCE_USECS = 11644473600000000ULL;
+    static constexpr uint64_t EPOCH_DIFFERENCE_USECS = 11644473600000000ULL;
 
     FILETIME ft;  // contains number of 0.1us intervals since the beginning of 1601 UTC.
     GetSystemTimeAsFileTime(&ft);
diff --git a/src/V3PreExpr.h b/src/V3PreExpr.h
index dc4968a0d..9be6b1863 100644
--- a/src/V3PreExpr.h
+++ b/src/V3PreExpr.h
@@ -75,7 +75,7 @@ class V3PreExpr final {
         EE  // Error
     };
     static const char* actionAscii(action_t en) {
-        static const char* names[] = {"VV", "AA", "RR", "SS", "EE"};
+        static constexpr const char* names[] = {"VV", "AA", "RR", "SS", "EE"};
         return names[en];
     }
 
diff --git a/src/V3Randomize.cpp b/src/V3Randomize.cpp
index b4abd8030..8ba865d27 100644
--- a/src/V3Randomize.cpp
+++ b/src/V3Randomize.cpp
@@ -3836,7 +3836,7 @@ class RandomizeVisitor final : public VNVisitor {
         return it->second;
     }
     AstTask* getCreateConstraintSetupFunc(AstClass* classp) {
-        static const char* const name = "__Vsetup_constraints";
+        static constexpr const char* const name = "__Vsetup_constraints";
         AstTask* setupAllTaskp = VN_AS(m_memberMap.findMember(classp, name), Task);
         if (setupAllTaskp) return setupAllTaskp;
         setupAllTaskp = new AstTask{classp->fileline(), "__Vsetup_constraints", nullptr};
@@ -3847,7 +3847,7 @@ class RandomizeVisitor final : public VNVisitor {
         return setupAllTaskp;
     }
     AstTask* getCreateAggrResizeTask(AstClass* const classp) {
-        static const char* const name = "__Vresize_constrained_arrays";
+        static constexpr const char* const name = "__Vresize_constrained_arrays";
         AstTask* resizeTaskp = VN_AS(m_memberMap.findMember(classp, name), Task);
         if (resizeTaskp) return resizeTaskp;
         resizeTaskp = new AstTask{classp->fileline(), name, nullptr};
@@ -5088,7 +5088,7 @@ class RandomizeVisitor final : public VNVisitor {
     //   3. if (fvar) post_randomize() -- IEEE 1800-2023 18.6.3 says
     //      post_randomize is not called when randomize() fails.
     AstFunc* getCreateRandomizeNullFunc(AstClass* const classp) {
-        static const char* const name = "__Vrandomize_null";
+        static constexpr const char* const name = "__Vrandomize_null";
         if (AstFunc* const existingp = VN_AS(m_memberMap.findMember(classp, name), Func)) {
             return existingp;
         }
diff --git a/src/V3String.cpp b/src/V3String.cpp
index 983b502ca..0e5360c1a 100644
--- a/src/V3String.cpp
+++ b/src/V3String.cpp
@@ -113,8 +113,8 @@ string VString::dequotePercent(const string& str) {
 
 string VString::quoteStringLiteralForShell(const string& str) {
     string result;
-    const char dquote = '"';
-    const char escape = '\\';
+    constexpr char dquote = '"';
+    constexpr char escape = '\\';
     result.push_back(dquote);  // Start quoted string
     result.push_back(escape);
     result.push_back(dquote);  // "
@@ -133,8 +133,8 @@ string VString::escapeStringForPath(const string& str) {
         return str;  // if it has been escaped already, don't do it again
     if (str.find('/') != string::npos) return str;  // can be replaced by `__MINGW32__` or `_WIN32`
     string result;
-    const char space = ' ';  // escape space like this `Program Files`
-    const char escape = '\\';
+    constexpr char space = ' ';  // escape space like this `Program Files`
+    constexpr char escape = '\\';
     for (const char c : str) {
         if (c == space || c == escape) result.push_back(escape);
         result.push_back(c);
@@ -355,9 +355,9 @@ string VString::aOrAn(const char* word) {
 uint64_t VString::hashMurmur(const string& str) VL_PURE {
     const char* key = str.c_str();
     const size_t len = str.size();
-    const uint64_t seed = 0;
-    const uint64_t m = 0xc6a4a7935bd1e995ULL;
-    const int r = 47;
+    constexpr uint64_t seed = 0;
+    constexpr uint64_t m = 0xc6a4a7935bd1e995ULL;
+    constexpr int r = 47;
 
     uint64_t h = seed ^ (len * m);
 
@@ -400,7 +400,7 @@ void VString::selfTest() { UASSERT_SELFTEST(VString::replaceSubstr("aa", "a", "b
 //######################################################################
 // VHashSha512
 
-static const uint64_t sha512K[]
+static constexpr uint64_t sha512K[]
     = {0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
        0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
        0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
@@ -514,7 +514,7 @@ void VHashSha512::insert(const void* datap, size_t length) {
 }
 
 void VHashSha512::insertFile(const string& filename) {
-    static const size_t BUFFER_SIZE = 64 * 1024;
+    static constexpr size_t BUFFER_SIZE = 64 * 1024;
 
     const int fd = ::open(filename.c_str(), O_RDONLY);
     if (fd < 0) return;
@@ -577,7 +577,7 @@ uint64_t VHashSha512::digestUInt64() {
 }
 
 string VHashSha512::digestHex() {
-    static const char* const digits = "0123456789abcdef";
+    static constexpr const char* const digits = "0123456789abcdef";
     const string& binhash = digestBinary();
     string result;
     result.reserve(128);
@@ -593,7 +593,7 @@ string VHashSha512::digestSymbol() {
     // has + and / for last two digits, but need C symbol, and we also
     // avoid conflicts with use of _, so use "AB" at the end.
     // Thus this function is non-reversible.
-    static const char* const digits
+    static constexpr const char* const digits
         = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB";
     const string& binhash = digestBinary();
     string result;
@@ -671,7 +671,7 @@ void VHashSha512::selfTest() {
 // VName
 
 string VName::dehash(const string& in) {
-    static const char VHSH[] = "__Vhsh";
+    static constexpr const char VHSH[] = "__Vhsh";
     static const size_t DOT_LEN = std::strlen("__DOT__");
     std::string dehashed;
 
diff --git a/src/V3Width.cpp b/src/V3Width.cpp
index 084d3c342..c69881b7e 100644
--- a/src/V3Width.cpp
+++ b/src/V3Width.cpp
@@ -144,7 +144,7 @@ enum Determ : uint8_t {
     ASSIGN  // Assignment-like where sign comes from RHS only
 };
 std::ostream& operator<<(std::ostream& str, const Determ& rhs) {
-    static const char* const s_det[] = {"SELF", "CNTX", "ASSN"};
+    static constexpr const char* const s_det[] = {"SELF", "CNTX", "ASSN"};
     return str << s_det[rhs];
 }
 
diff --git a/src/VlcTop.cpp b/src/VlcTop.cpp
index e6f2edad4..afca3acdf 100644
--- a/src/VlcTop.cpp
+++ b/src/VlcTop.cpp
@@ -44,10 +44,10 @@ namespace {
 // Map coverage type to (covered points, total points).
 using TypeTally = std::map<std::string, std::pair<uint64_t, uint64_t>>;
 
-static const char* const s_orderedTypes[]
+static constexpr const char* const s_orderedTypes[]
     = {"line", "toggle", "branch", "expr", "fsm_state", "fsm_arc"};
-static const size_t s_summaryIndent = 2;
-static const size_t s_reportRowIndent = 4;
+static constexpr size_t s_summaryIndent = 2;
+static constexpr size_t s_reportRowIndent = 4;
 
 string displayType(const VlcPoint& point) {
     const string type = point.type();