[LazyCallGraph] Reformat the code in accordance with the code style. NFC

[psamolysov]

Summary

Also, some local variables have been renamed in accordance with the code
style as well as structure bindings from C++17 were introduced instead of
std::tie.

[aeubanks]

lg, as long as the removed asserts don't break the expensive checks build

[psamolysov]

@aeubanks Thank you for the review. This patch doesn't remove any asserts just reformats them. At least it should...

[psamolysov]

More structure bindings have been inserted in the foreach loops. Also, some inserts to maps were replaced with the try_emplace operations in order to eliminate redundant copies of pairs (but as I see those pairs are small enough but "no-copy" is better than "copy" even whenever this "no-copy" is for free).

[aeubanks]

I mean that code in #ifdef EXPENSIVE_CHECKS may use headers that aren't otherwise used, e.g. the existing
#include "llvm/ADT/ScopeExit.h"

but if that's fine then still lgtm

[psamolysov]

@aeubanks Oh, thank you for the comment. I tried to explicitly define EXPENSIVE_CHECK at the beginning of the LazyCallGraph.cpp file and LLVM has successfully been built. So, I've landed the patch.

llvm/include/llvm/Analysis/LazyCallGraph.h

class LLVM_EXTERNAL_VISIBILITY SCC {
     ///
     /// We print the function names in the SCC wrapped in '()'s and skipping
     /// the middle functions if there are a large number.
     //
     // Note: this is defined inline to dodge issues with GCC's interpretation
     // of enclosing namespaces for friend function declarations.
     friend raw_ostream &operator<<(raw_ostream &OS, const SCC &C) {
       OS << '(';
-      int i = 0;
+      int I = 0;
       for (LazyCallGraph::Node &N : C) {
-        if (i > 0)
+        if (I > 0)
           OS << ", ";
         // Elide the inner elements if there are too many.
-        if (i > 8) {
+        if (I > 8) {
           OS << "..., " << *C.Nodes.back();
           break;
         }
         OS << N;
-        ++i;
+        ++I;
       }
       OS << ')';
       return OS;
     }
 
     /// Dump a short description of this SCC to stderr.
     void dump() const;
 
class RefSCC {
     ///
     /// We print the SCCs wrapped in '[]'s and skipping the middle SCCs if
     /// there are a large number.
     //
     // Note: this is defined inline to dodge issues with GCC's interpretation
     // of enclosing namespaces for friend function declarations.
     friend raw_ostream &operator<<(raw_ostream &OS, const RefSCC &RC) {
       OS << '[';
-      int i = 0;
+      int I = 0;
       for (LazyCallGraph::SCC &C : RC) {
-        if (i > 0)
+        if (I > 0)
           OS << ", ";
         // Elide the inner elements if there are too many.
-        if (i > 4) {
+        if (I > 4) {
           OS << "..., " << *RC.SCCs.back();
           break;
         }
         OS << C;
-        ++i;
+        ++I;
       }
       OS << ']';
       return OS;
     }
 
     /// Dump a short description of this RefSCC to stderr.
     void dump() const;
 
private:
   Node &initNode(Function &F);
 
   /// Helper to update pointers back to the graph object during moves.
   void updateGraphPtrs();
 
   /// Allocates an SCC and constructs it using the graph allocator.
   ///
   /// The arguments are forwarded to the constructor.
-  template <typename... Ts> SCC *createSCC(Ts &&... Args) {
+  template <typename... Ts> SCC *createSCC(Ts &&...Args) {
     return new (SCCBPA.Allocate()) SCC(std::forward<Ts>(Args)...);
   }
 
   /// Allocates a RefSCC and constructs it using the graph allocator.
   ///
   /// The arguments are forwarded to the constructor.
-  template <typename... Ts> RefSCC *createRefSCC(Ts &&... Args) {
+  template <typename... Ts> RefSCC *createRefSCC(Ts &&...Args) {
     return new (RefSCCBPA.Allocate()) RefSCC(std::forward<Ts>(Args)...);
   }
 
   /// Common logic for building SCCs from a sequence of roots.
   ///
   /// This is a very generic implementation of the depth-first walk and SCC
   /// formation algorithm. It uses a generic sequence of roots and generic
   /// callbacks for each step. This is designed to be used to implement both

llvm/lib/Analysis/LazyCallGraph.cpp

 //===- LazyCallGraph.cpp - Analysis of a Module's call graph --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/LazyCallGraph.h"
+
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
-#include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cassert>
-#include <iterator>
-#include <string>
-#include <tuple>
-#include <utility>
 
 #ifdef EXPENSIVE_CHECKS
 #include "llvm/ADT/ScopeExit.h"
 #endif
 
 using namespace llvm;
 
 #define DEBUG_TYPE "lcg"
 
 void LazyCallGraph::EdgeSequence::insertEdgeInternal(Node &TargetN,
                                                      Edge::Kind EK) {
-  EdgeIndexMap.insert({&TargetN, Edges.size()});
+  EdgeIndexMap.try_emplace(&TargetN, Edges.size());
   Edges.emplace_back(TargetN, EK);
 }
 
 void LazyCallGraph::EdgeSequence::setEdgeKind(Node &TargetN, Edge::Kind EK) {
   Edges[EdgeIndexMap.find(&TargetN)->second].setKind(EK);
 }
 
 bool LazyCallGraph::EdgeSequence::removeEdgeInternal(Node &TargetN) {
   auto IndexMapI = EdgeIndexMap.find(&TargetN);
   if (IndexMapI == EdgeIndexMap.end())
     return false;
 
   Edges[IndexMapI->second] = Edge();
   EdgeIndexMap.erase(IndexMapI);
   return true;
 }
 
 static void addEdge(SmallVectorImpl<LazyCallGraph::Edge> &Edges,
                     DenseMap<LazyCallGraph::Node *, int> &EdgeIndexMap,
                     LazyCallGraph::Node &N, LazyCallGraph::Edge::Kind EK) {
-  if (!EdgeIndexMap.insert({&N, Edges.size()}).second)
+  if (!EdgeIndexMap.try_emplace(&N, Edges.size()).second)
     return;
 
   LLVM_DEBUG(dbgs() << "    Added callable function: " << N.getName() << "\n");
   Edges.emplace_back(LazyCallGraph::Edge(N, EK));
 }
 
 LazyCallGraph::EdgeSequence &LazyCallGraph::Node::populateSlow() {
   assert(!Edges && "Must not have already populated the edges for this node!");
for (Instruction &I : BB) {
 
       for (Value *Op : I.operand_values())
         if (Constant *C = dyn_cast<Constant>(Op))
           if (Visited.insert(C).second)
             Worklist.push_back(C);
     }
 
   // We've collected all the constant (and thus potentially function or
-  // function containing) operands to all of the instructions in the function.
+  // function containing) operands to all the instructions in the function.
   // Process them (recursively) collecting every function found.
   visitReferences(Worklist, Visited, [&](Function &F) {
     addEdge(Edges->Edges, Edges->EdgeIndexMap, G->get(F),
             LazyCallGraph::Edge::Ref);
   });
 
   // Add implicit reference edges to any defined libcall functions (if we
   // haven't found an explicit edge).
visitReferences(Worklist, Visited, [&](Function &F) {
     addEdge(EntryEdges.Edges, EntryEdges.EdgeIndexMap, get(F),
             LazyCallGraph::Edge::Ref);
   });
 }
 
 LazyCallGraph::LazyCallGraph(LazyCallGraph &&G)
     : BPA(std::move(G.BPA)), NodeMap(std::move(G.NodeMap)),
       EntryEdges(std::move(G.EntryEdges)), SCCBPA(std::move(G.SCCBPA)),
-      SCCMap(std::move(G.SCCMap)),
-      LibFunctions(std::move(G.LibFunctions)) {
+      SCCMap(std::move(G.SCCMap)), LibFunctions(std::move(G.LibFunctions)) {
   updateGraphPtrs();
 }
 
 bool LazyCallGraph::invalidate(Module &, const PreservedAnalyses &PA,
                                ModuleAnalysisManager::Invalidator &) {
   // Check whether the analysis, all analyses on functions, or the function's
   // CFG have been preserved.
   auto PAC = PA.getChecker<llvm::LazyCallGraphAnalysis>();
for (SCC *C : SCCs) {
     bool Inserted = SCCSet.insert(C).second;
     assert(Inserted && "Found a duplicate SCC!");
     auto IndexIt = SCCIndices.find(C);
     assert(IndexIt != SCCIndices.end() &&
            "Found an SCC that doesn't have an index!");
   }
 
   // Check that our indices map correctly.
-  for (auto &SCCIndexPair : SCCIndices) {
-    SCC *C = SCCIndexPair.first;
-    int i = SCCIndexPair.second;
+  for (auto [C, I] : SCCIndices) {
     assert(C && "Can't have a null SCC in the indices!");
     assert(SCCSet.count(C) && "Found an index for an SCC not in the RefSCC!");
-    assert(SCCs[i] == C && "Index doesn't point to SCC!");
+    assert(SCCs[I] == C && "Index doesn't point to SCC!");
   }
 
   // Check that the SCCs are in fact in post-order.
-  for (int i = 0, Size = SCCs.size(); i < Size; ++i) {
-    SCC &SourceSCC = *SCCs[i];
+  for (int I = 0, Size = SCCs.size(); I < Size; ++I) {
+    SCC &SourceSCC = *SCCs[I];
     for (Node &N : SourceSCC)
       for (Edge &E : *N) {
         if (!E.isCall())
           continue;
         SCC &TargetSCC = *G->lookupSCC(E.getNode());
         if (&TargetSCC.getOuterRefSCC() == this) {
-          assert(SCCIndices.find(&TargetSCC)->second <= i &&
+          assert(SCCIndices.find(&TargetSCC)->second <= I &&
                  "Edge between SCCs violates post-order relationship.");
           continue;
         }
       }
   }
 
 #ifdef EXPENSIVE_CHECKS
   // Verify that all nodes in this RefSCC can reach all other nodes.
updatePostorderSequenceForEdgeInsertion(
   ComputeSourceConnectedSet(ConnectedSet);
 
   // Partition the SCCs in this part of the port-order sequence so only SCCs
   // connecting to the source remain between it and the target. This is
   // a benign partition as it preserves postorder.
   auto SourceI = std::stable_partition(
       SCCs.begin() + SourceIdx, SCCs.begin() + TargetIdx + 1,
       [&ConnectedSet](SCCT *C) { return !ConnectedSet.count(C); });
-  for (int i = SourceIdx, e = TargetIdx + 1; i < e; ++i)
-    SCCIndices.find(SCCs[i])->second = i;
+  for (int I = SourceIdx, E = TargetIdx + 1; I < E; ++I)
+    SCCIndices.find(SCCs[I])->second = I;
 
   // If the target doesn't connect to the source, then we've corrected the
   // post-order and there are no cycles formed.
   if (!ConnectedSet.count(&TargetSCC)) {
     assert(SourceI > (SCCs.begin() + SourceIdx) &&
            "Must have moved the source to fix the post-order.");
     assert(*std::prev(SourceI) == &TargetSCC &&
            "Last SCC to move should have bene the target.");
 
     // Return an empty range at the target SCC indicating there is nothing to
     // merge.
     return make_range(std::prev(SourceI), std::prev(SourceI));
   }
 
   assert(SCCs[TargetIdx] == &TargetSCC &&
          "Should not have moved target if connected!");
   SourceIdx = SourceI - SCCs.begin();
   assert(SCCs[SourceIdx] == &SourceSCC &&
          "Bad updated index computation for the source SCC!");
 
-
   // See whether there are any remaining intervening SCCs between the source
   // and target. If so we need to make sure they all are reachable form the
   // target.
   if (SourceIdx + 1 < TargetIdx) {
     ConnectedSet.clear();
     ComputeTargetConnectedSet(ConnectedSet);
 
     // Partition SCCs so that only SCCs reached from the target remain between
     // the source and the target. This preserves postorder.
     auto TargetI = std::stable_partition(
         SCCs.begin() + SourceIdx + 1, SCCs.begin() + TargetIdx + 1,
         [&ConnectedSet](SCCT *C) { return ConnectedSet.count(C); });
-    for (int i = SourceIdx + 1, e = TargetIdx + 1; i < e; ++i)
-      SCCIndices.find(SCCs[i])->second = i;
+    for (int I = SourceIdx + 1, E = TargetIdx + 1; I < E; ++I)
+      SCCIndices.find(SCCs[I])->second = I;
     TargetIdx = std::prev(TargetI) - SCCs.begin();
     assert(SCCs[TargetIdx] == &TargetSCC &&
            "Should always end with the target!");
   }
 
   // At this point, we know that connecting source to target forms a cycle
-  // because target connects back to source, and we know that all of the SCCs
+  // because target connects back to source, and we know that all the SCCs
   // between the source and target in the postorder sequence participate in that
   // cycle.
   return make_range(SCCs.begin() + SourceIdx, SCCs.begin() + TargetIdx);
 }
 
-bool
-LazyCallGraph::RefSCC::switchInternalEdgeToCall(
+bool LazyCallGraph::RefSCC::switchInternalEdgeToCall(
     Node &SourceN, Node &TargetN,
     function_ref<void(ArrayRef<SCC *> MergeSCCs)> MergeCB) {
   assert(!(*SourceN)[TargetN].isCall() && "Must start with a ref edge!");
   SmallVector<SCC *, 1> DeletedSCCs;
 
 #ifdef EXPENSIVE_CHECKS
   verify();
   auto VerifyOnExit = make_scope_exit([&]() { verify(); });
#endif
   }
 
 #ifdef EXPENSIVE_CHECKS
   // Before merging, check that the RefSCC remains valid after all the
   // postorder updates.
   verify();
 #endif
 
-  // Otherwise we need to merge all of the SCCs in the cycle into a single
-  // result SCC.
+  // Otherwise we need to merge all the SCCs in the cycle into a single result
+  // SCC.
   //
   // NB: We merge into the target because all of these functions were already
   // reachable from the target, meaning any SCC-wide properties deduced about it
   // other than the set of functions within it will not have changed.
   for (SCC *C : MergeRange) {
     assert(C != &TargetSCC &&
            "We merge *into* the target and shouldn't process it here!");
     SCCIndices.erase(C);
void LazyCallGraph::RefSCC::switchTrivialInternalEdgeToRef(Node &SourceN,
                                                            Node &TargetN) {
   assert((*SourceN)[TargetN].isCall() && "Must start with a call edge!");
 
 #ifdef EXPENSIVE_CHECKS
   verify();
   auto VerifyOnExit = make_scope_exit([&]() { verify(); });
 #endif
 
-  assert(G->lookupRefSCC(SourceN) == this &&
-         "Source must be in this RefSCC.");
-  assert(G->lookupRefSCC(TargetN) == this &&
-         "Target must be in this RefSCC.");
+  assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
+  assert(G->lookupRefSCC(TargetN) == this && "Target must be in this RefSCC.");
   assert(G->lookupSCC(SourceN) != G->lookupSCC(TargetN) &&
          "Source and Target must be in separate SCCs for this to be trivial!");
 
   // Set the edge kind.
   SourceN->setEdgeKind(TargetN, Edge::Ref);
 }
 
 iterator_range<LazyCallGraph::RefSCC::iterator>
 LazyCallGraph::RefSCC::switchInternalEdgeToRef(Node &SourceN, Node &TargetN) {
   assert((*SourceN)[TargetN].isCall() && "Must start with a call edge!");
 
 #ifdef EXPENSIVE_CHECKS
   verify();
   auto VerifyOnExit = make_scope_exit([&]() { verify(); });
 #endif
 
-  assert(G->lookupRefSCC(SourceN) == this &&
-         "Source must be in this RefSCC.");
-  assert(G->lookupRefSCC(TargetN) == this &&
-         "Target must be in this RefSCC.");
+  assert(G->lookupRefSCC(SourceN) == this && "Source must be in this RefSCC.");
+  assert(G->lookupRefSCC(TargetN) == this && "Target must be in this RefSCC.");
 
   SCC &TargetSCC = *G->lookupSCC(TargetN);
   assert(G->lookupSCC(SourceN) == &TargetSCC && "Source and Target must be in "
                                                 "the same SCC to require the "
                                                 "full CG update.");
 
   // Set the edge kind.
   SourceN->setEdgeKind(TargetN, Edge::Ref);
if (RootN->DFSNumber != 0) {
       assert(RootN->DFSNumber == -1 &&
              "Shouldn't have any mid-DFS root nodes!");
       continue;
     }
 
     RootN->DFSNumber = RootN->LowLink = 1;
     int NextDFSNumber = 2;
 
-    DFSStack.push_back({RootN, (*RootN)->call_begin()});
+    DFSStack.emplace_back(RootN, (*RootN)->call_begin());
     do {
-      Node *N;
-      EdgeSequence::call_iterator I;
-      std::tie(N, I) = DFSStack.pop_back_val();
+      auto [N, I] = DFSStack.pop_back_val();
       auto E = (*N)->call_end();
       while (I != E) {
         Node &ChildN = I->getNode();
         if (ChildN.DFSNumber == 0) {
           // We haven't yet visited this child, so descend, pushing the current
           // node onto the stack.
-          DFSStack.push_back({N, I});
+          DFSStack.emplace_back(N, I);
 
           assert(!G->SCCMap.count(&ChildN) &&
                  "Found a node with 0 DFS number but already in an SCC!");
           ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++;
           N = &ChildN;
           I = (*N)->call_begin();
           E = (*N)->call_end();
           continue;
do {
         G->SCCMap[&N] = NewSCCs.back();
       }
       PendingSCCStack.erase(SCCNodes.end().base(), PendingSCCStack.end());
     } while (!DFSStack.empty());
   }
 
   // Insert the remaining SCCs before the old one. The old SCC can reach all
   // other SCCs we form because it contains the target node of the removed edge
-  // of the old SCC. This means that we will have edges into all of the new
-  // SCCs, which means the old one must come last for postorder.
+  // of the old SCC. This means that we will have edges into all the new SCCs,
+  // which means the old one must come last for postorder.
   int OldIdx = SCCIndices[&OldSCC];
   SCCs.insert(SCCs.begin() + OldIdx, NewSCCs.begin(), NewSCCs.end());
 
   // Update the mapping from SCC* to index to use the new SCC*s, and remove the
   // old SCC from the mapping.
   for (int Idx = OldIdx, Size = SCCs.size(); Idx < Size; ++Idx)
     SCCIndices[SCCs[Idx]] = Idx;
 
#endif
   // a range of any RefSCCs connected into a cycle by inserting this edge. This
   // routine will also take care of updating the indices into the postorder
   // sequence.
   iterator_range<SmallVectorImpl<RefSCC *>::iterator> MergeRange =
       updatePostorderSequenceForEdgeInsertion(
           SourceC, *this, G->PostOrderRefSCCs, G->RefSCCIndices,
           ComputeSourceConnectedSet, ComputeTargetConnectedSet);
 
-  // Build a set so we can do fast tests for whether a RefSCC will end up as
+  // Build a set, so we can do fast tests for whether a RefSCC will end up as
   // part of the merged RefSCC.
   SmallPtrSet<RefSCC *, 16> MergeSet(MergeRange.begin(), MergeRange.end());
 
   // This RefSCC will always be part of that set, so just insert it here.
   MergeSet.insert(this);
 
-  // Now that we have identified all of the SCCs which need to be merged into
+  // Now that we have identified all the SCCs which need to be merged into
   // a connected set with the inserted edge, merge all of them into this SCC.
   SmallVector<SCC *, 16> MergedSCCs;
   int SCCIndex = 0;
   for (RefSCC *RC : MergeRange) {
     assert(RC != this && "We're merging into the target RefSCC, so it "
                          "shouldn't be in the range.");
 
     // Walk the inner SCCs to update their up-pointer and walk all the edges to
if (RootN->DFSNumber != 0) {
       assert(RootN->DFSNumber == -1 &&
              "Shouldn't have any mid-DFS root nodes!");
       continue;
     }
 
     RootN->DFSNumber = RootN->LowLink = 1;
     int NextDFSNumber = 2;
 
-    DFSStack.push_back({RootN, (*RootN)->begin()});
+    DFSStack.emplace_back(RootN, (*RootN)->begin());
     do {
-      Node *N;
-      EdgeSequence::iterator I;
-      std::tie(N, I) = DFSStack.pop_back_val();
+      auto [N, I] = DFSStack.pop_back_val();
       auto E = (*N)->end();
 
       assert(N->DFSNumber != 0 && "We should always assign a DFS number "
                                   "before processing a node.");
 
       while (I != E) {
         Node &ChildN = I->getNode();
         if (ChildN.DFSNumber == 0) {
           // Mark that we should start at this child when next this node is the
           // top of the stack. We don't start at the next child to ensure this
           // child's lowlink is reflected.
-          DFSStack.push_back({N, I});
+          DFSStack.emplace_back(N, I);
 
           // Continue, resetting to the child node.
           ChildN.LowLink = ChildN.DFSNumber = NextDFSNumber++;
           N = &ChildN;
           I = ChildN->begin();
           E = ChildN->end();
           continue;
         }
do {
         // it to map SCCs into new RefSCCs after we finish the DFS.
         N->LowLink = RefSCCNumber;
         return false;
       });
       auto RefSCCNodes = make_range(StackRI.base(), PendingRefSCCStack.end());
 
       // If we find a cycle containing all nodes originally in this RefSCC then
       // the removal hasn't changed the structure at all. This is an important
-      // special case and we can directly exit the entire routine more
+      // special case, and we can directly exit the entire routine more
       // efficiently as soon as we discover it.
       if (llvm::size(RefSCCNodes) == NumRefSCCNodes) {
         // Clear out the low link field as we won't need it.
         for (Node *N : RefSCCNodes)
           N->LowLink = -1;
         // Return the empty result immediately.
         return Result;
       }
#endif
 
   assert(PostOrderNumber > 1 &&
          "Should never finish the DFS when the existing RefSCC remains valid!");
 
   // Otherwise we create a collection of new RefSCC nodes and build
   // a radix-sort style map from postorder number to these new RefSCCs. We then
   // append SCCs to each of these RefSCCs in the order they occurred in the
   // original SCCs container.
-  for (int i = 0; i < PostOrderNumber; ++i)
+  for (int I = 0; I < PostOrderNumber; ++I)
     Result.push_back(G->createRefSCC(*G));
 
   // Insert the resulting postorder sequence into the global graph postorder
   // sequence before the current RefSCC in that sequence, and then remove the
   // current one.
   //
   // FIXME: It'd be nice to change the APIs so that we returned an iterator
   // range over the global postorder sequence and generally use that sequence
   // rather than building a separate result vector here.
   int Idx = G->getRefSCCIndex(*this);
   G->PostOrderRefSCCs.erase(G->PostOrderRefSCCs.begin() + Idx);
   G->PostOrderRefSCCs.insert(G->PostOrderRefSCCs.begin() + Idx, Result.begin(),
                              Result.end());
-  for (int i : seq<int>(Idx, G->PostOrderRefSCCs.size()))
-    G->RefSCCIndices[G->PostOrderRefSCCs[i]] = i;
+  for (int I : seq<int>(Idx, G->PostOrderRefSCCs.size()))
+    G->RefSCCIndices[G->PostOrderRefSCCs[I]] = I;
 
   for (SCC *C : SCCs) {
     // We store the SCC number in the node's low-link field above.
     int SCCNumber = C->begin()->LowLink;
-    // Clear out all of the SCC's node's low-link fields now that we're done
+    // Clear out all the SCC's node's low-link fields now that we're done
     // using them as side-storage.
     for (Node &N : *C) {
       assert(N.LowLink == SCCNumber &&
              "Cannot have different numbers for nodes in the same SCC!");
       N.LowLink = -1;
     }
 
     RefSCC &RC = *Result[SCCNumber];
#ifdef EXPENSIVE_CHECKS
   SCC &SourceC = *G->lookupSCC(SourceN);
   SCC &TargetC = *G->lookupSCC(TargetN);
   if (&SourceC != &TargetC)
     assert(SourceC.isAncestorOf(TargetC) &&
            "Call edge is not trivial in the SCC graph!");
 #endif
 
   // First insert it into the source or find the existing edge.
-  auto InsertResult =
-      SourceN->EdgeIndexMap.insert({&TargetN, SourceN->Edges.size()});
-  if (!InsertResult.second) {
+  auto [Iterator, Inserted] =
+      SourceN->EdgeIndexMap.try_emplace(&TargetN, SourceN->Edges.size());
+  if (!Inserted) {
     // Already an edge, just update it.
-    Edge &E = SourceN->Edges[InsertResult.first->second];
+    Edge &E = SourceN->Edges[Iterator->second];
     if (E.isCall())
       return; // Nothing to do!
     E.setKind(Edge::Call);
   } else {
     // Create the new edge.
     SourceN->Edges.emplace_back(TargetN, Edge::Call);
   }
 }
 
 void LazyCallGraph::RefSCC::insertTrivialRefEdge(Node &SourceN, Node &TargetN) {
 #ifdef EXPENSIVE_CHECKS
   auto ExitVerifier = make_scope_exit([this] { verify(); });
 
   // Check that we aren't breaking some invariants of the RefSCC graph.
   RefSCC &SourceRC = *G->lookupRefSCC(SourceN);
   RefSCC &TargetRC = *G->lookupRefSCC(TargetN);
   if (&SourceRC != &TargetRC)
     assert(SourceRC.isAncestorOf(TargetRC) &&
            "Ref edge is not trivial in the RefSCC graph!");
 #endif
 
   // First insert it into the source or find the existing edge.
-  auto InsertResult =
-      SourceN->EdgeIndexMap.insert({&TargetN, SourceN->Edges.size()});
-  if (!InsertResult.second)
+  auto [Iterator, Inserted] =
+      SourceN->EdgeIndexMap.try_emplace(&TargetN, SourceN->Edges.size());
+  (void)Iterator;
+  if (!Inserted)
     // Already an edge, we're done.
     return;
 
   // Create the new edge.
   SourceN->Edges.emplace_back(TargetN, Edge::Ref);
 }
 
 void LazyCallGraph::RefSCC::replaceNodeFunction(Node &N, Function &NewF) {
for (Edge &E : *NewN) {
         // function but a new SCC.
         RefSCC *NewRC = OriginalRC;
         NewC = createSCC(*NewRC, SmallVector<Node *, 1>({&NewN}));
 
         // The new function's SCC is not the same as the original function's
         // SCC, since that case was handled earlier. If the edge from the
         // original function to the new function was a call edge, then we need
         // to insert the newly created function's SCC before the original
-        // function's SCC. Otherwise either the new SCC comes after the original
-        // function's SCC, or it doesn't matter, and in both cases we can add it
-        // to the very end.
+        // function's SCC. Otherwise, either the new SCC comes after the
+        // original function's SCC, or it doesn't matter, and in both cases we
+        // can add it to the very end.
         int InsertIndex = EK == Edge::Kind::Call ? NewRC->SCCIndices[OriginalC]
                                                  : NewRC->SCCIndices.size();
         NewRC->SCCs.insert(NewRC->SCCs.begin() + InsertIndex, NewC);
         for (int I = InsertIndex, Size = NewRC->SCCs.size(); I < Size; ++I)
           NewRC->SCCIndices[NewRC->SCCs[I]] = I;
 
         break;
       }

 }
 
 LazyCallGraph::Node &LazyCallGraph::insertInto(Function &F, Node *&MappedN) {
   return *new (MappedN = BPA.Allocate()) Node(*this, F);
 }
 
 void LazyCallGraph::updateGraphPtrs() {
   // Walk the node map to update their graph pointers. While this iterates in
-  // an unstable order, the order has no effect so it remains correct.
+  // an unstable order, the order has no effect, so it remains correct.
   for (auto &FunctionNodePair : NodeMap)
     FunctionNodePair.second->G = this;
 
   for (auto *RC : PostOrderRefSCCs)
     RC->G = this;
 }
 
 LazyCallGraph::Node &LazyCallGraph::initNode(Function &F) {
if (RootN->DFSNumber != 0) {
       assert(RootN->DFSNumber == -1 &&
              "Shouldn't have any mid-DFS root nodes!");
       continue;
     }
 
     RootN->DFSNumber = RootN->LowLink = 1;
     int NextDFSNumber = 2;
 
-    DFSStack.push_back({RootN, GetBegin(*RootN)});
+    DFSStack.emplace_back(RootN, GetBegin(*RootN));
     do {
-      Node *N;
-      EdgeItT I;
-      std::tie(N, I) = DFSStack.pop_back_val();
+      auto [N, I] = DFSStack.pop_back_val();
       auto E = GetEnd(*N);
       while (I != E) {
         Node &ChildN = GetNode(I);
         if (ChildN.DFSNumber == 0) {
           // We haven't yet visited this child, so descend, pushing the current
           // node onto the stack.
-          DFSStack.push_back({N, I});
+          DFSStack.emplace_back(N, I);
 
           ChildN.DFSNumber = ChildN.LowLink = NextDFSNumber++;
           N = &ChildN;
           I = GetBegin(*N);
           E = GetEnd(*N);
           continue;
         }
 
buildGenericSCCs(
         RC.SCCs.push_back(createSCC(RC, Nodes));
         for (Node &N : *RC.SCCs.back()) {
           N.DFSNumber = N.LowLink = -1;
           SCCMap[&N] = RC.SCCs.back();
         }
       });
 
   // Wire up the SCC indices.
-  for (int i = 0, Size = RC.SCCs.size(); i < Size; ++i)
-    RC.SCCIndices[RC.SCCs[i]] = i;
+  for (int I = 0, Size = RC.SCCs.size(); I < Size; ++I)
+    RC.SCCIndices[RC.SCCs[I]] = I;
 }
 
 void LazyCallGraph::buildRefSCCs() {
   if (EntryEdges.empty() || !PostOrderRefSCCs.empty())
     // RefSCCs are either non-existent or already built!
     return;
 
   assert(RefSCCIndices.empty() && "Already mapped RefSCC indices!");
buildGenericSCCs(
       [](EdgeSequence::iterator I) -> Node & { return I->getNode(); },
       [this](node_stack_range Nodes) {
         RefSCC *NewRC = createRefSCC(*this);
         buildSCCs(*NewRC, Nodes);
 
         // Push the new node into the postorder list and remember its position
         // in the index map.
         bool Inserted =
-            RefSCCIndices.insert({NewRC, PostOrderRefSCCs.size()}).second;
+            RefSCCIndices.try_emplace(NewRC, PostOrderRefSCCs.size()).second;
         (void)Inserted;
         assert(Inserted && "Cannot already have this RefSCC in the index map!");
         PostOrderRefSCCs.push_back(NewRC);
 #ifdef EXPENSIVE_CHECKS
         NewRC->verify();
 #endif
       });
 }