[BOLT][NFC] Move out handleAArch64IndirectCall

[Amir]

Summary

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

[rafauler]

LGTM

bolt/include/bolt/Core/BinaryFunction.h

 
   MCSymbol *handleExternalReference(MCInst &Instruction, uint64_t Size,
                                     uint64_t Offset, uint64_t TargetAddress,
                                     bool &IsCall);
 
   void handleIndirectBranch(MCInst &Instruction, uint64_t Size,
                             uint64_t Offset);
 
+  // Check for linker veneers, which lack relocations and need manual
+  // adjustments.
+  void handleAArch64IndirectCall(MCInst &Instruction, const uint64_t Offset);
+
   /// 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

void BinaryFunction::handleIndirectBranch(MCInst &Instruction, uint64_t Size,
   case IndirectBranchType::UNKNOWN:
     // Keep processing. We'll do more checks and fixes in
     // postProcessIndirectBranches().
     UnknownIndirectBranchOffsets.emplace(Offset);
     break;
   }
 }
 
-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;
+void BinaryFunction::handleAArch64IndirectCall(MCInst &Instruction,
+                                               const uint64_t Offset) {
   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");
-
-  // Check for linker veneers, which lack relocations and need manual
-  // adjustments.
-  auto handleAArch64IndirectCall = [&](MCInst &Instruction, uint64_t Offset) {
-    const uint64_t AbsoluteInstrAddr = getAddress() + Offset;
-    MCInst *TargetHiBits, *TargetLowBits;
-    uint64_t TargetAddress, Count;
-    Count = MIB->matchLinkerVeneer(Instructions.begin(), Instructions.end(),
-                                   AbsoluteInstrAddr, Instruction, TargetHiBits,
-                                   TargetLowBits, TargetAddress);
-    if (Count) {
-      MIB->addAnnotation(Instruction, "AArch64Veneer", true);
-      --Count;
-      for (auto It = std::prev(Instructions.end()); Count != 0;
-           It = std::prev(It), --Count) {
-        MIB->addAnnotation(It->second, "AArch64Veneer", true);
-      }
 
-      BC.addAdrpAddRelocAArch64(*this, *TargetLowBits, *TargetHiBits,
-                                TargetAddress);
-    }
-  };
+}
+
+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");
 
   uint64_t Size = 0; // instruction size
   for (uint64_t Offset = 0; Offset < getSize(); Offset += Size) {
     MCInst Instruction;
     const uint64_t AbsoluteInstrAddr = getAddress() + Offset;
 
     // Check for data inside code and ignore it
     if (const size_t DataInCodeSize = getSizeOfDataInCodeAt(Offset)) {