[BOLT][NFC] Const-ify analyzeJumpTable

[Amir]

Summary

Avoid modifying BF, instead set extra output parameter and modify BF in caller
scope.

[rafauler]

bolt/include/bolt/Core/JumpTable.h

70

do we have plans to use this elsewhere?

[rafauler]

nevermind, saw the other diff in the stack, LGTM, thanks

bolt/include/bolt/Core/BinaryContext.h

public:
   /// the \p Address. This is useful when we need to locate functions for
   /// references pointing immediately past a function body.
   ///
   /// If \p UseMaxSize is true, then include the space between this function
   /// body and the next object in address ranges that we check.
   BinaryFunction *getBinaryFunctionContainingAddress(uint64_t Address,
                                                      bool CheckPastEnd = false,
                                                      bool UseMaxSize = false);
+  const BinaryFunction *
+  getBinaryFunctionContainingAddress(uint64_t Address,
+                                     bool CheckPastEnd = false,
+                                     bool UseMaxSize = false) const {
+    return const_cast<BinaryContext *>(this)
+        ->getBinaryFunctionContainingAddress(Address, CheckPastEnd, UseMaxSize);
+  }
 
   /// Return a BinaryFunction that starts at a given \p Address.
   BinaryFunction *getBinaryFunctionAtAddress(uint64_t Address);
 
   const BinaryFunction *getBinaryFunctionAtAddress(uint64_t Address) const {
     return const_cast<BinaryContext *>(this)->getBinaryFunctionAtAddress(
         Address);
   }
public:
   /// otherwise.
   ///
   /// If \p NextJTAddress is different from zero, it is used as an upper
   /// bound for jump table memory layout.
   ///
   /// Optionally, populate \p Address from jump table entries. The entries
   /// could be partially populated if the jump table detection fails.
   bool analyzeJumpTable(const uint64_t Address,
-                        const JumpTable::JumpTableType Type, BinaryFunction &BF,
+                        const JumpTable::JumpTableType Type,
+                        const BinaryFunction &BF,
                         const uint64_t NextJTAddress = 0,
-                        JumpTable::AddressesType *EntriesAsAddress = nullptr);
+                        JumpTable::AddressesType *EntriesAsAddress = nullptr,
+                        bool *HasEntryInFragment = nullptr) const;
 
   /// After jump table locations are established, this function will populate
   /// their EntriesAsAddress based on memory contents.
   void populateJumpTables();
 
   /// Returns a jump table ID and label pointing to the duplicated jump table.
   /// Ordinarily, jump tables are identified by their address in the input
   /// binary. We return an ID with the high bit set to differentiate it from
public:
   void foldFunction(BinaryFunction &ChildBF, BinaryFunction &ParentBF);
 
   /// Add a Section relocation at a given \p Address.
   void addRelocation(uint64_t Address, MCSymbol *Symbol, uint64_t Type,
                      uint64_t Addend = 0, uint64_t Value = 0);
 
   /// Return a relocation registered at a given \p Address, or nullptr if there
   /// is no relocation at such address.
-  const Relocation *getRelocationAt(uint64_t Address);
+  const Relocation *getRelocationAt(uint64_t Address) const;
 
   /// Register a presence of PC-relative relocation at the given \p Address.
   void addPCRelativeDataRelocation(uint64_t Address) {
     DataPCRelocations.emplace(Address);
   }
 
   /// Register dynamic relocation at \p Address.
   void addDynamicRelocation(uint64_t Address, MCSymbol *Symbol, uint64_t Type,

bolt/include/bolt/Core/JumpTable.h

public:
   size_t EntrySize;
 
   /// Size of the entry size we will write (we may use a more compact layout)
   size_t OutputEntrySize;
 
   /// The type of this jump table.
   JumpTableType Type;
 
+  /// Whether this jump table has entries pointing to multiple functions.
+  bool IsSplit{false};
+
   /// All the entries as labels.
   std::vector<MCSymbol *> Entries;
 
   /// All the entries as absolute addresses. Invalid after disassembly is done.
   using AddressesType = std::vector<uint64_t>;
   AddressesType EntriesAsAddress;
 
   /// Map <Offset> -> <Label> used for embedded jump tables. Label at 0 offset

bolt/lib/Core/BinaryContext.cpp

if (analyzeJumpTable(Address, JumpTable::JTT_PIC, BF))
     return MemoryContentsType::POSSIBLE_PIC_JUMP_TABLE;
 
   if (analyzeJumpTable(Address, JumpTable::JTT_NORMAL, BF))
     return MemoryContentsType::POSSIBLE_JUMP_TABLE;
 
   return MemoryContentsType::UNKNOWN;
 }
 
-bool BinaryContext::analyzeJumpTable(
-    const uint64_t Address, const JumpTable::JumpTableType Type,
-    BinaryFunction &BF, const uint64_t NextJTAddress,
-    JumpTable::AddressesType *EntriesAsAddress) {
+bool BinaryContext::analyzeJumpTable(const uint64_t Address,
+                                     const JumpTable::JumpTableType Type,
+                                     const BinaryFunction &BF,
+                                     const uint64_t NextJTAddress,
+                                     JumpTable::AddressesType *EntriesAsAddress,
+                                     bool *HasEntryInFragment) const {
   // Is one of the targets __builtin_unreachable?
   bool HasUnreachable = false;
 
   // Number of targets other than __builtin_unreachable.
   uint64_t NumRealEntries = 0;
 
   auto addEntryAddress = [&](uint64_t EntryAddress) {
     if (EntriesAsAddress)
       EntriesAsAddress->emplace_back(EntryAddress);
   };
 
   auto doesBelongToFunction = [&](const uint64_t Addr,
-                                  BinaryFunction *TargetBF) -> bool {
+                                  const BinaryFunction *TargetBF) -> bool {
     if (BF.containsAddress(Addr))
       return true;
     // Nothing to do if we failed to identify the containing function.
     if (!TargetBF)
       return false;
     // Check if BF is a fragment of TargetBF or vice versa.
     return BF.isChildOf(*TargetBF) || TargetBF->isChildOf(BF);
   };
 
-  ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
+  ErrorOr<const BinarySection &> Section = getSectionForAddress(Address);
   if (!Section)
     return false;
 
   // The upper bound is defined by containing object, section limits, and
   // the next jump table in memory.
   uint64_t UpperBound = Section->getEndAddress();
   const BinaryData *JumpTableBD = getBinaryDataAtAddress(Address);
   if (JumpTableBD && JumpTableBD->getSize()) {
for (uint64_t EntryAddress = Address; EntryAddress <= UpperBound - EntrySize;
     if (Value == BF.getAddress() + BF.getSize()) {
       addEntryAddress(Value);
       HasUnreachable = true;
       LLVM_DEBUG(dbgs() << formatv("OK: {0:x} __builtin_unreachable\n", Value));
       continue;
     }
 
     // Function or one of its fragments.
-    BinaryFunction *TargetBF = getBinaryFunctionContainingAddress(Value);
+    const BinaryFunction *TargetBF = getBinaryFunctionContainingAddress(Value);
 
     // We assume that a jump table cannot have function start as an entry.
     if (!doesBelongToFunction(Value, TargetBF) || Value == BF.getAddress()) {
       LLVM_DEBUG({
         if (!BF.containsAddress(Value)) {
           dbgs() << "FAIL: function doesn't contain this address\n";
           if (TargetBF) {
             dbgs() << "  ! function containing this address: "
if (TargetBF->getState() == BinaryFunction::State::Disassembled &&
         !TargetBF->getInstructionAtOffset(Value - TargetBF->getAddress())) {
       LLVM_DEBUG(dbgs() << formatv("FAIL: no instruction at {0:x}\n", Value));
       break;
     }
 
     ++NumRealEntries;
     LLVM_DEBUG(dbgs() << formatv("OK: {0:x} real entry\n", Value));
 
-    if (TargetBF != &BF)
-      BF.setHasIndirectTargetToSplitFragment(true);
+    if (TargetBF != &BF && HasEntryInFragment)
+      *HasEntryInFragment = true;
     addEntryAddress(Value);
   }
 
   // It's a jump table if the number of real entries is more than 1, or there's
   // one real entry and "unreachable" targets. If there are only multiple
   // "unreachable" targets, then it's not a jump table.
   return NumRealEntries + HasUnreachable >= 2;
 }
for (auto JTI = JumpTables.begin(), JTE = JumpTables.end(); JTI != JTE;
 
     uint64_t NextJTAddress = 0;
     auto NextJTI = std::next(JTI);
     if (NextJTI != JTE)
       NextJTAddress = NextJTI->second->getAddress();
 
     const bool Success =
         analyzeJumpTable(JT->getAddress(), JT->Type, *(JT->Parents[0]),
-                         NextJTAddress, &JT->EntriesAsAddress);
+                         NextJTAddress, &JT->EntriesAsAddress, &JT->IsSplit);
     if (!Success) {
       LLVM_DEBUG({
         dbgs() << "failed to analyze ";
         JT->print(dbgs());
         if (NextJTI != JTE) {
           dbgs() << "next ";
           NextJTI->second->print(dbgs());
         }
       });
       llvm_unreachable("jump table heuristic failure");
     }
     for (BinaryFunction *Frag : JT->Parents) {
+      if (JT->IsSplit)
+        Frag->setHasIndirectTargetToSplitFragment(true);
       for (uint64_t EntryAddress : JT->EntriesAsAddress)
         // if target is builtin_unreachable
         if (EntryAddress == Frag->getAddress() + Frag->getSize()) {
           Frag->IgnoredBranches.emplace_back(EntryAddress - Frag->getAddress(),
                                              Frag->getSize());
         } else if (EntryAddress >= Frag->getAddress() &&
                    EntryAddress < Frag->getAddress() + Frag->getSize()) {
           Frag->registerReferencedOffset(EntryAddress - Frag->getAddress());

 }
 
 bool BinaryContext::removeRelocationAt(uint64_t Address) {
   ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
   assert(Section && "cannot find section for address");
   return Section->removeRelocationAt(Address - Section->getAddress());
 }
 
-const Relocation *BinaryContext::getRelocationAt(uint64_t Address) {
-  ErrorOr<BinarySection &> Section = getSectionForAddress(Address);
+const Relocation *BinaryContext::getRelocationAt(uint64_t Address) const {
+  ErrorOr<const BinarySection &> Section = getSectionForAddress(Address);
   if (!Section)
     return nullptr;
 
   return Section->getRelocationAt(Address - Section->getAddress());
 }
 
 const Relocation *BinaryContext::getDynamicRelocationAt(uint64_t Address) {
   ErrorOr<BinarySection &> Section = getSectionForAddress(Address);