Internals: Prepare VPI runtime for lazy public signals. No functional change. (#8382)

include/verilated.cpp

@@ -4185,28 +4185,6 @@ std::unique_ptr<VerilatedTraceConfig> VerilatedModel::traceConfig() const { retu
 //======================================================================
 // VerilatedVar:: Methods
 
-// cppcheck-suppress unusedFunction  // Used by applications
-uint32_t VerilatedVarProps::entSize() const VL_MT_SAFE {
-    if (m_entSize) return m_entSize;
-    uint32_t size = 1;
-    switch (vltype()) {
-    case VLVT_PTR: size = sizeof(void*); break;
-    case VLVT_UINT8: size = sizeof(CData); break;
-    case VLVT_UINT16: size = sizeof(SData); break;
-    case VLVT_UINT32: size = sizeof(IData); break;
-    case VLVT_UINT64: size = sizeof(QData); break;
-    case VLVT_WDATA: size = VL_WORDS_I(entBits()) * sizeof(IData); break;
-    default: size = 0; break;  // LCOV_EXCL_LINE
-    }
-    return size;
-}
-
-size_t VerilatedVarProps::totalSize() const {
-    size_t size = entSize();
-    for (int udim = 0; udim < udims(); ++udim) size *= m_unpacked[udim].elements();
-    return size;
-}
-
 void* VerilatedVarProps::datapAdjustIndex(void* datap, int dim, int indx) const VL_MT_SAFE {
     if (VL_UNLIKELY(dim <= 0 || dim > udims())) return nullptr;
     if (VL_UNLIKELY(indx < low(dim) || indx > high(dim))) return nullptr;

include/verilated_sym_props.h

@@ -158,7 +158,18 @@ public:
     VerilatedVarFlags vldir() const {
         return static_cast<VerilatedVarFlags>(static_cast<int>(m_vlflags) & VLVF_MASK_DIR);
     }
-    uint32_t entSize() const VL_MT_SAFE;
+    uint32_t entSize() const VL_MT_SAFE {
+        if (m_entSize) return m_entSize;
+        switch (vltype()) {
+        case VLVT_PTR: return sizeof(void*);
+        case VLVT_UINT8: return sizeof(CData);
+        case VLVT_UINT16: return sizeof(SData);
+        case VLVT_UINT32: return sizeof(IData);
+        case VLVT_UINT64: return sizeof(QData);
+        case VLVT_WDATA: return VL_WORDS_I(entBits()) * sizeof(IData);
+        default: return 0;  // LCOV_EXCL_LINE
+        }
+    }
     uint32_t entBits() const VL_MT_SAFE {
         uint32_t bits = 1;
         for (auto it : m_packed) bits *= it.elements();
@@ -214,7 +225,11 @@ public:
                                                        : 0;
     }
     // Total size in bytes (note DPI limited to 4GB)
-    size_t totalSize() const;
+    size_t totalSize() const {
+        size_t size = entSize();
+        for (int udim = 0; udim < udims(); ++udim) size *= m_unpacked[udim].elements();
+        return size;
+    }
     // Adjust a data pointer to access a given array element, NULL if something goes bad
     void* datapAdjustIndex(void* datap, int dim, int indx) const VL_MT_SAFE;
 };

include/verilated_vpi.cpp

@@ -253,34 +253,34 @@ public:
         if (m_fullname.empty()) m_fullname = std::string{m_scopep->name()} + '.' + m_varp->name();
         return m_fullname.c_str();
     }
-    virtual void* varDatap() const { return m_varp->datap(); }
-    CData* varCDatap() const {
+    virtual void* readDatap() const { return m_varp->datap(); }
+    CData* readCDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT8););
-        return reinterpret_cast<CData*>(varDatap());
+        return static_cast<CData*>(readDatap());
     }
-    SData* varSDatap() const {
+    SData* readSDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT16););
-        return reinterpret_cast<SData*>(varDatap());
+        return static_cast<SData*>(readDatap());
     }
-    IData* varIDatap() const {
+    IData* readIDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT32););
-        return reinterpret_cast<IData*>(varDatap());
+        return static_cast<IData*>(readDatap());
     }
-    QData* varQDatap() const {
+    QData* readQDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT64););
-        return reinterpret_cast<QData*>(varDatap());
+        return static_cast<QData*>(readDatap());
     }
-    EData* varEDatap() const {
+    EData* readEDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_WDATA););
-        return reinterpret_cast<EData*>(varDatap());
+        return static_cast<EData*>(readDatap());
     }
-    double* varRealDatap() const {
+    double* readRealDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_REAL););
-        return reinterpret_cast<double*>(varDatap());
+        return static_cast<double*>(readDatap());
     }
-    std::string* varStringDatap() const {
+    std::string* readStringDatap() const {
         VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_STRING););
-        return reinterpret_cast<std::string*>(varDatap());
+        return static_cast<std::string*>(readDatap());
     }
     virtual uint32_t bitOffset() const { return 0; }
 };
@@ -412,6 +412,9 @@ public:
         m_name = name;
         m_fullNameOverride = fullname;
     }
+    VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep,
+                     const std::string& name, const std::string& fullname)
+        : VerilatedVpioVar{varp, scopep, varp->datap(), name, fullname} {}
     explicit VerilatedVpioVar(const VerilatedVpioVar* vop)
         : VerilatedVpioVarBase{vop} {
         if (vop) {
@@ -517,7 +520,7 @@ public:
         const std::string localName = _vl_vpi_member_local_name(memberVarp->name());
 
         return new VerilatedVpioVar{memberVarp, scopep(),
-                                    static_cast<uint8_t*>(varDatap()) + offset, localName,
+                                    static_cast<uint8_t*>(readDatap()) + offset, localName,
                                     std::string{fullname()} + memberName.substr(parentLen)};
     }
     uint32_t type() const override {
@@ -542,7 +545,7 @@ public:
         return m_fullname.c_str();
     }
     uint8_t* prevDatap() const { return m_prevDatap; }
-    void* varDatap() const override { return m_varDatap; }
+    void* readDatap() const override { return m_varDatap; }
     void createPrevDatap() {
         if (VL_UNLIKELY(!m_prevDatap)) {
             m_prevDatap = new uint8_t[entSize()];
@@ -1291,8 +1294,8 @@ public:
     template <typename T>
     static bool valueDiffersFromPrev(VerilatedVpioVar* varop) {
         VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_test %s v[0]=%d/%d %p %p size=%d\n",
-                                    varop->fullname(), *(static_cast<CData*>(varop->varDatap())),
-                                    *(varop->prevDatap()), varop->varDatap(), varop->prevDatap(),
+                                    varop->fullname(), *(static_cast<CData*>(varop->readDatap())),
+                                    *(varop->prevDatap()), varop->readDatap(), varop->prevDatap(),
                                     varop->entSize()););
         if (varop->bitSize() == 1) {
             T* const prevDatap = reinterpret_cast<T*>(
@@ -1303,7 +1306,7 @@ public:
             prevInfo.m_datap = prevDatap;
             return vl_vpi_get_word_gen(currInfo) != vl_vpi_get_word_gen(prevInfo);
         }
-        return std::memcmp(varop->prevDatap(), varop->varDatap(), varop->entSize()) != 0;
+        return std::memcmp(varop->prevDatap(), varop->readDatap(), varop->entSize()) != 0;
     }
     static bool valueDiffersFromPrev(VerilatedVpioVar* varop) {
         switch (varop->varp()->vltype()) {
@@ -1332,9 +1335,9 @@ public:
             prevInfo.m_datap = prevDatap;
             const T currWord = vl_vpi_get_word_gen(currInfo);
             vl_vpi_put_word_gen(prevInfo, currWord);
-            assert(std::memcmp(varop->prevDatap(), varop->varDatap(), varop->entSize()) == 0);
+            assert(std::memcmp(varop->prevDatap(), varop->readDatap(), varop->entSize()) == 0);
         } else {
-            std::memcpy(varop->prevDatap(), varop->varDatap(), varop->entSize());
+            std::memcpy(varop->prevDatap(), varop->readDatap(), varop->entSize());
         }
     }
     static void updatePrev(const VerilatedVpioVar* const varop) {
@@ -1375,7 +1378,7 @@ public:
             if (valueDiffersFromPrev(varop)) {
                 VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_callback %" PRId64 " %s v[0]=%d\n",
                                             ho.id(), varop->fullname(),
-                                            *(static_cast<CData*>(varop->varDatap()))););
+                                            *(static_cast<CData*>(varop->readDatap()))););
                 update.insert(varop);
                 vpi_get_value(ho.cb_datap()->obj, ho.cb_datap()->value);
                 (ho.cb_rtnp())(ho.cb_datap());
@@ -1726,9 +1729,9 @@ VerilatedVpiImp::getForceControlSignals(const VerilatedVpioVar* const baseSignal
     // assert(forceEnableSignalVop->entSize() == baseSignalVop->entSize());
     assert(forceValueSignalVop->entSize() == baseSignalVop->entSize());
     assert(forceReadSignalVop->entSize() == baseSignalVop->entSize());
-    assert(forceEnableSignalVop->varDatap() == forceEnableSignalVarp->datap());
-    assert(forceValueSignalVop->varDatap() == forceValueSignalVarp->datap());
-    assert(forceReadSignalVop->varDatap() == forceReadSignalVarp->datap());
+    assert(forceEnableSignalVop->readDatap() == forceEnableSignalVarp->datap());
+    assert(forceValueSignalVop->readDatap() == forceValueSignalVarp->datap());
+    assert(forceReadSignalVop->readDatap() == forceReadSignalVarp->datap());
 #endif  // VL_DEBUG
 
     return VerilatedVpiImp::ForceControlSignalVops{
@@ -1758,9 +1761,9 @@ double VerilatedVpiImp::getReadDataWord(const VerilatedVpioVar* baseSignalVop,
                                         const VerilatedVpioVar* forceEnableSignalVop,
                                         const VerilatedVpioVar* forceValueSignalVop,
                                         size_t /*bitCount*/, size_t /*bitOffset*/) {
-    const double baseSignalData = *baseSignalVop->varRealDatap();
-    const bool forceEnableData = *forceEnableSignalVop->varCDatap();
-    const double forceValueData = *forceValueSignalVop->varRealDatap();
+    const double baseSignalData = *baseSignalVop->readRealDatap();
+    const bool forceEnableData = *forceEnableSignalVop->readCDatap();
+    const double forceValueData = *forceValueSignalVop->readRealDatap();
     const double readData = forceEnableData ? forceValueData : baseSignalData;
     return readData;
 }
@@ -2805,7 +2808,7 @@ _vl_vpi_handle_indexed_member_from_scope(const VerilatedScope* const scopep,
     VerilatedVpioVar* baseVop
         = fullnameOverride.empty()
               ? new VerilatedVpioVar{baseVarp, varScopep}
-              : new VerilatedVpioVar{baseVarp, varScopep, baseVarp->datap(),
+              : new VerilatedVpioVar{baseVarp, varScopep,
                                      _vl_vpi_member_local_name(baseVarp->name()),
                                      fullnameOverride};
     VerilatedVpioVar* vop = _vl_vpi_handle_apply_indices(baseVop, indices);
@@ -2977,10 +2980,9 @@ vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
     if (varp->isParam()) {
         resultHandle = (new VerilatedVpioParam{varp, scopep})->castVpiHandle();
     } else if (!fullnameOverride.empty()) {
-        resultHandle
-            = (new VerilatedVpioVar{varp, scopep, varp->datap(),
-                                    _vl_vpi_member_local_name(varp->name()), fullnameOverride})
-                  ->castVpiHandle();
+        resultHandle = (new VerilatedVpioVar{varp, scopep, _vl_vpi_member_local_name(varp->name()),
+                                             fullnameOverride})
+                           ->castVpiHandle();
     } else {
         resultHandle = (new VerilatedVpioVar{varp, scopep})->castVpiHandle();
     }
@@ -3436,7 +3438,7 @@ VarAccessInfo<T> vl_vpi_var_access_info(const VerilatedVpioVarBase* vop, size_t
                          bitCount, varBits - addOffset});
 
     VarAccessInfo<T> info;
-    info.m_datap = reinterpret_cast<T*>(vop->varDatap());
+    info.m_datap = static_cast<T*>(vop->readDatap());
     if (vop->varp()->vltype() == VLVT_WDATA) {
         assert(sizeof(T) == sizeof(EData));
         assert(bitCount <= wordBits);
@@ -3484,8 +3486,7 @@ T vl_vpi_get_word_gen(VarAccessInfo<T> info) {
 
 template <typename T>
 T vl_vpi_get_word_gen(const VerilatedVpioVarBase* vop, size_t bitCount, size_t addOffset) {
-    const VarAccessInfo<T> info = vl_vpi_var_access_info<T>(vop, bitCount, addOffset);
-    return vl_vpi_get_word_gen(info);
+    return vl_vpi_get_word_gen(vl_vpi_var_access_info<T>(vop, bitCount, addOffset));
 }
 
 template <typename T>
@@ -3503,8 +3504,7 @@ void vl_vpi_put_word_gen(VarAccessInfo<T> info, T word) {
 
 template <typename T>
 void vl_vpi_put_word_gen(const VerilatedVpioVar* vop, T word, size_t bitCount, size_t addOffset) {
-    const VarAccessInfo<T> info = vl_vpi_var_access_info<T>(vop, bitCount, addOffset);
-    vl_vpi_put_word_gen(info, word);
+    vl_vpi_put_word_gen(vl_vpi_var_access_info<T>(vop, bitCount, addOffset), word);
 }
 
 // bitCount: maximum number of bits to read, will stop earlier if it reaches the var bounds
@@ -3541,7 +3541,7 @@ void vl_vpi_put_word(const VerilatedVpioVar* vop, QData word, size_t bitCount, s
 
 void vl_vpi_get_value(const VerilatedVpioVarBase* vop, p_vpi_value valuep) {
     const VerilatedVar* const varp = vop->varp();
-    void* const varDatap = vop->varDatap();
+    void* const varDatap = vop->readDatap();
 
     if (!vl_check_format(vop, valuep, true)) return;
     // string data type is dynamic and may vary in size during simulation
@@ -3582,7 +3582,7 @@ void vl_vpi_get_value(const VerilatedVpioVarBase* vop, p_vpi_value valuep) {
         return;
     } else if (valuep->format == vpiBinStrVal) {
         t_outDynamicStr.resize(varBits);
-        const CData* datap = reinterpret_cast<CData*>(varDatap);
+        const CData* datap = static_cast<CData*>(varDatap);
         for (size_t i = 0; i < varBits; ++i) {
             const size_t pos = i + vop->bitOffset();
             const char val = (datap[pos >> 3] >> (pos & 7)) & 1;
@@ -3627,10 +3627,10 @@ void vl_vpi_get_value(const VerilatedVpioVarBase* vop, p_vpi_value valuep) {
     } else if (valuep->format == vpiStringVal) {
         if (varp->vltype() == VLVT_STRING) {
             if (varp->isParam()) {
-                valuep->value.str = reinterpret_cast<char*>(varDatap);
+                valuep->value.str = static_cast<char*>(varDatap);
                 return;
             }
-            t_outDynamicStr = *vop->varStringDatap();
+            t_outDynamicStr = *vop->readStringDatap();
             valuep->value.str = const_cast<char*>(t_outDynamicStr.c_str());
             return;
         } else {
@@ -3648,7 +3648,7 @@ void vl_vpi_get_value(const VerilatedVpioVarBase* vop, p_vpi_value valuep) {
         valuep->value.integer = vl_vpi_get_word(vop, 32, 0);
         return;
     } else if (valuep->format == vpiRealVal) {
-        valuep->value.real = *(vop->varRealDatap());
+        valuep->value.real = *(vop->readRealDatap());
         return;
     } else if (valuep->format == vpiScalarVal) {
         valuep->value.scalar = vl_vpi_get_word(vop, 32, 0) ? vpi1 : vpi0;
@@ -3739,7 +3739,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
                                     baseSignalVop->fullname(), valuep->format,
                                     valuep->value.integer);
                         VL_DBG_MSGF("- vpi:   varp=%p  putatp=%p\n",
-                                    baseSignalVop->varp()->datap(), baseSignalVop->varDatap()););
+                                    baseSignalVop->varp()->datap(), baseSignalVop->readDatap()););
 
         if (VL_UNLIKELY(!baseSignalVop->varp()->isPublicRW())) {
             VL_VPI_ERROR_(__FILE__, __LINE__,
@@ -3817,7 +3817,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
                   if (baseSignalVop->varp()->vltype() == VLVT_REAL) {
                       const double readData = VerilatedVpiImp::getReadDataWord<double>(
                           baseSignalVop, forceEnableSignalVop, forceValueSignalVop, 64, 0);
-                      *forceReadSignalVop->varRealDatap() = readData;
+                      *forceReadSignalVop->readRealDatap() = readData;
                       return;
                   }
 
@@ -3939,7 +3939,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
             }
         } else if (valuep->format == vpiBinStrVal) {
             const int len = std::strlen(valuep->value.str);
-            CData* const datap = reinterpret_cast<CData*>(valueVop->varDatap());
+            CData* const datap = static_cast<CData*>(valueVop->readDatap());
             for (int i = 0; i < varBits; ++i) {
                 const bool set = (i < len) && (valuep->value.str[len - i - 1] == '1');
                 const size_t pos = valueVop->bitOffset() + i;
@@ -4021,7 +4021,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
         } else if (valuep->format == vpiStringVal) {
             if (valueVop->varp()->vltype() == VLVT_STRING) {
                 // Does not use valueVop, because strings are not forceable anyway
-                *(baseSignalVop->varStringDatap()) = valuep->value.str;
+                *(baseSignalVop->readStringDatap()) = valuep->value.str;
                 return object;
             }
             const int chars = VL_BYTES_I(varBits);
@@ -4038,7 +4038,7 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
             return object;
         } else if (valuep->format == vpiRealVal) {
             if (valueVop->varp()->vltype() == VLVT_REAL) {
-                *(valueVop->varRealDatap()) = valuep->value.real;
+                *(valueVop->readRealDatap()) = valuep->value.real;
                 if (baseSignalVop->varp()->isForceable()) updateVforceRd();
                 return object;
             }
@@ -4309,10 +4309,10 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varCDatap(), shortintsp);
+                                         vop->readCDatap(), shortintsp);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varSDatap(), shortintsp);
+                                         vop->readSDatap(), shortintsp);
         }
 
         return;
@@ -4324,13 +4324,13 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varCDatap(), integersp);
+                                         vop->readCDatap(), integersp);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varSDatap(), integersp);
+                                         vop->readSDatap(), integersp);
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varIDatap(), integersp);
+                                         vop->readIDatap(), integersp);
         }
 
         return;
@@ -4342,16 +4342,16 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varCDatap(), longintsp);
+                                         vop->readCDatap(), longintsp);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varSDatap(), longintsp);
+                                         vop->readSDatap(), longintsp);
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varIDatap(), longintsp);
+                                         vop->readIDatap(), longintsp);
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_get_value_array_integrals(index, num, size, varp->entBits(), leftIsLow,
-                                         vop->varQDatap(), longintsp);
+                                         vop->readQDatap(), longintsp);
         }
 
         return;
@@ -4363,19 +4363,19 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_vectors(index, num, size, varp->entBits(), leftIsLow,
-                                       vop->varCDatap(), vectorsp);
+                                       vop->readCDatap(), vectorsp);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_vectors(index, num, size, varp->entBits(), leftIsLow,
-                                       vop->varSDatap(), vectorsp);
+                                       vop->readSDatap(), vectorsp);
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_get_value_array_vectors(index, num, size, varp->entBits(), leftIsLow,
-                                       vop->varIDatap(), vectorsp);
+                                       vop->readIDatap(), vectorsp);
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_get_value_array_vectors(index, num, size, varp->entBits(), leftIsLow,
-                                       vop->varQDatap(), vectorsp);
+                                       vop->readQDatap(), vectorsp);
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_get_value_array_vectors(index, num, size, varp->entBits(), leftIsLow,
-                                       vop->varEDatap(), vectorsp);
+                                       vop->readEDatap(), vectorsp);
         }
 
         return;
@@ -4387,19 +4387,19 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vop->varCDatap(), valuep);
+                                       vop->readCDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vop->varSDatap(), valuep);
+                                       vop->readSDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vop->varIDatap(), valuep);
+                                       vop->readIDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vop->varQDatap(), valuep);
+                                       vop->readQDatap(), valuep);
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vop->varEDatap(), valuep);
+                                       vop->readEDatap(), valuep);
         }
 
         return;
@@ -4411,19 +4411,19 @@ void vl_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false,
-                                       vop->varCDatap(), valuep);
+                                       vop->readCDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false,
-                                       vop->varSDatap(), valuep);
+                                       vop->readSDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false,
-                                       vop->varIDatap(), valuep);
+                                       vop->readIDatap(), valuep);
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false,
-                                       vop->varQDatap(), valuep);
+                                       vop->readQDatap(), valuep);
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_get_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false,
-                                       vop->varEDatap(), valuep);
+                                       vop->readEDatap(), valuep);
         }
 
         return;
@@ -4508,10 +4508,10 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, shortintsp,
-                                         vop->varCDatap());
+                                         vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, shortintsp,
-                                         vop->varSDatap());
+                                         vop->readSDatap());
         }
 
         return;
@@ -4520,13 +4520,13 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, integersp,
-                                         vop->varCDatap());
+                                         vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, integersp,
-                                         vop->varSDatap());
+                                         vop->readSDatap());
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, integersp,
-                                         vop->varIDatap());
+                                         vop->readIDatap());
         }
 
         return;
@@ -4535,16 +4535,16 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, longintsp,
-                                         vop->varCDatap());
+                                         vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, longintsp,
-                                         vop->varSDatap());
+                                         vop->readSDatap());
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, longintsp,
-                                         vop->varIDatap());
+                                         vop->readIDatap());
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_put_value_array_integrals(index, num, size, varp->entBits(), leftIsLow, longintsp,
-                                         vop->varQDatap());
+                                         vop->readQDatap());
         }
 
         return;
@@ -4553,19 +4553,19 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_vectors(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vectorsp, vop->varCDatap());
+                                       vectorsp, vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_vectors(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vectorsp, vop->varSDatap());
+                                       vectorsp, vop->readSDatap());
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_put_value_array_vectors(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vectorsp, vop->varIDatap());
+                                       vectorsp, vop->readIDatap());
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_put_value_array_vectors(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vectorsp, vop->varQDatap());
+                                       vectorsp, vop->readQDatap());
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_put_value_array_vectors(index, num, size, varp->entBits(), leftIsLow, true,
-                                       vectorsp, vop->varEDatap());
+                                       vectorsp, vop->readEDatap());
         }
 
         return;
@@ -4574,19 +4574,19 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true, valuep,
-                                       vop->varCDatap());
+                                       vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true, valuep,
-                                       vop->varSDatap());
+                                       vop->readSDatap());
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true, valuep,
-                                       vop->varIDatap());
+                                       vop->readIDatap());
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true, valuep,
-                                       vop->varQDatap());
+                                       vop->readQDatap());
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, true, valuep,
-                                       vop->varEDatap());
+                                       vop->readEDatap());
         }
 
         return;
@@ -4595,19 +4595,19 @@ void vl_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p, const P
 
         if (varp->vltype() == VLVT_UINT8) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false, valuep,
-                                       vop->varCDatap());
+                                       vop->readCDatap());
         } else if (varp->vltype() == VLVT_UINT16) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false, valuep,
-                                       vop->varSDatap());
+                                       vop->readSDatap());
         } else if (varp->vltype() == VLVT_UINT32) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false, valuep,
-                                       vop->varIDatap());
+                                       vop->readIDatap());
         } else if (varp->vltype() == VLVT_UINT64) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false, valuep,
-                                       vop->varQDatap());
+                                       vop->readQDatap());
         } else if (varp->vltype() == VLVT_WDATA) {
             vl_put_value_array_rawvals(index, num, size, varp->entBits(), leftIsLow, false, valuep,
-                                       vop->varEDatap());
+                                       vop->readEDatap());
         }
 
         return;

src/V3EmitCSyms.cpp

@@ -545,7 +545,8 @@ class EmitCSyms final : EmitCBaseVisitorConst {
     }
 
     static std::string getKeyName(const AstScope* const scopep, const std::string& signal_name) {
-        // Copies the process from `varsExpand` which created the keys in the first place, in order
+        // Copies the process from `addScopeVarEntry` which created the keys in the first place, in
+        // order
         // signal can be found.
         std::string whole = scopep->name() + "__DOT__" + signal_name;
         std::string scpName;
@@ -661,6 +662,38 @@ class EmitCSyms final : EmitCBaseVisitorConst {
         }
     }
 
+    void addScopeVarEntry(const AstScope* const scopep, const AstNodeModule* const modp,
+                          const AstVar* const varp) {
+        // Need to split the module + var name into the original-ish full scope
+        // and variable name under that scope. The module instance name is
+        // included later, when we know the scopes this module is under.
+        std::string whole = scopep->name() + "__DOT__" + varp->name();
+        if (VString::startsWith(whole, "__DOT__TOP")) whole.replace(0, 10, "");
+        const std::string::size_type dpos = whole.rfind("__DOT__");
+        UASSERT_OBJ(dpos != std::string::npos, varp,
+                    "Scope/variable name lost its appended __DOT__ separator");
+        const std::string scpName = whole.substr(0, dpos);
+        const std::string varBase = whole.substr(dpos + std::strlen("__DOT__"));
+        // UINFO(9, "For " << scopep->name() << " - " << varp->name() << "  Scp "
+        // << scpName << "Var " << varBase);
+        const std::string varBasePretty = AstNode::vpiName(VName::dehash(varBase));
+        const std::string scpPretty = AstNode::prettyName(VName::dehash(scpName));
+        const std::string scpSym = scopeSymString(VName::dehash(scpName));
+        // UINFO(9, " scnameins sp " << scpName << " sp " << scpPretty << " ss "
+        // << scpSym);
+        if (v3Global.opt.vpi()) varHierarchyScopes(scpName);
+
+        m_scopeNames.emplace(  //
+            std::piecewise_construct,  //
+            std::forward_as_tuple(scpSym),  //
+            std::forward_as_tuple(varp, scpSym, scpPretty, "<null>", 0, "SCOPE_OTHER"));
+
+        m_scopeVars.emplace(  //
+            std::piecewise_construct,  //
+            std::forward_as_tuple(scpSym + " " + varp->name()),  //
+            std::forward_as_tuple(scpSym, varBasePretty, varp, modp, scopep));
+    }
+
     void varsExpand() {
         // We didn't have all m_scopes loaded when we encountered variables, so expand them now
         // It would be less code if each module inserted its own variables.
@@ -672,40 +705,7 @@ class EmitCSyms final : EmitCBaseVisitorConst {
                 const AstNodeModule* const modp = mvPair.first;
                 const AstVar* const varp = mvPair.second;
                 if (modp != smodp) continue;
-
-                // Need to split the module + var name into the
-                // original-ish full scope and variable name under that scope.
-                // The module instance name is included later, when we
-                // know the scopes this module is under
-                std::string whole = scopep->name() + "__DOT__" + varp->name();
-                std::string scpName;
-                std::string varBase;
-                if (VString::startsWith(whole, "__DOT__TOP")) whole.replace(0, 10, "");
-                const std::string::size_type dpos = whole.rfind("__DOT__");
-                if (dpos != std::string::npos) {
-                    scpName = whole.substr(0, dpos);
-                    varBase = whole.substr(dpos + std::strlen("__DOT__"));
-                } else {
-                    varBase = whole;
-                }
-                // UINFO(9, "For " << scopep->name() << " - " << varp->name() << "  Scp "
-                // << scpName << "Var " << varBase);
-                const std::string varBasePretty = AstNode::vpiName(VName::dehash(varBase));
-                const std::string scpPretty = AstNode::prettyName(VName::dehash(scpName));
-                const std::string scpSym = scopeSymString(VName::dehash(scpName));
-                // UINFO(9, " scnameins sp " << scpName << " sp " << scpPretty << " ss "
-                // << scpSym);
-                if (v3Global.opt.vpi()) varHierarchyScopes(scpName);
-
-                m_scopeNames.emplace(  //
-                    std::piecewise_construct,  //
-                    std::forward_as_tuple(scpSym),  //
-                    std::forward_as_tuple(varp, scpSym, scpPretty, "<null>", 0, "SCOPE_OTHER"));
-
-                m_scopeVars.emplace(  //
-                    std::piecewise_construct,  //
-                    std::forward_as_tuple(scpSym + " " + varp->name()),  //
-                    std::forward_as_tuple(scpSym, varBasePretty, varp, modp, scopep));
+                addScopeVarEntry(scopep, modp, varp);
             }
         }
     }

src/V3Options.cpp

@@ -1088,7 +1088,7 @@ void V3Options::notify() VL_MT_DISABLED {
     if (timing().isSetTrue()) V3PreShell::defineCmdLine("VERILATOR_TIMING", "1");
 
     // If VPI is used, and no explicit ico change detect option was passed, disable it by default
-    if (m_vpi && m_fIcoChangeDetect.isDefault()) m_fIcoChangeDetect.setTrueOrFalse(false);
+    if (m_vpi.isTrue() && m_fIcoChangeDetect.isDefault()) m_fIcoChangeDetect.setTrueOrFalse(false);
 
     // === Leave last
     // Mark options as available

src/V3Options.h

@@ -312,7 +312,7 @@ private:
     bool m_traceUnderscore = false; // main switch: --trace-underscore
     bool m_underlineZero = false;   // main switch: --underline-zero; undocumented old Verilator 2
     bool m_verilate = true;         // main switch: --verilate
-    bool m_vpi = false;             // main switch: --vpi
+    VOptionBool m_vpi;              // main switch: --vpi
     bool m_waiverMultiline = false;  // main switch: --waiver-multiline
     bool m_xInitialEdge = false;    // main switch: --x-initial-edge
 
@@ -613,7 +613,7 @@ public:
     bool quietStats() const VL_MT_SAFE { return m_quietStats; }
     bool reportUnoptflat() const { return m_reportUnoptflat; }
     bool verilate() const { return m_verilate; }
-    bool vpi() const { return m_vpi; }
+    bool vpi() const { return m_vpi.isTrue(); }
     bool waiverMultiline() const { return m_waiverMultiline; }
     bool xInitialEdge() const { return m_xInitialEdge; }
     bool serializeOnly() const { return m_jsonOnly; }