[BOLT][NFC] Move out handlePCRelOperand

[Amir]

Summary

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

[rafauler]

LGTM

bolt/include/bolt/Core/BinaryFunction.h

   /// is called. I.e. function address and size should be set.
   ///
   /// 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);
+
   /// 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

bool BinaryFunction::isZeroPaddingAt(uint64_t Offset) const {
   }
   for (uint64_t I = Offset; I < EndOfCode; ++I)
     if (FunctionData[I] != 0)
       return false;
 
   return true;
 }
 
-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 handlePCRelOperand = [&](MCInst &Instruction, uint64_t Address,
+void BinaryFunction::handlePCRelOperand(MCInst &Instruction, uint64_t Address,
                                         uint64_t Size) {
-    uint64_t TargetAddress = 0;
-    if (!MIB->evaluateMemOperandTarget(Instruction, TargetAddress, Address,
-                                       Size)) {
-      errs() << "BOLT-ERROR: PC-relative operand can't be evaluated:\n";
-      BC.InstPrinter->printInst(&Instruction, 0, "", *BC.STI, errs());
-      errs() << '\n';
-      Instruction.dump_pretty(errs(), BC.InstPrinter.get());
-      errs() << '\n';
-      errs() << "BOLT-ERROR: cannot handle PC-relative operand at 0x"
-             << Twine::utohexstr(Address) << ". Skipping function " << *this
-             << ".\n";
-      if (BC.HasRelocations)
-        exit(1);
-      IsSimple = false;
-      return;
-    }
-    if (TargetAddress == 0 && opts::Verbosity >= 1) {
-      outs() << "BOLT-INFO: PC-relative operand is zero in function " << *this
-             << '\n';
-    }
+  auto &MIB = BC.MIB;
 
-    const MCSymbol *TargetSymbol;
-    uint64_t TargetOffset;
-    std::tie(TargetSymbol, TargetOffset) =
-        BC.handleAddressRef(TargetAddress, *this, /*IsPCRel*/ true);
-    const MCExpr *Expr = MCSymbolRefExpr::create(
-        TargetSymbol, MCSymbolRefExpr::VK_None, *BC.Ctx);
-    if (TargetOffset) {
-      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)));
-  };
+  const MCExpr *Expr =
+      MCSymbolRefExpr::create(TargetSymbol, MCSymbolRefExpr::VK_None, *BC.Ctx);
+}
+
+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 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) {