[BOLT-AArch64] Support rewriting bzip2

Summary:
Add basic AArch64 read/write capability to be able to
disassemble bzip2 for AArch64 compiled with gcc 5.4.0 and write
it back after going through the basic BOLT pipeline with no block
reordering (NOPs/unreachable blocks get removed).

This is not for relocation mode.

(cherry picked from FBD5701994)

Author: rafaelauler

bolt/BinaryFunction.cpp

@@ -775,13 +775,13 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
   Labels[0] = Ctx->createTempSymbol("BB0", false);
   addEntryPointAtOffset(0);
 
-  auto handleRIPOperand =
+  auto handlePCRelOperand =
       [&](MCInst &Instruction, uint64_t Address, uint64_t Size) {
     uint64_t TargetAddress{0};
     MCSymbol *TargetSymbol{nullptr};
     if (!MIA->evaluateMemOperandTarget(Instruction, TargetAddress, Address,
                                        Size)) {
-      errs() << "BOLT-ERROR: rip-relative operand can't be evaluated:\n";
+      errs() << "BOLT-ERROR: PC-relative operand can't be evaluated:\n";
       BC.InstPrinter->printInst(&Instruction, errs(), "", *BC.STI);
       errs() << '\n';
       Instruction.dump_pretty(errs(), BC.InstPrinter.get());
@@ -790,7 +790,7 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
     }
     if (TargetAddress == 0) {
       if (opts::Verbosity >= 1) {
-        outs() << "BOLT-INFO: rip-relative operand is zero in function "
+        outs() << "BOLT-INFO: PC-relative operand is zero in function "
                << *this << ".\n";
       }
     }
@@ -816,8 +816,11 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
     if (!TargetSymbol)
       TargetSymbol = BC.getOrCreateGlobalSymbol(TargetAddress, "DATAat");
     MIA->replaceMemOperandDisp(
-        Instruction, MCOperand::createExpr(MCSymbolRefExpr::create(
-                         TargetSymbol, MCSymbolRefExpr::VK_None, *BC.Ctx)));
+        Instruction, MCOperand::createExpr(BC.MIA->getTargetExprFor(
+                         Instruction,
+                         MCSymbolRefExpr::create(
+                             TargetSymbol, MCSymbolRefExpr::VK_None, *BC.Ctx),
+                         *BC.Ctx)));
     return true;
   };
 
@@ -954,7 +957,7 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
             // Assign proper opcode for tail calls, so that they could be
             // treated as calls.
             if (!IsCall) {
-              if (!MIA->convertJmpToTailCall(Instruction)) {
+              if (!MIA->convertJmpToTailCall(Instruction, BC.Ctx.get())) {
                 assert(IsCondBranch && "unknown tail call instruction");
                 if (opts::Verbosity >= 2) {
                   errs() << "BOLT-WARNING: conditional tail call detected in "
@@ -1007,12 +1010,7 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
           // Add taken branch info.
           TakenBranches.emplace_back(Offset, TargetAddress - getAddress());
         }
-        Instruction.clear();
-        Instruction.addOperand(
-            MCOperand::createExpr(
-              MCSymbolRefExpr::create(TargetSymbol,
-                                      MCSymbolRefExpr::VK_None,
-                                      *Ctx)));
+        BC.MIA->replaceBranchTarget(Instruction, TargetSymbol, &*Ctx);
 
         // Record call offset for profile matching.
         if (IsCall) {
@@ -1036,7 +1034,8 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
             llvm_unreachable("unexpected result");
           case IndirectBranchType::POSSIBLE_TAIL_CALL:
             {
-              auto Result = MIA->convertJmpToTailCall(Instruction);
+              auto Result =
+                MIA->convertJmpToTailCall(Instruction, BC.Ctx.get());
               (void)Result;
               assert(Result);
             }
@@ -1053,8 +1052,8 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
           };
         }
         // Indirect call. We only need to fix it if the operand is RIP-relative
-        if (IsSimple && MIA->hasRIPOperand(Instruction)) {
-          if (!handleRIPOperand(Instruction, AbsoluteInstrAddr, Size)) {
+        if (IsSimple && MIA->hasPCRelOperand(Instruction)) {
+          if (!handlePCRelOperand(Instruction, AbsoluteInstrAddr, Size)) {
             errs() << "BOLT-ERROR: cannot handle RIP operand at 0x"
                    << Twine::utohexstr(AbsoluteInstrAddr)
                    << ". Skipping function " << *this << ".\n";
@@ -1065,8 +1064,8 @@ void BinaryFunction::disassemble(ArrayRef<uint8_t> FunctionData) {
         }
       }
     } else {
-      if (MIA->hasRIPOperand(Instruction)) {
-        if (!handleRIPOperand(Instruction, AbsoluteInstrAddr, Size)) {
+      if (MIA->hasPCRelOperand(Instruction)) {
+        if (!handlePCRelOperand(Instruction, AbsoluteInstrAddr, Size)) {
           errs() << "BOLT-ERROR: cannot handle RIP operand at 0x"
                  << Twine::utohexstr(AbsoluteInstrAddr)
                  << ". Skipping function " << *this << ".\n";
@@ -1152,7 +1151,7 @@ bool BinaryFunction::postProcessIndirectBranches() {
       // If there's an indirect branch in a single-block function -
       // it must be a tail call.
       if (layout_size() == 1) {
-        BC.MIA->convertJmpToTailCall(Instr);
+        BC.MIA->convertJmpToTailCall(Instr, BC.Ctx.get());
         return true;
       }
 
@@ -1231,7 +1230,7 @@ bool BinaryFunction::postProcessIndirectBranches() {
         }
         return false;
       }
-      BC.MIA->convertJmpToTailCall(Instr);
+      BC.MIA->convertJmpToTailCall(Instr, BC.Ctx.get());
     }
   }
   return true;

bolt/Passes/BinaryPasses.cpp

@@ -1005,12 +1005,12 @@ bool SimplifyRODataLoads::simplifyRODataLoads(
       // Try to statically evaluate the target memory address;
       uint64_t TargetAddress;
 
-      if (MIA->hasRIPOperand(Inst)) {
-        // Try to find the symbol that corresponds to the RIP-relative operand.
+      if (MIA->hasPCRelOperand(Inst)) {
+        // Try to find the symbol that corresponds to the PC-relative operand.
         auto DispOpI = MIA->getMemOperandDisp(Inst);
-        assert(DispOpI != Inst.end() && "expected RIP-relative displacement");
+        assert(DispOpI != Inst.end() && "expected PC-relative displacement");
         assert(DispOpI->isExpr() &&
-              "found RIP-relative with non-symbolic displacement");
+              "found PC-relative with non-symbolic displacement");
 
         // Get displacement symbol.
         const MCSymbolRefExpr *DisplExpr;

bolt/Passes/StokeInfo.cpp

@@ -65,7 +65,7 @@ void StokeInfo::checkInstr(const BinaryContext &BC, const BinaryFunction &BF,
       // check if this function modify stack or heap
       // TODO: more accurate analysis
       auto IsPush = BC.MIA->isPush(It);
-      auto IsRipAddr = BC.MIA->hasRIPOperand(It);
+      auto IsRipAddr = BC.MIA->hasPCRelOperand(It);
       if (IsPush) {
         FuncInfo.StackOut = true;
       }

bolt/RewriteInstance.cpp

@@ -675,7 +675,10 @@ void RewriteInstance::aggregateData() {
 
 void RewriteInstance::discoverStorage() {
 
-  EFMM.reset(new ExecutableFileMemoryManager());
+  // Tell EE that we guarantee we don't need stubs for x86, but not for aarch64
+  EFMM.reset(new ExecutableFileMemoryManager(
+      /*AllowStubs*/ (BC->TheTriple->getArch() == llvm::Triple::aarch64 &&
+                      opts::Relocs)));
 
   auto ELF64LEFile = dyn_cast<ELF64LEObjectFile>(InputFile);
   if (!ELF64LEFile) {
@@ -1224,7 +1227,8 @@ void RewriteInstance::discoverFileObjects() {
   }
 
   // Process PLT section.
-  disassemblePLT();
+  if (BC->TheTriple->getArch() == Triple::x86_64)
+    disassemblePLT();
 
   // See if we missed any functions marked by FDE.
   for (const auto &FDEI : CFIRdWrt->getFDEs()) {

bolt/RewriteInstance.h

@@ -104,6 +104,8 @@ class ExecutableFileMemoryManager : public SectionMemoryManager {
                            bool IsCode,
                            bool IsReadOnly);
 
+  bool AllowStubs;
+
 public:
   /// [start memory address] -> [segment info] mapping.
   std::map<uint64_t, SegmentInfo> SegmentMapInfo;
@@ -114,7 +116,7 @@ class ExecutableFileMemoryManager : public SectionMemoryManager {
   /// Information about non-allocatable sections.
   std::map<std::string, SectionInfo> NoteSectionInfo;
 
-  ExecutableFileMemoryManager() {}
+  ExecutableFileMemoryManager(bool AllowStubs) : AllowStubs(AllowStubs) {}
 
   ~ExecutableFileMemoryManager();
 
@@ -136,8 +138,7 @@ class ExecutableFileMemoryManager : public SectionMemoryManager {
                              unsigned Alignment, unsigned SectionID,
                              StringRef SectionName) override;
 
-  // Tell EE that we guarantee we don't need stubs.
-  bool allowStubAllocation() const override { return false; }
+  bool allowStubAllocation() const override { return AllowStubs; }
 
   bool finalizeMemory(std::string *ErrMsg = nullptr) override;
 };