[BOLT][NFC] Move out handleIndirectBranch

[Amir]

Summary

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

bolt/include/bolt/Core/BinaryFunction.h

   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);
 
+  void handleIndirectBranch(MCInst &Instruction, uint64_t Size,
+                            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

if (opts::Verbosity >= 2 && TargetAddress == 0) {
     // to be executed.
     outs() << "BOLT-INFO: Function " << *this
            << " has a call to address zero.\n";
   }
 
   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,
+void BinaryFunction::handleIndirectBranch(MCInst &Instruction, uint64_t Size,
                                           uint64_t Offset) {
-    uint64_t IndirectTarget = 0;
-    IndirectBranchType Result =
-        processIndirectBranch(Instruction, Size, Offset, IndirectTarget);
-    switch (Result) {
-    default:
-      llvm_unreachable("unexpected result");
-    case IndirectBranchType::POSSIBLE_TAIL_CALL: {
-      bool Result = MIB->convertJmpToTailCall(Instruction);
-      (void)Result;
-      assert(Result);
-      break;
-    }
-    case IndirectBranchType::POSSIBLE_JUMP_TABLE:
-    case IndirectBranchType::POSSIBLE_PIC_JUMP_TABLE:
-      if (opts::JumpTables == JTS_NONE)
-        IsSimple = false;
-      break;
-    case IndirectBranchType::POSSIBLE_FIXED_BRANCH: {
-      if (containsAddress(IndirectTarget)) {
-        const MCSymbol *TargetSymbol = getOrCreateLocalLabel(IndirectTarget);
-        Instruction.clear();
-        MIB->createUncondBranch(Instruction, TargetSymbol, BC.Ctx.get());
-        TakenBranches.emplace_back(Offset, IndirectTarget - getAddress());
-        HasFixedIndirectBranch = true;
-      } else {
-        MIB->convertJmpToTailCall(Instruction);
-        BC.addInterproceduralReference(this, IndirectTarget);
-      }
-      break;
-    }
-    case IndirectBranchType::UNKNOWN:
-      // Keep processing. We'll do more checks and fixes in
-      // postProcessIndirectBranches().
-      UnknownIndirectBranchOffsets.emplace(Offset);
-      break;
-    }
-  };
+  auto &MIB = BC.MIB;
+}
+
+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");
 
   // 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(),