Internals: Add std:: to make_pair. No functional change.

include/verilated_cov.cpp

@@ -395,7 +395,7 @@ public:
                 cit->second.second += itemp->count();
                 cit->second.first = combineHier(oldhier, hier);
             } else {
-                eventCounts.emplace(name, make_pair(hier, itemp->count()));
+                eventCounts.emplace(name, std::make_pair(hier, itemp->count()));
             }
         }
 

src/V3AstNodes.cpp

@@ -784,7 +784,7 @@ std::pair<uint32_t, uint32_t> AstNodeDType::dimensions(bool includeBasic) {
         }
         break;
     }
-    return make_pair(packed, unpacked);
+    return std::make_pair(packed, unpacked);
 }
 
 int AstNodeDType::widthPow2() const {

src/V3Class.cpp

@@ -100,7 +100,7 @@ private:
         // Don't move now, or wouldn't keep interating the class
         // TODO move class statics too
         if (m_packageScopep && m_ftaskp && m_ftaskp->lifetime().isStatic()) {
-            m_moves.push_back(make_pair(nodep, m_packageScopep));
+            m_moves.push_back(std::make_pair(nodep, m_packageScopep));
         }
     }
 
@@ -115,7 +115,7 @@ private:
             m_ftaskp = nodep;
             iterateChildren(nodep);
             if (m_packageScopep && nodep->lifetime().isStatic()) {
-                m_moves.push_back(make_pair(nodep, m_packageScopep));
+                m_moves.push_back(std::make_pair(nodep, m_packageScopep));
             }
         }
     }
@@ -125,7 +125,7 @@ private:
         // Don't move now, or wouldn't keep interating the class
         // TODO move function statics only
         // if (m_classScopep) {
-        //    m_moves.push_back(make_pair(nodep, m_classScopep));
+        //    m_moves.push_back(std::make_pair(nodep, m_classScopep));
         //}
     }
 

src/V3Config.cpp

@@ -292,7 +292,7 @@ public:
         m_lastIgnore.it = m_ignLines.begin();
     }
     void addWaiver(V3ErrorCode code, const string& match) {
-        m_waivers.push_back(make_pair(code, match));
+        m_waivers.push_back(std::make_pair(code, match));
     }
 
     void applyBlock(AstNodeBlock* nodep) {

src/V3Delayed.cpp

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

src/V3EmitCSyms.cpp

@@ -217,12 +217,12 @@ class EmitCSyms final : EmitCBaseVisitor {
                     // UINFO(9," scnameins sp "<<scpName<<" sp "<<scpPretty<<" ss "<<scpSym<<endl);
                     if (v3Global.opt.vpi()) varHierarchyScopes(scpName);
                     if (m_scopeNames.find(scpSym) == m_scopeNames.end()) {
-                        m_scopeNames.insert(
+                        m_scopeNames.insert(std::make_pair(
-                            make_pair(scpSym, ScopeData(scpSym, scpPretty, 0, "SCOPE_OTHER")));
+                            scpSym, ScopeData(scpSym, scpPretty, 0, "SCOPE_OTHER")));
                     }
                     m_scopeVars.insert(
-                        make_pair(scpSym + " " + varp->name(),
+                        std::make_pair(scpSym + " " + varp->name(),
-                                  ScopeVarData(scpSym, varBasePretty, varp, modp, scopep)));
+                                       ScopeVarData(scpSym, varBasePretty, varp, modp, scopep)));
                 }
             }
         }
@@ -288,21 +288,21 @@ class EmitCSyms final : EmitCBaseVisitor {
             string name_dedot = AstNode::dedotName(name);
             int timeunit = m_modp->timeunit().powerOfTen();
             m_vpiScopeCandidates.insert(
-                make_pair(name, ScopeData(scopeSymString(name), name_dedot, timeunit, type)));
+                std::make_pair(name, ScopeData(scopeSymString(name), name_dedot, timeunit, type)));
         }
     }
     virtual void visit(AstScope* nodep) override {
         if (VN_IS(m_modp, Class)) return;  // The ClassPackage is what is visible
         nameCheck(nodep);
 
-        m_scopes.emplace_back(make_pair(nodep, m_modp));
+        m_scopes.emplace_back(std::make_pair(nodep, m_modp));
 
         if (v3Global.opt.vpi() && !nodep->isTop()) {
             string name_dedot = AstNode::dedotName(nodep->shortName());
             int timeunit = m_modp->timeunit().powerOfTen();
             m_vpiScopeCandidates.insert(
-                make_pair(nodep->name(), ScopeData(scopeSymString(nodep->name()), name_dedot,
+                std::make_pair(nodep->name(), ScopeData(scopeSymString(nodep->name()), name_dedot,
-                                                   timeunit, "SCOPE_MODULE")));
+                                                        timeunit, "SCOPE_MODULE")));
         }
     }
     virtual void visit(AstScopeName* nodep) override {
@@ -316,21 +316,21 @@ class EmitCSyms final : EmitCBaseVisitor {
         }
         if (nodep->dpiExport()) {
             UASSERT_OBJ(m_cfuncp, nodep, "ScopeName not under DPI function");
-            m_scopeFuncs.insert(
+            m_scopeFuncs.insert(std::make_pair(name + " " + m_cfuncp->name(),
-                make_pair(name + " " + m_cfuncp->name(), ScopeFuncData(nodep, m_cfuncp, m_modp)));
+                                               ScopeFuncData(nodep, m_cfuncp, m_modp)));
         } else {
             if (m_scopeNames.find(nodep->scopeDpiName()) == m_scopeNames.end()) {
                 m_scopeNames.insert(
-                    make_pair(nodep->scopeDpiName(),
+                    std::make_pair(nodep->scopeDpiName(),
-                              ScopeData(nodep->scopeDpiName(), nodep->scopePrettyDpiName(),
+                                   ScopeData(nodep->scopeDpiName(), nodep->scopePrettyDpiName(),
-                                        timeunit, "SCOPE_OTHER")));
+                                             timeunit, "SCOPE_OTHER")));
             }
         }
     }
     virtual void visit(AstVar* nodep) override {
         nameCheck(nodep);
         iterateChildren(nodep);
-        if (nodep->isSigUserRdPublic()) m_modVars.emplace_back(make_pair(m_modp, nodep));
+        if (nodep->isSigUserRdPublic()) m_modVars.emplace_back(std::make_pair(m_modp, nodep));
     }
     virtual void visit(AstCoverDecl* nodep) override {
         // Assign numbers to all bins, so we know how big of an array to use

src/V3LinkDot.cpp

@@ -407,18 +407,19 @@ public:
     void implicitOkAdd(AstNodeModule* nodep, const string& varname) {
         // Mark the given variable name as being allowed to be implicitly declared
         if (nodep) {
-            const auto it = m_implicitNameSet.find(make_pair(nodep, varname));
+            const auto it = m_implicitNameSet.find(std::make_pair(nodep, varname));
             if (it == m_implicitNameSet.end()) m_implicitNameSet.emplace(nodep, varname);
         }
     }
     bool implicitOk(AstNodeModule* nodep, const string& varname) {
         return nodep
-               && (m_implicitNameSet.find(make_pair(nodep, varname)) != m_implicitNameSet.end());
+               && (m_implicitNameSet.find(std::make_pair(nodep, varname))
+                   != m_implicitNameSet.end());
     }
 
     // Track and later recurse interface modules
     void insertIfaceModSym(AstIface* nodep, VSymEnt* symp) {
-        m_ifaceModSyms.push_back(make_pair(nodep, symp));
+        m_ifaceModSyms.push_back(std::make_pair(nodep, symp));
     }
     void computeIfaceModSyms();
 

src/V3LinkParse.cpp

@@ -363,7 +363,7 @@ private:
         // a new type won't change every verilated module.
         AstTypedef* defp = nullptr;
         ImplTypedefMap::iterator it
-            = m_implTypedef.find(make_pair(nodep->containerp(), nodep->name()));
+            = m_implTypedef.find(std::make_pair(nodep->containerp(), nodep->name()));
         if (it != m_implTypedef.end()) {
             defp = it->second;
         } else {
@@ -387,7 +387,7 @@ private:
                 defp = new AstTypedef(nodep->fileline(), nodep->name(), nullptr, VFlagChildDType(),
                                       dtypep);
                 m_implTypedef.insert(
-                    make_pair(make_pair(nodep->containerp(), defp->name()), defp));
+                    std::make_pair(std::make_pair(nodep->containerp(), defp->name()), defp));
                 backp->addNextHere(defp);
             }
         }

src/V3Order.cpp

@@ -158,7 +158,7 @@ public:
     }
     V3List<OrderMoveVertex*>& readyVertices() { return m_readyVertices; }
     static OrderMoveDomScope* findCreate(const AstSenTree* domainp, const AstScope* scopep) {
-        const DomScopeKey key = make_pair(domainp, scopep);
+        const DomScopeKey key = std::make_pair(domainp, scopep);
         const auto iter = s_dsMap.find(key);
         if (iter != s_dsMap.end()) {
             return iter->second;

src/V3Param.cpp

@@ -323,7 +323,7 @@ class ParamProcessor final {
             num = it->second.first;
         } else {
             num = m_nextValue++;
-            m_valueMap[hash] = make_pair(num, key);
+            m_valueMap[hash] = std::make_pair(num, key);
         }
         return string("z") + cvtToStr(num);
     }
@@ -712,7 +712,7 @@ class ParamProcessor final {
                         longnamer += ("_" + paramSmallName(srcModp, pinp->modVarp())
                                       + paramValueNumber(pinIrefp));
                         any_overridesr = true;
-                        ifaceRefRefs.push_back(make_pair(portIrefp, pinIrefp));
+                        ifaceRefRefs.push_back(std::make_pair(portIrefp, pinIrefp));
                         if (portIrefp->ifacep() != pinIrefp->ifacep()
                             // Might be different only due to param cloning, so check names too
                             && portIrefp->ifaceName() != pinIrefp->ifaceName()) {

src/V3Scope.cpp

@@ -72,7 +72,7 @@ private:
                 UASSERT_OBJ(it2 != m_packageScopes.end(), nodep, "Can't locate package scope");
                 scopep = it2->second;
             }
-            const auto it3 = m_varScopes.find(make_pair(nodep->varp(), scopep));
+            const auto it3 = m_varScopes.find(std::make_pair(nodep->varp(), scopep));
             UASSERT_OBJ(it3 != m_varScopes.end(), nodep, "Can't locate varref scope");
             AstVarScope* varscp = it3->second;
             nodep->varScopep(varscp);
@@ -271,7 +271,7 @@ private:
                 nodep->attrClocker(VVarAttrClocker::CLOCKER_NO);
             }
             UASSERT_OBJ(m_scopep, nodep, "No scope for var");
-            m_varScopes.emplace(make_pair(nodep, m_scopep), varscp);
+            m_varScopes.emplace(std::make_pair(nodep, m_scopep), varscp);
             m_scopep->addVarp(varscp);
         }
     }

src/V3Task.cpp

@@ -123,7 +123,7 @@ public:
         return scopep;
     }
     AstVarScope* findVarScope(AstScope* scopep, AstVar* nodep) {
-        const auto iter = m_varToScopeMap.find(make_pair(scopep, nodep));
+        const auto iter = m_varToScopeMap.find(std::make_pair(scopep, nodep));
         UASSERT_OBJ(iter != m_varToScopeMap.end(), nodep, "No scope for var");
         return iter->second;
     }
@@ -911,7 +911,7 @@ private:
         // as it's legal for the user to attach multiple tasks to one dpi cname
         const auto iter = m_dpiNames.find(nodep->cname());
         if (iter == m_dpiNames.end()) {
-            m_dpiNames.emplace(nodep->cname(), make_pair(nodep, dpiproto));
+            m_dpiNames.emplace(nodep->cname(), std::make_pair(nodep, dpiproto));
             return false;
         } else if (iter->second.second != dpiproto) {
             nodep->v3error(
@@ -1479,9 +1479,9 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
     for (AstNode* stmtp = taskStmtsp; stmtp; stmtp = stmtp->nextp()) {
         if (AstVar* portp = VN_CAST(stmtp, Var)) {
             if (portp->isIO()) {
-                tconnects.push_back(make_pair(portp, static_cast<AstArg*>(nullptr)));
+                tconnects.push_back(std::make_pair(portp, static_cast<AstArg*>(nullptr)));
                 nameToIndex.insert(
-                    make_pair(portp->name(), tpinnum));  // For name based connections
+                    std::make_pair(portp->name(), tpinnum));  // For name based connections
                 tpinnum++;
                 if (portp->attrSFormat()) {
                     sformatp = portp;
@@ -1521,7 +1521,7 @@ V3TaskConnects V3Task::taskConnects(AstNodeFTaskRef* nodep, AstNode* taskStmtsp)
         } else {  // By pin number
             if (ppinnum >= tpinnum) {
                 if (sformatp) {
-                    tconnects.push_back(make_pair(sformatp, static_cast<AstArg*>(nullptr)));
+                    tconnects.push_back(std::make_pair(sformatp, static_cast<AstArg*>(nullptr)));
                     tconnects[ppinnum].second = argp;
                     tpinnum++;
                 } else {

src/V3Width.cpp

@@ -5814,7 +5814,7 @@ private:
     }
     AstVar* dimensionVarp(AstNodeDType* nodep, AstAttrType attrType, uint32_t msbdim) {
         // Return a variable table which has specified dimension properties for this variable
-        const auto pos = m_tableMap.find(make_pair(nodep, attrType));
+        const auto pos = m_tableMap.find(std::make_pair(nodep, attrType));
         if (pos != m_tableMap.end()) return pos->second;
         AstNodeArrayDType* vardtypep
             = new AstUnpackArrayDType(nodep->fileline(), nodep->findSigned32DType(),
@@ -5836,7 +5836,7 @@ private:
             initp->addValuep(dimensionValue(nodep->fileline(), nodep, attrType, i));
         }
         userIterate(varp, nullptr);  // May have already done $unit so must do this var
-        m_tableMap.emplace(make_pair(nodep, attrType), varp);
+        m_tableMap.emplace(std::make_pair(nodep, attrType), varp);
         return varp;
     }
     uint64_t enumMaxValue(const AstNode* errNodep, const AstEnumDType* adtypep) {
@@ -5861,7 +5861,7 @@ private:
     }
     AstVar* enumVarp(AstEnumDType* nodep, AstAttrType attrType, uint32_t msbdim) {
         // Return a variable table which has specified dimension properties for this variable
-        const auto pos = m_tableMap.find(make_pair(nodep, attrType));
+        const auto pos = m_tableMap.find(std::make_pair(nodep, attrType));
         if (pos != m_tableMap.end()) return pos->second;
         UINFO(9, "Construct Venumtab attr=" << attrType.ascii() << " max=" << msbdim << " for "
                                             << nodep << endl);
@@ -5936,7 +5936,7 @@ private:
             if (values[i]) initp->addIndexValuep(i, values[i]);
         }
         userIterate(varp, nullptr);  // May have already done $unit so must do this var
-        m_tableMap.emplace(make_pair(nodep, attrType), varp);
+        m_tableMap.emplace(std::make_pair(nodep, attrType), varp);
         return varp;
     }
 

src/VlcSource.h

@@ -84,11 +84,11 @@ public:
     // METHODS
     void incCount(int lineno, int column, vluint64_t count, bool ok) {
         LinenoMap::iterator lit = m_lines.find(lineno);
-        if (lit == m_lines.end()) lit = m_lines.insert(make_pair(lineno, ColumnMap())).first;
+        if (lit == m_lines.end()) lit = m_lines.insert(std::make_pair(lineno, ColumnMap())).first;
         ColumnMap& cmap = lit->second;
         ColumnMap::iterator cit = cmap.find(column);
         if (cit == cmap.end()) {
-            cit = cmap.insert(make_pair(column, VlcSourceCount(lineno, column))).first;
+            cit = cmap.insert(std::make_pair(column, VlcSourceCount(lineno, column))).first;
         }
         VlcSourceCount& sc = cit->second;
         sc.incCount(count, ok);
@@ -123,7 +123,7 @@ public:
         if (iter != m_sources.end()) {
             return iter->second;
         } else {
-            iter = m_sources.insert(make_pair(name, VlcSource(name))).first;
+            iter = m_sources.insert(std::make_pair(name, VlcSource(name))).first;
             return iter->second;
         }
     }

src/config_build.h.in

@@ -70,7 +70,6 @@
 using string = std::string;
 using std::cout;
 using std::endl;
-using std::make_pair;
 
 //**********************************************************************
 //**** Configure-discovered library options