[BOLT][NFC] Reformat strings in handleRelocation

[Amir]

Summary

With reduced indentation, some strings can be reformatted to take less lines.
Also strategically apply formatv to shorten them.

[Amir]

remove unrelated change

[rafauler]

LGTM

bolt/lib/Rewrite/RewriteInstance.cpp

if (BC->isX86())
       return;
 
     // The non-got related TLS relocations on AArch64 also could be skipped.
     if (!Relocation::isGOT(RType))
       return;
   }
 
   if (!IsAArch64 && BC->getDynamicRelocationAt(Rel.getOffset())) {
-    LLVM_DEBUG(
-        dbgs() << "BOLT-DEBUG: address 0x" << Twine::utohexstr(Rel.getOffset())
-               << " has a dynamic relocation against it. Ignoring static "
-                  "relocation.\n");
+    LLVM_DEBUG({
+      dbgs() << formatv("BOLT-DEBUG: address {0:x} has a ", Rel.getOffset())
+             << "dynamic relocation against it. Ignoring static relocation.\n";
+    });
     return;
   }
 
   std::string SymbolName;
   uint64_t SymbolAddress;
   int64_t Addend;
   uint64_t ExtractedValue;
   bool IsSectionRelocation;
   bool Skip;
   if (!analyzeRelocation(Rel, RType, SymbolName, IsSectionRelocation,
                          SymbolAddress, Addend, ExtractedValue, Skip)) {
-    LLVM_DEBUG(dbgs() << "BOLT-WARNING: failed to analyze relocation @ "
-                      << "offset = 0x" << Twine::utohexstr(Rel.getOffset())
-                      << "; type name = " << TypeName << '\n');
+    LLVM_DEBUG({
+      dbgs() << "BOLT-WARNING: failed to analyze relocation @ offset = "
+             << formatv("{0:x}; type name = {1}\n", Rel.getOffset(), TypeName);
+    });
     ++NumFailedRelocations;
     return;
   }
 
   if (Skip) {
-    LLVM_DEBUG(dbgs() << "BOLT-DEBUG: skipping relocation @ offset = 0x"
-                      << Twine::utohexstr(Rel.getOffset())
-                      << "; type name = " << TypeName << '\n');
+    LLVM_DEBUG({
+      dbgs() << "BOLT-DEBUG: skipping relocation @ offset = "
+             << formatv("{0:x}; type name = {1}\n", Rel.getOffset(), TypeName);
+    });
     return;
   }
 
   const uint64_t Address = SymbolAddress + Addend;
 
   LLVM_DEBUG({
     dbgs() << "BOLT-DEBUG: ";
     printRelocationInfo(Rel, SymbolName, SymbolAddress, Addend, ExtractedValue);
   });
 
   BinaryFunction *ContainingBF = nullptr;
   if (IsFromCode) {
     ContainingBF =
         BC->getBinaryFunctionContainingAddress(Rel.getOffset(),
                                                /*CheckPastEnd*/ false,
                                                /*UseMaxSize*/ true);
     assert(ContainingBF && "cannot find function for address in code");
     if (!IsAArch64 && !ContainingBF->containsAddress(Rel.getOffset())) {
       if (opts::Verbosity >= 1)
-        outs() << "BOLT-INFO: " << *ContainingBF
-               << " has relocations in padding area\n";
+        outs() << formatv("BOLT-INFO: {0} has relocations in padding area\n",
+                          *ContainingBF);
       ContainingBF->setSize(ContainingBF->getMaxSize());
       ContainingBF->setSimple(false);
       return;
     }
   }
 
   MCSymbol *ReferencedSymbol = nullptr;
   if (!IsSectionRelocation)
if (!IsFromCode && IsToCode) {
       BC->addPCRelativeDataRelocation(Rel.getOffset());
     } else if (ContainingBF && !IsSectionRelocation && ReferencedSymbol) {
       // If we know the referenced symbol, register the relocation from
       // the code. It's required  to properly handle cases where
       // "symbol + addend" references an object different from "symbol".
       ContainingBF->addRelocation(Rel.getOffset(), ReferencedSymbol, RType,
                                   Addend, ExtractedValue);
     } else {
-      LLVM_DEBUG(
-          dbgs() << "BOLT-DEBUG: not creating PC-relative relocation at 0x"
-                 << Twine::utohexstr(Rel.getOffset()) << " for " << SymbolName
-                 << "\n");
+      LLVM_DEBUG({
+        dbgs() << "BOLT-DEBUG: not creating PC-relative relocation at"
+               << formatv("{0:x} for {1}\n", Rel.getOffset(), SymbolName);
+      });
     }
 
     return;
   }
 
   bool ForceRelocation = BC->forceSymbolRelocations(SymbolName);
   if (BC->isAArch64() && Relocation::isGOT(RType))
     ForceRelocation = true;
BinaryFunction *ReferencedBF = BC->getBinaryFunctionContainingAddress(
       Address, /*CheckPastEnd*/ true, /*UseMaxSize*/ IsAArch64);
 
   if (!IsSectionRelocation) {
     if (BinaryFunction *BF =
             BC->getBinaryFunctionContainingAddress(SymbolAddress)) {
       if (BF != ReferencedBF) {
         // It's possible we are referencing a function without referencing any
         // code, e.g. when taking a bitmask action on a function address.
-        errs() << "BOLT-WARNING: non-standard function reference (e.g. "
-                  "bitmask) detected against function "
-               << *BF;
+        errs() << "BOLT-WARNING: non-standard function reference (e.g. bitmask)"
+               << formatv(" detected against function {0} from ", *BF);
         if (IsFromCode)
-          errs() << " from function " << *ContainingBF << '\n';
+          errs() << formatv("function {0}\n", *ContainingBF);
         else
-          errs() << " from data section at 0x"
-                 << Twine::utohexstr(Rel.getOffset()) << '\n';
+          errs() << formatv("data section at {0:x}\n", Rel.getOffset());
         LLVM_DEBUG(printRelocationInfo(Rel, SymbolName, SymbolAddress, Addend,
                                        ExtractedValue));
         ReferencedBF = BF;
       }
     }
   } else if (ReferencedBF) {
     assert(ReferencedSection && "section expected for section relocation");
     if (*ReferencedBF->getOriginSection() != *ReferencedSection) {
if (const BinaryFunction *RogueBF =
         if (Rel.Symbol == RogueBF->getSymbol() &&
             !Relocation::isPCRelative(Rel.Type)) {
           Found = true;
           break;
         }
       }
 
       if (Found) {
-        errs() << "BOLT-WARNING: detected possible compiler "
-                  "de-virtualization bug: -1 addend used with "
-                  "non-pc-relative relocation against function "
-               << *RogueBF << " in function " << *ContainingBF << '\n';
+        errs() << "BOLT-WARNING: detected possible compiler de-virtualization "
+                  "bug: -1 addend used with non-pc-relative relocation against "
+               << formatv("function {0} in function {1}\n", *RogueBF,
+                          *ContainingBF);
         return;
       }
     }
   }
 
   if (ForceRelocation) {
     std::string Name = Relocation::isGOT(RType) ? "Zero" : SymbolName;
     ReferencedSymbol = BC->registerNameAtAddress(Name, 0, 0, 0);
if (ReferencedBF->containsAddress(Address, /*UseMaxSize = */ true)) {
         } else {
           ReferencedSymbol =
               ReferencedBF->getOrCreateLocalLabel(Address,
                                                   /*CreatePastEnd =*/true);
           ReferencedBF->registerReferencedOffset(RefFunctionOffset);
         }
         if (opts::Verbosity > 1 &&
             !BinarySection(*BC, RelocatedSection).isReadOnly())
-          errs() << "BOLT-WARNING: writable reference into the middle of "
-                 << "the function " << *ReferencedBF
-                 << " detected at address 0x"
-                 << Twine::utohexstr(Rel.getOffset()) << '\n';
+          errs() << "BOLT-WARNING: writable reference into the middle of the "
+                 << formatv("function {0} detected at address {1:x}\n",
+                            *ReferencedBF, Rel.getOffset());
       }
       SymbolAddress = Address;
       Addend = 0;
     }
     LLVM_DEBUG({
       dbgs() << "  referenced function " << *ReferencedBF;
       if (Address != ReferencedBF->getAddress())
-        dbgs() << " at offset 0x" << Twine::utohexstr(RefFunctionOffset);
+        dbgs() << formatv(" at offset {0:x}", RefFunctionOffset);
       dbgs() << '\n';
     });
   } else {
     if (IsToCode && SymbolAddress) {
       // This can happen e.g. with PIC-style jump tables.
       LLVM_DEBUG(dbgs() << "BOLT-DEBUG: no corresponding function for "
                            "relocation against code\n");
     }
 
     // In AArch64 there are zero reasons to keep a reference to the
     // "original" symbol plus addend. The original symbol is probably just a
     // section symbol. If we are here, this means we are probably accessing
     // data, so it is imperative to keep the original address.
     if (IsAArch64) {
-      SymbolName = ("SYMBOLat0x" + Twine::utohexstr(Address)).str();
+      SymbolName = formatv("SYMBOLat{0:x}", Address);
       SymbolAddress = Address;
       Addend = 0;
     }
 
     if (BinaryData *BD = BC->getBinaryDataContainingAddress(SymbolAddress)) {
       // Note: this assertion is trying to check sanity of BinaryData objects
       // but AArch64 has inferred and incomplete object locations coming from
       // GOT/TLS or any other non-trivial relocation (that requires creation
       // of sections and whose symbol address is not really what should be
       // encoded in the instruction). So we essentially disabled this check
       // for AArch64 and live with bogus names for objects.
       assert((IsAArch64 || IsSectionRelocation ||
               BD->nameStartsWith(SymbolName) ||
               BD->nameStartsWith("PG" + SymbolName) ||
               (BD->nameStartsWith("ANONYMOUS") &&
                (BD->getSectionName().startswith(".plt") ||
                 BD->getSectionName().endswith(".plt")))) &&
-             "BOLT symbol names of all non-section relocations must match "
-             "up with symbol names referenced in the relocation");
+             "BOLT symbol names of all non-section relocations must match up "
+             "with symbol names referenced in the relocation");
 
       if (IsSectionRelocation)
         BC->markAmbiguousRelocations(*BD, Address);
 
       ReferencedSymbol = BD->getSymbol();
       Addend += (SymbolAddress - BD->getAddress());
       SymbolAddress = BD->getAddress();
       assert(Address == SymbolAddress + Addend);
if (BinaryData *BD = BC->getBinaryDataContainingAddress(SymbolAddress)) {
       }
     }
   }
 
   auto checkMaxDataRelocations = [&]() {
     ++NumDataRelocations;
     if (opts::MaxDataRelocations &&
         NumDataRelocations + 1 == opts::MaxDataRelocations) {
-      LLVM_DEBUG(dbgs() << "BOLT-DEBUG: processing ending on data relocation "
-                        << NumDataRelocations << ": ");
+      LLVM_DEBUG({
+        dbgs() << "BOLT-DEBUG: processing ending on data relocation "
+               << NumDataRelocations << ": ";
+      });
       printRelocationInfo(Rel, ReferencedSymbol->getName(), SymbolAddress,
                           Addend, ExtractedValue);
     }
 
     return (!opts::MaxDataRelocations ||
             NumDataRelocations < opts::MaxDataRelocations);
   };