diff --git a/include/verilated.cpp b/include/verilated.cpp index 004941fd4..c8c3b8d87 100644 --- a/include/verilated.cpp +++ b/include/verilated.cpp @@ -71,9 +71,11 @@ VerilatedImp VerilatedImp::s_s; #ifndef VL_USER_FINISH ///< Define this to override this function void vl_finish(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE { if (0 && hier) {} - VL_PRINTF("- %s:%d: Verilog $finish\n", filename, linenum); // Not VL_PRINTF_MT, already on main thread + VL_PRINTF( // Not VL_PRINTF_MT, already on main thread + "- %s:%d: Verilog $finish\n", filename, linenum); if (Verilated::gotFinish()) { - VL_PRINTF("- %s:%d: Second verilog $finish, exiting\n", filename, linenum); // Not VL_PRINTF_MT, already on main thread + VL_PRINTF( // Not VL_PRINTF_MT, already on main thread + "- %s:%d: Second verilog $finish, exiting\n", filename, linenum); Verilated::flushCall(); exit(0); } @@ -93,7 +95,8 @@ void vl_stop(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE { void vl_fatal(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_UNSAFE { if (0 && hier) {} Verilated::gotFinish(true); - VL_PRINTF("%%Error: %s:%d: %s\n", filename, linenum, msg); // Not VL_PRINTF_MT, already on main thread + VL_PRINTF( // Not VL_PRINTF_MT, already on main thread + "%%Error: %s:%d: %s\n", filename, linenum, msg); Verilated::flushCall(); VL_PRINTF("Aborting...\n"); // Not VL_PRINTF_MT, already on main thread @@ -167,7 +170,8 @@ vluint64_t _vl_dbg_sequence_number() VL_MT_SAFE { vluint32_t VL_THREAD_ID() VL_MT_SAFE { #ifdef VL_THREADED - // Alternative is to use std::this_thread::get_id, but that returns a hard-to-read number and is very slow + // Alternative is to use std::this_thread::get_id, but that returns a + // hard-to-read number and is very slow static std::atomic s_nextId(0); static VL_THREAD_LOCAL vluint32_t t_myId = ++s_nextId; return t_myId; @@ -338,7 +342,8 @@ void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) VL_MT_SAFE { //=========================================================================== // Slow math -WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool is_modulus) VL_MT_SAFE { +WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, + bool is_modulus) VL_MT_SAFE { // See Knuth Algorithm D. Computes u/v = q.r // This isn't massively tuned, as wide division is rare // for debug see V3Number version @@ -398,7 +403,8 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo // Main loop for (int j = uw - vw; j >= 0; --j) { // Estimate - vluint64_t unw64 = (static_cast(un[j+vw])<(un[j+vw-1])); + vluint64_t unw64 = (static_cast(un[j+vw])<(un[j+vw-1])); vluint64_t qhat = unw64 / static_cast(vn[vw-1]); vluint64_t rhat = unw64 - qhat*static_cast(vn[vw-1]); @@ -447,7 +453,8 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo } } -WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE { +WDataOutP VL_POW_WWW(int obits, int, int rbits, + WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE { // obits==lbits, rbits can be different owp[0] = 1; for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0; @@ -469,7 +476,8 @@ WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDa } return owp; } -WDataOutP VL_POW_WWQ(int obits, int lbits, int rbits, WDataOutP owp, WDataInP lwp, QData rhs) VL_MT_SAFE { +WDataOutP VL_POW_WWQ(int obits, int lbits, int rbits, + WDataOutP owp, WDataInP lwp, QData rhs) VL_MT_SAFE { WData rhsw[2]; VL_SET_WQ(rhsw, rhs); return VL_POW_WWW(obits, lbits, rbits, owp, lwp, rhsw); } @@ -512,7 +520,8 @@ WDataOutP VL_POWSS_WWQ(int obits, int lbits, int rbits, WData rhsw[2]; VL_SET_WQ(rhsw, rhs); return VL_POWSS_WWW(obits, lbits, rbits, owp, lwp, rhsw, lsign, rsign); } -QData VL_POWSS_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp, bool lsign, bool rsign) VL_MT_SAFE { +QData VL_POWSS_QQW(int obits, int, int rbits, + QData lhs, WDataInP rwp, bool lsign, bool rsign) VL_MT_SAFE { // Skip check for rhs == 0, as short-circuit doesn't save time if (rsign && VL_SIGN_W(rbits, rwp)) { if (lhs==0) return 0; // "X" @@ -805,7 +814,8 @@ static inline void _vl_vsss_advance(FILE* fp, int& floc) VL_MT_SAFE { if (fp) fgetc(fp); else floc -= 8; } -static inline int _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, const std::string& fstr) VL_MT_SAFE { +static inline int _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, + const std::string& fstr) VL_MT_SAFE { // Get a character without advancing if (fp) { int data = fgetc(fp); @@ -822,7 +832,8 @@ static inline int _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, const std: } } } -static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp, const std::string& fstr) VL_MT_SAFE { +static inline void _vl_vsss_skipspace(FILE* fp, int& floc, + WDataInP fromp, const std::string& fstr) VL_MT_SAFE { while (1) { int c = _vl_vsss_peek(fp, floc, fromp, fstr); if (c==EOF || !isspace(c)) return; @@ -845,16 +856,19 @@ static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp, const std: *cp++ = '\0'; //VL_DBG_MSGF(" _read got='"<>=1) { VL_ASSIGNBIT_WI(0, lsb, owp, ld & 1); } } static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, - const char* strp, size_t posstart, size_t posend) VL_MT_SAFE { + const char* strp, + size_t posstart, size_t posend) VL_MT_SAFE { // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits. int lsb = 0; - for (int i=0, pos=static_cast(posend)-1; i=static_cast(posstart); --pos) { + for (int i=0, pos = static_cast(posend)-1; + i=static_cast(posstart); --pos) { switch (tolower (strp[pos])) { case 'x': case 'z': case '?': // FALLTHRU case '0': lsb += baseLog2; break; @@ -1501,8 +1515,15 @@ void VL_READMEM_N( if (VL_UNLIKELY(c==EOF)) break; //printf("%d: Got '%c' Addr%x IN%d IgE%d IgC%d ninc%d\n", // linenum, c, addr, innum, ignore_to_eol, ignore_to_cmt, needinc); - if (c=='\n') { linenum++; ignore_to_eol=false; if (innum) reading_addr=false; innum=false; } - else if (c=='\t' || c==' ' || c=='\r' || c=='\f') { if (innum) reading_addr=false; innum=false; } + if (c=='\n') { + linenum++; ignore_to_eol = false; + if (innum) reading_addr = false; + innum = false; + } + else if (c=='\t' || c==' ' || c=='\r' || c=='\f') { + if (innum) reading_addr = false; + innum = false; + } // Skip // comments and detect /* comments else if (ignore_to_cmt && lastc=='*' && c=='/') { ignore_to_cmt = false; if (innum) reading_addr=false; innum=false; @@ -1553,7 +1574,8 @@ void VL_READMEM_N( *datap = ((*datap << static_cast(shift)) + static_cast(value)) & VL_MASK_Q(width); } else { - WDataOutP datap = &(reinterpret_cast(memp))[ entry*VL_WORDS_I(width) ]; + WDataOutP datap = &(reinterpret_cast(memp)) + [ entry*VL_WORDS_I(width) ]; if (!innum) { VL_ZERO_RESET_W(width, datap); } _VL_SHIFTL_INPLACE_W(width, datap, static_cast(shift)); datap[0] |= value; @@ -1738,9 +1760,11 @@ void Verilated::debug(int level) VL_MT_SAFE { s_s.s_debug = level; if (level) { #ifdef VL_DEBUG - VL_DEBUG_IF(VL_DBG_MSGF("- Verilated::debug is on. Message prefix indicates {,}.\n");); + VL_DEBUG_IF(VL_DBG_MSGF("- Verilated::debug is on." + " Message prefix indicates {,}.\n");); #else - VL_PRINTF_MT("- Verilated::debug attempted, but compiled without VL_DEBUG, so messages suppressed.\n"); + VL_PRINTF_MT("- Verilated::debug attempted," + " but compiled without VL_DEBUG, so messages suppressed.\n"); #endif } } @@ -1967,11 +1991,13 @@ void VerilatedImp::commandArgVl(const std::string& arg) { } else if (arg == "+verilator+V") { versionDump(); // Someday more info too - VL_FATAL_MT("COMMAND_LINE", 0, "", "Exiting due to command line argument (not an error)"); + VL_FATAL_MT("COMMAND_LINE", 0, "", + "Exiting due to command line argument (not an error)"); } else if (arg == "+verilator+version") { versionDump(); - VL_FATAL_MT("COMMAND_LINE", 0, "", "Exiting due to command line argument (not an error)"); + VL_FATAL_MT("COMMAND_LINE", 0, "", + "Exiting due to command line argument (not an error)"); } else { VL_PRINTF_MT("%%Warning: Unknown +verilator runtime argument: '%s'\n", arg.c_str()); @@ -2074,7 +2100,8 @@ VerilatedScope::~VerilatedScope() { m_funcnumMax = 0; // Force callback table to empty } -void VerilatedScope::configure(VerilatedSyms* symsp, const char* prefixp, const char* suffixp) VL_MT_UNSAFE { +void VerilatedScope::configure(VerilatedSyms* symsp, const char* prefixp, + const char* suffixp) VL_MT_UNSAFE { // Slowpath - called once/scope at construction // We don't want the space and reference-count access overhead of strings. m_symsp = symsp; @@ -2110,7 +2137,8 @@ void VerilatedScope::exportInsert(int finalize, const char* namep, void* cb) VL_ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, VerilatedVarType vltype, int vlflags, int dims, ...) VL_MT_UNSAFE { // Grab dimensions - // In the future we may just create a large table at emit time and statically construct from that. + // In the future we may just create a large table at emit time and + // statically construct from that. if (!finalize) return; if (!m_varsp) m_varsp = new VerilatedVarNameMap(); diff --git a/include/verilated.h b/include/verilated.h index 41e4483b3..fb8553c0c 100644 --- a/include/verilated.h +++ b/include/verilated.h @@ -404,7 +404,8 @@ public: static void debug(int level) VL_MT_SAFE; #ifdef VL_DEBUG /// Return debug level - /// When multithreaded this may not immediately react to another thread changing the level (no mutex) + /// When multithreaded this may not immediately react to another thread + /// changing the level (no mutex) static inline int debug() VL_MT_SAFE { return s_s.s_debug; } #else static inline int debug() VL_PURE { return 0; } ///< Return constant 0 debug level, so C++'s optimizer rips up @@ -581,7 +582,8 @@ inline QData VL_RDTSC_Q() { vluint64_t val; VL_RDTSC(val); return val; } #endif /// Math -extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool is_modulus); +extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, + WDataInP lwp, WDataInP rwp, bool is_modulus); /// File I/O extern IData VL_FGETS_IXI(int obits, void* destp, IData fpi); @@ -1292,7 +1294,8 @@ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp, WDataInP lwp, WDataIn static inline WDataOutP VL_SUB_W(int words, WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE { QData carry = 0; for (int i=0; i(lwp[i]) + static_cast(static_cast(~rwp[i])); + carry = (carry + static_cast(lwp[i]) + + static_cast(static_cast(~rwp[i]))); if (i==0) ++carry; // Negation of temp2 owp[i] = (carry & VL_ULL(0xffffffff)); carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff); @@ -1344,7 +1347,8 @@ static inline QData VL_MULS_QQQ(int, int lbits, int, QData lhs, QData rhs) VL_PU return lhs_signed * rhs_signed; } -static inline WDataOutP VL_MULS_WWW(int, int lbits, int, WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE { +static inline WDataOutP VL_MULS_WWW(int, int lbits, int, + WDataOutP owp, WDataInP lwp, WDataInP rwp) VL_MT_SAFE { int words = VL_WORDS_I(lbits); // cppcheck-suppress variableScope WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here @@ -1774,7 +1778,8 @@ static inline QData VL_STREAML_QQI(int, int lbits, int, QData ld, IData rd) VL_P return ret; } -static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WDataInP lwp, IData rd) VL_MT_SAFE { +static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, + WDataOutP owp, WDataInP lwp, IData rd) VL_MT_SAFE { VL_ZERO_W(lbits, owp); // Slice size should never exceed the lhs width int ssize = (rd < static_cast(lbits)) ? rd : (static_cast(lbits)); @@ -1888,7 +1893,8 @@ static inline void _VL_SHIFTL_INPLACE_W(int obits, WDataOutP iowp, IData rd/*1 o // EMIT_RULE: VL_SHIFTL: oclean=lclean; rclean==clean; // Important: Unlike most other funcs, the shift might well be a computed // expression. Thus consider this when optimizing. (And perhaps have 2 funcs?) -static inline WDataOutP VL_SHIFTL_WWI(int obits, int, int, WDataOutP owp, WDataInP lwp, IData rd) VL_MT_SAFE { +static inline WDataOutP VL_SHIFTL_WWI(int obits, int, int, + WDataOutP owp, WDataInP lwp, IData rd) VL_MT_SAFE { int word_shift = VL_BITWORD_I(rd); int bit_shift = VL_BITBIT_I(rd); if (rd >= static_cast(obits)) { // rd may be huge with MSB set @@ -2142,7 +2148,8 @@ static inline QData VL_SEL_QWII(int, int lbits, int, int, } static inline WDataOutP VL_SEL_WWII(int obits, int lbits, int, int, - WDataOutP owp, WDataInP lwp, IData lsb, IData width) VL_MT_SAFE { + WDataOutP owp, WDataInP lwp, + IData lsb, IData width) VL_MT_SAFE { int msb = lsb+width-1; int word_shift = VL_BITWORD_I(lsb); if (VL_UNLIKELY(msb>lbits)) { // Outside bounds, diff --git a/include/verilated_cov.cpp b/include/verilated_cov.cpp index 6ee15a74b..00aaf446c 100644 --- a/include/verilated_cov.cpp +++ b/include/verilated_cov.cpp @@ -316,7 +316,9 @@ public: m_insertp->m_vals[addKeynum] = valueIndex(val); addKeynum++; if (!legalKey(key)) { - std::string msg = "%Error: Coverage keys of one character, or letter+digit are illegal: "+key; + std::string msg + = ("%Error: Coverage keys of one character, or letter+digit are illegal: " + +key); VL_FATAL_MT("", 0, "", msg.c_str()); } } diff --git a/include/verilated_dpi.cpp b/include/verilated_dpi.cpp index ead615e6e..9a4d86f33 100644 --- a/include/verilated_dpi.cpp +++ b/include/verilated_dpi.cpp @@ -320,7 +320,8 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, return; } default: - _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype()); + _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", + varp->vltype()); return; } } @@ -348,7 +349,8 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl return; } default: - _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype()); + _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", + varp->vltype()); return; } } @@ -370,7 +372,8 @@ static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecV return; } default: - _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype()); + _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", + varp->vltype()); return; } } @@ -707,11 +710,13 @@ void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1) { // Verilator doesn't support X/Z so can just call Bit version svPutBitArrElem1(d, value, indx1); } -void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1, int indx2) { +void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, + int indx1, int indx2) { // Verilator doesn't support X/Z so can just call Bit version svPutBitArrElem2(d, value, indx1, indx2); } -void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int indx2, int indx3) { +void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, + int indx1, int indx2, int indx3) { // Verilator doesn't support X/Z so can just call Bit version svPutBitArrElem3(d, value, indx1, indx2, indx3); } diff --git a/include/verilated_fst_c.cpp b/include/verilated_fst_c.cpp index db2f37b2a..bbd7d737b 100644 --- a/include/verilated_fst_c.cpp +++ b/include/verilated_fst_c.cpp @@ -174,7 +174,8 @@ void VerilatedFst::addCallback( VerilatedFstCallback_t changecb, void* userthis) VL_MT_UNSAFE_ONE { m_assertOne.check(); if (VL_UNLIKELY(isOpen())) { - std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file"; + std::string msg = (std::string("Internal: ")+__FILE__+"::"+__FUNCTION__ + +" called with already open file"); VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str()); } VerilatedFstCallInfo* vci = new VerilatedFstCallInfo(initcb, fullcb, changecb, userthis, 1); diff --git a/include/verilated_fst_c.h b/include/verilated_fst_c.h index d70fd8540..a7d4eb21b 100644 --- a/include/verilated_fst_c.h +++ b/include/verilated_fst_c.h @@ -157,12 +157,18 @@ public: fstWriterEmitValueChange(m_fst, m_code2symbol[code], array2Str(newval, bits)); } - void fullBit(vluint32_t code, const vluint32_t newval) { chgBit(code, newval); } - void fullBus(vluint32_t code, const vluint32_t newval, int bits) { chgBus(code, newval, bits); } - void fullDouble(vluint32_t code, const double newval) { chgDouble(code, newval); } - void fullFloat(vluint32_t code, const float newval) { chgFloat(code, newval); } - void fullQuad(vluint32_t code, const vluint64_t newval, int bits) { chgQuad(code, newval, bits); } - void fullArray(vluint32_t code, const vluint32_t* newval, int bits) { chgArray(code, newval, bits); } + void fullBit(vluint32_t code, const vluint32_t newval) { + chgBit(code, newval); } + void fullBus(vluint32_t code, const vluint32_t newval, int bits) { + chgBus(code, newval, bits); } + void fullDouble(vluint32_t code, const double newval) { + chgDouble(code, newval); } + void fullFloat(vluint32_t code, const float newval) { + chgFloat(code, newval); } + void fullQuad(vluint32_t code, const vluint64_t newval, int bits) { + chgQuad(code, newval, bits); } + void fullArray(vluint32_t code, const vluint32_t* newval, int bits) { + chgArray(code, newval, bits); } void declTriBit (vluint32_t code, const char* name, int arraynum); void declTriBus (vluint32_t code, const char* name, int arraynum, int msb, int lsb); diff --git a/include/verilated_heavy.h b/include/verilated_heavy.h index f3a507591..487a4bb5a 100644 --- a/include/verilated_heavy.h +++ b/include/verilated_heavy.h @@ -70,8 +70,10 @@ extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb, extern void VL_WRITEMEM_N(bool hex, int width, int depth, int array_lsb, const std::string& filename, const void* memp, IData start, IData end) VL_MT_SAFE; -extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp, ...) VL_MT_SAFE; -extern void VL_SFORMAT_X(int obits_ignored, std::string& output, const char* formatp, ...) VL_MT_SAFE; +extern IData VL_SSCANF_INX(int lbits, const std::string& ld, + const char* formatp, ...) VL_MT_SAFE; +extern void VL_SFORMAT_X(int obits_ignored, std::string& output, + const char* formatp, ...) VL_MT_SAFE; extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE; extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE; inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE { diff --git a/include/verilated_save.cpp b/include/verilated_save.cpp index 840cdce2b..016fbeb28 100644 --- a/include/verilated_save.cpp +++ b/include/verilated_save.cpp @@ -61,10 +61,11 @@ bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size return (miss!=0); } -VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE { +VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict datap, + size_t size) VL_MT_UNSAFE_ONE { if (VL_UNLIKELY(readDiffers(datap, size))) { std::string fn = filename(); - std::string msg = std::string("Can't deserialize save-restore file as was made from different model"); + std::string msg = "Can't deserialize save-restore file as was made from different model"; VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str()); close(); } diff --git a/include/verilated_sym_props.h b/include/verilated_sym_props.h index ea8ec7459..47f1f0a46 100644 --- a/include/verilated_sym_props.h +++ b/include/verilated_sym_props.h @@ -142,22 +142,28 @@ public: const VerilatedRange& unpacked() const { return m_unpacked[0]; } // DPI accessors int left(int dim) const { - return dim==0 ? m_packed.left() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].left() : 0; + return dim==0 ? m_packed.left() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].left() : 0; } int right(int dim) const { - return dim==0 ? m_packed.right() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].right() : 0; + return dim==0 ? m_packed.right() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].right() : 0; } int low(int dim) const { - return dim==0 ? m_packed.low() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].low() : 0; + return dim==0 ? m_packed.low() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].low() : 0; } int high(int dim) const { - return dim==0 ? m_packed.high() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].high() : 0; + return dim==0 ? m_packed.high() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].high() : 0; } int increment(int dim) const { - return dim==0 ? m_packed.increment() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].increment() : 0; + return dim==0 ? m_packed.increment() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].increment() : 0; } int elements(int dim) const { - return dim==0 ? m_packed.elements() : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].elements() : 0; + return dim==0 ? m_packed.elements() + : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].elements() : 0; } /// Total size in bytes (note DPI limited to 4GB) size_t totalSize() const; diff --git a/include/verilated_vcd_c.cpp b/include/verilated_vcd_c.cpp index e26674085..e1604b50c 100644 --- a/include/verilated_vcd_c.cpp +++ b/include/verilated_vcd_c.cpp @@ -68,14 +68,17 @@ public: } static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) { VerilatedLockGuard lock(singleton().s_vcdMutex); - VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(), singleton().s_vcdVecp.end(), vcdp); + VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(), + singleton().s_vcdVecp.end(), vcdp); if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); } } static void flush_all() VL_EXCLUDES(singleton().s_vcdMutex) VL_MT_UNSAFE_ONE { - // Thread safety: Although this function is protected by a mutex so perhaps - // in the future we can allow tracing in separate threads, vcdp->flush() assumes call from single thread + // Thread safety: Although this function is protected by a mutex so + // perhaps in the future we can allow tracing in separate threads, + // vcdp->flush() assumes call from single thread VerilatedLockGuard lock(singleton().s_vcdMutex); - for (VcdVec::const_iterator it=singleton().s_vcdVecp.begin(); it!=singleton().s_vcdVecp.end(); ++it) { + for (VcdVec::const_iterator it = singleton().s_vcdVecp.begin(); + it != singleton().s_vcdVecp.end(); ++it) { VerilatedVcd* vcdp = *it; vcdp->flush(); } @@ -523,7 +526,8 @@ void VerilatedVcd::module(const std::string& name) { void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep, int arraynum, bool tri, bool bussed, int msb, int lsb) { - if (!code) { VL_FATAL_MT(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); } + if (!code) { VL_FATAL_MT(__FILE__, __LINE__, "", + "Internal: internal trace problem, code 0 is illegal"); } int bits = ((msb>lsb)?(msb-lsb):(lsb-msb))+1; int codesNeeded = 1+int(bits/32); @@ -644,10 +648,12 @@ void VerilatedVcd::addCallback( { m_assertOne.check(); if (VL_UNLIKELY(isOpen())) { - std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file"; - VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str()); + std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__ + +" called with already open file"; + VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str()); } - VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode); + VerilatedVcdCallInfo* vci + = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode); m_callbacks.push_back(vci); } diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h index eb0177a8a..6099484a2 100644 --- a/include/verilated_vcd_c.h +++ b/include/verilated_vcd_c.h @@ -268,7 +268,8 @@ public: *m_writep++=' '; printCode(code); *m_writep++='\n'; bufferCheck(); } - void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) { + void fullTriQuad(vluint32_t code, const vluint64_t newval, + const vluint32_t newtri, int bits) { (*(reinterpret_cast(&m_sigs_oldvalp[code]))) = newval; (*(reinterpret_cast(&m_sigs_oldvalp[code+1]))) = newtri; *m_writep++='b'; @@ -279,7 +280,8 @@ public: *m_writep++=' '; printCode(code); *m_writep++='\n'; bufferCheck(); } - void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) { + void fullTriArray(vluint32_t code, const vluint32_t* newvalp, + const vluint32_t* newtrip, int bits) { for (int word=0; word<(((bits-1)/32)+1); ++word) { m_sigs_oldvalp[code+word*2] = newvalp[word]; m_sigs_oldvalp[code+word*2+1] = newtrip[word]; @@ -319,7 +321,8 @@ public: inline void chgBit(vluint32_t code, const vluint32_t newval) { vluint32_t diff = m_sigs_oldvalp[code] ^ newval; if (VL_UNLIKELY(diff)) { - // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility + // Verilator 3.510 and newer provide clean input, so the below + // is only for back compatibility if (VL_UNLIKELY(diff & 1)) { // Change after clean? fullBit(code, newval); } @@ -349,17 +352,20 @@ public: } } } - inline void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri) { + inline void chgTriBit(vluint32_t code, const vluint32_t newval, + const vluint32_t newtri) { vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval) | (m_sigs_oldvalp[code+1] ^ newtri)); if (VL_UNLIKELY(diff)) { - // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility + // Verilator 3.510 and newer provide clean input, so the below + // is only for back compatibility if (VL_UNLIKELY(diff & 1)) { // Change after clean? fullTriBit(code, newval, newtri); } } } - inline void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) { + inline void chgTriBus(vluint32_t code, const vluint32_t newval, + const vluint32_t newtri, int bits) { vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval) | (m_sigs_oldvalp[code+1] ^ newtri)); if (VL_UNLIKELY(diff)) { @@ -368,7 +374,8 @@ public: } } } - inline void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) { + inline void chgTriQuad(vluint32_t code, const vluint64_t newval, + const vluint32_t newtri, int bits) { vluint64_t diff = ( ((*(reinterpret_cast(&m_sigs_oldvalp[code]))) ^ newval) | ((*(reinterpret_cast(&m_sigs_oldvalp[code+1]))) ^ newtri)); if (VL_UNLIKELY(diff)) { @@ -377,7 +384,8 @@ public: } } } - inline void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) { + inline void chgTriArray(vluint32_t code, const vluint32_t* newvalp, + const vluint32_t* newtrip, int bits) { for (int word=0; word<(((bits-1)/32)+1); ++word) { if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word]) | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) { diff --git a/include/verilated_vcd_sc.h b/include/verilated_vcd_sc.h index d2bdb3aa3..0d7ac4e7d 100644 --- a/include/verilated_vcd_sc.h +++ b/include/verilated_vcd_sc.h @@ -47,7 +47,8 @@ public: sc_get_curr_simcontext()->add_trace_file(this); # if (SYSTEMC_VERSION>=20060505) // We want to avoid a depreciated warning, but still be back compatible. - // Turning off the message just for this still results in an annoying "to turn off" message. + // Turning off the message just for this still results in an + // annoying "to turn off" message. sc_time t1sec(1,SC_SEC); if (t1sec.to_default_time_units()!=0) { sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC); @@ -69,7 +70,8 @@ public: # if (SYSTEMC_VERSION>20011000) if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); } # else - // VCD files must have integer timestamps, so we write all times in increments of time_resolution + // VCD files must have integer timestamps, so we write all times in + // increments of time_resolution if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); } # endif } diff --git a/include/verilated_vpi.cpp b/include/verilated_vpi.cpp index 8de67d383..7b5db2d7b 100644 --- a/include/verilated_vpi.cpp +++ b/include/verilated_vpi.cpp @@ -417,8 +417,9 @@ public: void* newDatap = varop->varDatap(); void* prevDatap = varop->prevDatap(); // Was malloced when we added the callback VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_test %s v[0]=%d/%d %p %p\n", - varop->fullname(), *((CData*)newDatap), *((CData*)prevDatap), - newDatap, prevDatap);); + varop->fullname(), + *((CData*)newDatap), *((CData*)prevDatap), + newDatap, prevDatap);); if (memcmp(prevDatap, newDatap, varop->entSize())) { VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: value_callback %p %s v[0]=%d\n", vop, varop->fullname(), *((CData*)newDatap));); @@ -454,8 +455,9 @@ class VerilatedVpiError { // Stop on vpi error/unsupported vpi_unsupported(); } - // We need to run above code first because in the case that the callback executes further vpi - // functions we will loose the error as it will be overwritten. + // We need to run above code first because in the case that the + // callback executes further vpi functions we will loose the error + // as it will be overwritten. VerilatedVpiImp::callCbs(cbPLIError); } public: @@ -937,16 +939,16 @@ vpiHandle vpi_register_cb(p_cb_data cb_data_p) { VerilatedVpiImp::cbTimedAdd(vop); return vop->castVpiHandle(); } - case cbReadWriteSynch: // FALLTHRU // Supported via vlt_main.cpp - case cbReadOnlySynch: // FALLTHRU // Supported via vlt_main.cpp - case cbNextSimTime: // FALLTHRU // Supported via vlt_main.cpp - case cbStartOfSimulation: // FALLTHRU // Supported via vlt_main.cpp - case cbEndOfSimulation: // FALLTHRU // Supported via vlt_main.cpp - case cbValueChange: // FALLTHRU // Supported via vlt_main.cpp - case cbPLIError: // FALLTHRU // NOP, but need to return handle, so make object - case cbEnterInteractive: // FALLTHRU // NOP, but need to return handle, so make object - case cbExitInteractive: // FALLTHRU // NOP, but need to return handle, so make object - case cbInteractiveScopeChange: { // FALLTHRU // NOP, but need to return handle, so make object + case cbReadWriteSynch: // FALLTHRU // Supported via vlt_main.cpp + case cbReadOnlySynch: // FALLTHRU // Supported via vlt_main.cpp + case cbNextSimTime: // FALLTHRU // Supported via vlt_main.cpp + case cbStartOfSimulation: // FALLTHRU // Supported via vlt_main.cpp + case cbEndOfSimulation: // FALLTHRU // Supported via vlt_main.cpp + case cbValueChange: // FALLTHRU // Supported via vlt_main.cpp + case cbPLIError: // FALLTHRU // NOP, but need to return handle, so make object + case cbEnterInteractive: // FALLTHRU // NOP, but need to return handle, so make object + case cbExitInteractive: // FALLTHRU // NOP, but need to return handle, so make object + case cbInteractiveScopeChange: { // FALLTHRU // NOP, but need to return handle, so make object VerilatedVpioCb* vop = new VerilatedVpioCb(cb_data_p, 0); VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_register_cb %d %p\n", cb_data_p->reason, vop);); VerilatedVpiImp::cbReasonAdd(vop); @@ -1099,7 +1101,8 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) { if (VL_UNLIKELY(!vop)) return 0; if (vop->varp()->dims() < 2) return 0; if (vop->varp()->dims() > 2) { - _VL_VPI_WARNING(__FILE__, __LINE__, "%s: %s, object %s has unsupported number of indices (%d)", + _VL_VPI_WARNING(__FILE__, __LINE__, + "%s: %s, object %s has unsupported number of indices (%d)", VL_FUNC, VerilatedVpiError::strFromVpiMethod(type), vop->fullname() , vop->varp()->dims()); } @@ -1111,7 +1114,8 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) { if (vop->varp()->dims() < 2) return 0; // Unsupported is multidim list if (vop->varp()->dims() > 2) { - _VL_VPI_WARNING(__FILE__, __LINE__, "%s: %s, object %s has unsupported number of indices (%d)", + _VL_VPI_WARNING(__FILE__, __LINE__, + "%s: %s, object %s has unsupported number of indices (%d)", VL_FUNC, VerilatedVpiError::strFromVpiMethod(type), vop->fullname() , vop->varp()->dims()); } @@ -1252,7 +1256,8 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { case VLVT_WDATA: { int words = VL_WORDS_I(vop->varp()->packed().elements()); if (VL_UNLIKELY(words >= VL_MULS_MAX_WORDS)) { - VL_FATAL_MT(__FILE__, __LINE__, "", "vpi_get_value with more than VL_MULS_MAX_WORDS; increase and recompile"); + VL_FATAL_MT(__FILE__, __LINE__, "", + "vpi_get_value with more than VL_MULS_MAX_WORDS; increase and recompile"); } WDataInP datap = (reinterpret_cast(vop->varDatap())); for (int i=0; iformat), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return; } } @@ -1354,7 +1360,8 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { default: strcpy(outStr, "0"); _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return; } } else if (value_p->format == vpiDecStrVal) { @@ -1363,19 +1370,24 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { // outStrSz does not include NULL termination so add one case VLVT_UINT8: VL_SNPRINTF(outStr, outStrSz+1, "%hhu", - static_cast(*(reinterpret_cast(vop->varDatap())))); return; + static_cast(*(reinterpret_cast(vop->varDatap())))); + return; case VLVT_UINT16: VL_SNPRINTF(outStr, outStrSz+1, "%hu", - static_cast(*(reinterpret_cast(vop->varDatap())))); return; + static_cast(*(reinterpret_cast(vop->varDatap())))); + return; case VLVT_UINT32: VL_SNPRINTF(outStr, outStrSz+1, "%u", - static_cast(*(reinterpret_cast(vop->varDatap())))); return; + static_cast(*(reinterpret_cast(vop->varDatap())))); + return; case VLVT_UINT64: VL_SNPRINTF(outStr, outStrSz+1, "%llu", - static_cast(*(reinterpret_cast(vop->varDatap())))); return; + static_cast(*(reinterpret_cast(vop->varDatap())))); + return; default: strcpy(outStr, "-1"); - _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s, maximum limit is 64 bits", + _VL_VPI_ERROR(__FILE__, __LINE__, + "%s: Unsupported format (%s) for %s, maximum limit is 64 bits", VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); return; } @@ -1416,7 +1428,8 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { } default: _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return; } } else if (value_p->format == vpiStringVal) { @@ -1448,7 +1461,8 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { } default: _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return; } } else if (value_p->format == vpiIntVal) { @@ -1467,7 +1481,8 @@ void vpi_get_value(vpiHandle object, p_vpi_value value_p) { default: value_p->value.integer = 0; _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return; } } else if (value_p->format == vpiSuppressVal) { @@ -1505,7 +1520,8 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, VL_DBG_MSGF("- vpi: varp=%p putatp=%p\n", vop->varp()->datap(), vop->varDatap());); if (VL_UNLIKELY(!vop->varp()->isPublicRW())) { - _VL_VPI_WARNING(__FILE__, __LINE__, "Ignoring vpi_put_value to signal marked read-only," + _VL_VPI_WARNING(__FILE__, __LINE__, + "Ignoring vpi_put_value to signal marked read-only," " use public_flat_rw instead: ", vop->fullname()); return 0; @@ -1544,7 +1560,8 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, } default: { _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return NULL; } } @@ -1572,7 +1589,8 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, } default: _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return 0; } } else if (value_p->format == vpiOctStrVal) { @@ -1600,9 +1618,11 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, if (digit >= '0' && digit <= '7') { val.half = digit-'0'; } else { - _VL_VPI_WARNING(__FILE__, __LINE__, "%s: Non octal character '%c' in '%s' as value %s for %s", + _VL_VPI_WARNING(__FILE__, __LINE__, + "%s: Non octal character '%c' in '%s' as value %s for %s", VL_FUNC, digit, value_p->value.str, - VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); val.half = 0; } } else { @@ -1634,7 +1654,8 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, } default: _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return 0; } } else if (value_p->format == vpiDecStrVal) { @@ -1642,12 +1663,15 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, unsigned long long val; int success = sscanf(value_p->value.str, "%30llu%15s", &val, remainder); if (success < 1) { - _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Parsing failed for '%s' as value %s for %s", - VL_FUNC, value_p->value.str, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + _VL_VPI_ERROR(__FILE__, __LINE__, + "%s: Parsing failed for '%s' as value %s for %s", + VL_FUNC, value_p->value.str, + VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); return 0; } if (success > 1) { - _VL_VPI_WARNING(__FILE__, __LINE__, "%s: Trailing garbage '%s' in '%s' as value %s for %s", + _VL_VPI_WARNING(__FILE__, __LINE__, + "%s: Trailing garbage '%s' in '%s' as value %s for %s", VL_FUNC, remainder, value_p->value.str, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); @@ -1663,8 +1687,10 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p, (reinterpret_cast(vop->varDatap()))[1] &= vop->mask(); break; case VLVT_WDATA: default: - _VL_VPI_ERROR(__FILE__, __LINE__, "%s: Unsupported format (%s) for %s, maximum limit is 64 bits", - VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), vop->fullname()); + _VL_VPI_ERROR(__FILE__, __LINE__, + "%s: Unsupported format (%s) for %s, maximum limit is 64 bits", + VL_FUNC, VerilatedVpiError::strFromVpiVal(value_p->format), + vop->fullname()); return 0; } return object;