[BOLT][WIP] Check dynamic relocations in analyzeJumpTable

[Amir]

Summary

perf2bolt-multiple-edge.test has jump table entries with associated dynamic
relocations. Check their presence in analyzeJumpTable.

Test WIP

[maksfb]

Not sure how to reproduce with assembly.

Can you try a test case with goto labels compiled with PIC?

[Amir]

Check Section->isRelro

bolt/lib/Core/BinaryContext.cpp

 }
 
 bool BinaryContext::analyzeJumpTable(const uint64_t Address,
                                      const JumpTable::JumpTableType Type,
                                      const BinaryFunction &BF,
                                      const uint64_t NextJTAddress,
                                      JumpTable::AddressesType *EntriesAsAddress,
                                      bool *HasEntryInFragment) const {
+  using JTT = JumpTable::JumpTableType;
   // 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);
   };
 
+  // Dynamic relocations are only eligible for jump table entries if their
+  // computed value is known to always point to the same location (code target)
+  // at runtime.
+  //
+  // A prerequisite for that is that 1) they are from read-only section (or
+  // write-once, such as in PT_GNU_RELRO case), 2) the value can't point to any
+  // location other than jump table target. The latter only holds for *_RELATIVE
+  // relocations where the value is computed against the base address at which a
+  // shared object has been loaded into memory during execution, hence it can't
+  // arbitrarily change.
+  auto hasEligibleDynamicRelocation = [&](uint64_t EntryAddress) {
+    const Relocation *Relocation = getDynamicRelocationAt(EntryAddress);
+    if (!Relocation || !Relocation->isRelative())
+      return false;
+    if (auto SectionOrErr = getSectionForAddress(EntryAddress)) {
+      const BinarySection &Section = SectionOrErr.get();
+      return !Section.isWritable() || Section.isRelro();
+    }
+    return false;
+  };
+
   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()) {
     assert(JumpTableBD->getEndAddress() <= UpperBound &&
            "data object cannot cross a section boundary");
     UpperBound = JumpTableBD->getEndAddress();
   }
   if (NextJTAddress)
     UpperBound = std::min(NextJTAddress, UpperBound);
 
   LLVM_DEBUG({
-    using JTT = JumpTable::JumpTableType;
     dbgs() << formatv("BOLT-DEBUG: analyzeJumpTable @{0:x} in {1}, JTT={2}\n",
                       Address, BF.getPrintName(),
                       Type == JTT::JTT_PIC ? "PIC" : "Normal");
   });
   const uint64_t EntrySize = getJumpTableEntrySize(Type);
   for (uint64_t EntryAddress = Address; EntryAddress <= UpperBound - EntrySize;
        EntryAddress += EntrySize) {
     LLVM_DEBUG(dbgs() << "  * Checking 0x" << Twine::utohexstr(EntryAddress)
                       << " -> ");
     // Check if there's a proper relocation against the jump table entry.
     if (HasRelocations) {
-      if (Type == JumpTable::JTT_PIC &&
-          !DataPCRelocations.count(EntryAddress)) {
-        LLVM_DEBUG(
-            dbgs() << "FAIL: JTT_PIC table, no relocation for this address\n");
+      if (Type == JTT::JTT_PIC && !DataPCRelocations.count(EntryAddress)) {
+        LLVM_DEBUG(dbgs() << "FAIL: no relocation for this address\n");
         break;
       }
-      if (Type == JumpTable::JTT_NORMAL && !getRelocationAt(EntryAddress)) {
-        LLVM_DEBUG(
-            dbgs()
-            << "FAIL: JTT_NORMAL table, no relocation for this address\n");
+      if (Type == JTT::JTT_NORMAL && !getRelocationAt(EntryAddress) &&
+          !hasEligibleDynamicRelocation(EntryAddress)) {
+        LLVM_DEBUG(dbgs() << "FAIL: no relocation for this address\n");
         break;
       }
     }
 
     const uint64_t Value =
         (Type == JumpTable::JTT_PIC)
             ? Address + *getSignedValueAtAddress(EntryAddress, EntrySize)
             : *getPointerAtAddress(EntryAddress);