Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

C++11: Favor auto, range for. No functional change intended.

Browse Source
This commit is contained in:
Wilson Snyder 2020-08-16 11:43:49 -04:00
parent 034737d2a8
commit ee9d6dd63f
77 changed files with 371 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/verilated.cpp
View File

@ -1639,12 +1639,12 @@ std::string VL_TO_STRING_W(int words, WDataInP obj) {
std::string VL_TOLOWER_NN(const std::string& ld) VL_MT_SAFE { std::string VL_TOLOWER_NN(const std::string& ld) VL_MT_SAFE {
std::string out = ld; std::string out = ld;
for (std::string::iterator it = out.begin(); it != out.end(); ++it) *it = tolower(*it); for (auto& cr : out) cr = tolower(cr);
return out; return out;
} }
std::string VL_TOUPPER_NN(const std::string& ld) VL_MT_SAFE { std::string VL_TOUPPER_NN(const std::string& ld) VL_MT_SAFE {
std::string out = ld; std::string out = ld;
for (std::string::iterator it = out.begin(); it != out.end(); ++it) *it = toupper(*it); for (auto& cr : out) cr = toupper(cr);
return out; return out;
} }
@ -1862,8 +1862,8 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
QData shift = m_hex ? 4ULL : 1ULL; QData shift = m_hex ? 4ULL : 1ULL;
bool innum = false; bool innum = false;
// Shift value in // Shift value in
for (std::string::const_iterator it = rhs.begin(); it != rhs.end(); ++it) { for (const auto& i : rhs) {
char c = tolower(*it); char c = tolower(i);
int value = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0')); int value = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
if (m_bits <= 8) { if (m_bits <= 8) {
CData* datap = reinterpret_cast<CData*>(valuep); CData* datap = reinterpret_cast<CData*>(valuep);
@ -2312,7 +2312,7 @@ static void removeCb(Verilated::VoidPCb cb, void* datap, VoidPCbList& cbs) {
cbs.remove(pair); cbs.remove(pair);
} }
static void runCallbacks(VoidPCbList& cbs) VL_MT_SAFE { static void runCallbacks(VoidPCbList& cbs) VL_MT_SAFE {
for (VoidPCbList::iterator it = cbs.begin(); it != cbs.end(); ++it) { it->first(it->second); } for (const auto& i : cbs) i.first(i.second);
} }
void Verilated::addFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE { void Verilated::addFlushCb(VoidPCb cb, void* datap) VL_MT_SAFE {
@ -2445,9 +2445,7 @@ void VerilatedImp::internalsDump() VL_MT_SAFE {
VL_PRINTF_MT("internalsDump:\n"); VL_PRINTF_MT("internalsDump:\n");
versionDump(); versionDump();
VL_PRINTF_MT(" Argv:"); VL_PRINTF_MT(" Argv:");
for (ArgVec::const_iterator it = s_s.m_argVec.begin(); it != s_s.m_argVec.end(); ++it) { for (const auto& i : s_s.m_argVec) VL_PRINTF_MT(" %s", i.c_str());
VL_PRINTF_MT(" %s", it->c_str());
}
VL_PRINTF_MT("\n"); VL_PRINTF_MT("\n");
scopesDump(); scopesDump();
exportsDump(); exportsDump();
@ -2675,7 +2673,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap, boo
// cppcheck-suppress unusedFunction // Used by applications // cppcheck-suppress unusedFunction // Used by applications
VerilatedVar* VerilatedScope::varFind(const char* namep) const VL_MT_SAFE_POSTINIT { VerilatedVar* VerilatedScope::varFind(const char* namep) const VL_MT_SAFE_POSTINIT {
if (VL_LIKELY(m_varsp)) { if (VL_LIKELY(m_varsp)) {
VerilatedVarNameMap::iterator it = m_varsp->find(namep); const auto it = m_varsp->find(namep);
if (VL_LIKELY(it != m_varsp->end())) return &(it->second); if (VL_LIKELY(it != m_varsp->end())) return &(it->second);
} }
return nullptr; return nullptr;
@ -2708,9 +2706,7 @@ void VerilatedScope::scopeDump() const {
} }
} }
if (VerilatedVarNameMap* varsp = this->varsp()) { if (VerilatedVarNameMap* varsp = this->varsp()) {
for (VerilatedVarNameMap::const_iterator it = varsp->begin(); it != varsp->end(); ++it) { for (const auto& i : *varsp) VL_PRINTF_MT(" VAR %p: %s\n", &(i.second), i.first);
VL_PRINTF_MT(" VAR %p: %s\n", &(it->second), it->first);
}
} }
} }

27
include/verilated_cov.cpp
View File

@ -119,7 +119,7 @@ private:
// PRIVATE METHODS // PRIVATE METHODS
int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) { int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
static int nextIndex = KEY_UNDEF + 1; static int nextIndex = KEY_UNDEF + 1;
ValueIndexMap::iterator iter = m_valueIndexes.find(value); const auto iter = m_valueIndexes.find(value);
if (iter != m_valueIndexes.end()) return iter->second; if (iter != m_valueIndexes.end()) return iter->second;
nextIndex++; nextIndex++;
assert(nextIndex > 0); // Didn't rollover assert(nextIndex > 0); // Didn't rollover
@ -231,10 +231,7 @@ private:
#undef SELF_CHECK #undef SELF_CHECK
} }
void clearGuts() VL_REQUIRES(m_mutex) { void clearGuts() VL_REQUIRES(m_mutex) {
for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) { for (const auto& itemp : m_items) VL_DO_DANGLING(delete itemp, itemp);
VerilatedCovImpItem* itemp = *(it);
VL_DO_DANGLING(delete itemp, itemp);
}
m_items.clear(); m_items.clear();
m_indexValues.clear(); m_indexValues.clear();
m_valueIndexes.clear(); m_valueIndexes.clear();
@ -252,8 +249,7 @@ public:
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock(m_mutex);
if (matchp && matchp[0]) { if (matchp && matchp[0]) {
ItemList newlist; ItemList newlist;
for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) { for (const auto& itemp : m_items) {
VerilatedCovImpItem* itemp = *(it);
if (!itemMatchesString(itemp, matchp)) { if (!itemMatchesString(itemp, matchp)) {
VL_DO_DANGLING(delete itemp, itemp); VL_DO_DANGLING(delete itemp, itemp);
} else { } else {
@ -266,9 +262,7 @@ public:
void zero() VL_EXCLUDES(m_mutex) { void zero() VL_EXCLUDES(m_mutex) {
Verilated::quiesce(); Verilated::quiesce();
const VerilatedLockGuard lock(m_mutex); const VerilatedLockGuard lock(m_mutex);
for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) { for (const auto& itemp : m_items) itemp->zero();
(*it)->zero();
}
} }
// We assume there's always call to i/f/p in that order // We assume there's always call to i/f/p in that order
@ -358,8 +352,7 @@ public:
// Build list of events; totalize if collapsing hierarchy // Build list of events; totalize if collapsing hierarchy
typedef std::map<std::string, std::pair<std::string, vluint64_t>> EventMap; typedef std::map<std::string, std::pair<std::string, vluint64_t>> EventMap;
EventMap eventCounts; EventMap eventCounts;
for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) { for (const auto& itemp : m_items) {
VerilatedCovImpItem* itemp = *(it);
std::string name; std::string name;
std::string hier; std::string hier;
bool per_instance = false; bool per_instance = false;
@ -390,7 +383,7 @@ public:
// inefficient) // inefficient)
// Find or insert the named event // Find or insert the named event
EventMap::iterator cit = eventCounts.find(name); const auto cit = eventCounts.find(name);
if (cit != eventCounts.end()) { if (cit != eventCounts.end()) {
const std::string& oldhier = cit->second.first; const std::string& oldhier = cit->second.first;
cit->second.second += itemp->count(); cit->second.second += itemp->count();
@ -401,11 +394,11 @@ public:
} }
// Output body // Output body
for (EventMap::const_iterator it = eventCounts.begin(); it != eventCounts.end(); ++it) { for (const auto& i : eventCounts) {
os << "C '" << std::dec; os << "C '" << std::dec;
os << it->first; os << i.first;
if (!it->second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, it->second.first); if (!i.second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, i.second.first);
os << "' " << it->second.second; os << "' " << i.second.second;
os << std::endl; os << std::endl;
} }
} }

13
include/verilated_fst_c.cpp
View File

@ -80,7 +80,7 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
VerilatedTrace<VerilatedFst>::traceInit(); VerilatedTrace<VerilatedFst>::traceInit();
// Clear the scope stack // Clear the scope stack
std::list<std::string>::iterator it = m_curScope.begin(); auto it = m_curScope.begin();
while (it != m_curScope.end()) { while (it != m_curScope.end()) {
fstWriterSetUpscope(m_fst); fstWriterSetUpscope(m_fst);
it = m_curScope.erase(it); it = m_curScope.erase(it);
@ -89,10 +89,7 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
// convert m_code2symbol into an array for fast lookup // convert m_code2symbol into an array for fast lookup
if (!m_symbolp) { if (!m_symbolp) {
m_symbolp = new fstHandle[nextCode()]; m_symbolp = new fstHandle[nextCode()];
for (Code2SymbolType::iterator it = m_code2symbol.begin(); it != m_code2symbol.end(); for (const auto& i : m_code2symbol) m_symbolp[i.first] = i.second;
++it) {
m_symbolp[it->first] = it->second;
}
} }
m_code2symbol.clear(); m_code2symbol.clear();
@ -140,8 +137,8 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
tokens.insert(tokens.begin(), moduleName()); // Add current module to the hierarchy tokens.insert(tokens.begin(), moduleName()); // Add current module to the hierarchy
// Find point where current and new scope diverge // Find point where current and new scope diverge
std::list<std::string>::iterator cur_it = m_curScope.begin(); auto cur_it = m_curScope.begin();
std::list<std::string>::iterator new_it = tokens.begin(); auto new_it = tokens.begin();
while (cur_it != m_curScope.end() && new_it != tokens.end()) { while (cur_it != m_curScope.end() && new_it != tokens.end()) {
if (*cur_it != *new_it) break; if (*cur_it != *new_it) break;
++cur_it; ++cur_it;
@ -171,7 +168,7 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
fstWriterEmitEnumTableRef(m_fst, enumNum); fstWriterEmitEnumTableRef(m_fst, enumNum);
} }
Code2SymbolType::const_iterator it = m_code2symbol.find(code); const auto it = vlstd::as_const(m_code2symbol).find(code);
if (it == m_code2symbol.end()) { // New if (it == m_code2symbol.end()) { // New
m_code2symbol[code] m_code2symbol[code]
= fstWriterCreateVar(m_fst, vartype, vardir, bits, name_str.c_str(), 0); = fstWriterCreateVar(m_fst, vartype, vardir, bits, name_str.c_str(), 0);

27
include/verilated_heavy.h
View File

@ -145,21 +145,21 @@ public:
int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); } int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); }
// Return first element. Verilog: function int first(ref index); // Return first element. Verilog: function int first(ref index);
int first(T_Key& indexr) const { int first(T_Key& indexr) const {
typename Map::const_iterator it = m_map.begin(); const auto it = m_map.cbegin();
if (it == m_map.end()) return 0; if (it == m_map.end()) return 0;
indexr = it->first; indexr = it->first;
return 1; return 1;
} }
// Return last element. Verilog: function int last(ref index) // Return last element. Verilog: function int last(ref index)
int last(T_Key& indexr) const { int last(T_Key& indexr) const {
typename Map::const_reverse_iterator it = m_map.rbegin(); const auto it = m_map.crbegin();
if (it == m_map.rend()) return 0; if (it == m_map.rend()) return 0;
indexr = it->first; indexr = it->first;
return 1; return 1;
} }
// Return next element. Verilog: function int next(ref index) // Return next element. Verilog: function int next(ref index)
int next(T_Key& indexr) const { int next(T_Key& indexr) const {
typename Map::const_iterator it = m_map.find(indexr); auto it = m_map.find(indexr);
if (VL_UNLIKELY(it == m_map.end())) return 0; if (VL_UNLIKELY(it == m_map.end())) return 0;
++it; ++it;
if (VL_UNLIKELY(it == m_map.end())) return 0; if (VL_UNLIKELY(it == m_map.end())) return 0;
@ -168,7 +168,7 @@ public:
} }
// Return prev element. Verilog: function int prev(ref index) // Return prev element. Verilog: function int prev(ref index)
int prev(T_Key& indexr) const { int prev(T_Key& indexr) const {
typename Map::const_iterator it = m_map.find(indexr); auto it = m_map.find(indexr);
if (VL_UNLIKELY(it == m_map.end())) return 0; if (VL_UNLIKELY(it == m_map.end())) return 0;
if (VL_UNLIKELY(it == m_map.begin())) return 0; if (VL_UNLIKELY(it == m_map.begin())) return 0;
--it; --it;
@ -179,7 +179,7 @@ public:
// Can't just overload operator[] or provide a "at" reference to set, // Can't just overload operator[] or provide a "at" reference to set,
// because we need to be able to insert only when the value is set // because we need to be able to insert only when the value is set
T_Value& at(const T_Key& index) { T_Value& at(const T_Key& index) {
typename Map::iterator it = m_map.find(index); const auto it = m_map.find(index);
if (it == m_map.end()) { if (it == m_map.end()) {
std::pair<typename Map::iterator, bool> pit std::pair<typename Map::iterator, bool> pit
= m_map.insert(std::make_pair(index, m_defaultValue)); = m_map.insert(std::make_pair(index, m_defaultValue));
@ -189,7 +189,7 @@ public:
} }
// Accessing. Verilog: v = assoc[index] // Accessing. Verilog: v = assoc[index]
const T_Value& at(const T_Key& index) const { const T_Value& at(const T_Key& index) const {
typename Map::iterator it = m_map.find(index); const auto it = m_map.find(index);
if (it == m_map.end()) { if (it == m_map.end()) {
return m_defaultValue; return m_defaultValue;
} else { } else {
@ -204,8 +204,8 @@ public:
std::string to_string() const { std::string to_string() const {
std::string out = "'{"; std::string out = "'{";
std::string comma; std::string comma;
for (typename Map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { for (const auto& i : m_map) {
out += comma + VL_TO_STRING(it->first) + ":" + VL_TO_STRING(it->second); out += comma + VL_TO_STRING(i.first) + ":" + VL_TO_STRING(i.second);
comma = ", "; comma = ", ";
} }
// Default not printed - maybe random init data // Default not printed - maybe random init data
@ -239,10 +239,9 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE { const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
VlWriteMem wmem(hex, bits, filename, start, end); VlWriteMem wmem(hex, bits, filename, start, end);
if (VL_UNLIKELY(!wmem.isOpen())) return; if (VL_UNLIKELY(!wmem.isOpen())) return;
for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = obj.begin(); it != obj.end(); for (const auto& i : obj) {
++it) { QData addr = i.first;
QData addr = it->first; if (addr >= start && addr <= end) wmem.print(addr, true, &(i.second));
if (addr >= start && addr <= end) wmem.print(addr, true, &(it->second));
} }
} }
@ -361,8 +360,8 @@ public:
std::string to_string() const { std::string to_string() const {
std::string out = "'{"; std::string out = "'{";
std::string comma; std::string comma;
for (typename Deque::const_iterator it = m_deque.begin(); it != m_deque.end(); ++it) { for (const auto& i : m_deque) {
out += comma + VL_TO_STRING(*it); out += comma + VL_TO_STRING(i);
comma = ", "; comma = ", ";
} }
return out + "} "; return out + "} ";

55
include/verilated_imp.h
View File

@ -112,7 +112,7 @@ public:
// Unfortunately to release the lock we need to copy the message // Unfortunately to release the lock we need to copy the message
// (Or have the message be a pointer, but then new/delete cost on each message) // (Or have the message be a pointer, but then new/delete cost on each message)
// We assume messages are small, so copy // We assume messages are small, so copy
auto it = m_queue.begin(); const auto it = m_queue.begin();
const VerilatedMsg msg = *(it); const VerilatedMsg msg = *(it);
m_queue.erase(it); m_queue.erase(it);
m_mutex.unlock(); m_mutex.unlock();
@ -284,9 +284,9 @@ public:
"%Error: Verilog called $test$plusargs or $value$plusargs without" "%Error: Verilog called $test$plusargs or $value$plusargs without"
" testbench C first calling Verilated::commandArgs(argc,argv)."); " testbench C first calling Verilated::commandArgs(argc,argv).");
} }
for (ArgVec::const_iterator it = s_s.m_argVec.begin(); it != s_s.m_argVec.end(); ++it) { for (const auto& i : s_s.m_argVec) {
if ((*it)[0] == '+') { if (i[0] == '+') {
if (0 == strncmp(prefixp, it->c_str() + 1, len)) return *it; if (0 == strncmp(prefixp, i.c_str() + 1, len)) return i;
} }
} }
return ""; return "";
@ -305,7 +305,7 @@ public:
// per map overhead * N scopes would take much more space and cache thrashing. // per map overhead * N scopes would take much more space and cache thrashing.
static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE { static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex); const VerilatedLockGuard lock(s_s.m_userMapMutex);
UserMap::iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey)); const auto it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
if (it != s_s.m_userMap.end()) { if (it != s_s.m_userMap.end()) {
it->second = userData; it->second = userData;
} else { } else {
@ -314,7 +314,7 @@ public:
} }
static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE { static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex); const VerilatedLockGuard lock(s_s.m_userMapMutex);
UserMap::const_iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey)); const auto& it = vlstd::as_const(s_s.m_userMap).find(std::make_pair(scopep, userKey));
if (VL_UNLIKELY(it == s_s.m_userMap.end())) return nullptr; if (VL_UNLIKELY(it == s_s.m_userMap.end())) return nullptr;
return it->second; return it->second;
} }
@ -324,7 +324,7 @@ private:
static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE { static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope on destruction, so we simply iterate. // Slow ok - called once/scope on destruction, so we simply iterate.
const VerilatedLockGuard lock(s_s.m_userMapMutex); const VerilatedLockGuard lock(s_s.m_userMapMutex);
for (UserMap::iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end();) { for (auto it = s_s.m_userMap.begin(); it != s_s.m_userMap.end();) {
if (it->first.first == scopep) { if (it->first.first == scopep) {
s_s.m_userMap.erase(it++); s_s.m_userMap.erase(it++);
} else { } else {
@ -335,13 +335,13 @@ private:
static void userDump() VL_MT_SAFE { static void userDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_userMapMutex); // Avoid it changing in middle of dump const VerilatedLockGuard lock(s_s.m_userMapMutex); // Avoid it changing in middle of dump
bool first = true; bool first = true;
for (UserMap::const_iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end(); ++it) { for (const auto& i : s_s.m_userMap) {
if (first) { if (first) {
VL_PRINTF_MT(" userDump:\n"); VL_PRINTF_MT(" userDump:\n");
first = false; first = false;
} }
VL_PRINTF_MT(" DPI_USER_DATA scope %p key %p: %p\n", it->first.first, VL_PRINTF_MT(" DPI_USER_DATA scope %p key %p: %p\n", i.first.first, i.first.second,
it->first.second, it->second); i.second);
} }
} }
@ -350,7 +350,7 @@ public: // But only for verilated*.cpp
static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE { static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
// Slow ok - called once/scope at construction // Slow ok - called once/scope at construction
const VerilatedLockGuard lock(s_s.m_nameMutex); const VerilatedLockGuard lock(s_s.m_nameMutex);
VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name()); const auto it = s_s.m_nameMap.find(scopep->name());
if (it == s_s.m_nameMap.end()) { if (it == s_s.m_nameMap.end()) {
s_s.m_nameMap.insert(it, std::make_pair(scopep->name(), scopep)); s_s.m_nameMap.insert(it, std::make_pair(scopep->name(), scopep));
} }
@ -358,7 +358,7 @@ public: // But only for verilated*.cpp
static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE { static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_nameMutex); const VerilatedLockGuard lock(s_s.m_nameMutex);
// If too slow, can assume this is only VL_MT_SAFE_POSINIT // If too slow, can assume this is only VL_MT_SAFE_POSINIT
VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.find(namep); const auto& it = s_s.m_nameMap.find(namep);
if (VL_UNLIKELY(it == s_s.m_nameMap.end())) return nullptr; if (VL_UNLIKELY(it == s_s.m_nameMap.end())) return nullptr;
return it->second; return it->second;
} }
@ -366,15 +366,14 @@ public: // But only for verilated*.cpp
// Slow ok - called once/scope at destruction // Slow ok - called once/scope at destruction
const VerilatedLockGuard lock(s_s.m_nameMutex); const VerilatedLockGuard lock(s_s.m_nameMutex);
userEraseScope(scopep); userEraseScope(scopep);
VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name()); const auto it = s_s.m_nameMap.find(scopep->name());
if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it); if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
} }
static void scopesDump() VL_MT_SAFE { static void scopesDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_nameMutex); const VerilatedLockGuard lock(s_s.m_nameMutex);
VL_PRINTF_MT(" scopesDump:\n"); VL_PRINTF_MT(" scopesDump:\n");
for (VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.begin(); for (const auto& i : s_s.m_nameMap) {
it != s_s.m_nameMap.end(); ++it) { const VerilatedScope* scopep = i.second;
const VerilatedScope* scopep = it->second;
scopep->scopeDump(); scopep->scopeDump();
} }
VL_PRINTF_MT("\n"); VL_PRINTF_MT("\n");
@ -408,7 +407,7 @@ public: // But only for verilated*.cpp
static int exportInsert(const char* namep) VL_MT_SAFE { static int exportInsert(const char* namep) VL_MT_SAFE {
// Slow ok - called once/function at creation // Slow ok - called once/function at creation
const VerilatedLockGuard lock(s_s.m_exportMutex); const VerilatedLockGuard lock(s_s.m_exportMutex);
ExportNameMap::iterator it = s_s.m_exportMap.find(namep); const auto it = s_s.m_exportMap.find(namep);
if (it == s_s.m_exportMap.end()) { if (it == s_s.m_exportMap.end()) {
s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++)); s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++));
return s_s.m_exportNext++; return s_s.m_exportNext++;
@ -418,7 +417,7 @@ public: // But only for verilated*.cpp
} }
static int exportFind(const char* namep) VL_MT_SAFE { static int exportFind(const char* namep) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_exportMutex); const VerilatedLockGuard lock(s_s.m_exportMutex);
ExportNameMap::const_iterator it = s_s.m_exportMap.find(namep); const auto& it = s_s.m_exportMap.find(namep);
if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second; if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
std::string msg = (std::string("%Error: Testbench C called ") + namep std::string msg = (std::string("%Error: Testbench C called ") + namep
+ " but no such DPI export function name exists in ANY model"); + " but no such DPI export function name exists in ANY model");
@ -428,22 +427,20 @@ public: // But only for verilated*.cpp
static const char* exportName(int funcnum) VL_MT_SAFE { static const char* exportName(int funcnum) VL_MT_SAFE {
// Slowpath; find name for given export; errors only so no map to reverse-map it // Slowpath; find name for given export; errors only so no map to reverse-map it
const VerilatedLockGuard lock(s_s.m_exportMutex); const VerilatedLockGuard lock(s_s.m_exportMutex);
for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin(); for (const auto& i : s_s.m_exportMap) {
it != s_s.m_exportMap.end(); ++it) { if (i.second == funcnum) return i.first;
if (it->second == funcnum) return it->first;
} }
return "*UNKNOWN*"; return "*UNKNOWN*";
} }
static void exportsDump() VL_MT_SAFE { static void exportsDump() VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_exportMutex); const VerilatedLockGuard lock(s_s.m_exportMutex);
bool first = true; bool first = true;
for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin(); for (const auto& i : s_s.m_exportMap) {
it != s_s.m_exportMap.end(); ++it) {
if (first) { if (first) {
VL_PRINTF_MT(" exportDump:\n"); VL_PRINTF_MT(" exportDump:\n");
first = false; first = false;
} }
VL_PRINTF_MT(" DPI_EXPORT_NAME %05d: %s\n", it->second, it->first); VL_PRINTF_MT(" DPI_EXPORT_NAME %05d: %s\n", i.second, i.first);
} }
} }
// We don't free up m_exportMap until the end, because we can't be sure // We don't free up m_exportMap until the end, because we can't be sure
@ -500,9 +497,7 @@ public: // But only for verilated*.cpp
static void fdFlush(IData fdi) VL_MT_SAFE { static void fdFlush(IData fdi) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex); const VerilatedLockGuard lock(s_s.m_fdMutex);
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) { for (const auto& i : fdlist) fflush(i);
fflush(*it);
}
} }
static IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE { static IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex); const VerilatedLockGuard lock(s_s.m_fdMutex);
@ -520,9 +515,9 @@ public: // But only for verilated*.cpp
static void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE { static void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE {
const VerilatedLockGuard lock(s_s.m_fdMutex); const VerilatedLockGuard lock(s_s.m_fdMutex);
const VerilatedFpList fdlist = fdToFpList(fdi); const VerilatedFpList fdlist = fdToFpList(fdi);
for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) { for (const auto& i : fdlist) {
if (VL_UNLIKELY(!*it)) continue; if (VL_UNLIKELY(!i)) continue;
fwrite(output.c_str(), 1, output.size(), *it); fwrite(output.c_str(), 1, output.size(), i);
} }
} }
static void fdClose(IData fdi) VL_MT_SAFE { static void fdClose(IData fdi) VL_MT_SAFE {

7
include/verilated_save.h
View File

@ -252,10 +252,9 @@ VerilatedSerialize& operator<<(VerilatedSerialize& os, VlAssocArray<T_Key, T_Val
os << rhs.atDefault(); os << rhs.atDefault();
vluint32_t len = rhs.size(); vluint32_t len = rhs.size();
os << len; os << len;
for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = rhs.begin(); it != rhs.end(); for (const auto& i : rhs) {
++it) { T_Key index = i.first; // Copy to get around const_iterator
T_Key index = it->first; // Copy to get around const_iterator T_Value value = i.second;
T_Value value = it->second;
os << index << value; os << index << value;
} }
return os; return os;

16
include/verilated_threads.cpp
View File

@ -125,9 +125,9 @@ void VlThreadPool::setupProfilingClientThread() {
void VlThreadPool::profileAppendAll(const VlProfileRec& rec) { void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
const VerilatedLockGuard lk(m_mutex); const VerilatedLockGuard lk(m_mutex);
for (ProfileSet::iterator it = m_allProfiles.begin(); it != m_allProfiles.end(); ++it) { for (const auto& profilep : m_allProfiles) {
// Every thread's profile trace gets a copy of rec. // Every thread's profile trace gets a copy of rec.
(*it)->emplace_back(rec); profilep->emplace_back(rec);
} }
} }
@ -152,13 +152,12 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n", VlMTaskVertex::yields()); fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n", VlMTaskVertex::yields());
vluint32_t thread_id = 0; vluint32_t thread_id = 0;
for (ProfileSet::const_iterator pit = m_allProfiles.begin(); pit != m_allProfiles.end(); for (const auto& pi : m_allProfiles) {
++pit) {
++thread_id; ++thread_id;
bool printing = false; // False while in warmup phase bool printing = false; // False while in warmup phase
for (ProfileTrace::const_iterator eit = (*pit)->begin(); eit != (*pit)->end(); ++eit) { for (const auto& ei : *pi) {
switch (eit->m_type) { switch (ei.m_type) {
case VlProfileRec::TYPE_BARRIER: // case VlProfileRec::TYPE_BARRIER: //
printing = true; printing = true;
break; break;
@ -168,9 +167,8 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
"VLPROF mtask %d" "VLPROF mtask %d"
" start %" VL_PRI64 "u end %" VL_PRI64 "u elapsed %" VL_PRI64 "u" " start %" VL_PRI64 "u end %" VL_PRI64 "u elapsed %" VL_PRI64 "u"
" predict_time %u cpu %u on thread %u\n", " predict_time %u cpu %u on thread %u\n",
eit->m_mtaskId, eit->m_startTime, eit->m_endTime, ei.m_mtaskId, ei.m_startTime, ei.m_endTime,
(eit->m_endTime - eit->m_startTime), eit->m_predictTime, eit->m_cpu, (ei.m_endTime - ei.m_startTime), ei.m_predictTime, ei.m_cpu, thread_id);
thread_id);
break; break;
default: assert(false); break; // LCOV_EXCL_LINE default: assert(false); break; // LCOV_EXCL_LINE
} }

16
include/verilated_vcd_c.cpp
View File

@ -185,15 +185,15 @@ void VerilatedVcd::makeNameMap() {
// If no scope was specified, prefix everything with a "top" // If no scope was specified, prefix everything with a "top"
// This comes from user instantiations with no name - IE Vtop(""). // This comes from user instantiations with no name - IE Vtop("").
bool nullScope = false; bool nullScope = false;
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) { for (const auto& i : *m_namemapp) {
const std::string& hiername = it->first; const std::string& hiername = i.first;
if (!hiername.empty() && hiername[0] == '\t') nullScope = true; if (!hiername.empty() && hiername[0] == '\t') nullScope = true;
} }
if (nullScope) { if (nullScope) {
NameMap* newmapp = new NameMap; NameMap* newmapp = new NameMap;
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) { for (const auto& i : *m_namemapp) {
const std::string& hiername = it->first; const std::string& hiername = i.first;
const std::string& decl = it->second; const std::string& decl = i.second;
std::string newname = std::string("top"); std::string newname = std::string("top");
if (hiername[0] != '\t') newname += ' '; if (hiername[0] != '\t') newname += ' ';
newname += hiername; newname += hiername;
@ -367,9 +367,9 @@ void VerilatedVcd::dumpHeader() {
// Print the signal names // Print the signal names
const char* lastName = ""; const char* lastName = "";
for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) { for (const auto& i : *m_namemapp) {
const std::string& hiernamestr = it->first; const std::string& hiernamestr = i.first;
const std::string& decl = it->second; const std::string& decl = i.second;
// Determine difference between the old and new names // Determine difference between the old and new names
const char* hiername = hiernamestr.c_str(); const char* hiername = hiernamestr.c_str();

26
include/verilated_vpi.cpp
View File

@ -445,21 +445,21 @@ public:
VpioCbList& cbObjList = s_s.m_cbObjLists[cbp->reason()]; VpioCbList& cbObjList = s_s.m_cbObjLists[cbp->reason()];
// We do not remove it now as we may be iterating the list, // We do not remove it now as we may be iterating the list,
// instead set to nullptr and will cleanup later // instead set to nullptr and will cleanup later
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end(); ++it) { for (auto& ir : cbObjList) {
if (*it == cbp) *it = nullptr; if (ir == cbp) ir = nullptr;
} }
} }
static void cbTimedRemove(VerilatedVpioCb* cbp) { static void cbTimedRemove(VerilatedVpioCb* cbp) {
VpioTimedCbs::iterator it = s_s.m_timedCbs.find(std::make_pair(cbp->time(), cbp)); const auto it = s_s.m_timedCbs.find(std::make_pair(cbp->time(), cbp));
if (VL_LIKELY(it != s_s.m_timedCbs.end())) { s_s.m_timedCbs.erase(it); } if (VL_LIKELY(it != s_s.m_timedCbs.end())) s_s.m_timedCbs.erase(it);
} }
static void callTimedCbs() VL_MT_UNSAFE_ONE { static void callTimedCbs() VL_MT_UNSAFE_ONE {
assertOneCheck(); assertOneCheck();
QData time = VL_TIME_Q(); QData time = VL_TIME_Q();
for (VpioTimedCbs::iterator it = s_s.m_timedCbs.begin(); it != s_s.m_timedCbs.end();) { for (auto it = s_s.m_timedCbs.begin(); it != s_s.m_timedCbs.end();) {
if (VL_UNLIKELY(it->first <= time)) { if (VL_UNLIKELY(it->first <= time)) {
VerilatedVpioCb* vop = it->second; VerilatedVpioCb* vop = it->second;
VpioTimedCbs::iterator last_it = it; const auto last_it = it;
++it; // Timed callbacks are one-shot ++it; // Timed callbacks are one-shot
s_s.m_timedCbs.erase(last_it); s_s.m_timedCbs.erase(last_it);
VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: timed_callback %p\n", vop);); VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: timed_callback %p\n", vop););
@ -470,14 +470,14 @@ public:
} }
} }
static QData cbNextDeadline() { static QData cbNextDeadline() {
VpioTimedCbs::const_iterator it = s_s.m_timedCbs.begin(); const auto it = s_s.m_timedCbs.cbegin();
if (VL_LIKELY(it != s_s.m_timedCbs.end())) return it->first; if (VL_LIKELY(it != s_s.m_timedCbs.cend())) return it->first;
return ~0ULL; // maxquad return ~0ULL; // maxquad
} }
static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE { static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE {
VpioCbList& cbObjList = s_s.m_cbObjLists[reason]; VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
bool called = false; bool called = false;
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end();) { for (auto it = cbObjList.begin(); it != cbObjList.end();) {
if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
it = cbObjList.erase(it); it = cbObjList.erase(it);
continue; continue;
@ -494,7 +494,7 @@ public:
VpioCbList& cbObjList = s_s.m_cbObjLists[cbValueChange]; VpioCbList& cbObjList = s_s.m_cbObjLists[cbValueChange];
typedef std::set<VerilatedVpioVar*> VpioVarSet; typedef std::set<VerilatedVpioVar*> VpioVarSet;
VpioVarSet update; // set of objects to update after callbacks VpioVarSet update; // set of objects to update after callbacks
for (VpioCbList::iterator it = cbObjList.begin(); it != cbObjList.end();) { for (auto it = cbObjList.begin(); it != cbObjList.end();) {
if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
it = cbObjList.erase(it); it = cbObjList.erase(it);
continue; continue;
@ -515,9 +515,7 @@ public:
} }
} }
} }
for (VpioVarSet::const_iterator it = update.begin(); it != update.end(); ++it) { for (const auto& ip : update) { memcpy(ip->prevDatap(), ip->varDatap(), ip->entSize()); }
memcpy((*it)->prevDatap(), (*it)->varDatap(), (*it)->entSize());
}
} }
static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE; // getter for vpi error info static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE; // getter for vpi error info
@ -1253,7 +1251,7 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
VerilatedVpioModule* vop = VerilatedVpioModule::castp(object); VerilatedVpioModule* vop = VerilatedVpioModule::castp(object);
const VerilatedHierarchyMap* map = VerilatedImp::hierarchyMap(); const VerilatedHierarchyMap* map = VerilatedImp::hierarchyMap();
const VerilatedScope* mod = vop ? vop->scopep() : nullptr; const VerilatedScope* mod = vop ? vop->scopep() : nullptr;
VerilatedHierarchyMap::const_iterator it = map->find(const_cast<VerilatedScope*>(mod)); const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(mod));
if (it == map->end()) return 0; if (it == map->end()) return 0;
return ((new VerilatedVpioModuleIter(it->second))->castVpiHandle()); return ((new VerilatedVpioModuleIter(it->second))->castVpiHandle());
} }

8
include/verilatedos.h
View File

@ -488,6 +488,14 @@ typedef unsigned long long vluint64_t; ///< 64-bit unsigned type
#define VL_STRINGIFY(x) VL_STRINGIFY2(x) #define VL_STRINGIFY(x) VL_STRINGIFY2(x)
#define VL_STRINGIFY2(x) #x #define VL_STRINGIFY2(x) #x
//=========================================================================
// Conversions
namespace vlstd {
// C++17's std::as_const
template <class T> T const& as_const(T& v) { return v; }
}; // namespace vlstd
//========================================================================= //=========================================================================
#endif // Guard #endif // Guard

2
src/V3Active.cpp
View File

@ -109,7 +109,7 @@ public:
AstActive* activep = nullptr; AstActive* activep = nullptr;
AstSenTree* activeSenp = m_activeSens.find(sensesp); AstSenTree* activeSenp = m_activeSens.find(sensesp);
if (activeSenp) { if (activeSenp) {
ActiveMap::iterator it = m_activeMap.find(activeSenp); const auto it = m_activeMap.find(activeSenp);
UASSERT(it != m_activeMap.end(), "Corrupt active map"); UASSERT(it != m_activeMap.end(), "Corrupt active map");
activep = it->second; activep = it->second;
} }

4
src/V3Ast.cpp
View File

@ -1267,8 +1267,6 @@ AstNodeDType* AstNode::findVoidDType() const {
// AstNVisitor // AstNVisitor
void AstNVisitor::doDeletes() { void AstNVisitor::doDeletes() {
for (std::vector<AstNode*>::iterator it = m_deleteps.begin(); it != m_deleteps.end(); ++it) { for (AstNode* nodep : m_deleteps) nodep->deleteTree();
(*it)->deleteTree();
}
m_deleteps.clear(); m_deleteps.clear();
} }

2
src/V3Ast.h
View File

@ -2464,7 +2464,7 @@ public:
void clearCache() { m_members.clear(); } void clearCache() { m_members.clear(); }
void repairMemberCache(); void repairMemberCache();
AstMemberDType* findMember(const string& name) const { AstMemberDType* findMember(const string& name) const {
MemberNameMap::const_iterator it = m_members.find(name); const auto it = m_members.find(name);
return (it == m_members.end()) ? nullptr : it->second; return (it == m_members.end()) ? nullptr : it->second;
} }
static int lsb() { return 0; } static int lsb() { return 0; }

6
src/V3AstNodes.cpp
View File

@ -481,9 +481,9 @@ string AstVar::vlPropDecl(string propName) const {
out += "static const int " + propName + "__ulims["; out += "static const int " + propName + "__ulims[";
out += cvtToStr(ulims.size()); out += cvtToStr(ulims.size());
out += "] = {"; out += "] = {";
std::vector<int>::const_iterator it = ulims.begin(); auto it = ulims.cbegin();
out += cvtToStr(*it); out += cvtToStr(*it);
while (++it != ulims.end()) { while (++it != ulims.cend()) {
out += ", "; out += ", ";
out += cvtToStr(*it); out += cvtToStr(*it);
} }
@ -920,7 +920,7 @@ AstBasicDType* AstTypeTable::findInsertSameDType(AstBasicDType* nodep) {
VBasicTypeKey key(nodep->width(), nodep->widthMin(), nodep->numeric(), nodep->keyword(), VBasicTypeKey key(nodep->width(), nodep->widthMin(), nodep->numeric(), nodep->keyword(),
nodep->nrange()); nodep->nrange());
DetailedMap& mapr = m_detailedMap; DetailedMap& mapr = m_detailedMap;
DetailedMap::const_iterator it = mapr.find(key); const auto it = mapr.find(key);
if (it != mapr.end()) return it->second; if (it != mapr.end()) return it->second;
mapr.insert(make_pair(key, nodep)); mapr.insert(make_pair(key, nodep));
nodep->generic(true); nodep->generic(true);

6
src/V3AstNodes.h
View File

@ -333,7 +333,7 @@ public:
void clearCache() { m_members.clear(); } void clearCache() { m_members.clear(); }
void repairCache(); void repairCache();
AstNode* findMember(const string& name) const { AstNode* findMember(const string& name) const {
MemberNameMap::const_iterator it = m_members.find(name); const auto it = m_members.find(name);
return (it == m_members.end()) ? nullptr : it->second; return (it == m_members.end()) ? nullptr : it->second;
} }
bool isVirtual() const { return m_virtual; } bool isVirtual() const { return m_virtual; }
@ -4728,7 +4728,7 @@ public:
AstNode* addIndexValuep(uint32_t index, AstNode* newp) { AstNode* addIndexValuep(uint32_t index, AstNode* newp) {
// Returns old value, caller must garbage collect // Returns old value, caller must garbage collect
AstNode* oldp = nullptr; AstNode* oldp = nullptr;
KeyItemMap::iterator it = m_map.find(index); const auto it = m_map.find(index);
if (it != m_map.end()) { if (it != m_map.end()) {
oldp = it->second->valuep(); oldp = it->second->valuep();
it->second->valuep(newp); it->second->valuep(newp);
@ -4740,7 +4740,7 @@ public:
return oldp; return oldp;
} }
AstNode* getIndexValuep(uint32_t index) const { AstNode* getIndexValuep(uint32_t index) const {
KeyItemMap::const_iterator it = m_map.find(index); const auto it = m_map.find(index);
if (it == m_map.end()) { if (it == m_map.end()) {
return nullptr; return nullptr;
} else { } else {

3
src/V3Branch.cpp
View File

@ -108,8 +108,7 @@ private:
// METHODS // METHODS
void calc_tasks() { void calc_tasks() {
for (CFuncVec::iterator it = m_cfuncsp.begin(); it != m_cfuncsp.end(); ++it) { for (AstCFunc* nodep : m_cfuncsp) {
AstCFunc* nodep = *it;
if (!nodep->dontInline()) nodep->isInline(true); if (!nodep->dontInline()) nodep->isInline(true);
} }
} }

16
src/V3Broken.cpp
View File

@ -54,7 +54,7 @@ public:
static void deleted(const AstNode* nodep) { static void deleted(const AstNode* nodep) {
// Called by operator delete on any node - only if VL_LEAK_CHECKS // Called by operator delete on any node - only if VL_LEAK_CHECKS
if (debug() >= 9) cout << "-nodeDel: " << cvtToHex(nodep) << endl; if (debug() >= 9) cout << "-nodeDel: " << cvtToHex(nodep) << endl;
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
UASSERT_OBJ(!(iter == s_nodes.end() || !(iter->second & FLAG_ALLOCATED)), UASSERT_OBJ(!(iter == s_nodes.end() || !(iter->second & FLAG_ALLOCATED)),
reinterpret_cast<const AstNode*>(nodep), reinterpret_cast<const AstNode*>(nodep),
"Deleting AstNode object that was never tracked or already deleted"); "Deleting AstNode object that was never tracked or already deleted");
@ -67,7 +67,7 @@ public:
static void addNewed(const AstNode* nodep) { static void addNewed(const AstNode* nodep) {
// Called by operator new on any node - only if VL_LEAK_CHECKS // Called by operator new on any node - only if VL_LEAK_CHECKS
if (debug() >= 9) cout << "-nodeNew: " << cvtToHex(nodep) << endl; if (debug() >= 9) cout << "-nodeNew: " << cvtToHex(nodep) << endl;
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
UASSERT_OBJ(!(iter != s_nodes.end() && (iter->second & FLAG_ALLOCATED)), nodep, UASSERT_OBJ(!(iter != s_nodes.end() && (iter->second & FLAG_ALLOCATED)), nodep,
"Newing AstNode object that is already allocated"); "Newing AstNode object that is already allocated");
if (iter == s_nodes.end()) { if (iter == s_nodes.end()) {
@ -78,7 +78,7 @@ public:
static void setUnder(const AstNode* nodep, bool flag) { static void setUnder(const AstNode* nodep, bool flag) {
// Called by BrokenCheckVisitor when each node entered/exited // Called by BrokenCheckVisitor when each node entered/exited
if (!okIfLinkedTo(nodep)) return; if (!okIfLinkedTo(nodep)) return;
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (iter != s_nodes.end()) { if (iter != s_nodes.end()) {
iter->second &= ~FLAG_UNDER_NOW; iter->second &= ~FLAG_UNDER_NOW;
if (flag) iter->second |= FLAG_UNDER_NOW; if (flag) iter->second |= FLAG_UNDER_NOW;
@ -89,7 +89,7 @@ public:
// cppcheck-suppress knownConditionTrueFalse // cppcheck-suppress knownConditionTrueFalse
if (!linkable) return; // save some time, else the map will get huge! if (!linkable) return; // save some time, else the map will get huge!
#endif #endif
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (VL_UNCOVERABLE(iter == s_nodes.end())) { if (VL_UNCOVERABLE(iter == s_nodes.end())) {
#ifdef VL_LEAK_CHECKS #ifdef VL_LEAK_CHECKS
nodep->v3fatalSrc("AstNode is in tree, but not allocated"); nodep->v3fatalSrc("AstNode is in tree, but not allocated");
@ -113,7 +113,7 @@ public:
// Some generic node has a pointer to this node. Is it allocated? // Some generic node has a pointer to this node. Is it allocated?
// Use this when might not be in tree; otherwise use okIfLinkedTo(). // Use this when might not be in tree; otherwise use okIfLinkedTo().
#ifdef VL_LEAK_CHECKS #ifdef VL_LEAK_CHECKS
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false; if (iter == s_nodes.end()) return false;
if (!(iter->second & FLAG_ALLOCATED)) return false; if (!(iter->second & FLAG_ALLOCATED)) return false;
#endif #endif
@ -121,7 +121,7 @@ public:
} }
static bool okIfLinkedTo(const AstNode* nodep) { static bool okIfLinkedTo(const AstNode* nodep) {
// Some node in tree has a pointer to this node. Is it kosher? // Some node in tree has a pointer to this node. Is it kosher?
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false; if (iter == s_nodes.end()) return false;
#ifdef VL_LEAK_CHECKS #ifdef VL_LEAK_CHECKS
if (!(iter->second & FLAG_ALLOCATED)) return false; if (!(iter->second & FLAG_ALLOCATED)) return false;
@ -133,7 +133,7 @@ public:
static bool okIfAbove(const AstNode* nodep) { static bool okIfAbove(const AstNode* nodep) {
// Must be linked to and below current node // Must be linked to and below current node
if (!okIfLinkedTo(nodep)) return false; if (!okIfLinkedTo(nodep)) return false;
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false; if (iter == s_nodes.end()) return false;
if ((iter->second & FLAG_UNDER_NOW)) return false; if ((iter->second & FLAG_UNDER_NOW)) return false;
return true; return true;
@ -141,7 +141,7 @@ public:
static bool okIfBelow(const AstNode* nodep) { static bool okIfBelow(const AstNode* nodep) {
// Must be linked to and below current node // Must be linked to and below current node
if (!okIfLinkedTo(nodep)) return false; if (!okIfLinkedTo(nodep)) return false;
NodeMap::iterator iter = s_nodes.find(nodep); const auto iter = s_nodes.find(nodep);
if (iter == s_nodes.end()) return false; if (iter == s_nodes.end()) return false;
if (!(iter->second & FLAG_UNDER_NOW)) return false; if (!(iter->second & FLAG_UNDER_NOW)) return false;
return true; return true;

4
src/V3Cdc.cpp
View File

@ -543,9 +543,7 @@ private:
} }
} }
stable_sort(report.begin(), report.end()); stable_sort(report.begin(), report.end());
for (std::deque<string>::iterator it = report.begin(); it != report.end(); ++it) { for (const auto& line : report) *ofp << line;
*ofp << *it;
}
} }
void edgeDomainRecurse(CdcEitherVertex* vertexp, bool traceDests, int level) { void edgeDomainRecurse(CdcEitherVertex* vertexp, bool traceDests, int level) {

4
src/V3Combine.cpp
View File

@ -108,8 +108,8 @@ public:
void deleteCall(AstCCall* nodep) { void deleteCall(AstCCall* nodep) {
std::pair<CallMmap::iterator, CallMmap::iterator> eqrange std::pair<CallMmap::iterator, CallMmap::iterator> eqrange
= m_callMmap.equal_range(nodep->funcp()); = m_callMmap.equal_range(nodep->funcp());
for (CallMmap::iterator nextit = eqrange.first; nextit != eqrange.second;) { for (auto nextit = eqrange.first; nextit != eqrange.second;) {
CallMmap::iterator eqit = nextit++; const auto eqit = nextit++;
AstCCall* callp = eqit->second; AstCCall* callp = eqit->second;
if (callp == nodep) { if (callp == nodep) {
m_callMmap.erase(eqit); m_callMmap.erase(eqit);

2
src/V3Config.cpp
View File

@ -60,7 +60,7 @@ public:
// Access an entity and resolve wildcards that match it // Access an entity and resolve wildcards that match it
T* resolve(const string& name) { T* resolve(const string& name) {
// Lookup if it was resolved before, typically not // Lookup if it was resolved before, typically not
typename Map::iterator it = m_mapResolved.find(name); auto it = m_mapResolved.find(name);
if (VL_UNLIKELY(it != m_mapResolved.end())) { return &it->second; } if (VL_UNLIKELY(it != m_mapResolved.end())) { return &it->second; }
T* newp = nullptr; T* newp = nullptr;

10
src/V3Const.cpp
View File

@ -1788,14 +1788,8 @@ private:
vec.push_back(senp); vec.push_back(senp);
} }
stable_sort(vec.begin(), vec.end(), SenItemCmp()); stable_sort(vec.begin(), vec.end(), SenItemCmp());
for (std::vector<AstSenItem*>::iterator it = vec.begin(); it != vec.end(); for (const auto& ip : vec) ip->unlinkFrBack();
++it) { for (const auto& ip : vec) nodep->addSensesp(ip);
(*it)->unlinkFrBack();
}
for (std::vector<AstSenItem*>::iterator it = vec.begin(); it != vec.end();
++it) {
nodep->addSensesp(*it);
}
break; break;
} }
} }

2
src/V3Coverage.cpp
View File

@ -140,7 +140,7 @@ private:
string traceNameForLine(AstNode* nodep, const string& type) { string traceNameForLine(AstNode* nodep, const string& type) {
string name = "vlCoverageLineTrace_" + nodep->fileline()->filebasenameNoExt() + "__" string name = "vlCoverageLineTrace_" + nodep->fileline()->filebasenameNoExt() + "__"
+ cvtToStr(nodep->fileline()->lineno()) + "_" + type; + cvtToStr(nodep->fileline()->lineno()) + "_" + type;
VarNameMap::iterator it = m_varnames.find(name); const auto it = m_varnames.find(name);
if (it == m_varnames.end()) { if (it == m_varnames.end()) {
m_varnames.insert(make_pair(name, 1)); m_varnames.insert(make_pair(name, 1));
} else { } else {

10
src/V3CoverageJoin.cpp
View File

@ -54,20 +54,16 @@ private:
// Note uses user4 // Note uses user4
V3Hashed hashed; // Duplicate code detection V3Hashed hashed; // Duplicate code detection
// Hash all of the original signals we toggle cover // Hash all of the original signals we toggle cover
for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) { for (AstCoverToggle* nodep : m_toggleps) hashed.hashAndInsert(nodep->origp());
AstCoverToggle* nodep = *it;
hashed.hashAndInsert(nodep->origp());
}
// Find if there are any duplicates // Find if there are any duplicates
for (ToggleList::iterator it = m_toggleps.begin(); it != m_toggleps.end(); ++it) { for (AstCoverToggle* nodep : m_toggleps) {
AstCoverToggle* nodep = *it;
// nodep->backp() is null if we already detected it's a duplicate and unlinked it. // nodep->backp() is null if we already detected it's a duplicate and unlinked it.
if (nodep->backp()) { if (nodep->backp()) {
// Want to choose a base node, and keep finding duplicates that are identical. // Want to choose a base node, and keep finding duplicates that are identical.
// This prevents making chains where a->b, then c->d, then b->c, as we'll // This prevents making chains where a->b, then c->d, then b->c, as we'll
// find a->b, a->c, a->d directly. // find a->b, a->c, a->d directly.
while (true) { while (true) {
V3Hashed::iterator dupit = hashed.findDuplicate(nodep->origp()); const auto dupit = hashed.findDuplicate(nodep->origp());
if (dupit == hashed.end()) break; if (dupit == hashed.end()) break;
// //
AstNode* duporigp = hashed.iteratorNodep(dupit); AstNode* duporigp = hashed.iteratorNodep(dupit);

6
src/V3Dead.cpp
View File

@ -358,8 +358,7 @@ private:
} }
void deadCheckCells() { void deadCheckCells() {
for (std::vector<AstCell*>::iterator it = m_cellsp.begin(); it != m_cellsp.end(); ++it) { for (AstCell* cellp : m_cellsp) {
AstCell* cellp = *it;
if (cellp->user1() == 0 && !cellp->modp()->stmtsp()) { if (cellp->user1() == 0 && !cellp->modp()->stmtsp()) {
cellp->modp()->user1Inc(-1); cellp->modp()->user1Inc(-1);
VL_DO_DANGLING(cellp->unlinkFrBack()->deleteTree(), cellp); VL_DO_DANGLING(cellp->unlinkFrBack()->deleteTree(), cellp);
@ -386,8 +385,7 @@ private:
void deadCheckVar() { void deadCheckVar() {
// Delete any unused varscopes // Delete any unused varscopes
for (std::vector<AstVarScope*>::iterator it = m_vscsp.begin(); it != m_vscsp.end(); ++it) { for (AstVarScope* vscp : m_vscsp) {
AstVarScope* vscp = *it;
if (vscp->user1() == 0) { if (vscp->user1() == 0) {
UINFO(4, " Dead " << vscp << endl); UINFO(4, " Dead " << vscp << endl);
std::pair<AssignMap::iterator, AssignMap::iterator> eqrange std::pair<AssignMap::iterator, AssignMap::iterator> eqrange

2
src/V3Delayed.cpp
View File

@ -120,7 +120,7 @@ private:
AstVar* varp; AstVar* varp;
AstNodeModule* addmodp = oldvarscp->scopep()->modp(); AstNodeModule* addmodp = oldvarscp->scopep()->modp();
// We need a new AstVar, but only one for all scopes, to match the new AstVarScope // We need a new AstVar, but only one for all scopes, to match the new AstVarScope
VarMap::iterator it = m_modVarMap.find(make_pair(addmodp, name)); const auto it = m_modVarMap.find(make_pair(addmodp, name));
if (it != m_modVarMap.end()) { if (it != m_modVarMap.end()) {
// Created module's AstVar earlier under some other scope // Created module's AstVar earlier under some other scope
varp = it->second; varp = it->second;

4
src/V3Descope.cpp
View File

@ -148,7 +148,7 @@ private:
for (FuncMmap::iterator it = m_modFuncs.begin(); it != m_modFuncs.end(); ++it) { for (FuncMmap::iterator it = m_modFuncs.begin(); it != m_modFuncs.end(); ++it) {
string name = it->first; string name = it->first;
AstCFunc* topFuncp = it->second; AstCFunc* topFuncp = it->second;
FuncMmap::iterator nextIt1 = it; auto nextIt1 = it;
++nextIt1; ++nextIt1;
bool moreOfSame1 = (nextIt1 != m_modFuncs.end() && nextIt1->first == name); bool moreOfSame1 = (nextIt1 != m_modFuncs.end() && nextIt1->first == name);
if (moreOfSame1) { if (moreOfSame1) {
@ -171,7 +171,7 @@ private:
eachIt != m_modFuncs.end() && eachIt->first == name; ++eachIt) { eachIt != m_modFuncs.end() && eachIt->first == name; ++eachIt) {
it = eachIt; it = eachIt;
AstCFunc* funcp = eachIt->second; AstCFunc* funcp = eachIt->second;
FuncMmap::iterator nextIt2 = eachIt; auto nextIt2 = eachIt;
++nextIt2; ++nextIt2;
bool moreOfSame = (nextIt2 != m_modFuncs.end() && nextIt2->first == name); bool moreOfSame = (nextIt2 != m_modFuncs.end() && nextIt2->first == name);
UASSERT_OBJ(funcp->scopep(), funcp, "Not scoped"); UASSERT_OBJ(funcp->scopep(), funcp, "Not scoped");

16
src/V3EmitC.cpp
View File

@ -226,8 +226,7 @@ public:
stable_sort(funcsp.begin(), funcsp.end(), CmpName()); stable_sort(funcsp.begin(), funcsp.end(), CmpName());
for (FuncVec::iterator it = funcsp.begin(); it != funcsp.end(); ++it) { for (const AstCFunc* funcp : funcsp) {
const AstCFunc* funcp = *it;
ofp()->putsPrivate(funcp->declPrivate()); ofp()->putsPrivate(funcp->declPrivate());
if (!funcp->ifdef().empty()) puts("#ifdef " + funcp->ifdef() + "\n"); if (!funcp->ifdef().empty()) puts("#ifdef " + funcp->ifdef() + "\n");
if (funcp->isStatic().trueUnknown()) puts("static "); if (funcp->isStatic().trueUnknown()) puts("static ");
@ -1528,9 +1527,7 @@ class EmitCImp : EmitCStmts {
puts("QData __req = false; // Logically a bool\n"); // But not because it results in puts("QData __req = false; // Logically a bool\n"); // But not because it results in
// faster code // faster code
bool gotOne = false; bool gotOne = false;
for (std::vector<AstChangeDet*>::iterator it = m_blkChangeDetVec.begin(); for (AstChangeDet* changep : m_blkChangeDetVec) {
it != m_blkChangeDetVec.end(); ++it) {
AstChangeDet* changep = *it;
if (changep->lhsp()) { if (changep->lhsp()) {
if (!gotOne) { // Not a clocked block if (!gotOne) { // Not a clocked block
puts("__req |= ("); puts("__req |= (");
@ -1543,9 +1540,7 @@ class EmitCImp : EmitCStmts {
if (gotOne) puts(");\n"); if (gotOne) puts(");\n");
if (gotOne && !v3Global.opt.protectIds()) { if (gotOne && !v3Global.opt.protectIds()) {
// puts("VL_DEBUG_IF( if (__req) cout<<\"- CLOCKREQ );"); // puts("VL_DEBUG_IF( if (__req) cout<<\"- CLOCKREQ );");
for (std::vector<AstChangeDet*>::iterator it = m_blkChangeDetVec.begin(); for (AstChangeDet* nodep : m_blkChangeDetVec) {
it != m_blkChangeDetVec.end(); ++it) {
AstChangeDet* nodep = *it;
if (nodep->lhsp()) { if (nodep->lhsp()) {
puts("VL_DEBUG_IF( if(__req && ("); puts("VL_DEBUG_IF( if(__req && (");
bool gotOneIgnore = false; bool gotOneIgnore = false;
@ -1854,8 +1849,7 @@ void EmitCStmts::emitVarCtors(bool* firstp) {
ofp()->indentInc(); ofp()->indentInc();
puts("\n"); puts("\n");
puts("#if (SYSTEMC_VERSION>20011000)\n"); // SystemC 2.0.1 and newer puts("#if (SYSTEMC_VERSION>20011000)\n"); // SystemC 2.0.1 and newer
for (VarVec::iterator it = m_ctorVarsVec.begin(); it != m_ctorVarsVec.end(); ++it) { for (const AstVar* varp : m_ctorVarsVec) {
const AstVar* varp = *it;
bool isArray = !VN_CAST(varp->dtypeSkipRefp(), BasicDType); bool isArray = !VN_CAST(varp->dtypeSkipRefp(), BasicDType);
if (isArray) { if (isArray) {
puts("// Skipping array: "); puts("// Skipping array: ");
@ -2887,7 +2881,7 @@ void EmitCStmts::emitSortedVarList(const VarVec& anons, const VarVec& nonanons,
} }
if (anonL1s != 1) if (anonL1s != 1)
puts("// Anonymous structures to workaround compiler member-count bugs\n"); puts("// Anonymous structures to workaround compiler member-count bugs\n");
VarVec::const_iterator it = anons.begin(); auto it = anons.cbegin();
for (int l3 = 0; l3 < anonL3s && it != anons.end(); ++l3) { for (int l3 = 0; l3 < anonL3s && it != anons.end(); ++l3) {
if (anonL3s != 1) puts("struct {\n"); if (anonL3s != 1) puts("struct {\n");
for (int l2 = 0; l2 < anonL2s && it != anons.end(); ++l2) { for (int l2 = 0; l2 < anonL2s && it != anons.end(); ++l2) {

12
src/V3EmitCSyms.cpp
View File

@ -168,7 +168,7 @@ class EmitCSyms : EmitCBaseVisitor {
void varHierarchyScopes(string scp) { void varHierarchyScopes(string scp) {
while (!scp.empty()) { while (!scp.empty()) {
ScopeNames::const_iterator scpit = m_vpiScopeCandidates.find(scp); const auto scpit = m_vpiScopeCandidates.find(scp);
if ((scpit != m_vpiScopeCandidates.end()) if ((scpit != m_vpiScopeCandidates.end())
&& (m_scopeNames.find(scp) == m_scopeNames.end())) { && (m_scopeNames.find(scp) == m_scopeNames.end())) {
m_scopeNames.insert(make_pair(scpit->second.m_symName, scpit->second)); m_scopeNames.insert(make_pair(scpit->second.m_symName, scpit->second));
@ -704,8 +704,8 @@ void EmitCSyms::emitSymImp() {
++lit) { ++lit) {
string fromname = scopeSymString(it->first); string fromname = scopeSymString(it->first);
string toname = scopeSymString(*lit); string toname = scopeSymString(*lit);
ScopeNames::const_iterator from = m_scopeNames.find(fromname); const auto from = vlstd::as_const(m_scopeNames).find(fromname);
ScopeNames::const_iterator to = m_scopeNames.find(toname); const auto to = vlstd::as_const(m_scopeNames).find(toname);
UASSERT(from != m_scopeNames.end(), fromname + " not in m_scopeNames"); UASSERT(from != m_scopeNames.end(), fromname + " not in m_scopeNames");
UASSERT(to != m_scopeNames.end(), toname + " not in m_scopeNames"); UASSERT(to != m_scopeNames.end(), toname + " not in m_scopeNames");
puts("__Vhier.add("); puts("__Vhier.add(");
@ -859,8 +859,7 @@ void EmitCSyms::emitDpiHdr() {
int firstExp = 0; int firstExp = 0;
int firstImp = 0; int firstImp = 0;
for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) { for (AstCFunc* nodep : m_dpis) {
AstCFunc* nodep = *it;
if (nodep->dpiExportWrapper()) { if (nodep->dpiExportWrapper()) {
if (!firstExp++) puts("\n// DPI EXPORTS\n"); if (!firstExp++) puts("\n// DPI EXPORTS\n");
puts("// DPI export" + ifNoProtect(" at " + nodep->fileline()->ascii()) + "\n"); puts("// DPI export" + ifNoProtect(" at " + nodep->fileline()->ascii()) + "\n");
@ -909,8 +908,7 @@ void EmitCSyms::emitDpiImp() {
puts("#include \"" + topClassName() + ".h\"\n"); puts("#include \"" + topClassName() + ".h\"\n");
puts("\n"); puts("\n");
for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) { for (AstCFunc* nodep : m_dpis) {
AstCFunc* nodep = *it;
if (nodep->dpiExportWrapper()) { if (nodep->dpiExportWrapper()) {
puts("#ifndef _VL_DPIDECL_" + nodep->name() + "\n"); puts("#ifndef _VL_DPIDECL_" + nodep->name() + "\n");
puts("#define _VL_DPIDECL_" + nodep->name() + "\n"); puts("#define _VL_DPIDECL_" + nodep->name() + "\n");

7
src/V3EmitMk.cpp
View File

@ -210,8 +210,7 @@ public:
of.puts("# User .cpp files (from .cpp's on Verilator command line)\n"); of.puts("# User .cpp files (from .cpp's on Verilator command line)\n");
of.puts("VM_USER_CLASSES = \\\n"); of.puts("VM_USER_CLASSES = \\\n");
const V3StringSet& cppFiles = v3Global.opt.cppFiles(); const V3StringSet& cppFiles = v3Global.opt.cppFiles();
for (V3StringSet::const_iterator it = cppFiles.begin(); it != cppFiles.end(); ++it) { for (const auto& cppfile : cppFiles) {
string cppfile = *it;
of.puts("\t" + V3Os::filenameNonExt(cppfile) + " \\\n"); of.puts("\t" + V3Os::filenameNonExt(cppfile) + " \\\n");
string dir = V3Os::filenameDir(cppfile); string dir = V3Os::filenameDir(cppfile);
dirs.insert(dir); dirs.insert(dir);
@ -220,9 +219,7 @@ public:
of.puts("# User .cpp directories (from .cpp's on Verilator command line)\n"); of.puts("# User .cpp directories (from .cpp's on Verilator command line)\n");
of.puts("VM_USER_DIR = \\\n"); of.puts("VM_USER_DIR = \\\n");
for (V3StringSet::iterator it = dirs.begin(); it != dirs.end(); ++it) { for (const auto& i : dirs) of.puts("\t" + i + " \\\n");
of.puts("\t" + *it + " \\\n");
}
of.puts("\n"); of.puts("\n");
of.puts("\n### Default rules...\n"); of.puts("\n### Default rules...\n");

7
src/V3EmitXml.cpp
View File

@ -293,10 +293,9 @@ public:
nodep->accept(*this); nodep->accept(*this);
// Xml output // Xml output
m_os << "<module_files>\n"; m_os << "<module_files>\n";
for (std::deque<FileLine*>::iterator it = m_nodeModules.begin(); it != m_nodeModules.end(); for (const FileLine* ifp : m_nodeModules) {
++it) { m_os << "<file id=\"" << ifp->filenameLetters() << "\" filename=\"" << ifp->filename()
m_os << "<file id=\"" << (*it)->filenameLetters() << "\" filename=\"" << "\" language=\"" << ifp->language().ascii() << "\"/>\n";
<< (*it)->filename() << "\" language=\"" << (*it)->language().ascii() << "\"/>\n";
} }
m_os << "</module_files>\n"; m_os << "</module_files>\n";
} }

25
src/V3File.cpp
View File

@ -149,26 +149,23 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename)); const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename); if (ofp->fail()) v3fatal("Can't write " << filename);
for (std::set<DependFile>::iterator iter = m_filenameList.begin(); for (const DependFile& i : m_filenameList) {
iter != m_filenameList.end(); ++iter) { if (i.target()) *ofp << i.filename() << " ";
if (iter->target()) { *ofp << iter->filename() << " "; }
} }
*ofp << " : "; *ofp << " : ";
*ofp << v3Global.opt.bin(); *ofp << v3Global.opt.bin();
*ofp << " "; *ofp << " ";
for (std::set<DependFile>::iterator iter = m_filenameList.begin(); for (const DependFile& i : m_filenameList) {
iter != m_filenameList.end(); ++iter) { if (!i.target()) *ofp << i.filename() << " ";
if (!iter->target()) { *ofp << iter->filename() << " "; }
} }
*ofp << endl; *ofp << endl;
if (v3Global.opt.makePhony()) { if (v3Global.opt.makePhony()) {
*ofp << endl; *ofp << endl;
for (std::set<DependFile>::iterator iter = m_filenameList.begin(); for (const DependFile& i : m_filenameList) {
iter != m_filenameList.end(); ++iter) { if (!i.target()) *ofp << i.filename() << ":" << endl;
if (!iter->target()) { *ofp << iter->filename() << ":" << endl; }
} }
} }
} }
@ -576,7 +573,7 @@ protected:
friend class VInFilter; friend class VInFilter;
// Read file contents and return it // Read file contents and return it
bool readWholefile(const string& filename, StrList& outl) { bool readWholefile(const string& filename, StrList& outl) {
FileContentsMap::iterator it = m_contentsMap.find(filename); const auto it = m_contentsMap.find(filename);
if (it != m_contentsMap.end()) { if (it != m_contentsMap.end()) {
outl.push_back(it->second); outl.push_back(it->second);
return true; return true;
@ -592,12 +589,12 @@ protected:
} }
size_t listSize(StrList& sl) { size_t listSize(StrList& sl) {
size_t out = 0; size_t out = 0;
for (StrList::iterator it = sl.begin(); it != sl.end(); ++it) out += it->length(); for (const string& i : sl) out += i.length();
return out; return out;
} }
string listString(StrList& sl) { string listString(StrList& sl) {
string out; string out;
for (StrList::iterator it = sl.begin(); it != sl.end(); ++it) out += *it; for (const string& i : sl) out += i;
return out; return out;
} }
// CONSTRUCTORS // CONSTRUCTORS
@ -984,7 +981,7 @@ public:
// METHODS // METHODS
string passthru(const string& old) { string passthru(const string& old) {
if (!v3Global.opt.protectIds()) return old; if (!v3Global.opt.protectIds()) return old;
IdMap::iterator it = m_nameMap.find(old); const auto it = m_nameMap.find(old);
if (it != m_nameMap.end()) { if (it != m_nameMap.end()) {
// No way to go back and correct the older crypt name // No way to go back and correct the older crypt name
UASSERT(old == it->second, UASSERT(old == it->second,
@ -997,7 +994,7 @@ public:
} }
string protectIf(const string& old, bool doIt) { string protectIf(const string& old, bool doIt) {
if (!v3Global.opt.protectIds() || old.empty() || !doIt) return old; if (!v3Global.opt.protectIds() || old.empty() || !doIt) return old;
IdMap::iterator it = m_nameMap.find(old); const auto it = m_nameMap.find(old);
if (it != m_nameMap.end()) if (it != m_nameMap.end())
return it->second; return it->second;
else { else {

6
src/V3FileLine.cpp
View File

@ -58,7 +58,7 @@ string FileLineSingleton::filenameLetters(int fileno) {
//! We associate a language with each source file, so we also set the default //! We associate a language with each source file, so we also set the default
//! for this. //! for this.
int FileLineSingleton::nameToNumber(const string& filename) { int FileLineSingleton::nameToNumber(const string& filename) {
FileNameNumMap::const_iterator it = m_namemap.find(filename); const auto it = vlstd::as_const(m_namemap).find(filename);
if (VL_LIKELY(it != m_namemap.end())) return it->second; if (VL_LIKELY(it != m_namemap.end())) return it->second;
int num = m_names.size(); int num = m_names.size();
m_names.push_back(filename); m_names.push_back(filename);
@ -454,7 +454,7 @@ void* FileLine::operator new(size_t size) {
void FileLine::operator delete(void* objp, size_t size) { void FileLine::operator delete(void* objp, size_t size) {
if (!objp) return; if (!objp) return;
FileLine* flp = static_cast<FileLine*>(objp); FileLine* flp = static_cast<FileLine*>(objp);
FileLineCheckSet::iterator it = fileLineLeakChecks.find(flp); const auto it = fileLineLeakChecks.find(flp);
if (it != fileLineLeakChecks.end()) { if (it != fileLineLeakChecks.end()) {
fileLineLeakChecks.erase(it); fileLineLeakChecks.erase(it);
} else { } else {
@ -470,7 +470,7 @@ void FileLine::deleteAllRemaining() {
// that way. Unfortunately this makes our leak checking a big mess, so // that way. Unfortunately this makes our leak checking a big mess, so
// only when leak checking we'll track them all and cleanup. // only when leak checking we'll track them all and cleanup.
while (true) { while (true) {
FileLineCheckSet::iterator it = fileLineLeakChecks.begin(); const auto it = fileLineLeakChecks.begin();
if (it == fileLineLeakChecks.end()) break; if (it == fileLineLeakChecks.end()) break;
delete *it; delete *it;
// Operator delete will remove the iterated object from the list. // Operator delete will remove the iterated object from the list.

4
src/V3Gate.cpp
View File

@ -983,8 +983,8 @@ public:
hash(extra1p); hash(extra1p);
hash(extra2p); hash(extra2p);
V3Hashed::iterator inserted = m_hashed.hashAndInsert(rhsp); const auto inserted = m_hashed.hashAndInsert(rhsp);
V3Hashed::iterator dupit = m_hashed.findDuplicate(rhsp, this); const auto dupit = m_hashed.findDuplicate(rhsp, this);
// Even though rhsp was just inserted, V3Hashed::findDuplicate doesn't // Even though rhsp was just inserted, V3Hashed::findDuplicate doesn't
// return anything in the hash that has the same pointer (V3Hashed.cpp::findDuplicate) // return anything in the hash that has the same pointer (V3Hashed.cpp::findDuplicate)
// So dupit is either a different, duplicate rhsp, or the end of the hash. // So dupit is either a different, duplicate rhsp, or the end of the hash.

2
src/V3Global.cpp
View File

@ -83,7 +83,7 @@ void V3Global::dumpCheckGlobalTree(const string& stagename, int newNumber, bool
} }
const std::string& V3Global::ptrToId(const void* p) { const std::string& V3Global::ptrToId(const void* p) {
PtrToIdMap::iterator it = m_ptrToId.find(p); auto it = m_ptrToId.find(p);
if (it == m_ptrToId.end()) { if (it == m_ptrToId.end()) {
std::ostringstream os; std::ostringstream os;
if (p) { if (p) {

10
src/V3GraphAcyc.cpp
View File

@ -189,10 +189,7 @@ public:
: m_origGraphp{origGraphp} : m_origGraphp{origGraphp}
, m_origEdgeFuncp{edgeFuncp} {} , m_origEdgeFuncp{edgeFuncp} {}
~GraphAcyc() { ~GraphAcyc() {
for (std::vector<OrigEdgeList*>::iterator it = m_origEdgeDelp.begin(); for (OrigEdgeList* ip : m_origEdgeDelp) delete ip;
it != m_origEdgeDelp.end(); ++it) {
delete (*it);
}
m_origEdgeDelp.clear(); m_origEdgeDelp.clear();
} }
void main(); void main();
@ -476,10 +473,7 @@ void GraphAcyc::place() {
// Process each edge in weighted order // Process each edge in weighted order
m_placeStep = 10; m_placeStep = 10;
for (std::vector<V3GraphEdge*>::iterator it = edges.begin(); it != edges.end(); ++it) { for (V3GraphEdge* edgep : edges) placeTryEdge(edgep);
V3GraphEdge* edgep = (*it);
placeTryEdge(edgep);
}
} }
void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) { void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) {

4
src/V3GraphAlg.cpp
View File

@ -487,9 +487,7 @@ void V3Graph::sortVertices() {
} }
std::stable_sort(vertices.begin(), vertices.end(), GraphSortVertexCmp()); std::stable_sort(vertices.begin(), vertices.end(), GraphSortVertexCmp());
this->verticesUnlink(); this->verticesUnlink();
for (std::vector<V3GraphVertex*>::iterator it = vertices.begin(); it != vertices.end(); ++it) { for (V3GraphVertex* ip : vertices) ip->verticesPushBack(this);
(*it)->verticesPushBack(this);
}
} }
void V3Graph::sortEdges() { void V3Graph::sortEdges() {

2
src/V3GraphDfa.cpp
View File

@ -182,7 +182,7 @@ private:
// not depend on order of edges // not depend on order of edges
uint32_t hash = hashDfaOrigins(nfasWithInput); uint32_t hash = hashDfaOrigins(nfasWithInput);
std::pair<HashMap::iterator, HashMap::iterator> eqrange = m_hashMap.equal_range(hash); const auto eqrange = m_hashMap.equal_range(hash);
for (HashMap::iterator it = eqrange.first; it != eqrange.second; ++it) { for (HashMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
DfaVertex* testp = it->second; DfaVertex* testp = it->second;
if (compareDfaOrigins(nfasWithInput, testp)) { if (compareDfaOrigins(nfasWithInput, testp)) {

4
src/V3GraphStream.h
View File

@ -197,7 +197,7 @@ private:
for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) { for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
V3GraphVertex* toVertexp = edgep->top(); V3GraphVertex* toVertexp = edgep->top();
typename WaitingVertices::iterator it = m_waitingVertices.find(toVertexp); const auto it = m_waitingVertices.find(toVertexp);
UASSERT_OBJ(it != m_waitingVertices.end(), toVertexp, UASSERT_OBJ(it != m_waitingVertices.end(), toVertexp,
"Found edge into vertex not in waiting list."); "Found edge into vertex not in waiting list.");
if (it->second.unblock()) { if (it->second.unblock()) {
@ -209,7 +209,7 @@ private:
for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) { for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
V3GraphVertex* fromVertexp = edgep->fromp(); V3GraphVertex* fromVertexp = edgep->fromp();
typename WaitingVertices::iterator it = m_waitingVertices.find(fromVertexp); const auto it = m_waitingVertices.find(fromVertexp);
UASSERT_OBJ(it != m_waitingVertices.end(), fromVertexp, UASSERT_OBJ(it != m_waitingVertices.end(), fromVertexp,
"Found edge into vertex not in waiting list."); "Found edge into vertex not in waiting list.");
if (it->second.unblock()) { if (it->second.unblock()) {

2
src/V3HierBlock.cpp
View File

@ -377,7 +377,7 @@ V3HierBlockPlan::HierVector V3HierBlockPlan::hierBlocksSorted() const {
for (V3HierBlock::HierBlockSet::const_iterator it = p.begin(); it != p.end(); ++it) { for (V3HierBlock::HierBlockSet::const_iterator it = p.begin(); it != p.end(); ++it) {
// Delete hblockp from parrents. If a parent does not have a child anymore, then it is // Delete hblockp from parrents. If a parent does not have a child anymore, then it is
// a leaf too. // a leaf too.
const ChildrenMap::iterator parentIt = childrenOfHierBlock.find(*it); const auto parentIt = childrenOfHierBlock.find(*it);
UASSERT_OBJ(parentIt != childrenOfHierBlock.end(), (*it)->modp(), "must be included"); UASSERT_OBJ(parentIt != childrenOfHierBlock.end(), (*it)->modp(), "must be included");
const V3HierBlock::HierBlockSet::size_type erased = parentIt->second.erase(hblockp); const V3HierBlock::HierBlockSet::size_type erased = parentIt->second.erase(hblockp);
UASSERT_OBJ(erased == 1, hblockp->modp(), UASSERT_OBJ(erased == 1, hblockp->modp(),

2
src/V3Inline.cpp
View File

@ -174,7 +174,7 @@ private:
// Iterate through all modules in bottom-up order. // Iterate through all modules in bottom-up order.
// Make a final inlining decision for each. // Make a final inlining decision for each.
for (ModVec::reverse_iterator it = m_allMods.rbegin(); it != m_allMods.rend(); ++it) { for (auto it = m_allMods.rbegin(); it != m_allMods.rend(); ++it) {
AstNodeModule* modp = *it; AstNodeModule* modp = *it;
// If we're going to inline some modules into this one, // If we're going to inline some modules into this one,

2
src/V3Inst.cpp
View File

@ -164,7 +164,7 @@ public:
m_modVarNameMap.insert(make_pair(nodep->name(), nodep)); m_modVarNameMap.insert(make_pair(nodep->name(), nodep));
} }
AstVar* find(const string& name) { AstVar* find(const string& name) {
VarNameMap::iterator it = m_modVarNameMap.find(name); const auto it = m_modVarNameMap.find(name);
if (it != m_modVarNameMap.end()) { if (it != m_modVarNameMap.end()) {
return it->second; return it->second;
} else { } else {

2
src/V3LanguageWords.h
View File

@ -41,7 +41,7 @@ public:
static const_iterator begin() { return s().s_kwdMap.begin(); } static const_iterator begin() { return s().s_kwdMap.begin(); }
static const_iterator end() { return s().s_kwdMap.end(); } static const_iterator end() { return s().s_kwdMap.end(); }
static string isKeyword(const string& kwd) { static string isKeyword(const string& kwd) {
KeywordMap::const_iterator it = s().s_kwdMap.find(kwd); const auto it = vlstd::as_const(s().s_kwdMap).find(kwd);
if (it == s().s_kwdMap.end()) return ""; if (it == s().s_kwdMap.end()) return "";
return it->second; return it->second;
} }

19
src/V3Life.cpp
View File

@ -55,10 +55,9 @@ public:
~LifeState() { ~LifeState() {
V3Stats::addStatSum("Optimizations, Lifetime assign deletions", m_statAssnDel); V3Stats::addStatSum("Optimizations, Lifetime assign deletions", m_statAssnDel);
V3Stats::addStatSum("Optimizations, Lifetime constant prop", m_statAssnCon); V3Stats::addStatSum("Optimizations, Lifetime constant prop", m_statAssnCon);
for (std::vector<AstNode*>::iterator it = m_unlinkps.begin(); it != m_unlinkps.end(); for (AstNode* ip : m_unlinkps) {
++it) { ip->unlinkFrBack();
(*it)->unlinkFrBack(); ip->deleteTree();
(*it)->deleteTree();
} }
} }
// METHODS // METHODS
@ -168,7 +167,7 @@ public:
// Do we have a old assignment we can nuke? // Do we have a old assignment we can nuke?
UINFO(4, " ASSIGNof: " << nodep << endl); UINFO(4, " ASSIGNof: " << nodep << endl);
UINFO(7, " new: " << assp << endl); UINFO(7, " new: " << assp << endl);
LifeMap::iterator it = m_map.find(nodep); const auto it = m_map.find(nodep);
if (it != m_map.end()) { if (it != m_map.end()) {
checkRemoveAssign(it); checkRemoveAssign(it);
it->second.simpleAssign(assp); it->second.simpleAssign(assp);
@ -179,7 +178,7 @@ public:
} }
void complexAssign(AstVarScope* nodep) { void complexAssign(AstVarScope* nodep) {
UINFO(4, " clearof: " << nodep << endl); UINFO(4, " clearof: " << nodep << endl);
LifeMap::iterator it = m_map.find(nodep); const auto it = m_map.find(nodep);
if (it != m_map.end()) { if (it != m_map.end()) {
it->second.complexAssign(); it->second.complexAssign();
} else { } else {
@ -188,7 +187,7 @@ public:
} }
void varUsageReplace(AstVarScope* nodep, AstVarRef* varrefp) { void varUsageReplace(AstVarScope* nodep, AstVarRef* varrefp) {
// Variable rvalue. If it references a constant, we can simply replace it // Variable rvalue. If it references a constant, we can simply replace it
LifeMap::iterator it = m_map.find(nodep); const auto it = m_map.find(nodep);
if (it != m_map.end()) { if (it != m_map.end()) {
if (AstConst* constp = it->second.constNodep()) { if (AstConst* constp = it->second.constNodep()) {
if (!varrefp->varp()->isSigPublic()) { if (!varrefp->varp()->isSigPublic()) {
@ -208,7 +207,7 @@ public:
} }
} }
void complexAssignFind(AstVarScope* nodep) { void complexAssignFind(AstVarScope* nodep) {
LifeMap::iterator it = m_map.find(nodep); const auto it = m_map.find(nodep);
if (it != m_map.end()) { if (it != m_map.end()) {
UINFO(4, " casfind: " << it->first << endl); UINFO(4, " casfind: " << it->first << endl);
it->second.complexAssign(); it->second.complexAssign();
@ -217,7 +216,7 @@ public:
} }
} }
void consumedFind(AstVarScope* nodep) { void consumedFind(AstVarScope* nodep) {
LifeMap::iterator it = m_map.find(nodep); const auto it = m_map.find(nodep);
if (it != m_map.end()) { if (it != m_map.end()) {
it->second.consumed(); it->second.consumed();
} else { } else {
@ -254,7 +253,7 @@ public:
if (it->second.setBeforeUse() && nodep->user1()) { if (it->second.setBeforeUse() && nodep->user1()) {
// Both branches set the var, we can remove the assignment before the IF. // Both branches set the var, we can remove the assignment before the IF.
UINFO(4, "DUALBRANCH " << nodep << endl); UINFO(4, "DUALBRANCH " << nodep << endl);
LifeMap::iterator itab = m_map.find(nodep); const auto itab = m_map.find(nodep);
if (itab != m_map.end()) checkRemoveAssign(itab); if (itab != m_map.end()) checkRemoveAssign(itab);
} }
} }

2
src/V3LinkCells.cpp
View File

@ -467,7 +467,7 @@ private:
void readModNames() { void readModNames() {
// mangled_name, BlockOptions // mangled_name, BlockOptions
const V3HierBlockOptSet& hierBlocks = v3Global.opt.hierBlocks(); const V3HierBlockOptSet& hierBlocks = v3Global.opt.hierBlocks();
V3HierBlockOptSet::const_iterator hierIt = hierBlocks.find(v3Global.opt.topModule()); const auto hierIt = vlstd::as_const(hierBlocks).find(v3Global.opt.topModule());
UASSERT((hierIt != hierBlocks.end()) == v3Global.opt.hierChild(), UASSERT((hierIt != hierBlocks.end()) == v3Global.opt.hierChild(),
"information of the top module must exist if --hierarchical-child is set"); "information of the top module must exist if --hierarchical-child is set");
// Look at all modules, and store pointers to all module names // Look at all modules, and store pointers to all module names

10
src/V3LinkDot.cpp
View File

@ -396,7 +396,7 @@ public:
return symp; return symp;
} }
VSymEnt* getScopeSym(AstScope* nodep) { VSymEnt* getScopeSym(AstScope* nodep) {
NameScopeSymMap::iterator it = m_nameScopeSymMap.find(nodep->name()); const auto it = m_nameScopeSymMap.find(nodep->name());
UASSERT_OBJ(it != m_nameScopeSymMap.end(), nodep, UASSERT_OBJ(it != m_nameScopeSymMap.end(), nodep,
"Scope never assigned a symbol entry '" << nodep->name() << "'"); "Scope never assigned a symbol entry '" << nodep->name() << "'");
return it->second; return it->second;
@ -404,7 +404,7 @@ public:
void implicitOkAdd(AstNodeModule* nodep, const string& varname) { void implicitOkAdd(AstNodeModule* nodep, const string& varname) {
// Mark the given variable name as being allowed to be implicitly declared // Mark the given variable name as being allowed to be implicitly declared
if (nodep) { if (nodep) {
ImplicitNameSet::iterator it = m_implicitNameSet.find(make_pair(nodep, varname)); const auto it = m_implicitNameSet.find(make_pair(nodep, varname));
if (it == m_implicitNameSet.end()) { if (it == m_implicitNameSet.end()) {
m_implicitNameSet.insert(make_pair(nodep, varname)); m_implicitNameSet.insert(make_pair(nodep, varname));
} }
@ -438,9 +438,7 @@ public:
return ifacerefp; return ifacerefp;
} }
void computeIfaceVarSyms() { void computeIfaceVarSyms() {
for (IfaceVarSyms::iterator it = m_ifaceVarSyms.begin(); it != m_ifaceVarSyms.end(); for (VSymEnt* varSymp : m_ifaceVarSyms) {
++it) {
VSymEnt* varSymp = *it;
AstVar* varp = varSymp ? VN_CAST(varSymp->nodep(), Var) : nullptr; AstVar* varp = varSymp ? VN_CAST(varSymp->nodep(), Var) : nullptr;
UINFO(9, " insAllIface se" << cvtToHex(varSymp) << " " << varp << endl); UINFO(9, " insAllIface se" << cvtToHex(varSymp) << " " << varp << endl);
AstIfaceRefDType* ifacerefp = ifaceRefFromArray(varp->subDTypep()); AstIfaceRefDType* ifacerefp = ifaceRefFromArray(varp->subDTypep());
@ -507,7 +505,7 @@ public:
VSymEnt* lhsp = it->first; VSymEnt* lhsp = it->first;
VSymEnt* srcp = lhsp; VSymEnt* srcp = lhsp;
while (true) { // Follow chain of aliases up to highest level non-alias while (true) { // Follow chain of aliases up to highest level non-alias
ScopeAliasMap::iterator it2 = m_scopeAliasMap[samn].find(srcp); const auto it2 = m_scopeAliasMap[samn].find(srcp);
if (it2 != m_scopeAliasMap[samn].end()) { if (it2 != m_scopeAliasMap[samn].end()) {
srcp = it2->second; srcp = it2->second;
continue; continue;

3
src/V3LinkJump.cpp
View File

@ -255,8 +255,7 @@ private:
UINFO(8, " DISABLE " << nodep << endl); UINFO(8, " DISABLE " << nodep << endl);
iterateChildren(nodep); iterateChildren(nodep);
AstNodeBlock* blockp = nullptr; AstNodeBlock* blockp = nullptr;
for (BlockStack::reverse_iterator it = m_blockStack.rbegin(); it != m_blockStack.rend(); for (auto it = m_blockStack.rbegin(); it != m_blockStack.rend(); ++it) {
++it) {
UINFO(9, " UNDERBLK " << *it << endl); UINFO(9, " UNDERBLK " << *it << endl);
if ((*it)->name() == nodep->name()) { if ((*it)->name() == nodep->name()) {
blockp = *it; blockp = *it;

3
src/V3Localize.cpp
View File

@ -118,8 +118,7 @@ private:
flags.setNodeFlags(nodep); flags.setNodeFlags(nodep);
} }
void moveVars() { void moveVars() {
for (std::vector<AstVar*>::iterator it = m_varps.begin(); it != m_varps.end(); ++it) { for (AstVar* nodep : m_varps) {
AstVar* nodep = *it;
if (nodep->valuep()) clearOptimizable(nodep, "HasInitValue"); if (nodep->valuep()) clearOptimizable(nodep, "HasInitValue");
if (!VarFlags(nodep).m_stdFuncAsn) clearStdOptimizable(nodep, "NoStdAssign"); if (!VarFlags(nodep).m_stdFuncAsn) clearStdOptimizable(nodep, "NoStdAssign");
VarFlags flags(nodep); VarFlags flags(nodep);

8
src/V3Number.cpp
View File

@ -567,8 +567,8 @@ string V3Number::displayed(AstNode* nodep, const string& vformat) const {
} }
string V3Number::displayed(FileLine* fl, const string& vformat) const { string V3Number::displayed(FileLine* fl, const string& vformat) const {
string::const_iterator pos = vformat.begin(); auto pos = vformat.cbegin();
UASSERT(pos != vformat.end() && pos[0] == '%', UASSERT(pos != vformat.cend() && pos[0] == '%',
"$display-like function with non format argument " << *this); "$display-like function with non format argument " << *this);
++pos; ++pos;
bool left = false; bool left = false;
@ -2400,14 +2400,14 @@ V3Number& V3Number::opToLowerN(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs); NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_STRING_ARGS1(lhs); NUM_ASSERT_STRING_ARGS1(lhs);
std::string out = lhs.toString(); std::string out = lhs.toString();
for (std::string::iterator it = out.begin(); it != out.end(); ++it) { *it = tolower(*it); } for (auto& cr : out) cr = tolower(cr);
return setString(out); return setString(out);
} }
V3Number& V3Number::opToUpperN(const V3Number& lhs) { V3Number& V3Number::opToUpperN(const V3Number& lhs) {
NUM_ASSERT_OP_ARGS1(lhs); NUM_ASSERT_OP_ARGS1(lhs);
NUM_ASSERT_STRING_ARGS1(lhs); NUM_ASSERT_STRING_ARGS1(lhs);
std::string out = lhs.toString(); std::string out = lhs.toString();
for (std::string::iterator it = out.begin(); it != out.end(); ++it) { *it = toupper(*it); } for (auto& cr : out) cr = toupper(cr);
return setString(out); return setString(out);
} }

45
src/V3Options.cpp
View File

@ -469,7 +469,7 @@ string V3Options::fileExists(const string& filename) {
string dir = V3Os::filenameDir(filename); string dir = V3Os::filenameDir(filename);
string basename = V3Os::filenameNonDir(filename); string basename = V3Os::filenameNonDir(filename);
V3OptionsImp::DirMap::iterator diriter = m_impp->m_dirMap.find(dir); auto diriter = m_impp->m_dirMap.find(dir);
if (diriter == m_impp->m_dirMap.end()) { if (diriter == m_impp->m_dirMap.end()) {
// Read the listing // Read the listing
m_impp->m_dirMap.insert(std::make_pair(dir, std::set<string>())); m_impp->m_dirMap.insert(std::make_pair(dir, std::set<string>()));
@ -484,7 +484,7 @@ string V3Options::fileExists(const string& filename) {
} }
// Find it // Find it
std::set<string>* filesetp = &(diriter->second); std::set<string>* filesetp = &(diriter->second);
std::set<string>::iterator fileiter = filesetp->find(basename); const auto fileiter = filesetp->find(basename);
if (fileiter == filesetp->end()) { if (fileiter == filesetp->end()) {
return ""; // Not found return ""; // Not found
} }
@ -495,9 +495,8 @@ string V3Options::fileExists(const string& filename) {
} }
string V3Options::filePathCheckOneDir(const string& modname, const string& dirname) { string V3Options::filePathCheckOneDir(const string& modname, const string& dirname) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin(); for (const string& i : m_impp->m_libExtVs) {
extIter != m_impp->m_libExtVs.end(); ++extIter) { string fn = V3Os::filenameFromDirBase(dirname, modname + i);
string fn = V3Os::filenameFromDirBase(dirname, modname + *extIter);
string exists = fileExists(fn); string exists = fileExists(fn);
if (exists != "") { if (exists != "") {
// Strip ./, it just looks ugly // Strip ./, it just looks ugly
@ -530,14 +529,12 @@ string V3Options::filePath(FileLine* fl, const string& modname, const string& la
// Find a filename to read the specified module name, // Find a filename to read the specified module name,
// using the incdir and libext's. // using the incdir and libext's.
// Return "" if not found. // Return "" if not found.
for (std::list<string>::iterator dirIter = m_impp->m_incDirUsers.begin(); for (const string& dir : m_impp->m_incDirUsers) {
dirIter != m_impp->m_incDirUsers.end(); ++dirIter) { string exists = filePathCheckOneDir(modname, dir);
string exists = filePathCheckOneDir(modname, *dirIter);
if (exists != "") return exists; if (exists != "") return exists;
} }
for (std::list<string>::iterator dirIter = m_impp->m_incDirFallbacks.begin(); for (const string& dir : m_impp->m_incDirFallbacks) {
dirIter != m_impp->m_incDirFallbacks.end(); ++dirIter) { string exists = filePathCheckOneDir(modname, dir);
string exists = filePathCheckOneDir(modname, *dirIter);
if (exists != "") return exists; if (exists != "") return exists;
} }
@ -568,19 +565,15 @@ void V3Options::filePathLookedMsg(FileLine* fl, const string& modname) {
<< endl); << endl);
} }
std::cerr << V3Error::warnMore() << "... Looked in:" << endl; std::cerr << V3Error::warnMore() << "... Looked in:" << endl;
for (std::list<string>::iterator dirIter = m_impp->m_incDirUsers.begin(); for (const string& dir : m_impp->m_incDirUsers) {
dirIter != m_impp->m_incDirUsers.end(); ++dirIter) { for (const string& ext : m_impp->m_libExtVs) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin(); string fn = V3Os::filenameFromDirBase(dir, modname + ext);
extIter != m_impp->m_libExtVs.end(); ++extIter) {
string fn = V3Os::filenameFromDirBase(*dirIter, modname + *extIter);
std::cerr << V3Error::warnMore() << " " << fn << endl; std::cerr << V3Error::warnMore() << " " << fn << endl;
} }
} }
for (std::list<string>::iterator dirIter = m_impp->m_incDirFallbacks.begin(); for (const string& dir : m_impp->m_incDirFallbacks) {
dirIter != m_impp->m_incDirFallbacks.end(); ++dirIter) { for (const string& ext : m_impp->m_libExtVs) {
for (std::list<string>::iterator extIter = m_impp->m_libExtVs.begin(); string fn = V3Os::filenameFromDirBase(dir, modname + ext);
extIter != m_impp->m_libExtVs.end(); ++extIter) {
string fn = V3Os::filenameFromDirBase(*dirIter, modname + *extIter);
std::cerr << V3Error::warnMore() << " " << fn << endl; std::cerr << V3Error::warnMore() << " " << fn << endl;
} }
} }
@ -596,7 +589,7 @@ V3LangCode V3Options::fileLanguage(const string& filename) {
string::size_type pos; string::size_type pos;
if ((pos = ext.rfind('.')) != string::npos) { if ((pos = ext.rfind('.')) != string::npos) {
ext.erase(0, pos + 1); ext.erase(0, pos + 1);
std::map<string, V3LangCode>::iterator it = m_impp->m_langExts.find(ext); const auto it = m_impp->m_langExts.find(ext);
if (it != m_impp->m_langExts.end()) return it->second; if (it != m_impp->m_langExts.end()) return it->second;
} }
return m_defaultLanguage; return m_defaultLanguage;
@ -1816,7 +1809,7 @@ void V3Options::setDebugMode(int level) {
} }
void V3Options::setDebugSrcLevel(const string& srcfile, int level) { void V3Options::setDebugSrcLevel(const string& srcfile, int level) {
DebugSrcMap::iterator iter = m_debugSrcs.find(srcfile); const auto iter = m_debugSrcs.find(srcfile);
if (iter != m_debugSrcs.end()) { if (iter != m_debugSrcs.end()) {
iter->second = level; iter->second = level;
} else { } else {
@ -1828,7 +1821,7 @@ int V3Options::debugSrcLevel(const string& srcfile_path, int default_level) {
// For simplicity, calling functions can just use __FILE__ for srcfile. // For simplicity, calling functions can just use __FILE__ for srcfile.
// That means though we need to cleanup the filename from ../Foo.cpp -> Foo // That means though we need to cleanup the filename from ../Foo.cpp -> Foo
string srcfile = V3Os::filenameNonDirExt(srcfile_path); string srcfile = V3Os::filenameNonDirExt(srcfile_path);
DebugSrcMap::iterator iter = m_debugSrcs.find(srcfile); const auto iter = m_debugSrcs.find(srcfile);
if (iter != m_debugSrcs.end()) { if (iter != m_debugSrcs.end()) {
return iter->second; return iter->second;
} else { } else {
@ -1837,7 +1830,7 @@ int V3Options::debugSrcLevel(const string& srcfile_path, int default_level) {
} }
void V3Options::setDumpTreeLevel(const string& srcfile, int level) { void V3Options::setDumpTreeLevel(const string& srcfile, int level) {
DebugSrcMap::iterator iter = m_dumpTrees.find(srcfile); const auto iter = m_dumpTrees.find(srcfile);
if (iter != m_dumpTrees.end()) { if (iter != m_dumpTrees.end()) {
iter->second = level; iter->second = level;
} else { } else {
@ -1849,7 +1842,7 @@ int V3Options::dumpTreeLevel(const string& srcfile_path) {
// For simplicity, calling functions can just use __FILE__ for srcfile. // For simplicity, calling functions can just use __FILE__ for srcfile.
// That means though we need to cleanup the filename from ../Foo.cpp -> Foo // That means though we need to cleanup the filename from ../Foo.cpp -> Foo
string srcfile = V3Os::filenameNonDirExt(srcfile_path); string srcfile = V3Os::filenameNonDirExt(srcfile_path);
DebugSrcMap::iterator iter = m_dumpTrees.find(srcfile); const auto iter = m_dumpTrees.find(srcfile);
if (iter != m_dumpTrees.end()) { if (iter != m_dumpTrees.end()) {
return iter->second; return iter->second;
} else { } else {

15
src/V3Order.cpp
View File

@ -157,7 +157,7 @@ public:
V3List<OrderMoveVertex*>& readyVertices() { return m_readyVertices; } V3List<OrderMoveVertex*>& readyVertices() { return m_readyVertices; }
static OrderMoveDomScope* findCreate(const AstSenTree* domainp, const AstScope* scopep) { static OrderMoveDomScope* findCreate(const AstSenTree* domainp, const AstScope* scopep) {
const DomScopeKey key = make_pair(domainp, scopep); const DomScopeKey key = make_pair(domainp, scopep);
DomScopeMap::iterator iter = s_dsMap.find(key); const auto iter = s_dsMap.find(key);
if (iter != s_dsMap.end()) { if (iter != s_dsMap.end()) {
return iter->second; return iter->second;
} else { } else {
@ -1222,10 +1222,7 @@ public:
} }
} }
// Destruction // Destruction
for (std::deque<OrderUser*>::iterator it = m_orderUserps.begin(); for (OrderUser* ip : m_orderUserps) delete ip;
it != m_orderUserps.end(); ++it) {
delete *it;
}
m_graph.debug(V3Error::debugDefault()); m_graph.debug(V3Error::debugDefault());
} }
void main(AstNode* nodep) { iterate(nodep); } void main(AstNode* nodep) { iterate(nodep); }
@ -1573,9 +1570,7 @@ void OrderVisitor::processEdgeReport() {
*logp << "Signals and their clock domains:" << endl; *logp << "Signals and their clock domains:" << endl;
stable_sort(report.begin(), report.end()); stable_sort(report.begin(), report.end());
for (std::deque<string>::iterator it = report.begin(); it != report.end(); ++it) { for (const string& i : report) *logp << i << endl;
*logp << (*it) << endl;
}
} }
void OrderVisitor::processMoveClear() { void OrderVisitor::processMoveClear() {
@ -1888,9 +1883,7 @@ void OrderVisitor::processMTasks() {
const AstSenTree* last_domainp = nullptr; const AstSenTree* last_domainp = nullptr;
AstCFunc* leafCFuncp = nullptr; AstCFunc* leafCFuncp = nullptr;
int leafStmts = 0; int leafStmts = 0;
for (MTaskState::Logics::iterator it = state.m_logics.begin(); it != state.m_logics.end(); for (const OrderLogicVertex* logicp : state.m_logics) {
++it) {
const OrderLogicVertex* logicp = *it;
if (logicp->domainp() != last_domainp) { if (logicp->domainp() != last_domainp) {
// Start a new leaf function. // Start a new leaf function.
leafCFuncp = nullptr; leafCFuncp = nullptr;

24
src/V3Param.cpp
View File

@ -169,7 +169,7 @@ public:
AstConst* constp = VN_CAST(pinp->exprp(), Const); AstConst* constp = VN_CAST(pinp->exprp(), Const);
UASSERT_OBJ(constp, pinp, UASSERT_OBJ(constp, pinp,
"parameter for a hierarchical block must have been constified"); "parameter for a hierarchical block must have been constified");
ParamConstMap::const_iterator pIt = params.find(modvarp->name()); const auto pIt = vlstd::as_const(params).find(modvarp->name());
UINFO(5, "Comparing " << modvarp->name() << " " << constp << std::endl); UINFO(5, "Comparing " << modvarp->name() << " " << constp << std::endl);
if (pIt == params.end() || paramIdx >= params.size() if (pIt == params.end() || paramIdx >= params.size()
|| !areSame(constp, pIt->second)) { || !areSame(constp, pIt->second)) {
@ -190,7 +190,7 @@ public:
UASSERT_OBJ(modIt != m_hierBlockMod.end(), firstPinp, UASSERT_OBJ(modIt != m_hierBlockMod.end(), firstPinp,
hierIt->second->mangledName() << " is not found"); hierIt->second->mangledName() << " is not found");
HierBlockModMap::const_iterator it = m_hierBlockMod.find(hierIt->second->mangledName()); const auto it = vlstd::as_const(m_hierBlockMod).find(hierIt->second->mangledName());
if (it == m_hierBlockMod.end()) return nullptr; if (it == m_hierBlockMod.end()) return nullptr;
return it->second; return it->second;
} }
@ -309,7 +309,7 @@ private:
// Force hash collisions -- for testing only // Force hash collisions -- for testing only
if (VL_UNLIKELY(v3Global.opt.debugCollision())) hash = V3Hash(); if (VL_UNLIKELY(v3Global.opt.debugCollision())) hash = V3Hash();
int num; int num;
ValueMap::iterator it = m_valueMap.find(hash); const auto it = m_valueMap.find(hash);
if (it != m_valueMap.end() && it->second.second == key) { if (it != m_valueMap.end() && it->second.second == key) {
num = it->second.first; num = it->second.first;
} else { } else {
@ -355,12 +355,12 @@ private:
if (pinp->modVarp()) { if (pinp->modVarp()) {
// Find it in the clone structure // Find it in the clone structure
// UINFO(8,"Clone find 0x"<<hex<<(uint32_t)pinp->modVarp()<<endl); // UINFO(8,"Clone find 0x"<<hex<<(uint32_t)pinp->modVarp()<<endl);
CloneMap::iterator cloneiter = clonemapp->find(pinp->modVarp()); const auto cloneiter = clonemapp->find(pinp->modVarp());
UASSERT_OBJ(cloneiter != clonemapp->end(), pinp, UASSERT_OBJ(cloneiter != clonemapp->end(), pinp,
"Couldn't find pin in clone list"); "Couldn't find pin in clone list");
pinp->modVarp(VN_CAST(cloneiter->second, Var)); pinp->modVarp(VN_CAST(cloneiter->second, Var));
} else if (pinp->modPTypep()) { } else if (pinp->modPTypep()) {
CloneMap::iterator cloneiter = clonemapp->find(pinp->modPTypep()); const auto cloneiter = clonemapp->find(pinp->modPTypep());
UASSERT_OBJ(cloneiter != clonemapp->end(), pinp, UASSERT_OBJ(cloneiter != clonemapp->end(), pinp,
"Couldn't find pin in clone list"); "Couldn't find pin in clone list");
pinp->modPTypep(VN_CAST(cloneiter->second, ParamTypeDType)); pinp->modPTypep(VN_CAST(cloneiter->second, ParamTypeDType));
@ -380,7 +380,7 @@ private:
} }
for (AstPin* pinp = startpinp; pinp; pinp = VN_CAST(pinp->nextp(), Pin)) { for (AstPin* pinp = startpinp; pinp; pinp = VN_CAST(pinp->nextp(), Pin)) {
if (AstVar* varp = pinp->modVarp()) { if (AstVar* varp = pinp->modVarp()) {
std::map<string, AstVar*>::const_iterator varIt = nameToPin.find(varp->name()); const auto varIt = vlstd::as_const(nameToPin).find(varp->name());
UASSERT_OBJ(varIt != nameToPin.end(), varp, UASSERT_OBJ(varIt != nameToPin.end(), varp,
"Not found in " << modp->prettyNameQ()); "Not found in " << modp->prettyNameQ());
pinp->modVarp(varIt->second); pinp->modVarp(varIt->second);
@ -444,7 +444,7 @@ private:
// Hitting a cell adds to the appropriate level of this level-sorted list, // Hitting a cell adds to the appropriate level of this level-sorted list,
// so since cells originally exist top->bottom we process in top->bottom order too. // so since cells originally exist top->bottom we process in top->bottom order too.
while (!m_todoModps.empty()) { while (!m_todoModps.empty()) {
LevelModMap::iterator itm = m_todoModps.begin(); const auto itm = m_todoModps.cbegin();
AstNodeModule* nodep = itm->second; AstNodeModule* nodep = itm->second;
m_todoModps.erase(itm); m_todoModps.erase(itm);
if (!nodep->user5SetOnce()) { // Process once; note clone() must clear so we do it if (!nodep->user5SetOnce()) { // Process once; note clone() must clear so we do it
@ -457,8 +457,7 @@ private:
// //
// Process interface cells, then non-interface which may ref an interface cell // Process interface cells, then non-interface which may ref an interface cell
for (int nonIf = 0; nonIf < 2; ++nonIf) { for (int nonIf = 0; nonIf < 2; ++nonIf) {
for (CellList::iterator it = m_cellps.begin(); it != m_cellps.end(); ++it) { for (AstCell* cellp : m_cellps) {
AstCell* cellp = *it;
if ((nonIf == 0 && VN_IS(cellp->modp(), Iface)) if ((nonIf == 0 && VN_IS(cellp->modp(), Iface))
|| (nonIf == 1 && !VN_IS(cellp->modp(), Iface))) { || (nonIf == 1 && !VN_IS(cellp->modp(), Iface))) {
string fullName(m_modp->hierName()); string fullName(m_modp->hierName());
@ -469,8 +468,7 @@ private:
} }
} }
} }
for (CellList::iterator it = m_cellps.begin(); it != m_cellps.end(); ++it) { for (AstCell* cellp : m_cellps) {
AstCell* cellp = *it;
if (string* genHierNamep = (string*)cellp->user5p()) { if (string* genHierNamep = (string*)cellp->user5p()) {
cellp->user5p(nullptr); cellp->user5p(nullptr);
VL_DO_DANGLING(delete genHierNamep, genHierNamep); VL_DO_DANGLING(delete genHierNamep, genHierNamep);
@ -964,7 +962,7 @@ void ParamVisitor::visitCell(AstCell* nodep, const string& hierName) {
// Shorter name is convenient for hierarchical block // Shorter name is convenient for hierarchical block
string newname = longname; string newname = longname;
if (longname.length() > 30 || srcModp->hierBlock()) { if (longname.length() > 30 || srcModp->hierBlock()) {
LongMap::iterator iter = m_longMap.find(longname); const auto iter = m_longMap.find(longname);
if (iter != m_longMap.end()) { if (iter != m_longMap.end()) {
newname = iter->second; newname = iter->second;
} else { } else {
@ -983,7 +981,7 @@ void ParamVisitor::visitCell(AstCell* nodep, const string& hierName) {
// //
// Already made this flavor? // Already made this flavor?
AstNodeModule* cellmodp = nullptr; AstNodeModule* cellmodp = nullptr;
ModNameMap::iterator iter = m_modNameMap.find(newname); auto iter = m_modNameMap.find(newname);
if (iter != m_modNameMap.end()) cellmodp = iter->second.m_modp; if (iter != m_modNameMap.end()) cellmodp = iter->second.m_modp;
if (!cellmodp) { if (!cellmodp) {
// Deep clone of new module // Deep clone of new module

3
src/V3ParseSym.h
View File

@ -127,8 +127,7 @@ public:
} }
void showUpward() { void showUpward() {
UINFO(1, "ParseSym Stack:\n"); UINFO(1, "ParseSym Stack:\n");
for (SymStack::reverse_iterator it = m_sympStack.rbegin(); it != m_sympStack.rend(); for (auto it = m_sympStack.rbegin(); it != m_sympStack.rend(); ++it) {
++it) {
VSymEnt* symp = *it; VSymEnt* symp = *it;
UINFO(1, " " << symp->nodep() << endl); UINFO(1, " " << symp->nodep() << endl);
} }

17
src/V3Partition.cpp
View File

@ -244,7 +244,7 @@ public:
// //
// This generalizes to multiple seed nodes also. // This generalizes to multiple seed nodes also.
while (!m_pending.empty()) { while (!m_pending.empty()) {
PropCpPendSet::reverse_iterator it = m_pending.rbegin(); const auto it = m_pending.rbegin();
V3GraphVertex* updateMep = (*it).key(); V3GraphVertex* updateMep = (*it).key();
uint32_t cpGrowBy = (*it).value(); uint32_t cpGrowBy = (*it).value();
m_pending.erase(it); m_pending.erase(it);
@ -297,12 +297,12 @@ private:
// Confirm that we only set each node's CP once. That's an // Confirm that we only set each node's CP once. That's an
// important property of PartPropagateCp which allows it to be far // important property of PartPropagateCp which allows it to be far
// faster than a recursive algorithm on some graphs. // faster than a recursive algorithm on some graphs.
CpMap::iterator it = m_seen.find(vxp); const auto it = m_seen.find(vxp);
UASSERT_OBJ(it == m_seen.end(), vxp, "Set CP on node twice"); UASSERT_OBJ(it == m_seen.end(), vxp, "Set CP on node twice");
m_seen[vxp] = cost; m_seen[vxp] = cost;
} }
uint32_t critPathCost(V3GraphVertex* vxp, GraphWay way) const { uint32_t critPathCost(V3GraphVertex* vxp, GraphWay way) const {
CpMap::const_iterator it = m_cp.find(vxp); const auto it = m_cp.find(vxp);
if (it != m_cp.end()) return it->second; if (it != m_cp.end()) return it->second;
return 0; return 0;
} }
@ -425,7 +425,7 @@ public:
LogicMTask* mtaskp = dynamic_cast<LogicMTask*>(vxp); LogicMTask* mtaskp = dynamic_cast<LogicMTask*>(vxp);
EdgeSet& edges = mtaskp->m_edges[way.invert()]; EdgeSet& edges = mtaskp->m_edges[way.invert()];
// This is mtaskp's relative with longest !wayward inclusive CP: // This is mtaskp's relative with longest !wayward inclusive CP:
EdgeSet::reverse_iterator edgeIt = edges.rbegin(); const auto edgeIt = edges.rbegin();
uint32_t edgeCp = (*edgeIt).value(); uint32_t edgeCp = (*edgeIt).value();
UASSERT_OBJ(edgeCp == cp, vxp, "CP doesn't match longest wayward edge"); UASSERT_OBJ(edgeCp == cp, vxp, "CP doesn't match longest wayward edge");
} }
@ -686,8 +686,7 @@ public:
<< " (should match the computed critical path cost (CP) for the graph)\n"; << " (should match the computed critical path cost (CP) for the graph)\n";
// Dump // Dump
for (std::vector<const LogicMTask*>::iterator it = path.begin(); it != path.end(); ++it) { for (const LogicMTask* mtaskp : path) {
const LogicMTask* mtaskp = *it;
*osp << "begin mtask with cost " << mtaskp->cost() << endl; *osp << "begin mtask with cost " << mtaskp->cost() << endl;
for (VxList::const_iterator lit = mtaskp->vertexListp()->begin(); for (VxList::const_iterator lit = mtaskp->vertexListp()->begin();
lit != mtaskp->vertexListp()->end(); ++lit) { lit != mtaskp->vertexListp()->end(); ++lit) {
@ -1523,7 +1522,7 @@ private:
// Don't make all NxN/2 possible pairs of prereqs, that's a lot // Don't make all NxN/2 possible pairs of prereqs, that's a lot
// to cart around. Just make a few pairs. // to cart around. Just make a few pairs.
std::vector<LogicMTask*>::iterator it = shortestPrereqs.begin(); auto it = shortestPrereqs.cbegin();
for (unsigned i = 0; exhaustive || (i < 3); ++i) { for (unsigned i = 0; exhaustive || (i < 3); ++i) {
if (it == shortestPrereqs.end()) break; if (it == shortestPrereqs.end()) break;
LogicMTask* ap = *(it++); LogicMTask* ap = *(it++);
@ -1834,7 +1833,7 @@ private:
rankIt->second.erase(mergedp); rankIt->second.erase(mergedp);
while (!rankIt->second.empty()) { while (!rankIt->second.empty()) {
LogicMTaskSet::iterator begin = rankIt->second.begin(); const auto begin = rankIt->second.cbegin();
LogicMTask* donorp = *begin; LogicMTask* donorp = *begin;
UASSERT_OBJ(donorp != mergedp, donorp, "Donor can't be merged edge"); UASSERT_OBJ(donorp != mergedp, donorp, "Donor can't be merged edge");
rankIt->second.erase(begin); rankIt->second.erase(begin);
@ -2360,7 +2359,7 @@ void V3Partition::setupMTaskDeps(V3Graph* mtasksp, const Vx2MTaskMap* vx2mtaskp)
UASSERT(outp->weight() > 0, "Mtask not assigned weight"); UASSERT(outp->weight() > 0, "Mtask not assigned weight");
const MTaskMoveVertex* top = dynamic_cast<MTaskMoveVertex*>(outp->top()); const MTaskMoveVertex* top = dynamic_cast<MTaskMoveVertex*>(outp->top());
UASSERT(top, "MoveVertex not associated to mtask"); UASSERT(top, "MoveVertex not associated to mtask");
Vx2MTaskMap::const_iterator it = vx2mtaskp->find(top); const auto it = vlstd::as_const(vx2mtaskp)->find(top);
UASSERT(it != vx2mtaskp->end(), "MTask map can't find id"); UASSERT(it != vx2mtaskp->end(), "MTask map can't find id");
LogicMTask* otherMTaskp = it->second; LogicMTask* otherMTaskp = it->second;
UASSERT(otherMTaskp, "nullptr other Mtask"); UASSERT(otherMTaskp, "nullptr other Mtask");

2
src/V3Partition.h
View File

@ -86,7 +86,7 @@ public:
PartPtrIdMap() {} PartPtrIdMap() {}
// METHODS // METHODS
vluint64_t findId(const void* ptrp) const { vluint64_t findId(const void* ptrp) const {
PtrMap::const_iterator it = m_id.find(ptrp); const auto it = m_id.find(ptrp);
if (it != m_id.end()) return it->second; if (it != m_id.end()) return it->second;
m_id[ptrp] = m_nextId; m_id[ptrp] = m_nextId;
return m_nextId++; return m_nextId++;

14
src/V3PreProc.cpp
View File

@ -299,11 +299,11 @@ void V3PreProcImp::undefineall() {
} }
} }
bool V3PreProcImp::defExists(const string& name) { bool V3PreProcImp::defExists(const string& name) {
DefinesMap::iterator iter = m_defines.find(name); const auto iter = m_defines.find(name);
return (iter != m_defines.end()); return (iter != m_defines.end());
} }
string V3PreProcImp::defValue(const string& name) { string V3PreProcImp::defValue(const string& name) {
DefinesMap::iterator iter = m_defines.find(name); const auto iter = m_defines.find(name);
if (iter == m_defines.end()) { if (iter == m_defines.end()) {
fileline()->v3error("Define or directive not defined: `" + name); fileline()->v3error("Define or directive not defined: `" + name);
return ""; return "";
@ -311,7 +311,7 @@ string V3PreProcImp::defValue(const string& name) {
return iter->second.value(); return iter->second.value();
} }
string V3PreProcImp::defParams(const string& name) { string V3PreProcImp::defParams(const string& name) {
DefinesMap::iterator iter = m_defines.find(name); const auto iter = m_defines.find(name);
if (iter == m_defines.end()) { if (iter == m_defines.end()) {
fileline()->v3error("Define or directive not defined: `" + name); fileline()->v3error("Define or directive not defined: `" + name);
return ""; return "";
@ -319,7 +319,7 @@ string V3PreProcImp::defParams(const string& name) {
return iter->second.params(); return iter->second.params();
} }
FileLine* V3PreProcImp::defFileline(const string& name) { FileLine* V3PreProcImp::defFileline(const string& name) {
DefinesMap::iterator iter = m_defines.find(name); const auto iter = m_defines.find(name);
if (iter == m_defines.end()) return nullptr; if (iter == m_defines.end()) return nullptr;
return iter->second.fileline(); return iter->second.fileline();
} }
@ -686,7 +686,7 @@ string V3PreProcImp::defineSubst(VDefineRef* refp) {
} }
if (argName != "") { if (argName != "") {
// Found a possible variable substitution // Found a possible variable substitution
std::map<string, string>::iterator iter = argValueByName.find(argName); const auto iter = argValueByName.find(argName);
if (iter != argValueByName.end()) { if (iter != argValueByName.end()) {
// Substitute // Substitute
string subst = iter->second; string subst = iter->second;
@ -795,9 +795,7 @@ void V3PreProcImp::openFile(FileLine* fl, VInFilter* filterp, const string& file
FileLine* flsp = new FileLine(filename); FileLine* flsp = new FileLine(filename);
flsp->lineno(1); flsp->lineno(1);
flsp->newContent(); flsp->newContent();
for (StrList::iterator it = wholefile.begin(); it != wholefile.end(); ++it) { for (const string& i : wholefile) flsp->contentp()->pushText(i);
flsp->contentp()->pushText(*it);
}
// Create new stream structure // Create new stream structure
m_lexp->scanNewFile(flsp); m_lexp->scanNewFile(flsp);

3
src/V3Reloop.cpp
View File

@ -124,8 +124,7 @@ private:
if (debug() >= 9) whilep->dumpTree(cout, "-new: "); if (debug() >= 9) whilep->dumpTree(cout, "-new: ");
// Remove remaining assigns // Remove remaining assigns
for (AssVec::iterator it = m_mgAssignps.begin(); it != m_mgAssignps.end(); ++it) { for (AstNodeAssign* assp : m_mgAssignps) {
AstNodeAssign* assp = *it;
if (assp != bodyp) { if (assp != bodyp) {
VL_DO_DANGLING(assp->unlinkFrBack()->deleteTree(), assp); VL_DO_DANGLING(assp->unlinkFrBack()->deleteTree(), assp);
} }

4
src/V3Scope.cpp
View File

@ -70,11 +70,11 @@ private:
AstVarRef* nodep = it->first; AstVarRef* nodep = it->first;
AstScope* scopep = it->second; AstScope* scopep = it->second;
if (nodep->packagep() && !nodep->varp()->isClassMember()) { if (nodep->packagep() && !nodep->varp()->isClassMember()) {
PackageScopeMap::iterator it2 = m_packageScopes.find(nodep->packagep()); const auto it2 = m_packageScopes.find(nodep->packagep());
UASSERT_OBJ(it2 != m_packageScopes.end(), nodep, "Can't locate package scope"); UASSERT_OBJ(it2 != m_packageScopes.end(), nodep, "Can't locate package scope");
scopep = it2->second; scopep = it2->second;
} }
VarScopeMap::iterator it3 = m_varScopes.find(make_pair(nodep->varp(), scopep)); const auto it3 = m_varScopes.find(make_pair(nodep->varp(), scopep));
UASSERT_OBJ(it3 != m_varScopes.end(), nodep, "Can't locate varref scope"); UASSERT_OBJ(it3 != m_varScopes.end(), nodep, "Can't locate varref scope");
AstVarScope* varscp = it3->second; AstVarScope* varscp = it3->second;
nodep->varScopep(varscp); nodep->varScopep(varscp);

34
src/V3Scoreboard.h
View File

@ -247,16 +247,16 @@ private:
public: public:
iterator begin() { iterator begin() {
typename Val2Keys::iterator valIt = m_vals.begin(); const auto valIt = m_vals.begin();
if (valIt == m_vals.end()) return end(); if (valIt == m_vals.end()) return end();
typename KeySet::const_iterator keyIt = valIt->second.begin(); const auto keyIt = valIt->second.begin();
return iterator(valIt, keyIt, this); return iterator(valIt, keyIt, this);
} }
const_iterator begin() const { const_iterator begin() const {
SortByValueMap* mutp = const_cast<SortByValueMap*>(this); SortByValueMap* mutp = const_cast<SortByValueMap*>(this);
typename Val2Keys::iterator valIt = mutp->m_vals.begin(); const auto valIt = mutp->m_vals.begin();
if (valIt == mutp->m_vals.end()) return end(); if (valIt == mutp->m_vals.end()) return end();
typename KeySet::const_iterator keyIt = valIt->second.begin(); const auto keyIt = valIt->second.begin();
return const_iterator(valIt, keyIt, mutp); return const_iterator(valIt, keyIt, mutp);
} }
iterator end() { return iterator(this); } iterator end() { return iterator(this); }
@ -271,24 +271,24 @@ public:
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
iterator find(const T_Key& k) { iterator find(const T_Key& k) {
typename Key2Val::iterator kvit = m_keys.find(k); const auto kvit = m_keys.find(k);
if (kvit == m_keys.end()) return end(); if (kvit == m_keys.end()) return end();
typename Val2Keys::iterator valIt = m_vals.find(kvit->second); const auto valIt = m_vals.find(kvit->second);
typename KeySet::iterator keyIt = valIt->second.find(k); const auto keyIt = valIt->second.find(k);
return iterator(valIt, keyIt, this); return iterator(valIt, keyIt, this);
} }
const_iterator find(const T_Key& k) const { const_iterator find(const T_Key& k) const {
SortByValueMap* mutp = const_cast<SortByValueMap*>(this); SortByValueMap* mutp = const_cast<SortByValueMap*>(this);
typename Key2Val::iterator kvit = mutp->m_keys.find(k); const auto kvit = mutp->m_keys.find(k);
if (kvit == mutp->m_keys.end()) return end(); if (kvit == mutp->m_keys.end()) return end();
typename Val2Keys::iterator valIt = mutp->m_vals.find(kvit->second); const auto valIt = mutp->m_vals.find(kvit->second);
typename KeySet::iterator keyIt = valIt->second.find(k); const auto keyIt = valIt->second.find(k);
return const_iterator(valIt, keyIt, mutp); return const_iterator(valIt, keyIt, mutp);
} }
void set(const T_Key& k, const T_Value& v) { void set(const T_Key& k, const T_Value& v) {
typename Key2Val::iterator kvit = m_keys.find(k); const auto kvit = m_keys.find(k);
if (kvit != m_keys.end()) { if (kvit != m_keys.end()) {
if (kvit->second == v) { if (kvit->second == v) {
return; // LCOV_EXCL_LINE // Same value already present; stop. return; // LCOV_EXCL_LINE // Same value already present; stop.
@ -300,7 +300,7 @@ public:
m_vals[v].insert(k); m_vals[v].insert(k);
} }
size_t erase(const T_Key& k) { size_t erase(const T_Key& k) {
typename Key2Val::iterator kvit = m_keys.find(k); const auto kvit = m_keys.find(k);
if (kvit == m_keys.end()) return 0; if (kvit == m_keys.end()) return 0;
removeKeyFromOldVal(k, kvit->second); removeKeyFromOldVal(k, kvit->second);
m_keys.erase(kvit); m_keys.erase(kvit);
@ -319,7 +319,7 @@ public:
// be a const reference, otherwise the client could corrupt the sorted // be a const reference, otherwise the client could corrupt the sorted
// order of m_byValue by reaching through and changing the value. // order of m_byValue by reaching through and changing the value.
const T_Value& at(const T_Key& k) const { const T_Value& at(const T_Key& k) const {
typename Key2Val::const_iterator kvit = m_keys.find(k); const auto kvit = m_keys.find(k);
UASSERT(kvit != m_keys.end(), "at() lookup key not found"); UASSERT(kvit != m_keys.end(), "at() lookup key not found");
return kvit->second; return kvit->second;
} }
@ -415,7 +415,7 @@ public:
// reflected in the result of bestp(). Otherwise, bestp() only // reflected in the result of bestp(). Otherwise, bestp() only
// considers elements that aren't pending rescore. // considers elements that aren't pending rescore.
const T_Elem* bestp() { const T_Elem* bestp() {
typename SortedMap::iterator result = m_sorted.begin(); const auto result = m_sorted.begin();
if (VL_UNLIKELY(result == m_sorted.end())) return nullptr; if (VL_UNLIKELY(result == m_sorted.end())) return nullptr;
return (*result).key(); return (*result).key();
} }
@ -444,7 +444,7 @@ public:
bool needsRescore(const T_Elem* elp) { return (m_unknown.find(elp) != m_unknown.end()); } bool needsRescore(const T_Elem* elp) { return (m_unknown.find(elp) != m_unknown.end()); }
// Retrieve the last known score for an element. // Retrieve the last known score for an element.
T_Score cachedScore(const T_Elem* elp) { T_Score cachedScore(const T_Elem* elp) {
typename SortedMap::iterator result = m_sorted.find(elp); const auto result = m_sorted.find(elp);
UASSERT(result != m_sorted.end(), "V3Scoreboard::cachedScore() failed to find element"); UASSERT(result != m_sorted.end(), "V3Scoreboard::cachedScore() failed to find element");
return (*result).value(); return (*result).value();
} }
@ -452,9 +452,7 @@ public:
// call the client's scoring function to get a new score, // call the client's scoring function to get a new score,
// and sort all elements by their current score. // and sort all elements by their current score.
void rescore() { void rescore() {
for (typename NeedRescoreSet::iterator it = m_unknown.begin(); it != m_unknown.end(); for (const T_Elem* elp : m_unknown) {
++it) {
const T_Elem* elp = *it;
T_Score sortScore = m_scoreFnp(elp); T_Score sortScore = m_scoreFnp(elp);
m_sorted.set(elp, sortScore); m_sorted.set(elp, sortScore);
} }

2
src/V3SenTree.h
View File

@ -60,7 +60,7 @@ public:
AstSenTree* find(AstSenTree* likep) { AstSenTree* find(AstSenTree* likep) {
AstSenTree* resultp = nullptr; AstSenTree* resultp = nullptr;
Set::iterator it = m_trees.find(likep); const auto it = m_trees.find(likep);
if (it != m_trees.end()) resultp = *it; if (it != m_trees.end()) resultp = *it;
return resultp; return resultp;
} }

13
src/V3Simulate.h
View File

@ -1009,7 +1009,7 @@ private:
string result; string result;
string format = nodep->text(); string format = nodep->text();
string::const_iterator pos = format.begin(); auto pos = format.cbegin();
bool inPct = false; bool inPct = false;
for (; pos != format.end(); ++pos) { for (; pos != format.end(); ++pos) {
if (!inPct && pos[0] == '%') { if (!inPct && pos[0] == '%') {
@ -1132,15 +1132,10 @@ public:
mainGuts(nodep); mainGuts(nodep);
} }
virtual ~SimulateVisitor() override { virtual ~SimulateVisitor() override {
for (ConstPile::iterator it = m_constAllps.begin(); it != m_constAllps.end(); ++it) { for (const auto& i : m_constAllps) {
for (ConstDeque::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) { for (AstConst* i2p : i.second) delete i2p;
delete (*it2);
}
}
for (std::deque<AstNode*>::iterator it = m_reclaimValuesp.begin();
it != m_reclaimValuesp.end(); ++it) {
delete (*it);
} }
for (AstNode* ip : m_reclaimValuesp) delete ip;
m_reclaimValuesp.clear(); m_reclaimValuesp.clear();
m_constFreeps.clear(); m_constFreeps.clear();
m_constAllps.clear(); m_constAllps.clear();

16
src/V3Split.cpp
View File

@ -394,18 +394,16 @@ protected:
SplitVarPostVertex* vpostp SplitVarPostVertex* vpostp
= reinterpret_cast<SplitVarPostVertex*>(vscp->user2p()); = reinterpret_cast<SplitVarPostVertex*>(vscp->user2p());
// Add edges // Add edges
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); for (SplitLogicVertex* vxp : m_stmtStackps) {
++it) { new SplitLVEdge(&m_graph, vpostp, vxp);
new SplitLVEdge(&m_graph, vpostp, *it);
} }
} else { // Nondelayed assignment } else { // Nondelayed assignment
if (nodep->lvalue()) { if (nodep->lvalue()) {
// Non-delay; need to maintain existing ordering // Non-delay; need to maintain existing ordering
// with all consumers of the signal // with all consumers of the signal
UINFO(4, " VARREFLV: " << nodep << endl); UINFO(4, " VARREFLV: " << nodep << endl);
for (VStack::iterator it = m_stmtStackps.begin(); for (SplitLogicVertex* ivxp : m_stmtStackps) {
it != m_stmtStackps.end(); ++it) { new SplitLVEdge(&m_graph, vstdp, ivxp);
new SplitLVEdge(&m_graph, vstdp, *it);
} }
} else { } else {
UINFO(4, " VARREF: " << nodep << endl); UINFO(4, " VARREF: " << nodep << endl);
@ -450,9 +448,7 @@ public:
// METHODS // METHODS
protected: protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override { virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); ++it) { for (SplitLogicVertex* vxp : m_stmtStackps) new SplitRVEdge(&m_graph, vxp, vstdp);
new SplitRVEdge(&m_graph, *it, vstdp);
}
} }
void cleanupBlockGraph(AstNode* nodep) { void cleanupBlockGraph(AstNode* nodep) {
@ -647,7 +643,7 @@ public:
// METHODS // METHODS
const ColorSet& colors() const { return m_colors; } const ColorSet& colors() const { return m_colors; }
const ColorSet& colors(AstNodeIf* nodep) const { const ColorSet& colors(AstNodeIf* nodep) const {
IfColorMap::const_iterator it = m_ifColors.find(nodep); const auto it = m_ifColors.find(nodep);
UASSERT_OBJ(it != m_ifColors.end(), nodep, "Node missing from split color() map"); UASSERT_OBJ(it != m_ifColors.end(), nodep, "Node missing from split color() map");
return it->second; return it->second;
} }

9
src/V3SplitVar.cpp
View File

@ -981,7 +981,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
virtual void visit(AstVarRef* nodep) override { virtual void visit(AstVarRef* nodep) override {
AstVar* varp = nodep->varp(); AstVar* varp = nodep->varp();
visit(varp); visit(varp);
PackedVarRefMap::iterator refit = m_refs.find(varp); const auto refit = m_refs.find(varp);
if (refit == m_refs.end()) return; // variable without split_var metacomment if (refit == m_refs.end()) return; // variable without split_var metacomment
UASSERT_OBJ(varp->attrSplitVar(), varp, "split_var attribute must be attached"); UASSERT_OBJ(varp->attrSplitVar(), varp, "split_var attribute must be attached");
UASSERT_OBJ(!nodep->packagep(), nodep, UASSERT_OBJ(!nodep->packagep(), nodep,
@ -1000,7 +1000,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
} }
AstVar* varp = vrefp->varp(); AstVar* varp = vrefp->varp();
PackedVarRefMap::iterator refit = m_refs.find(varp); const auto refit = m_refs.find(varp);
if (refit == m_refs.end()) { if (refit == m_refs.end()) {
iterateChildren(nodep); iterateChildren(nodep);
return; // Variable without split_var metacomment return; // Variable without split_var metacomment
@ -1114,13 +1114,12 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
} }
static void updateReferences(AstVar* varp, PackedVarRef& ref, static void updateReferences(AstVar* varp, PackedVarRef& ref,
const std::vector<SplitNewVar>& vars) { const std::vector<SplitNewVar>& vars) {
typedef std::vector<SplitNewVar> NewVars; // Sorted by its lsb
for (int lvalue = 0; lvalue <= 1; ++lvalue) { // Refer the new split variables for (int lvalue = 0; lvalue <= 1; ++lvalue) { // Refer the new split variables
std::vector<PackedVarRefEntry>& refs = lvalue ? ref.lhs() : ref.rhs(); std::vector<PackedVarRefEntry>& refs = lvalue ? ref.lhs() : ref.rhs();
for (PackedVarRef::iterator refit = refs.begin(), refitend = refs.end(); for (PackedVarRef::iterator refit = refs.begin(), refitend = refs.end();
refit != refitend; ++refit) { refit != refitend; ++refit) {
NewVars::const_iterator varit = std::upper_bound( auto varit = std::upper_bound(vars.begin(), vars.end(), refit->lsb(),
vars.begin(), vars.end(), refit->lsb(), SplitNewVar::Match()); SplitNewVar::Match());
UASSERT_OBJ(varit != vars.end(), refit->nodep(), "Not found"); UASSERT_OBJ(varit != vars.end(), refit->nodep(), "Not found");
UASSERT(!(varit->msb() < refit->lsb() || refit->msb() < varit->lsb()), UASSERT(!(varit->msb() < refit->lsb() || refit->msb() < varit->lsb()),
"wrong search result"); "wrong search result");

4
src/V3String.cpp
View File

@ -74,13 +74,13 @@ string VString::dot(const string& a, const string& dot, const string& b) {
string VString::downcase(const string& str) { string VString::downcase(const string& str) {
string out = str; string out = str;
for (string::iterator pos = out.begin(); pos != out.end(); ++pos) *pos = tolower(*pos); for (auto& cr : out) cr = tolower(cr);
return out; return out;
} }
string VString::upcase(const string& str) { string VString::upcase(const string& str) {
string out = str; string out = str;
for (string::iterator pos = out.begin(); pos != out.end(); ++pos) *pos = toupper(*pos); for (auto& cr : out) cr = toupper(cr);
return out; return out;
} }

7
src/V3Subst.cpp
View File

@ -372,10 +372,9 @@ public:
} }
virtual ~SubstVisitor() override { virtual ~SubstVisitor() override {
V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts); V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts);
for (std::vector<SubstVarEntry*>::iterator it = m_entryps.begin(); it != m_entryps.end(); for (SubstVarEntry* ip : m_entryps) {
++it) { ip->deleteUnusedAssign();
(*it)->deleteUnusedAssign(); delete ip;
delete (*it);
} }
} }
}; };

10
src/V3SymTable.h
View File

@ -133,7 +133,7 @@ public:
} }
} }
void reinsert(const string& name, VSymEnt* entp) { void reinsert(const string& name, VSymEnt* entp) {
IdNameMap::iterator it = m_idNameMap.find(name); const auto it = m_idNameMap.find(name);
if (name != "" && it != m_idNameMap.end()) { if (name != "" && it != m_idNameMap.end()) {
UINFO(9, " SymReinsert se" << cvtToHex(this) << " '" << name << "' se" UINFO(9, " SymReinsert se" << cvtToHex(this) << " '" << name << "' se"
<< cvtToHex(entp) << " " << entp->nodep() << endl); << cvtToHex(entp) << " " << entp->nodep() << endl);
@ -145,7 +145,7 @@ public:
VSymEnt* findIdFlat(const string& name) const { VSymEnt* findIdFlat(const string& name) const {
// Find identifier without looking upward through symbol hierarchy // Find identifier without looking upward through symbol hierarchy
// First, scan this begin/end block or module for the name // First, scan this begin/end block or module for the name
IdNameMap::const_iterator it = m_idNameMap.find(name); const auto it = m_idNameMap.find(name);
UINFO(9, " SymFind se" UINFO(9, " SymFind se"
<< cvtToHex(this) << " '" << name << "' -> " << cvtToHex(this) << " '" << name << "' -> "
<< (it == m_idNameMap.end() << (it == m_idNameMap.end()
@ -211,7 +211,7 @@ public:
void importFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) { void importFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) {
// Import tokens from source symbol table into this symbol table // Import tokens from source symbol table into this symbol table
if (id_or_star != "*") { if (id_or_star != "*") {
IdNameMap::const_iterator it = srcp->m_idNameMap.find(id_or_star); const auto it = srcp->m_idNameMap.find(id_or_star);
if (it != srcp->m_idNameMap.end()) { if (it != srcp->m_idNameMap.end()) {
importOneSymbol(graphp, it->first, it->second, true); importOneSymbol(graphp, it->first, it->second, true);
} }
@ -225,7 +225,7 @@ public:
void exportFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) { void exportFromPackage(VSymGraph* graphp, const VSymEnt* srcp, const string& id_or_star) {
// Export tokens from source symbol table into this symbol table // Export tokens from source symbol table into this symbol table
if (id_or_star != "*") { if (id_or_star != "*") {
IdNameMap::const_iterator it = srcp->m_idNameMap.find(id_or_star); const auto it = vlstd::as_const(srcp->m_idNameMap).find(id_or_star);
if (it != srcp->m_idNameMap.end()) exportOneSymbol(graphp, it->first, it->second); if (it != srcp->m_idNameMap.end()) exportOneSymbol(graphp, it->first, it->second);
} else { } else {
for (IdNameMap::const_iterator it = srcp->m_idNameMap.begin(); for (IdNameMap::const_iterator it = srcp->m_idNameMap.begin();
@ -292,7 +292,7 @@ class VSymGraph {
public: public:
explicit VSymGraph(AstNetlist* nodep) { m_symRootp = new VSymEnt(this, nodep); } explicit VSymGraph(AstNetlist* nodep) { m_symRootp = new VSymEnt(this, nodep); }
~VSymGraph() { ~VSymGraph() {
for (SymStack::iterator it = m_symsp.begin(); it != m_symsp.end(); ++it) delete (*it); for (const VSymEnt* entp : m_symsp) delete entp;
} }
// METHODS // METHODS

14
src/V3TSP.cpp
View File

@ -84,7 +84,7 @@ public:
// METHODS // METHODS
void addVertex(const T_Key& key) { void addVertex(const T_Key& key) {
typename VMap::iterator itr = m_vertices.find(key); const auto itr = m_vertices.find(key);
UASSERT(itr == m_vertices.end(), "Vertex already exists with same key"); UASSERT(itr == m_vertices.end(), "Vertex already exists with same key");
Vertex* v = new Vertex(this, key); Vertex* v = new Vertex(this, key);
m_vertices[key] = v; m_vertices[key] = v;
@ -177,7 +177,7 @@ public:
// discard it and repeat again. // discard it and repeat again.
unsigned edges_made = 0; unsigned edges_made = 0;
while (!pendingEdges.empty()) { while (!pendingEdges.empty()) {
typename PendingEdgeSet::iterator firstIt = pendingEdges.begin(); const auto firstIt = pendingEdges.cbegin();
V3GraphEdge* bestEdgep = *firstIt; V3GraphEdge* bestEdgep = *firstIt;
pendingEdges.erase(firstIt); pendingEdges.erase(firstIt);
@ -317,8 +317,7 @@ public:
// Look for nodes on the tour that still have // Look for nodes on the tour that still have
// un-marked edges. If we find one, recurse. // un-marked edges. If we find one, recurse.
for (typename std::vector<Vertex*>::iterator it = tour.begin(); it != tour.end(); ++it) { for (Vertex* vxp : tour) {
Vertex* vxp = *it;
bool recursed; bool recursed;
do { do {
recursed = false; recursed = false;
@ -338,10 +337,7 @@ public:
} }
UINFO(6, "Tour was: "); UINFO(6, "Tour was: ");
for (typename std::vector<Vertex*>::iterator it = tour.begin(); it != tour.end(); ++it) { for (const Vertex* vxp : tour) UINFONL(6, " " << vxp->key());
Vertex* vxp = *it;
UINFONL(6, " " << vxp->key());
}
UINFONL(6, "\n"); UINFONL(6, "\n");
} }
@ -390,7 +386,7 @@ public:
private: private:
Vertex* findVertex(const T_Key& key) const { Vertex* findVertex(const T_Key& key) const {
typename VMap::const_iterator it = m_vertices.find(key); const auto it = m_vertices.find(key);
UASSERT(it != m_vertices.end(), "Vertex not found"); UASSERT(it != m_vertices.end(), "Vertex not found");
return it->second; return it->second;
} }

26
src/V3Table.cpp
View File

@ -224,16 +224,14 @@ private:
// Create table for each output // Create table for each output
typedef std::map<string, int> NameCounts; typedef std::map<string, int> NameCounts;
NameCounts namecounts; NameCounts namecounts;
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); it != m_outVarps.end(); for (const AstVarScope* outvscp : m_outVarps) {
++it) {
AstVarScope* outvscp = *it;
AstVar* outvarp = outvscp->varp(); AstVar* outvarp = outvscp->varp();
FileLine* fl = nodep->fileline(); FileLine* fl = nodep->fileline();
AstNodeArrayDType* dtypep = new AstUnpackArrayDType( AstNodeArrayDType* dtypep = new AstUnpackArrayDType(
fl, outvarp->dtypep(), new AstRange(fl, VL_MASK_I(m_inWidth), 0)); fl, outvarp->dtypep(), new AstRange(fl, VL_MASK_I(m_inWidth), 0));
v3Global.rootp()->typeTablep()->addTypesp(dtypep); v3Global.rootp()->typeTablep()->addTypesp(dtypep);
string name = "__Vtable" + cvtToStr(m_modTables) + "_" + outvarp->name(); string name = "__Vtable" + cvtToStr(m_modTables) + "_" + outvarp->name();
NameCounts::iterator nit = namecounts.find(name); const auto nit = namecounts.find(name);
if (nit != namecounts.end()) { if (nit != namecounts.end()) {
// Multiple scopes can have same var name. We could append the // Multiple scopes can have same var name. We could append the
// scope name but that is very long, so just deduplicate. // scope name but that is very long, so just deduplicate.
@ -256,9 +254,7 @@ private:
// Concat inputs into a single temp variable (inside always) // Concat inputs into a single temp variable (inside always)
// First var in inVars becomes the LSB of the concat // First var in inVars becomes the LSB of the concat
AstNode* concatp = nullptr; AstNode* concatp = nullptr;
for (std::deque<AstVarScope*>::iterator it = m_inVarps.begin(); it != m_inVarps.end(); for (AstVarScope* invscp : m_inVarps) {
++it) {
AstVarScope* invscp = *it;
AstVarRef* refp = new AstVarRef(nodep->fileline(), invscp, false); AstVarRef* refp = new AstVarRef(nodep->fileline(), invscp, false);
if (concatp) { if (concatp) {
concatp = new AstConcat(nodep->fileline(), refp, concatp); concatp = new AstConcat(nodep->fileline(), refp, concatp);
@ -293,9 +289,7 @@ private:
// Set all inputs to the constant // Set all inputs to the constant
uint32_t shift = 0; uint32_t shift = 0;
for (std::deque<AstVarScope*>::iterator it = m_inVarps.begin(); it != m_inVarps.end(); for (AstVarScope* invscp : m_inVarps) {
++it) {
AstVarScope* invscp = *it;
// LSB is first variable, so extract it that way // LSB is first variable, so extract it that way
AstConst cnst(invscp->fileline(), AstConst::WidthedValue(), invscp->width(), AstConst cnst(invscp->fileline(), AstConst::WidthedValue(), invscp->width(),
VL_MASK_I(invscp->width()) & (inValue >> shift)); VL_MASK_I(invscp->width()) & (inValue >> shift));
@ -316,9 +310,7 @@ private:
// If a output changed, add it to table // If a output changed, add it to table
int outnum = 0; int outnum = 0;
V3Number outputChgMask(nodep, m_outVarps.size(), 0); V3Number outputChgMask(nodep, m_outVarps.size(), 0);
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); for (AstVarScope* outvscp : m_outVarps) {
it != m_outVarps.end(); ++it) {
AstVarScope* outvscp = *it;
V3Number* outnump = simvis.fetchOutNumberNull(outvscp); V3Number* outnump = simvis.fetchOutNumberNull(outvscp);
AstNode* setp; AstNode* setp;
if (!outnump) { if (!outnump) {
@ -353,9 +345,7 @@ private:
// See if another table we've created is identical, if so use it for both. // See if another table we've created is identical, if so use it for both.
// (A more 'modern' way would be to instead use V3Hashed::findDuplicate) // (A more 'modern' way would be to instead use V3Hashed::findDuplicate)
AstVar* var1p = vsc1p->varp(); AstVar* var1p = vsc1p->varp();
for (std::deque<AstVarScope*>::iterator it = m_modTableVscs.begin(); for (AstVarScope* vsc2p : m_modTableVscs) {
it != m_modTableVscs.end(); ++it) {
AstVarScope* vsc2p = *it;
AstVar* var2p = vsc2p->varp(); AstVar* var2p = vsc2p->varp();
if (var1p->width() == var2p->width() if (var1p->width() == var2p->width()
&& (var1p->dtypep()->arrayUnpackedElements() && (var1p->dtypep()->arrayUnpackedElements()
@ -381,9 +371,7 @@ private:
// elimination will remove it for us. // elimination will remove it for us.
// Set each output from array ref into our table // Set each output from array ref into our table
int outnum = 0; int outnum = 0;
for (std::deque<AstVarScope*>::iterator it = m_outVarps.begin(); it != m_outVarps.end(); for (AstVarScope* outvscp : m_outVarps) {
++it) {
AstVarScope* outvscp = *it;
AstNode* alhsp = new AstVarRef(nodep->fileline(), outvscp, true); AstNode* alhsp = new AstVarRef(nodep->fileline(), outvscp, true);
AstNode* arhsp = new AstArraySel( AstNode* arhsp = new AstArraySel(
nodep->fileline(), new AstVarRef(nodep->fileline(), m_tableVarps[outnum], false), nodep->fileline(), new AstVarRef(nodep->fileline(), m_tableVarps[outnum], false),

9
src/V3Task.cpp
View File

@ -121,7 +121,7 @@ public:
return scopep; return scopep;
} }
AstVarScope* findVarScope(AstScope* scopep, AstVar* nodep) { AstVarScope* findVarScope(AstScope* scopep, AstVar* nodep) {
VarToScopeMap::iterator iter = m_varToScopeMap.find(make_pair(scopep, nodep)); const auto iter = m_varToScopeMap.find(make_pair(scopep, nodep));
UASSERT_OBJ(iter != m_varToScopeMap.end(), nodep, "No scope for var"); UASSERT_OBJ(iter != m_varToScopeMap.end(), nodep, "No scope for var");
return iter->second; return iter->second;
} }
@ -233,8 +233,7 @@ private:
iterateChildren(nodep); iterateChildren(nodep);
} }
UASSERT_OBJ(m_ctorp, nodep, "class constructor missing"); // LinkDot always makes it UASSERT_OBJ(m_ctorp, nodep, "class constructor missing"); // LinkDot always makes it
for (Initials::iterator it = m_initialps.begin(); it != m_initialps.end(); ++it) { for (AstInitial* initialp : m_initialps) {
AstInitial* initialp = *it;
if (AstNode* newp = initialp->bodysp()) { if (AstNode* newp = initialp->bodysp()) {
newp->unlinkFrBackWithNext(); newp->unlinkFrBackWithNext();
if (!m_ctorp->stmtsp()) { if (!m_ctorp->stmtsp()) {
@ -812,7 +811,7 @@ private:
bool duplicatedDpiProto(AstNodeFTask* nodep, const string& dpiproto) { bool duplicatedDpiProto(AstNodeFTask* nodep, const string& dpiproto) {
// Only create one DPI extern prototype for each specified cname // Only create one DPI extern prototype for each specified cname
// as it's legal for the user to attach multiple tasks to one dpi cname // as it's legal for the user to attach multiple tasks to one dpi cname
DpiNames::iterator iter = m_dpiNames.find(nodep->cname()); const auto iter = m_dpiNames.find(nodep->cname());
if (iter == m_dpiNames.end()) { if (iter == m_dpiNames.end()) {
m_dpiNames.insert(make_pair(nodep->cname(), make_pair(nodep, dpiproto))); m_dpiNames.insert(make_pair(nodep->cname(), make_pair(nodep, dpiproto)));
return false; return false;
@ -1401,7 +1400,7 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
UASSERT_OBJ(argp, pinp, "Non-arg under ftask reference"); UASSERT_OBJ(argp, pinp, "Non-arg under ftask reference");
if (argp->name() != "") { if (argp->name() != "") {
// By name // By name
NameToIndex::iterator it = nameToIndex.find(argp->name()); const auto it = nameToIndex.find(argp->name());
if (it == nameToIndex.end()) { if (it == nameToIndex.end()) {
pinp->v3error("No such argument " << argp->prettyNameQ() << " in function call to " pinp->v3error("No such argument " << argp->prettyNameQ() << " in function call to "
<< nodep->taskp()->prettyTypeName()); << nodep->taskp()->prettyTypeName());

15
src/V3Trace.cpp
View File

@ -220,7 +220,7 @@ private:
if (TraceTraceVertex* const vvertexp = dynamic_cast<TraceTraceVertex*>(itp)) { if (TraceTraceVertex* const vvertexp = dynamic_cast<TraceTraceVertex*>(itp)) {
AstTraceDecl* const nodep = vvertexp->nodep(); AstTraceDecl* const nodep = vvertexp->nodep();
if (nodep->valuep() && !vvertexp->duplicatep()) { if (nodep->valuep() && !vvertexp->duplicatep()) {
V3Hashed::iterator dupit = hashed.findDuplicate(nodep->valuep()); const auto dupit = hashed.findDuplicate(nodep->valuep());
if (dupit != hashed.end()) { if (dupit != hashed.end()) {
const AstTraceDecl* const dupDeclp const AstTraceDecl* const dupDeclp
= VN_CAST_CONST(hashed.iteratorNodep(dupit)->backp(), TraceDecl); = VN_CAST_CONST(hashed.iteratorNodep(dupit)->backp(), TraceDecl);
@ -381,10 +381,10 @@ private:
// For each activity set with only a small number of signals, make those // For each activity set with only a small number of signals, make those
// signals always traced, as it's cheaper to check a few value changes // signals always traced, as it's cheaper to check a few value changes
// than to test a lot of activity flags // than to test a lot of activity flags
TraceVec::iterator it = traces.begin(); auto it = traces.begin();
const TraceVec::iterator end = traces.end(); const auto end = traces.end();
while (it != end) { while (it != end) {
TraceVec::iterator head = it; auto head = it;
// Approximate the complexity of the value change check // Approximate the complexity of the value change check
uint32_t complexity = 0; uint32_t complexity = 0;
const ActCodeSet& actSet = it->first; const ActCodeSet& actSet = it->first;
@ -533,8 +533,8 @@ private:
int topFuncNum = 0; int topFuncNum = 0;
int subFuncNum = 0; int subFuncNum = 0;
TraceVec::const_iterator it = traces.begin(); auto it = traces.cbegin();
while (it != traces.end()) { while (it != traces.cend()) {
AstCFunc* topFuncp = nullptr; AstCFunc* topFuncp = nullptr;
AstCFunc* subFuncp = nullptr; AstCFunc* subFuncp = nullptr;
int subStmts = 0; int subStmts = 0;
@ -637,8 +637,7 @@ private:
if (always) { if (always) {
condp = new AstConst(flp, 1); // Always true, will be folded later condp = new AstConst(flp, 1); // Always true, will be folded later
} else { } else {
for (ActCodeSet::iterator it = actSet.begin(); it != actSet.end(); ++it) { for (const uint32_t actCode : actSet) {
const uint32_t actCode = *it;
AstNode* const selp = selectActivity(flp, actCode, false); AstNode* const selp = selectActivity(flp, actCode, false);
condp = condp ? new AstOr(flp, condp, selp) : selp; condp = condp ? new AstOr(flp, condp, selp) : selp;
} }

4
src/V3Tristate.cpp
View File

@ -421,7 +421,7 @@ class TristateVisitor : public TristateBaseVisitor {
void mapInsertLhsVarRef(AstVarRef* nodep) { void mapInsertLhsVarRef(AstVarRef* nodep) {
AstVar* key = nodep->varp(); AstVar* key = nodep->varp();
VarMap::iterator it = m_lhsmap.find(key); const auto it = m_lhsmap.find(key);
UINFO(9, " mapInsertLhsVarRef " << nodep << endl); UINFO(9, " mapInsertLhsVarRef " << nodep << endl);
if (it == m_lhsmap.end()) { // Not found if (it == m_lhsmap.end()) { // Not found
RefVec* refsp = new RefVec(); RefVec* refsp = new RefVec();
@ -482,7 +482,7 @@ class TristateVisitor : public TristateBaseVisitor {
for (TristateGraph::VarVec::iterator ii = vars.begin(); ii != vars.end(); ++ii) { for (TristateGraph::VarVec::iterator ii = vars.begin(); ii != vars.end(); ++ii) {
AstVar* varp = (*ii); AstVar* varp = (*ii);
if (m_tgraph.isTristate(varp)) { if (m_tgraph.isTristate(varp)) {
VarMap::iterator it = m_lhsmap.find(varp); const auto it = m_lhsmap.find(varp);
if (it == m_lhsmap.end()) { if (it == m_lhsmap.end()) {
// set output enable to always be off on this assign // set output enable to always be off on this assign
// statement so that this var is floating // statement so that this var is floating

10
src/V3Undriven.cpp
View File

@ -441,15 +441,9 @@ public:
// CONSTRUCTORS // CONSTRUCTORS
explicit UndrivenVisitor(AstNetlist* nodep) { iterate(nodep); } explicit UndrivenVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~UndrivenVisitor() override { virtual ~UndrivenVisitor() override {
for (std::vector<UndrivenVarEntry*>::iterator it = m_entryps[1].begin(); for (UndrivenVarEntry* ip : m_entryps[1]) ip->reportViolations();
it != m_entryps[1].end(); ++it) {
(*it)->reportViolations();
}
for (int usr = 1; usr < 3; ++usr) { for (int usr = 1; usr < 3; ++usr) {
for (std::vector<UndrivenVarEntry*>::iterator it = m_entryps[usr].begin(); for (UndrivenVarEntry* ip : m_entryps[usr]) delete ip;
it != m_entryps[usr].end(); ++it) {
delete (*it);
}
} }
} }
}; };

10
src/V3Width.cpp
View File

@ -2876,7 +2876,7 @@ private:
AstNode* newp = nullptr; AstNode* newp = nullptr;
for (AstMemberDType* memp = vdtypep->membersp(); memp; for (AstMemberDType* memp = vdtypep->membersp(); memp;
memp = VN_CAST(memp->nextp(), MemberDType)) { memp = VN_CAST(memp->nextp(), MemberDType)) {
PatMap::iterator it = patmap.find(memp); const auto it = patmap.find(memp);
AstPatMember* newpatp = nullptr; AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr; AstPatMember* patp = nullptr;
if (it == patmap.end()) { if (it == patmap.end()) {
@ -2923,7 +2923,7 @@ private:
for (int ent = range.hi(); ent >= range.lo(); --ent) { for (int ent = range.hi(); ent >= range.lo(); --ent) {
AstPatMember* newpatp = nullptr; AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr; AstPatMember* patp = nullptr;
PatVecMap::iterator it = patmap.find(ent); const auto it = patmap.find(ent);
if (it == patmap.end()) { if (it == patmap.end()) {
if (defaultp) { if (defaultp) {
newpatp = defaultp->cloneTree(false); newpatp = defaultp->cloneTree(false);
@ -2978,7 +2978,7 @@ private:
for (int ent = range.hi(); ent >= range.lo(); --ent) { for (int ent = range.hi(); ent >= range.lo(); --ent) {
AstPatMember* newpatp = nullptr; AstPatMember* newpatp = nullptr;
AstPatMember* patp = nullptr; AstPatMember* patp = nullptr;
PatVecMap::iterator it = patmap.find(ent); const auto it = patmap.find(ent);
if (it == patmap.end()) { if (it == patmap.end()) {
if (defaultp) { if (defaultp) {
newpatp = defaultp->cloneTree(false); newpatp = defaultp->cloneTree(false);
@ -5158,7 +5158,7 @@ private:
} }
AstVar* dimensionVarp(AstNodeDType* nodep, AstAttrType attrType, uint32_t msbdim) { AstVar* dimensionVarp(AstNodeDType* nodep, AstAttrType attrType, uint32_t msbdim) {
// Return a variable table which has specified dimension properties for this variable // Return a variable table which has specified dimension properties for this variable
TableMap::iterator pos = m_tableMap.find(make_pair(nodep, attrType)); const auto pos = m_tableMap.find(make_pair(nodep, attrType));
if (pos != m_tableMap.end()) return pos->second; if (pos != m_tableMap.end()) return pos->second;
AstNodeArrayDType* vardtypep AstNodeArrayDType* vardtypep
= new AstUnpackArrayDType(nodep->fileline(), nodep->findSigned32DType(), = new AstUnpackArrayDType(nodep->fileline(), nodep->findSigned32DType(),
@ -5185,7 +5185,7 @@ private:
} }
AstVar* enumVarp(AstEnumDType* nodep, AstAttrType attrType, uint32_t msbdim) { AstVar* enumVarp(AstEnumDType* nodep, AstAttrType attrType, uint32_t msbdim) {
// Return a variable table which has specified dimension properties for this variable // Return a variable table which has specified dimension properties for this variable
TableMap::iterator pos = m_tableMap.find(make_pair(nodep, attrType)); const auto pos = m_tableMap.find(make_pair(nodep, attrType));
if (pos != m_tableMap.end()) return pos->second; if (pos != m_tableMap.end()) return pos->second;
UINFO(9, "Construct Venumtab attr=" << attrType.ascii() << " max=" << msbdim << " for " UINFO(9, "Construct Venumtab attr=" << attrType.ascii() << " max=" << msbdim << " for "
<< nodep << endl); << nodep << endl);

10
src/VlcMain.cpp
View File

@ -154,10 +154,7 @@ int main(int argc, char** argv, char** /*env*/) {
{ {
const VlStringSet& readFiles = top.opt.readFiles(); const VlStringSet& readFiles = top.opt.readFiles();
for (VlStringSet::const_iterator it = readFiles.begin(); it != readFiles.end(); ++it) { for (const auto& filename : readFiles) top.readCoverage(filename);
string filename = *it;
top.readCoverage(filename);
}
} }
if (debug() >= 9) { if (debug() >= 9) {
@ -179,10 +176,7 @@ int main(int argc, char** argv, char** /*env*/) {
V3Error::abortIfWarnings(); V3Error::abortIfWarnings();
if (top.opt.unlink()) { if (top.opt.unlink()) {
const VlStringSet& readFiles = top.opt.readFiles(); const VlStringSet& readFiles = top.opt.readFiles();
for (VlStringSet::const_iterator it = readFiles.begin(); it != readFiles.end(); ++it) { for (const auto& filename : readFiles) { unlink(filename.c_str()); }
string filename = *it;
unlink(filename.c_str());
}
} }
} }

6
src/VlcPoint.h
View File

@ -113,15 +113,15 @@ public:
void dump() { void dump() {
UINFO(2, "dumpPoints...\n"); UINFO(2, "dumpPoints...\n");
VlcPoint::dumpHeader(); VlcPoint::dumpHeader();
for (VlcPoints::ByName::const_iterator it = begin(); it != end(); ++it) { for (const auto& i : *this) {
const VlcPoint& point = pointNumber(it->second); const VlcPoint& point = pointNumber(i.second);
point.dump(); point.dump();
} }
} }
VlcPoint& pointNumber(vluint64_t num) { return m_points[num]; } VlcPoint& pointNumber(vluint64_t num) { return m_points[num]; }
vluint64_t findAddPoint(const string& name, vluint64_t count) { vluint64_t findAddPoint(const string& name, vluint64_t count) {
vluint64_t pointnum; vluint64_t pointnum;
NameMap::const_iterator iter = m_nameMap.find(name); const auto iter = m_nameMap.find(name);
if (iter != m_nameMap.end()) { if (iter != m_nameMap.end()) {
pointnum = iter->second; pointnum = iter->second;
m_points[pointnum].countInc(count); m_points[pointnum].countInc(count);

10
src/VlcTest.h
View File

@ -102,18 +102,14 @@ public:
// CONSTRUCTORS // CONSTRUCTORS
VlcTests() {} VlcTests() {}
~VlcTests() { ~VlcTests() {
for (VlcTests::ByName::iterator it = begin(); it != end(); ++it) { for (auto it = begin(); it != end(); ++it) { VL_DO_CLEAR(delete *it, *it = nullptr); }
VL_DO_CLEAR(delete *it, *it = nullptr);
}
} }
// METHODS // METHODS
void dump(bool bucketsToo) { void dump(bool bucketsToo) {
UINFO(2, "dumpTests...\n"); UINFO(2, "dumpTests...\n");
VlcTest::dumpHeader(); VlcTest::dumpHeader();
for (VlcTests::ByName::const_iterator it = begin(); it != end(); ++it) { for (const auto& testp : m_tests) testp->dump(bucketsToo);
(*it)->dump(bucketsToo);
}
} }
VlcTest* newTest(const string& name, vluint64_t testrun, double comp) { VlcTest* newTest(const string& name, vluint64_t testrun, double comp) {
VlcTest* testp = new VlcTest(name, testrun, comp); VlcTest* testp = new VlcTest(name, testrun, comp);
@ -121,7 +117,7 @@ public:
return testp; return testp;
} }
void clearUser() { void clearUser() {
for (ByName::iterator it = m_tests.begin(); it != m_tests.end(); ++it) (*it)->user(0); for (const auto& testp : m_tests) testp->user(0);
} }
}; };

56
src/VlcTop.cpp
View File

@ -70,8 +70,8 @@ void VlcTop::writeCoverage(const string& filename) {
} }
os << "# SystemC::Coverage-3" << endl; os << "# SystemC::Coverage-3" << endl;
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) { for (const auto& i : m_points) {
const VlcPoint& point = m_points.pointNumber(it->second); const VlcPoint& point = m_points.pointNumber(i.second);
os << "C '" << point.name() << "' " << point.count() << endl; os << "C '" << point.name() << "' " << point.count() << endl;
} }
} }
@ -107,17 +107,17 @@ void VlcTop::writeInfo(const string& filename) {
// end_of_record // end_of_record
os << "TN:verilator_coverage\n"; os << "TN:verilator_coverage\n";
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) { for (auto& si : m_sources) {
VlcSource& source = sit->second; VlcSource& source = si.second;
os << "SF:" << source.name() << endl; os << "SF:" << source.name() << endl;
VlcSource::LinenoMap& lines = source.lines(); VlcSource::LinenoMap& lines = source.lines();
for (VlcSource::LinenoMap::iterator lit = lines.begin(); lit != lines.end(); ++lit) { for (auto& li : lines) {
int lineno = lit->first; int lineno = li.first;
VlcSource::ColumnMap& cmap = lit->second; VlcSource::ColumnMap& cmap = li.second;
bool first = true; bool first = true;
vluint64_t min_count = 0; // Minimum across all columns on line vluint64_t min_count = 0; // Minimum across all columns on line
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) { for (auto& ci : cmap) {
VlcSourceCount& col = cit->second; VlcSourceCount& col = ci.second;
if (first) { if (first) {
min_count = col.count(); min_count = col.count();
first = false; first = false;
@ -148,17 +148,16 @@ void VlcTop::rank() {
// Sort by computrons, so fast tests get selected first // Sort by computrons, so fast tests get selected first
std::vector<VlcTest*> bytime; std::vector<VlcTest*> bytime;
for (VlcTests::ByName::const_iterator it = m_tests.begin(); it != m_tests.end(); ++it) { for (const auto& testp : m_tests) {
VlcTest* testp = *it;
if (testp->bucketsCovered()) { // else no points, so can't help us if (testp->bucketsCovered()) { // else no points, so can't help us
bytime.push_back(*it); bytime.push_back(testp);
} }
} }
sort(bytime.begin(), bytime.end(), CmpComputrons()); // Sort the vector sort(bytime.begin(), bytime.end(), CmpComputrons()); // Sort the vector
VlcBuckets remaining; VlcBuckets remaining;
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) { for (const auto& i : m_points) {
VlcPoint* pointp = &points().pointNumber(it->second); VlcPoint* pointp = &points().pointNumber(i.second);
// If any tests hit this point, then we'll need to cover it. // If any tests hit this point, then we'll need to cover it.
if (pointp->testsCovering()) remaining.addData(pointp->pointNum(), 1); if (pointp->testsCovering()) remaining.addData(pointp->pointNum(), 1);
} }
@ -174,8 +173,7 @@ void VlcTop::rank() {
} }
VlcTest* bestTestp = nullptr; VlcTest* bestTestp = nullptr;
vluint64_t bestRemain = 0; vluint64_t bestRemain = 0;
for (std::vector<VlcTest*>::iterator it = bytime.begin(); it != bytime.end(); ++it) { for (const auto& testp : bytime) {
VlcTest* testp = *it;
if (!testp->rank()) { if (!testp->rank()) {
vluint64_t remain = testp->buckets().dataPopCount(remaining); vluint64_t remain = testp->buckets().dataPopCount(remaining);
if (remain > bestRemain) { if (remain > bestRemain) {
@ -198,8 +196,8 @@ void VlcTop::rank() {
void VlcTop::annotateCalc() { void VlcTop::annotateCalc() {
// Calculate per-line information into filedata structure // Calculate per-line information into filedata structure
for (VlcPoints::ByName::const_iterator it = m_points.begin(); it != m_points.end(); ++it) { for (const auto& i : m_points) {
const VlcPoint& point = m_points.pointNumber(it->second); const VlcPoint& point = m_points.pointNumber(i.second);
string filename = point.filename(); string filename = point.filename();
int lineno = point.lineno(); int lineno = point.lineno();
if (!filename.empty() && lineno != 0) { if (!filename.empty() && lineno != 0) {
@ -244,15 +242,15 @@ void VlcTop::annotateCalcNeeded() {
// coverage in all categories // coverage in all categories
int totCases = 0; int totCases = 0;
int totOk = 0; int totOk = 0;
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) { for (auto& si : m_sources) {
VlcSource& source = sit->second; VlcSource& source = si.second;
// UINFO(1,"Source "<<source.name()<<endl); // UINFO(1,"Source "<<source.name()<<endl);
if (opt.annotateAll()) source.needed(true); if (opt.annotateAll()) source.needed(true);
VlcSource::LinenoMap& lines = source.lines(); VlcSource::LinenoMap& lines = source.lines();
for (VlcSource::LinenoMap::iterator lit = lines.begin(); lit != lines.end(); ++lit) { for (auto& li : lines) {
VlcSource::ColumnMap& cmap = lit->second; VlcSource::ColumnMap& cmap = li.second;
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) { for (auto& ci : cmap) {
VlcSourceCount& col = cit->second; VlcSourceCount& col = ci.second;
// UINFO(0,"Source "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl); // UINFO(0,"Source "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl);
++totCases; ++totCases;
if (col.ok()) { if (col.ok()) {
@ -272,8 +270,8 @@ void VlcTop::annotateCalcNeeded() {
void VlcTop::annotateOutputFiles(const string& dirname) { void VlcTop::annotateOutputFiles(const string& dirname) {
// Create if uncreated, ignore errors // Create if uncreated, ignore errors
V3Os::createDir(dirname); V3Os::createDir(dirname);
for (VlcSources::NameMap::iterator sit = m_sources.begin(); sit != m_sources.end(); ++sit) { for (auto& si : m_sources) {
VlcSource& source = sit->second; VlcSource& source = si.second;
if (!source.needed()) continue; if (!source.needed()) continue;
string filename = source.name(); string filename = source.name();
string outfilename = dirname + "/" + V3Os::filenameNonDir(filename); string outfilename = dirname + "/" + V3Os::filenameNonDir(filename);
@ -302,11 +300,11 @@ void VlcTop::annotateOutputFiles(const string& dirname) {
bool first = true; bool first = true;
VlcSource::LinenoMap& lines = source.lines(); VlcSource::LinenoMap& lines = source.lines();
VlcSource::LinenoMap::iterator lit = lines.find(lineno); const auto lit = lines.find(lineno);
if (lit != lines.end()) { if (lit != lines.end()) {
VlcSource::ColumnMap& cmap = lit->second; VlcSource::ColumnMap& cmap = lit->second;
for (VlcSource::ColumnMap::iterator cit = cmap.begin(); cit != cmap.end(); ++cit) { for (auto& ci : cmap) {
VlcSourceCount& col = cit->second; VlcSourceCount& col = ci.second;
// UINFO(0,"Source // UINFO(0,"Source
// "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl); // "<<source.name()<<":"<<col.lineno()<<":"<<col.column()<<endl);
os << (col.ok() ? " " : "%") << std::setfill('0') << std::setw(6) os << (col.ok() ? " " : "%") << std::setfill('0') << std::setw(6)

34
test_regress/t/t_scope_map.cpp
View File

@ -48,19 +48,18 @@ int main(int argc, char** argv, char** env) {
return -1; return -1;
} }
for (VerilatedVarNameMap::iterator varIt = varNameMap->begin(); varIt != varNameMap->end(); for (const auto& varname : *varNameMap) {
++varIt) { const VerilatedVar* varp = &(varname.second);
VerilatedVar* var = &varIt->second; int varLeft = varp->packed().left();
int varLeft = var->packed().left(); int varRight = varp->packed().right();
int varRight = var->packed().right();
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
VL_PRINTF("\tVar = %s\n", varIt->first); VL_PRINTF("\tVar = %s\n", varname.first);
VL_PRINTF("\t Type = %d\n", var->vltype()); VL_PRINTF("\t Type = %d\n", varp->vltype());
VL_PRINTF("\t EntSize = %d\n", var->entSize()); VL_PRINTF("\t EntSize = %d\n", varp->entSize());
VL_PRINTF("\t Dims = %d\n", var->dims()); VL_PRINTF("\t Dims = %d\n", varp->dims());
VL_PRINTF("\t Range = %d:%d\n", varLeft, varRight); VL_PRINTF("\t Range = %d:%d\n", varLeft, varRight);
VL_PRINTF("\t Is RW = %d\n", var->isPublicRW()); VL_PRINTF("\t Is RW = %d\n", varp->isPublicRW());
#endif #endif
if (varRight != 0) { if (varRight != 0) {
@ -71,7 +70,7 @@ int main(int argc, char** argv, char** env) {
int varBits = varLeft + 1; int varBits = varLeft + 1;
// First expect an incrementing byte pattern // First expect an incrementing byte pattern
vluint8_t* varData = reinterpret_cast<vluint8_t*>(var->datap()); vluint8_t* varData = reinterpret_cast<vluint8_t*>(varp->datap());
for (int i = 0; i < varBits / 8; i++) { for (int i = 0; i < varBits / 8; i++) {
#ifdef TEST_VERBOSE #ifdef TEST_VERBOSE
VL_PRINTF("%02x ", varData[i]); VL_PRINTF("%02x ", varData[i]);
@ -124,19 +123,18 @@ int main(int argc, char** argv, char** env) {
return -1; return -1;
} }
for (VerilatedVarNameMap::iterator varIt = varNameMap->begin(); varIt != varNameMap->end(); for (const auto& varname : *varNameMap) {
++varIt) { const VerilatedVar* varp = &(varname.second);
VerilatedVar* var = &varIt->second; int varLeft = varp->packed().left();
int varLeft = var->packed().left();
int varBits = varLeft + 1; int varBits = varLeft + 1;
vluint8_t* varData = reinterpret_cast<vluint8_t*>(var->datap()); vluint8_t* varData = reinterpret_cast<vluint8_t*>(varp->datap());
// Check that all bits are high now // Check that all bits are high now
for (int i = 0; i < varBits / 8; i++) { for (int i = 0; i < varBits / 8; i++) {
vluint8_t expected = 0xff; vluint8_t expected = 0xff;
if (varData[i] != expected) { if (varData[i] != expected) {
VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n", VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n",
varIt->first, varData[i], expected); varname.first, varData[i], expected);
return -1; return -1;
} }
} }
@ -146,7 +144,7 @@ int main(int argc, char** argv, char** env) {
vluint8_t expected = ~(0xff << (varBits % 8)); vluint8_t expected = ~(0xff << (varBits % 8));
if (got != expected) { if (got != expected) {
VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n", VL_PRINTF("%%Error: Data mismatch (%s), got 0x%02x, expected 0x%02x\n",
varIt->first, got, expected); varname.first, got, expected);
return -1; return -1;
} }
} }