[BOLT][NFC] Simplify instrumentFunction v2

[Amir]

Summary

Extract InstrumentEdge lambda used in three places.

bolt/lib/Passes/Instrumentation.cpp

void Instrumentation::instrumentFunction(BinaryFunction &Function,
   }
 
   for (auto BBI = Function.begin(), BBE = Function.end(); BBI != BBE; ++BBI) {
     BinaryBasicBlock &BB = *BBI;
     bool HasUnconditionalBranch = false;
     bool HasJumpTable = false;
     bool IsInvokeBlock = InvokeBlocks.count(&BB) > 0;
 
+    auto InstrumentEdge = [&](BinaryFunction &TargetFunction,
+                              BinaryBasicBlock &TargetBB, uint64_t FromOffset,
+                              uint64_t TargetOffset,
+                              BinaryBasicBlock::iterator &I) {
+      // Do not instrument edges in the spanning tree
+      if (llvm::is_contained(STOutSet[&BB], &TargetBB)) {
+        auto L = BC.scopeLock();
+        createEdgeDescription(*FuncDesc, Function, FromOffset, BBToID[&BB],
+                              Function, TargetOffset, BBToID[&TargetBB],
+                              /*Instrumented=*/false);
+      } else {
+        instrumentOneTarget(SplitWorklist, SplitInstrs, I, Function, BB,
+                            FromOffset, TargetFunction, &TargetBB, TargetOffset,
+                            IsLeafFunction, IsInvokeBlock, FuncDesc,
+                            BBToID[&BB], BBToID[&TargetBB]);
+      }
+    };
     for (auto I = BB.begin(); I != BB.end(); ++I) {
       const MCInst &Inst = *I;
       if (!BC.MIB->getOffset(Inst))
         continue;
 
       const bool IsJumpTable = Function.getJumpTable(Inst);
       if (IsJumpTable)
         HasJumpTable = true;
for (auto I = BB.begin(); I != BB.end(); ++I) {
           instrumentOneTarget(SplitWorklist, SplitInstrs, I, Function, BB,
                               FromOffset, *TargetFunc, TargetBB, ToOffset,
                               IsLeafFunction, IsInvokeBlock, FuncDesc,
                               BBToID[&BB]);
         }
         continue;
       }
       if (TargetFunc) {
-        // Do not instrument edges in the spanning tree
-        if (llvm::is_contained(STOutSet[&BB], TargetBB)) {
-          auto L = BC.scopeLock();
-          createEdgeDescription(*FuncDesc, Function, FromOffset, BBToID[&BB],
-                                Function, ToOffset, BBToID[TargetBB],
-                                /*Instrumented=*/false);
-          continue;
-        }
-        instrumentOneTarget(SplitWorklist, SplitInstrs, I, Function, BB,
-                            FromOffset, *TargetFunc, TargetBB, ToOffset,
-                            IsLeafFunction, IsInvokeBlock, FuncDesc,
-                            BBToID[&BB], BBToID[TargetBB]);
+        InstrumentEdge(*TargetFunc, *TargetBB, FromOffset, ToOffset, I);
         continue;
       }
 
       if (IsJumpTable) {
-        for (BinaryBasicBlock *&Succ : BB.successors()) {
-          // Do not instrument edges in the spanning tree
-          if (llvm::is_contained(STOutSet[&BB], &*Succ)) {
-            auto L = BC.scopeLock();
-            createEdgeDescription(*FuncDesc, Function, FromOffset, BBToID[&BB],
-                                  Function, Succ->getInputOffset(),
-                                  BBToID[&*Succ], /*Instrumented=*/false);
-            continue;
-          }
-          instrumentOneTarget(
-              SplitWorklist, SplitInstrs, I, Function, BB, FromOffset, Function,
-              &*Succ, Succ->getInputOffset(), IsLeafFunction, IsInvokeBlock,
-              FuncDesc, BBToID[&BB], BBToID[&*Succ]);
-        }
+        for (BinaryBasicBlock &Succ : llvm::make_pointee_range(BB.successors()))
+          InstrumentEdge(Function, Succ, FromOffset, Succ.getInputOffset(), I);
         continue;
       }
 
       // Handle indirect calls -- could be direct calls with unknown targets
       // or secondary entry points of known functions, so check it is indirect
       // to be sure.
       if (opts::InstrumentCalls && BC.MIB->isIndirectCall(*I))
         instrumentIndirectTarget(BB, I, Function, FromOffset);
if (!HasUnconditionalBranch && !HasJumpTable && BB.succ_size() > 0 &&
       // The last instruction in the BB should have an annotation, except
       // if it was branching to the end of the function as a result of
       // __builtin_unreachable(), in which case it was deleted by fixBranches.
       // Ignore this case. FIXME: force fixBranches() to preserve the offset.
       if (!BC.MIB->getOffset(*LastInstr))
         continue;
       FromOffset = *BC.MIB->getOffset(*LastInstr);
 
-      // Do not instrument edges in the spanning tree
-      if (llvm::is_contained(STOutSet[&BB], FTBB)) {
-        auto L = BC.scopeLock();
-        createEdgeDescription(*FuncDesc, Function, FromOffset, BBToID[&BB],
-                              Function, FTBB->getInputOffset(), BBToID[FTBB],
-                              /*Instrumented=*/false);
-        continue;
-      }
-      instrumentOneTarget(SplitWorklist, SplitInstrs, I, Function, BB,
-                          FromOffset, Function, FTBB, FTBB->getInputOffset(),
-                          IsLeafFunction, IsInvokeBlock, FuncDesc, BBToID[&BB],
-                          BBToID[FTBB]);
+      InstrumentEdge(Function, *FTBB, FromOffset, FTBB->getInputOffset(), I);
     }
   } // End of BBs loop
 
   // Instrument spanning tree leaves
   if (!opts::ConservativeInstrumentation) {
     for (auto BBI = Function.begin(), BBE = Function.end(); BBI != BBE; ++BBI) {
       BinaryBasicBlock &BB = *BBI;
       if (STOutSet[&BB].size() == 0)