diff --git a/include/verilated.cpp b/include/verilated.cpp index db9b32a01..d1aa95fba 100644 --- a/include/verilated.cpp +++ b/include/verilated.cpp @@ -4185,28 +4185,6 @@ std::unique_ptr 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; diff --git a/include/verilated_sym_props.h b/include/verilated_sym_props.h index 11e2fe8b8..030e14507 100644 --- a/include/verilated_sym_props.h +++ b/include/verilated_sym_props.h @@ -158,7 +158,18 @@ public: VerilatedVarFlags vldir() const { return static_cast(static_cast(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; }; diff --git a/include/verilated_vpi.cpp b/include/verilated_vpi.cpp index c5ec0f68f..ce4c5001e 100644 --- a/include/verilated_vpi.cpp +++ b/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(varDatap()); + return static_cast(readDatap()); } - SData* varSDatap() const { + SData* readSDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT16);); - return reinterpret_cast(varDatap()); + return static_cast(readDatap()); } - IData* varIDatap() const { + IData* readIDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT32);); - return reinterpret_cast(varDatap()); + return static_cast(readDatap()); } - QData* varQDatap() const { + QData* readQDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_UINT64);); - return reinterpret_cast(varDatap()); + return static_cast(readDatap()); } - EData* varEDatap() const { + EData* readEDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_WDATA);); - return reinterpret_cast(varDatap()); + return static_cast(readDatap()); } - double* varRealDatap() const { + double* readRealDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_REAL);); - return reinterpret_cast(varDatap()); + return static_cast(readDatap()); } - std::string* varStringDatap() const { + std::string* readStringDatap() const { VL_DEBUG_IFDEF(assert(varp()->vltype() == VLVT_STRING);); - return reinterpret_cast(varDatap()); + return static_cast(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(varDatap()) + offset, localName, + static_cast(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 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(varop->varDatap())), - *(varop->prevDatap()), varop->varDatap(), varop->prevDatap(), + varop->fullname(), *(static_cast(varop->readDatap())), + *(varop->prevDatap()), varop->readDatap(), varop->prevDatap(), varop->entSize());); if (varop->bitSize() == 1) { T* const prevDatap = reinterpret_cast( @@ -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(varop->varDatap())));); + *(static_cast(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 vl_vpi_var_access_info(const VerilatedVpioVarBase* vop, size_t bitCount, varBits - addOffset}); VarAccessInfo info; - info.m_datap = reinterpret_cast(vop->varDatap()); + info.m_datap = static_cast(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 info) { template T vl_vpi_get_word_gen(const VerilatedVpioVarBase* vop, size_t bitCount, size_t addOffset) { - const VarAccessInfo info = vl_vpi_var_access_info(vop, bitCount, addOffset); - return vl_vpi_get_word_gen(info); + return vl_vpi_get_word_gen(vl_vpi_var_access_info(vop, bitCount, addOffset)); } template @@ -3503,8 +3504,7 @@ void vl_vpi_put_word_gen(VarAccessInfo info, T word) { template void vl_vpi_put_word_gen(const VerilatedVpioVar* vop, T word, size_t bitCount, size_t addOffset) { - const VarAccessInfo info = vl_vpi_var_access_info(vop, bitCount, addOffset); - vl_vpi_put_word_gen(info, word); + vl_vpi_put_word_gen(vl_vpi_var_access_info(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(varDatap); + const CData* datap = static_cast(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(varDatap); + valuep->value.str = static_cast(varDatap); return; } - t_outDynamicStr = *vop->varStringDatap(); + t_outDynamicStr = *vop->readStringDatap(); valuep->value.str = const_cast(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( 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(valueVop->varDatap()); + CData* const datap = static_cast(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; diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index 42272175d..c60977558 100644 --- a/src/V3EmitCSyms.cpp +++ b/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, "", 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, "", 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); } } } diff --git a/src/V3Options.cpp b/src/V3Options.cpp index 018bd3bef..f72093fca 100644 --- a/src/V3Options.cpp +++ b/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 diff --git a/src/V3Options.h b/src/V3Options.h index b02060f87..9f4efa0e8 100644 --- a/src/V3Options.h +++ b/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; }