[BOLT][NFC] Move out handleExternalReference

[Amir]

Summary

Move the large lambda out of BinaryFunction::disassemble, reducing its size from
338 to 295 LoC.

[rafauler]

LGTM

bolt/include/bolt/Core/BinaryFunction.h

   /// Returns true on successful disassembly, and updates the current
   /// state to State:Disassembled.
   ///
   /// Returns false if disassembly failed.
   bool disassemble();
 
   void handlePCRelOperand(MCInst &Instruction, uint64_t Address, uint64_t Size);
 
+  MCSymbol *handleExternalReference(MCInst &Instruction, uint64_t Size,
+                                    uint64_t Offset, uint64_t TargetAddress,
+                                    bool &IsCall);
+
   /// Scan function for references to other functions. In relocation mode,
   /// add relocations for external references.
   ///
   /// Return true on success.
   bool scanExternalRefs();
 
   /// Return the size of a data object located at \p Offset in the function.
   /// Return 0 if there is no data object at the \p Offset.

bolt/lib/Core/BinaryFunction.cpp

const MCConstantExpr *Offset =
         MCConstantExpr::create(TargetOffset, *BC.Ctx);
     Expr = MCBinaryExpr::createAdd(Expr, Offset, *BC.Ctx);
   }
   MIB->replaceMemOperandDisp(Instruction,
                              MCOperand::createExpr(BC.MIB->getTargetExprFor(
                                  Instruction, Expr, *BC.Ctx, 0)));
 }
 
-bool BinaryFunction::disassemble() {
-  NamedRegionTimer T("disassemble", "Disassemble function", "buildfuncs",
-                     "Build Binary Functions", opts::TimeBuild);
-  ErrorOr<ArrayRef<uint8_t>> ErrorOrFunctionData = getData();
-  assert(ErrorOrFunctionData && "function data is not available");
-  ArrayRef<uint8_t> FunctionData = *ErrorOrFunctionData;
-  assert(FunctionData.size() == getMaxSize() &&
-         "function size does not match raw data size");
-
-  auto &Ctx = BC.Ctx;
+MCSymbol *BinaryFunction::handleExternalReference(MCInst &Instruction,
+                                                  uint64_t Size,
+                                                  uint64_t Offset,
+                                                  uint64_t TargetAddress,
+                                                  bool &IsCall) {
   auto &MIB = BC.MIB;
 
-  BC.SymbolicDisAsm->setSymbolizer(MIB->createTargetSymbolizer(*this));
-
-  // Insert a label at the beginning of the function. This will be our first
-  // basic block.
-  Labels[0] = Ctx->createNamedTempSymbol("BB0");
-
-  auto handleExternalReference = [&](MCInst &Instruction, uint64_t Size,
-                                     uint64_t Offset, uint64_t TargetAddress,
-                                     bool &IsCall) -> MCSymbol * {
-    const uint64_t AbsoluteInstrAddr = getAddress() + Offset;
-    MCSymbol *TargetSymbol = nullptr;
-    BC.addInterproceduralReference(this, TargetAddress);
-    if (opts::Verbosity >= 2 && !IsCall && Size == 2 && !BC.HasRelocations) {
-      errs() << "BOLT-WARNING: relaxed tail call detected at 0x"
-             << Twine::utohexstr(AbsoluteInstrAddr) << " in function " << *this
-             << ". Code size will be increased.\n";
-    }
 
-    assert(!MIB->isTailCall(Instruction) &&
-           "synthetic tail call instruction found");
 
-    // This is a call regardless of the opcode.
-    // Assign proper opcode for tail calls, so that they could be
-    // treated as calls.
-    if (!IsCall) {
-      if (!MIB->convertJmpToTailCall(Instruction)) {
-        assert(MIB->isConditionalBranch(Instruction) &&
-               "unknown tail call instruction");
-        if (opts::Verbosity >= 2) {
-          errs() << "BOLT-WARNING: conditional tail call detected in "
-                 << "function " << *this << " at 0x"
-                 << Twine::utohexstr(AbsoluteInstrAddr) << ".\n";
-        }
-      }
-      IsCall = true;
-    }
 
-    TargetSymbol = BC.getOrCreateGlobalSymbol(TargetAddress, "FUNCat");
-    if (opts::Verbosity >= 2 && TargetAddress == 0) {
-      // We actually see calls to address 0 in presence of weak
-      // symbols originating from libraries. This code is never meant
-      // to be executed.
-      outs() << "BOLT-INFO: Function " << *this
-             << " has a call to address zero.\n";
-    }
 
-    return TargetSymbol;
-  };
+  return BC.getOrCreateGlobalSymbol(TargetAddress, "FUNCat");
+}
+
+bool BinaryFunction::disassemble() {
+  NamedRegionTimer T("disassemble", "Disassemble function", "buildfuncs",
+                     "Build Binary Functions", opts::TimeBuild);
+  ErrorOr<ArrayRef<uint8_t>> ErrorOrFunctionData = getData();
+  assert(ErrorOrFunctionData && "function data is not available");
+  ArrayRef<uint8_t> FunctionData = *ErrorOrFunctionData;
+  assert(FunctionData.size() == getMaxSize() &&
+         "function size does not match raw data size");
+
+  auto &Ctx = BC.Ctx;
+  auto &MIB = BC.MIB;
+
+  BC.SymbolicDisAsm->setSymbolizer(MIB->createTargetSymbolizer(*this));
+
+  // Insert a label at the beginning of the function. This will be our first
+  // basic block.
+  Labels[0] = Ctx->createNamedTempSymbol("BB0");
 
   auto handleIndirectBranch = [&](MCInst &Instruction, uint64_t Size,
                                   uint64_t Offset) {
     uint64_t IndirectTarget = 0;
     IndirectBranchType Result =
         processIndirectBranch(Instruction, Size, Offset, IndirectTarget);
     switch (Result) {
     default: