[BOLT] Update dynamic relocations from section relocations

[yota9]

Summary

This patch changes patchELFAllocatableRelaSections from going through
old relocations sections and update the relocation offsets to emitting
the relocations stored in binary sections. This is needed in case we
would like to remove and add dynamic relocations during BOLT work and it
is used by golang support pass. Note: Currently we emit relocations in
the old sections, so the total number of them should be equal or less
of old number.

Testing: No special tests are neeeded, since this patch does not fix
anything or add new functionality (it only prepares to add). Every
PIC-compiled test binary will use this code and thus become a test.
But just in case the aarch64 dynamic relocations tests were added.

Vladislav Khmelevsky,
Advanced Software Technology Lab, Huawei

[yota9]

Replace isJmpRel() with IsJmpRel flag in relocation struct. Since some of the linkers are inconsistent (e.g. the LD places R_AARCH64_TLSDESC in .rela.plt and lld places it in .rela.dyn) the flag usage looks like more robust solution, then on-type decisions.

[yota9]

This comment was removed by yota9.

[yota9]

Add aarch64 dynamic relocations tests

[maksfb]

bolt/include/bolt/Core/Relocation.h

54

Instead of introducing this flag, could we change the rewriter to classify relocation types based on the input?

bolt/lib/Rewrite/RewriteInstance.cpp

4816

4821

bolt/test/runtime/AArch64/Inputs/runtime_relocs.c

3

11–12

bolt/test/runtime/AArch64/runtime_relocs.c

10

Is it necessary to run the binary?

49

51

53

[yota9]

bolt/include/bolt/Core/Relocation.h

54

Sorry I'm not quite understand. Do you mean to classify it based on the relocation type? I did it in the first iteration of the patch, but as I said above we have a problem here: for example LD places R_AARCH64_TLSDESC in .rela.plt and lld places it in .rela.dyn, so there is not stable way to determine where did the relocation came from. Or you mean something else?

bolt/test/runtime/AArch64/runtime_relocs.c

10

Well, no, it is just extra check the the binary works fine. Is there any reason to create non-runnable tests? AFAIU the X86 test bot won't run aarch64 tests even if they are not runnable, or I'm wrong?

[yota9]

bolt/include/bolt/Core/Relocation.h

54

Or you mean to create the map of REL_TYPE->section while reading the relocations? Well it might work (of course if for some reason we won't met the same rel type in both sections). Plus we will need to handle this structure explicitly in case the new relocations are created during bolt work..

[maksfb]

bolt/include/bolt/Core/Relocation.h

54

Exactly. Typically, only specific relocation types are classified as "jump", but if the input contains more we can extend the class.

[yota9]

Replace IsJmpRel field with std::map and resolve other comments

[yota9]

@maksfb Thank you for you review! I've resolved most of the comments with the latest patch update :)

[maksfb]

bolt/include/bolt/Core/Relocation.h

51–53

I feel uneasy about overloading the Value field. An alternative will be to keep MCSymbol -> index map for dynamic symbols. What do you think?

bolt/include/bolt/Rewrite/RewriteInstance.h

448

449

DenseMap is a better choice, maybe even IndexedMap.

bolt/lib/Rewrite/RewriteInstance.cpp

2129

Does it make sense to pre-populate the map with types that are known to be jump relocations?

[yota9]

bolt/include/bolt/Core/Relocation.h

51–53

Well to be honest I love this solution more.
Static relocations -> Extracted value
Dynamic relocations -> Symbol value
It seems logical for me, I'm not sure that we need this overcomplications with extra maps to be hones...

bolt/lib/Rewrite/RewriteInstance.cpp

2129

Well, currently I just don't see the reason to do this over using the values that came from the binary

[yota9]

Replace std::map with DenseMap

bolt/include/bolt/Rewrite/RewriteInstance.h

449

You're right, DenseMap is a bit of a better choice here. IndexedMap will consume more memory as I remember, since relocation type number might be quite big.

[maksfb]

bolt/include/bolt/Core/Relocation.h

51–53

It might be a bit more code, but less hacky. The index of the symbol in the input/output dynamic symbol table, is not a property of a relocation object. Note that you actually need the index in the output file. When we decide to update/rewrite the dynamic symbol table, the index may change. I suggest we add an interface to the rewriter that will return an index for a given MCSymbol (it can use the map for the current implementation).

[yota9]

bolt/include/bolt/Core/Relocation.h

51–53

Well, in case the symbol table will be updated one day we will need to create such a map anyway, you're right. I will do this :)

[yota9]

Add SymbolIndex map

[yota9]

bolt/include/bolt/Core/Relocation.h

51–53

Hello @maksfb ! I've added SymbolIndex map as we've discussed :)

[yota9]

clang-format

[maksfb]

bolt/include/bolt/Rewrite/RewriteInstance.h

451

Could you put a more accurate description? I.e. "index in the dynamic symbol table". Also, not all symbols will be in the table, right? Only those referenced by relocations?

452

Perhaps DenseMap here as well?

bolt/lib/Rewrite/RewriteInstance.cpp

2107

nit: there's no need for the variable as there's only one usage.

2108

nit: use RType defined above. You can make it const.

4797–4799

I'd rather put the code under getOutputDynamicSymbolIndex(MCSymbol *).

[yota9]

Resolve comments

bolt/include/bolt/Rewrite/RewriteInstance.h

451

Done. Yes, currently only relocation-related symbols will appear there. To be honest I just didn't find the way to get all the symbols in table order, anyway currently it is not needed, I will add a NOTE about this.

452

In my mind unordered_map is good choice here, I've forgot to fix it before upload. AFAIK DenseMap keeps the data in one allocation, I don't really think it is needed here, there might be quite a lot of symbols, so I feel like many small allocations is more winning here. Also the fata locality won't really change the overall performance. But I don't really insist, if you'd like I will replace it with DenseMap

bolt/lib/Rewrite/RewriteInstance.cpp

2108

My bad, thanks

4797–4799

I was thinking about this too, but rewriteinstance lacks of such wrappers so I've decided to add it in place. But I don't mind, so done :)

[maksfb]

It looks good. Thanks for the fixes.

In the summary: " so we the total number" -> "so the total number".

bolt/lib/Rewrite/RewriteInstance.cpp

4756

Can you use Section->getInputFileOffset()?

4781

4800

4809

[yota9]

Address comments

[yota9]

@maksfb Thank you for your review and valuable comments! :)

bolt/lib/Rewrite/RewriteInstance.cpp

4756

Thanks!

[maksfb]

There's a small typo left in the summary.

Regarding the testing, we need to make sure the relocation sections remain the same. This could be done via binary comparison, but unfortunately the order of relocations becomes different.

[yota9]

@maksfb Strange, fixed now :) + clang-formatted one line.

Regarding the order question, yes, the reorder is somewhat expected. Do you have ideas how to test it?

[yota9]

@maksfb The relocations are usually sorted by the offset in the file. But I didn't sort them, since I don't see any real reason to do this, it doesn't affect the runtime. Although theoretically it might help with the testing, but it is time & space consuming to find and reorder all the relocations and store them in needed order, so I don't really think we need to do this..

[maksfb]

At a couple cases I looked at, the relocations were unsorted before and are sorted now with this change.

[yota9]

@maksfb Interesting, usually I see that relocations are sorted initially. Now they will be sorted in storage order and per section order, which does not guarantee the offset order.. Anyway if you have any ideas about this please let me know :)

[maksfb]

I can do manual testing on internal binaries. More scalable approach is to alter the binary comparison to allow a set of modifications that preserve binary semantics. Ordering relocations would be an example of such transformation. Naturally we can sort them for the comparison purposes.

[yota9]

@maksfb Thanks! We can discuss such approach one day if you'd like (out of scope of this review, I think), since to be honest right now I don't have deep understanding how to make it properly..

[maksfb]

One way to do the binary comparison in this case, is to dump relocations (e.g. via llvm-objdump) from mismatched sections and sort them. But you are right, it's beyond the scope of this diff.

[yota9]

Oh you mean by external script. I think it is possible to make this, however it might be a bit challenging with no-symbol (e.g. relative) relocations. But we could always find the symbol by offset of course. I was also thinking about something like reorder-functions=user approach, but it is extra logic which I would not like to add to bolt it self.

bolt/include/bolt/Core/BinarySection.h

iterator_range<RelocationSetType::iterator> relocations() {
     return make_range(Relocations.begin(), Relocations.end());
   }
 
   /// Iterate over all non-pending relocations for this section.
   iterator_range<RelocationSetType::const_iterator> relocations() const {
     return make_range(Relocations.begin(), Relocations.end());
   }
 
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::iterator> dynamicRelocations() {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
+  /// Iterate over all dynamic relocations for this section.
+  iterator_range<RelocationSetType::const_iterator> dynamicRelocations() const {
+    return make_range(DynamicRelocations.begin(), DynamicRelocations.end());
+  }
+
   /// Does this section have any non-pending relocations?
   bool hasRelocations() const { return !Relocations.empty(); }
 
   /// Does this section have any pending relocations?
   bool hasPendingRelocations() const { return !PendingRelocations.empty(); }
 
   /// Remove non-pending relocation with the given /p Offset.
   bool removeRelocationAt(uint64_t Offset) {

bolt/include/bolt/Core/Relocation.h

struct Relocation {
 
   /// The offset from the \p Symbol base used to compute the final
   /// value of this relocation.
   uint64_t Addend;
 
   /// The computed relocation value extracted from the binary file.
   /// Used to validate relocation correctness.
   uint64_t Value;
 
   /// Return size of the given relocation \p Type.
   static size_t getSizeForType(uint64_t Type);
 
   /// Return size of this relocation.
   size_t getSize() const { return getSizeForType(Type); }
 
   /// Handle special cases when relocation should not be processed by bolt
   static bool skipRelocationProcess(uint64_t Type, uint64_t Contents);
 
   // Adjust value depending on relocation type (make it PC relative or not)
   static uint64_t adjustValue(uint64_t Type, uint64_t Value,
struct Relocation {
   static bool isRelative(uint64_t Type);
 
   /// Return true if relocation type is IRELATIVE
   static bool isIRelative(uint64_t Type);
 
   /// Return true if relocation type is for thread local storage.
   static bool isTLS(uint64_t Type);
 
+  /// Return code for a NONE relocation
+  static uint64_t getNone();
+
   /// Return code for a PC-relative 4-byte relocation
   static uint64_t getPC32();
 
   /// Return code for a PC-relative 8-byte relocation
   static uint64_t getPC64();
 
   /// Return true if this relocation is PC-relative. Return false otherwise.
   bool isPCRelative() const { return isPCRelative(Type); }
 
+  /// Return true if this relocation is R_*_RELATIVE type. Return false
+  /// otherwise.
+  bool isRelative() const { return isRelative(Type); }
+
   /// Emit relocation at a current \p Streamer' position. The caller is
   /// responsible for setting the position correctly.
   size_t emit(MCStreamer *Streamer) const;
 
   /// Print a relocation to \p OS.
   void print(raw_ostream &OS) const;
 };
 

bolt/include/bolt/Rewrite/RewriteInstance.h

 #include "bolt/Utils/NameResolver.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include <map>
 #include <set>
+#include <unordered_map>
 
 namespace llvm {
 
 class ToolOutputFile;
 
 namespace bolt {
 
 class BoltAddressTranslation;
private:
 
   /// Process special linux kernel section, __bug_table.
   void processLKBugTable();
 
   /// Process special linux kernel section, .smp_locks.
   void processLKSMPLocks();
 
   /// Read relocations from a given section.
-  void readDynamicRelocations(const object::SectionRef &Section);
+  void readDynamicRelocations(const object::SectionRef &Section, bool IsJmpRel);
 
   /// Read relocations from a given section.
   void readRelocations(const object::SectionRef &Section);
 
   /// Mark functions that are not meant for processing as ignored.
   void selectFunctionsToProcess();
 
   /// Read information from debug sections.
private:
   /// function. If we couldn't understand the function for some reason in
   /// disassembleFunctions(), also preserve the original version.
   void rewriteFile();
 
   /// Return address of a function in the new binary corresponding to
   /// \p OldAddress address in the original binary.
   uint64_t getNewFunctionAddress(uint64_t OldAddress);
 
+  /// Return address of a function or moved data in the new binary
+  /// corresponding to \p OldAddress address in the original binary.
+  uint64_t getNewFunctionOrDataAddress(uint64_t OldAddress);
+
   /// Return value for the symbol \p Name in the output.
   uint64_t getNewValueForSymbol(const StringRef Name);
 
   /// Detect addresses and offsets available in the binary for allocating
   /// new sections.
   void discoverStorage();
 
   /// Adjust function sizes and set proper maximum size values after the whole
#define ELF_FUNCTION(FUNC)                                                     \
   /// are updating it in-place with minimal modifications.
   template <typename ELFT, typename WriteFuncTy, typename StrTabFuncTy>
   void updateELFSymbolTable(
       object::ELFObjectFile<ELFT> *File, bool IsDynSym,
       const typename object::ELFObjectFile<ELFT>::Elf_Shdr &SymTabSection,
       const std::vector<uint32_t> &NewSectionIndex, WriteFuncTy Write,
       StrTabFuncTy AddToStrTab);
 
+  /// Get output index in dynamic symbol table.
+  uint32_t getOutputDynamicSymbolIndex(const MCSymbol *Symbol) {
+    auto It = SymbolIndex.find(Symbol);
+    if (It != SymbolIndex.end())
+      return It->second;
+    return 0;
+  }
+
   /// Add a notes section containing the BOLT revision and command line options.
   void addBoltInfoSection();
 
   /// Add a notes section containing the serialized BOLT Address Translation
   /// maps that can be used to enable sampling of the output binary for the
   /// purpose of generating BOLT profile data for the input binary.
   void addBATSection();
 
private:
   uint64_t NewTextSegmentSize{0};
 
   /// Track next available address for new allocatable sections.
   uint64_t NextAvailableAddress{0};
 
   /// Location and size of dynamic relocations.
   Optional<uint64_t> DynamicRelocationsAddress;
   uint64_t DynamicRelocationsSize{0};
+  uint64_t DynamicRelativeRelocationsCount{0};
 
   /// PLT relocations are special kind of dynamic relocations stored separately.
   Optional<uint64_t> PLTRelocationsAddress;
   uint64_t PLTRelocationsSize{0};
 
+  /// True if relocation of specified type came from .rela.plt
+  DenseMap<uint64_t, bool> IsJmpRelocation;
+
+  /// Index of specified symbol in the dynamic symbol table. NOTE Currently it
+  /// is filled and used only with the relocations-related symbols.
+  std::unordered_map<const MCSymbol *, uint32_t> SymbolIndex;
+
   /// Store all non-zero symbols in this map for a quick address lookup.
   std::map<uint64_t, llvm::object::SymbolRef> FileSymRefs;
 
   std::unique_ptr<DWARFRewriter> DebugInfoRewriter;
 
   std::unique_ptr<BoltAddressTranslation> BAT;
 
   /// Number of local symbols in newly written symbol table.

bolt/lib/Core/Relocation.cpp

 }
 
 bool Relocation::isGOT(uint64_t Type) {
   if (Arch == Triple::aarch64)
     return isGOTAArch64(Type);
   return isGOTX86(Type);
 }
 
-bool Relocation::isNone(uint64_t Type) {
-  if (Arch == Triple::aarch64)
-    return Type == ELF::R_AARCH64_NONE;
-  return Type == ELF::R_X86_64_NONE;
-}
+bool Relocation::isNone(uint64_t Type) { return Type == getNone(); }
 
 bool Relocation::isRelative(uint64_t Type) {
   if (Arch == Triple::aarch64)
     return Type == ELF::R_AARCH64_RELATIVE;
   return Type == ELF::R_X86_64_RELATIVE;
 }
 
 bool Relocation::isIRelative(uint64_t Type) {
   if (Arch == Triple::aarch64)
     return Type == ELF::R_AARCH64_IRELATIVE;
   return Type == ELF::R_X86_64_IRELATIVE;
 }
 
 bool Relocation::isTLS(uint64_t Type) {
   if (Arch == Triple::aarch64)
     return isTLSAArch64(Type);
   return isTLSX86(Type);
 }
 
-bool Relocation::isPCRelative(uint64_t Type) {
+uint64_t Relocation::getNone() {
   if (Arch == Triple::aarch64)
-    return isPCRelativeAArch64(Type);
-  return isPCRelativeX86(Type);
+    return ELF::R_AARCH64_NONE;
+  return ELF::R_X86_64_NONE;
 }
 
 uint64_t Relocation::getPC32() {
   if (Arch == Triple::aarch64)
     return ELF::R_AARCH64_PREL32;
   return ELF::R_X86_64_PC32;
 }
 
 uint64_t Relocation::getPC64() {
   if (Arch == Triple::aarch64)
     return ELF::R_AARCH64_PREL64;
   return ELF::R_X86_64_PC64;
 }
 
+bool Relocation::isPCRelative(uint64_t Type) {
+  if (Arch == Triple::aarch64)
+    return isPCRelativeAArch64(Type);
+  return isPCRelativeX86(Type);
+}
+
 size_t Relocation::emit(MCStreamer *Streamer) const {
   const size_t Size = getSizeForType(Type);
   MCContext &Ctx = Streamer->getContext();
   if (isPCRelative(Type)) {
     MCSymbol *TempLabel = Ctx.createNamedTempSymbol();
     Streamer->emitLabel(TempLabel);
     const MCExpr *Value = nullptr;
     if (Symbol) {

bolt/lib/Rewrite/RewriteInstance.cpp

if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
     return getRelocationAddend(ELF32LE, Rel);
   if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
     return getRelocationAddend(ELF64LE, Rel);
   if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
     return getRelocationAddend(ELF32BE, Rel);
   auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
   return getRelocationAddend(ELF64BE, Rel);
 }
+
+template <typename ELFT>
+uint32_t getRelocationSymbol(const ELFObjectFile<ELFT> *Obj,
+                             const RelocationRef &RelRef) {
+  using ELFShdrTy = typename ELFT::Shdr;
+  uint32_t Symbol = 0;
+  const ELFFile<ELFT> &EF = Obj->getELFFile();
+  DataRefImpl Rel = RelRef.getRawDataRefImpl();
+  const ELFShdrTy *RelocationSection = cantFail(EF.getSection(Rel.d.a));
+  switch (RelocationSection->sh_type) {
+  default:
+    llvm_unreachable("unexpected relocation section type");
+  case ELF::SHT_REL:
+    Symbol = Obj->getRel(Rel)->getSymbol(EF.isMips64EL());
+    break;
+  case ELF::SHT_RELA:
+    Symbol = Obj->getRela(Rel)->getSymbol(EF.isMips64EL());
+    break;
+  }
+
+  return Symbol;
+}
+
+uint32_t getRelocationSymbol(const ELFObjectFileBase *Obj,
+                             const RelocationRef &Rel) {
+  if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
+    return getRelocationSymbol(ELF32LE, Rel);
+  if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
+    return getRelocationSymbol(ELF64LE, Rel);
+  if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
+    return getRelocationSymbol(ELF32BE, Rel);
+  auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
+  return getRelocationSymbol(ELF64BE, Rel);
+}
 } // anonymous namespace
 
 bool RewriteInstance::analyzeRelocation(
     const RelocationRef &Rel, uint64_t RType, std::string &SymbolName,
     bool &IsSectionRelocation, uint64_t &SymbolAddress, int64_t &Addend,
     uint64_t &ExtractedValue, bool &Skip) const {
   Skip = false;
   if (!Relocation::isSupported(RType))
if (PLTRelocationsSize > 0) {
     ErrorOr<BinarySection &> PLTRelSectionOrErr =
         BC->getSectionForAddress(*PLTRelocationsAddress);
     if (!PLTRelSectionOrErr)
       report_error("unable to find section corresponding to DT_JMPREL",
                    PLTRelSectionOrErr.getError());
     if (PLTRelSectionOrErr->getSize() != PLTRelocationsSize)
       report_error("section size mismatch for DT_PLTRELSZ",
                    errc::executable_format_error);
-    readDynamicRelocations(PLTRelSectionOrErr->getSectionRef());
+    readDynamicRelocations(PLTRelSectionOrErr->getSectionRef(),
+                           /*IsJmpRel*/ true);
   }
 
   // The rest of dynamic relocations - DT_RELA.
   if (DynamicRelocationsSize > 0) {
     ErrorOr<BinarySection &> DynamicRelSectionOrErr =
         BC->getSectionForAddress(*DynamicRelocationsAddress);
     if (!DynamicRelSectionOrErr)
       report_error("unable to find section corresponding to DT_RELA",
                    DynamicRelSectionOrErr.getError());
     if (DynamicRelSectionOrErr->getSize() != DynamicRelocationsSize)
       report_error("section size mismatch for DT_RELASZ",
                    errc::executable_format_error);
-    readDynamicRelocations(DynamicRelSectionOrErr->getSectionRef());
+    readDynamicRelocations(DynamicRelSectionOrErr->getSectionRef(),
+                           /*IsJmpRel*/ false);
   }
 }
 
 void RewriteInstance::processRelocations() {
   if (!BC->HasRelocations)
     return;
 
   for (const SectionRef &Section : InputFile->sections()) {
BinaryFunction *ContainingBF =
         BC->getBinaryFunctionContainingAddress(RefAddress);
     if (!ContainingBF)
       continue;
 
     insertLKMarker(RefAddress, I, SignedOffset, true, ".smp_locks");
   }
 }
 
-void RewriteInstance::readDynamicRelocations(const SectionRef &Section) {
+void RewriteInstance::readDynamicRelocations(const SectionRef &Section,
+                                             bool IsJmpRel) {
   assert(BinarySection(*BC, Section).isAllocatable() && "allocatable expected");
 
   LLVM_DEBUG({
     StringRef SectionName = cantFail(Section.getName());
     dbgs() << "BOLT-DEBUG: reading relocations for section " << SectionName
            << ":\n";
   });
 
   for (const RelocationRef &Rel : Section.relocations()) {
-    uint64_t RType = Rel.getType();
+    const uint64_t RType = Rel.getType();
     if (Relocation::isNone(RType))
       continue;
 
     StringRef SymbolName = "<none>";
     MCSymbol *Symbol = nullptr;
     uint64_t SymbolAddress = 0;
     const uint64_t Addend = getRelocationAddend(InputFile, Rel);
 
     symbol_iterator SymbolIter = Rel.getSymbol();
     if (SymbolIter != InputFile->symbol_end()) {
       SymbolName = cantFail(SymbolIter->getName());
       BinaryData *BD = BC->getBinaryDataByName(SymbolName);
       Symbol = BD ? BD->getSymbol()
                   : BC->getOrCreateUndefinedGlobalSymbol(SymbolName);
       SymbolAddress = cantFail(SymbolIter->getAddress());
       (void)SymbolAddress;
     }
 
     LLVM_DEBUG(
       SmallString<16> TypeName;
       Rel.getTypeName(TypeName);
       dbgs() << "BOLT-DEBUG: dynamic relocation at 0x"
              << Twine::utohexstr(Rel.getOffset()) << " : " << TypeName
              << " : " << SymbolName << " : " <<  Twine::utohexstr(SymbolAddress)
              << " : + 0x" << Twine::utohexstr(Addend) << '\n'
     );
 
-    BC->addDynamicRelocation(Rel.getOffset(), Symbol, Rel.getType(), Addend);
+    if (IsJmpRel)
+      IsJmpRelocation[RType] = true;
+
+    if (Symbol)
+      SymbolIndex[Symbol] = getRelocationSymbol(InputFile, Rel);
+
+    BC->addDynamicRelocation(Rel.getOffset(), Symbol, RType, Addend);
   }
 }
 
 void RewriteInstance::readRelocations(const SectionRef &Section) {
   LLVM_DEBUG({
     StringRef SectionName = cantFail(Section.getName());
     dbgs() << "BOLT-DEBUG: reading relocations for section " << SectionName
            << ":\n";
BC->registerOrUpdateNoteSection(StrSecName,
                                   ELF::SHT_STRTAB);
 }
 
 template <typename ELFT>
 void
 RewriteInstance::patchELFAllocatableRelaSections(ELFObjectFile<ELFT> *File) {
   using Elf_Rela = typename ELFT::Rela;
   raw_fd_ostream &OS = Out->os();
+  const ELFFile<ELFT> &EF = File->getELFFile();
 
-  for (BinarySection &RelaSection : BC->allocatableRelaSections()) {
-    for (const RelocationRef &Rel : RelaSection.getSectionRef().relocations()) {
-      uint64_t RType = Rel.getType();
-      if (!Relocation::isRelative(RType) && !Relocation::isIRelative(RType))
-        continue;
-      DataRefImpl DRI = Rel.getRawDataRefImpl();
-      const Elf_Rela *RelA = File->getRela(DRI);
-      auto Address = RelA->r_addend;
-      uint64_t NewAddress = getNewFunctionAddress(Address);
-      if (!NewAddress)
-        continue;
-      LLVM_DEBUG(dbgs() << "BOLT-DEBUG: patching (I)RELATIVE "
-                        << RelaSection.getName() << " entry 0x"
-                        << Twine::utohexstr(Address) << " with 0x"
-                        << Twine::utohexstr(NewAddress) << '\n');
-      Elf_Rela NewRelA = *RelA;
-      NewRelA.r_addend = NewAddress;
-      OS.pwrite(reinterpret_cast<const char *>(&NewRelA), sizeof(NewRelA),
-                reinterpret_cast<const char *>(RelA) - File->getData().data());
+  uint64_t RelDynOffset = 0, RelDynEndOffset = 0;
+  uint64_t RelPltOffset = 0, RelPltEndOffset = 0;
+
+  auto setSectionFileOffsets = [&](uint64_t Address, uint64_t &Start,
+                                   uint64_t &End) {
+    ErrorOr<BinarySection &> Section = BC->getSectionForAddress(Address);
+    Start = Section->getInputFileOffset();
+    End = Start + Section->getSize();
+  };
+
+  if (!DynamicRelocationsAddress && !PLTRelocationsAddress)
+    return;
+
+  if (DynamicRelocationsAddress)
+    setSectionFileOffsets(*DynamicRelocationsAddress, RelDynOffset,
+                          RelDynEndOffset);
+
+  if (PLTRelocationsAddress)
+    setSectionFileOffsets(*PLTRelocationsAddress, RelPltOffset,
+                          RelPltEndOffset);
+
+  DynamicRelativeRelocationsCount = 0;
+
+  auto writeRela = [&OS](const Elf_Rela *RelA, uint64_t &Offset) {
+    OS.pwrite(reinterpret_cast<const char *>(RelA), sizeof(*RelA), Offset);
+    Offset += sizeof(*RelA);
+  };
+
+  auto writeRelocations = [&](bool PatchRelative) {
+    for (BinarySection &Section : BC->allocatableSections()) {
+      for (const Relocation &Rel : Section.dynamicRelocations()) {
+        const bool IsRelative = Rel.isRelative();
+        if (PatchRelative != IsRelative)
+          continue;
+
+        if (IsRelative)
+          ++DynamicRelativeRelocationsCount;
+
+        Elf_Rela NewRelA;
+        uint64_t SectionAddress = Section.getOutputAddress();
+        SectionAddress =
+            SectionAddress == 0 ? Section.getAddress() : SectionAddress;
+        MCSymbol *Symbol = Rel.Symbol;
+        uint32_t SymbolIdx = 0;
+        uint64_t Addend = Rel.Addend;
+
+        if (Rel.Symbol) {
+          SymbolIdx = getOutputDynamicSymbolIndex(Symbol);
+        } else {
+          // Usually this case is used for R_*_(I)RELATIVE relocations
+          const uint64_t Address = getNewFunctionOrDataAddress(Addend);
+          if (Address)
+            Addend = Address;
+        }
+
+        NewRelA.setSymbolAndType(SymbolIdx, Rel.Type, EF.isMips64EL());
+        NewRelA.r_offset = SectionAddress + Rel.Offset;
+        NewRelA.r_addend = Addend;
+
+        const bool IsJmpRel =
+            !!(IsJmpRelocation.find(Rel.Type) != IsJmpRelocation.end());
+        uint64_t &Offset = IsJmpRel ? RelPltOffset : RelDynOffset;
+        const uint64_t &EndOffset =
+            IsJmpRel ? RelPltEndOffset : RelDynEndOffset;
+        if (!Offset || !EndOffset) {
+          errs() << "BOLT-ERROR: Invalid offsets for dynamic relocation\n";
+          exit(1);
         }
+
+        if (Offset + sizeof(NewRelA) > EndOffset) {
+          errs() << "BOLT-ERROR: Offset overflow for dynamic relocation\n";
+          exit(1);
         }
+
+        writeRela(&NewRelA, Offset);
+      }
+    }
+  };
+
+  // The dynamic linker expects R_*_RELATIVE relocations to be emitted first
+  writeRelocations(/* PatchRelative */ true);
+  writeRelocations(/* PatchRelative */ false);
+
+  auto fillNone = [&](uint64_t &Offset, uint64_t EndOffset) {
+    if (!Offset)
+      return;
+
+    typename ELFObjectFile<ELFT>::Elf_Rela RelA;
+    RelA.setSymbolAndType(0, Relocation::getNone(), EF.isMips64EL());
+    RelA.r_offset = 0;
+    RelA.r_addend = 0;
+    while (Offset < EndOffset)
+      writeRela(&RelA, Offset);
+
+    assert(Offset == EndOffset && "Unexpected section overflow");
+  };
+
+  // Fill the rest of the sections with R_*_NONE relocations
+  fillNone(RelDynOffset, RelDynEndOffset);
+  fillNone(RelPltOffset, RelPltEndOffset);
 }
 
 template <typename ELFT>
 void RewriteInstance::patchELFGOT(ELFObjectFile<ELFT> *File) {
   raw_fd_ostream &OS = Out->os();
 
   SectionRef GOTSection;
   for (const SectionRef &Section : File->sections()) {
     StringRef SectionName = cantFail(Section.getName());
     if (SectionName == ".got") {
       GOTSection = Section;
       break;
     }
   }
   if (!GOTSection.getObject()) {
+    if (!BC->IsStaticExecutable)
       errs() << "BOLT-INFO: no .got section found\n";
     return;
   }
 
   StringRef GOTContents = cantFail(GOTSection.getContents());
   for (const uint64_t *GOTEntry =
            reinterpret_cast<const uint64_t *>(GOTContents.data());
        GOTEntry < reinterpret_cast<const uint64_t *>(GOTContents.data() +
                                                      GOTContents.size());
void RewriteInstance::patchELFDynamic(ELFObjectFile<ELFT> *File) {
   auto DTB = DynamicEntries.begin();
   for (const Elf_Dyn &Dyn : DynamicEntries) {
     Elf_Dyn NewDE = Dyn;
     bool ShouldPatch = true;
     switch (Dyn.d_tag) {
     default:
       ShouldPatch = false;
       break;
+    case ELF::DT_RELACOUNT:
+      NewDE.d_un.d_val = DynamicRelativeRelocationsCount;
+      break;
     case ELF::DT_INIT:
     case ELF::DT_FINI: {
       if (BC->HasRelocations) {
         if (uint64_t NewAddress = getNewFunctionAddress(Dyn.getPtr())) {
           LLVM_DEBUG(dbgs() << "BOLT-DEBUG: patching dynamic entry of type "
                             << Dyn.getTag() << '\n');
           NewDE.d_un.d_ptr = NewAddress;
         }
case ELF::DT_RELASZ:
       DynamicRelocationsSize = Dyn.getVal();
       break;
     case ELF::DT_JMPREL:
       PLTRelocationsAddress = Dyn.getPtr();
       break;
     case ELF::DT_PLTRELSZ:
       PLTRelocationsSize = Dyn.getVal();
       break;
+    case ELF::DT_RELACOUNT:
+      DynamicRelativeRelocationsCount = Dyn.getVal();
+      break;
     }
   }
 
-  if (!DynamicRelocationsAddress)
+  if (!DynamicRelocationsAddress || !DynamicRelocationsSize) {
+    DynamicRelocationsAddress.reset();
     DynamicRelocationsSize = 0;
+  }
 
-  if (!PLTRelocationsAddress)
+  if (!PLTRelocationsAddress || !PLTRelocationsSize) {
+    PLTRelocationsAddress.reset();
     PLTRelocationsSize = 0;
   }
+}
 
 uint64_t RewriteInstance::getNewFunctionAddress(uint64_t OldAddress) {
   const BinaryFunction *Function = BC->getBinaryFunctionAtAddress(OldAddress);
   if (!Function)
     return 0;
 
   assert(!Function->isFragment() && "cannot get new address for a fragment");
 
   return Function->getOutputAddress();
 }
 
+uint64_t RewriteInstance::getNewFunctionOrDataAddress(uint64_t OldAddress) {
+  if (uint64_t Function = getNewFunctionAddress(OldAddress))
+    return Function;
+
+  const BinaryData *BD = BC->getBinaryDataAtAddress(OldAddress);
+  if (BD && BD->isMoved())
+    return BD->getOutputAddress();
+
+  return 0;
+}
+
 void RewriteInstance::rewriteFile() {
   std::error_code EC;
   Out = std::make_unique<ToolOutputFile>(opts::OutputFilename, EC,
                                          sys::fs::OF_None);
   check_error(EC, "cannot create output executable file");
 
   raw_fd_ostream &OS = Out->os();
 
void RewriteInstance::rewriteFile() {
   patchBuildID();
 
   if (opts::EnableBAT)
     encodeBATSection();
 
   // Copy non-allocatable sections once allocatable part is finished.
   rewriteNoteSections();
 
-  // Patch dynamic section/segment.
-  patchELFDynamic();
-
   if (BC->HasRelocations) {
     patchELFAllocatableRelaSections();
     patchELFGOT();
   }
 
+  // Patch dynamic section/segment.
+  patchELFDynamic();
+
   // Update ELF book-keeping info.
   patchELFSectionHeaderTable();
 
   if (opts::PrintSections) {
     outs() << "BOLT-INFO: Sections after processing:\n";
     BC->printSections(outs());
   }
 

bolt/test/runtime/AArch64/Inputs/runtime_relocs.c

+int a = 1;
+__attribute__((used)) int *b = &a; // R_*_ABS64
+
+static int c;
+__attribute__((used)) static int *d = &c; // R_*_RELATIVE
+
+__thread int t1 = 0;
+
+int inc(int var) {
+  ++a;  // R_*_GLOB_DAT
+  ++t1; // R_*_TLSDESC
+  return var + 1;
+}

bolt/test/runtime/AArch64/Inputs/tls_ld.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_AARCH64
+  Entry:           0x590
+ProgramHeaders:
+  - Type:            PT_LOAD
+    Flags:           [ PF_X, PF_R, PF_W ]
+    FirstSec:        .dynsym
+    LastSec:         .got
+    Align:           0x10000
+  - Type:            PT_DYNAMIC
+    Flags:           [ PF_W, PF_R ]
+    FirstSec:        .dynamic
+    LastSec:         .dynamic
+    VAddr:           0x10DF0
+    Align:           0x8
+  - Type:            PT_TLS
+    Flags:           [ PF_R ]
+    FirstSec:        .tbss
+    LastSec:         .tbss
+    VAddr:           0x10DE0
+    Align:           0x4
+  - Type:            PT_GNU_EH_FRAME
+    Flags:           [ PF_R ]
+    FirstSec:        .eh_frame_hdr
+    LastSec:         .eh_frame_hdr
+    VAddr:           0x6B8
+    Align:           0x4
+Sections:
+  - Name:            .dynsym
+    Type:            SHT_DYNSYM
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x250
+    Link:            .dynstr
+    AddressAlign:    0x8
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x340
+    AddressAlign:    0x1
+  - Name:            .plt
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x540
+    AddressAlign:    0x10
+    EntSize:         0x10
+    Content:         F07BBFA99000009011FE47F910E23F9120021FD61F2003D51F2003D51F2003D5900000B0110240F91002009120021FD6900000B0110640F91022009120021FD6900000B0110A40F91042009120021FD6
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x590
+    AddressAlign:    0x8
+    Content:         8000009000F047F9400000B4F9FFFF17C0035FD61F2003D5800000B000800091810000B0218000913F0000EBC00000548100009021E447F9610000B4F00301AA00021FD6C0035FD6800000B000800091810000B021800091210000CB22FC7FD3410C818BFF0781EB21FC4193C00000548200009042E047F9620000B4F00302AA00021FD6C0035FD6FD7BBEA9FD030091F30B00F9930000B060824039400100358000009000DC47F9800000B4800000B0000C40F9C7FFFF97D8FFFF972000805260820039F30B40F9FD7BC2A8C0035FD6DEFFFF171F2003D5FD7BBEA9FD030091F30B00F9F303002A8000009000403F91BCFFFF971F2003D5E10300AA60060011F30B40F9220040B942040011220000B9FD7BC2A8C0035FD6
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .text
+    Relocations:
+      - Offset:          0x5C4
+        Symbol:          t1
+        Type:            R_AARCH64_TLSDESC_LD64_LO12
+  - Name:            .eh_frame_hdr
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x6B8
+    AddressAlign:    0x4
+    Content:         011B033B3400000005000000F0FEFFFF4C00000020FFFFFF6000000060FFFFFF74000000A8FFFFFF98000000B0FFFFFFB0000000
+  - Name:            .eh_frame
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x6F0
+    AddressAlign:    0x8
+    Content:         1000000000000000017A520004781E011B0C1F0010000000180000009CFEFFFF3000000000000000100000002C000000B8FEFFFF40000000000000002000000040000000E4FEFFFF4800000000410E209D049E034293024EDEDDD30E00000000140000006400000008FFFFFF040000000000000000000000200000007C000000F8FEFFFF4000000000410E209D049E034293024CDEDDD30E0000000000000000
+  - Name:            .tbss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
+    Address:         0x10DE0
+    AddressAlign:    0x4
+    Offset:          0xDE0
+    Size:            0x4
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x10DF0
+    Link:            .dynstr
+    AddressAlign:    0x8
+    Entries:
+      - Tag:             DT_STRTAB
+        Value:           0x340
+      - Tag:             DT_SYMTAB
+        Value:           0x250
+      - Tag:             DT_PLTRELSZ
+        Value:           0x18
+      - Tag:             DT_PLTREL
+        Value:           0x7
+      - Tag:             DT_JMPREL
+        Value:           0x418
+      - Tag:             DT_NULL
+        Value:           0x0
+  - Name:            .got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x10FB0
+    AddressAlign:    0x8
+    EntSize:         0x8
+    Content:         F00D010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  - Name:            .rela.plt
+    Type:            SHT_RELA
+    Flags:           [ SHF_ALLOC, SHF_INFO_LINK ]
+    Address:         0x418
+    Link:            .dynsym
+    AddressAlign:    0x8
+    Info:            .got
+    Relocations:
+      - Offset:          0x10fb0
+        Symbol:          t1
+        Type:            R_AARCH64_TLSDESC
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .dynsym
+      - Name:            .dynstr
+      - Name:            .rela.plt
+      - Name:            .plt
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .eh_frame_hdr
+      - Name:            .eh_frame
+      - Name:            .tbss
+      - Name:            .dynamic
+      - Name:            .got
+      - Name:            .symtab
+      - Name:            .strtab
+      - Name:            .shstrtab
+Symbols:
+  - Name:            .text
+    Type:            STT_SECTION
+    Section:         .text
+    Value:           0x590
+  - Name:            t1
+    Type:            STT_TLS
+    Section:         .tbss
+    Binding:         STB_GLOBAL
+    Size:            0x4
+DynamicSymbols:
+  - Name:            t1
+    Type:            STT_TLS
+    Section:         .tbss
+    Binding:         STB_GLOBAL
+    Size:            0x4
+...

bolt/test/runtime/AArch64/Inputs/tls_trad.yaml

+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_DYN
+  Machine:         EM_AARCH64
+  Entry:           0x590
+ProgramHeaders:
+  - Type:            PT_LOAD
+    Flags:           [ PF_X, PF_R, PF_W ]
+    FirstSec:        .dynsym
+    LastSec:         .got
+    Align:           0x10000
+  - Type:            PT_DYNAMIC
+    Flags:           [ PF_W, PF_R ]
+    FirstSec:        .dynamic
+    LastSec:         .dynamic
+    VAddr:           0x10DF0
+    Align:           0x8
+  - Type:            PT_TLS
+    Flags:           [ PF_R ]
+    FirstSec:        .tbss
+    LastSec:         .tbss
+    VAddr:           0x10DE0
+    Align:           0x4
+  - Type:            PT_GNU_EH_FRAME
+    Flags:           [ PF_R ]
+    FirstSec:        .eh_frame_hdr
+    LastSec:         .eh_frame_hdr
+    VAddr:           0x6B8
+    Align:           0x4
+Sections:
+  - Name:            .dynsym
+    Type:            SHT_DYNSYM
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x250
+    Link:            .dynstr
+    AddressAlign:    0x8
+  - Name:            .dynstr
+    Type:            SHT_STRTAB
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x340
+    AddressAlign:    0x1
+  - Name:            .rela.dyn
+    Type:            SHT_RELA
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x400
+    Link:            .dynsym
+    AddressAlign:    0x8
+    Relocations:
+      - Offset:          0x10FD0
+        Symbol:          t1
+        Type:            R_AARCH64_TLS_DTPMOD64
+      - Offset:          0x10FD8
+        Symbol:          t1
+        Type:            R_AARCH64_TLS_DTPREL64
+  - Name:            .plt
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x540
+    AddressAlign:    0x10
+    EntSize:         0x10
+    Content:         F07BBFA99000009011FE47F910E23F9120021FD61F2003D51F2003D51F2003D5900000B0110240F91002009120021FD6900000B0110640F91022009120021FD6900000B0110A40F91042009120021FD6
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x590
+    AddressAlign:    0x8
+    Content:         8000009000F047F9400000B4F9FFFF17C0035FD61F2003D5800000B000800091810000B0218000913F0000EBC00000548100009021E447F9610000B4F00301AA00021FD6C0035FD6800000B000800091810000B021800091210000CB22FC7FD3410C818BFF0781EB21FC4193C00000548200009042E047F9620000B4F00302AA00021FD6C0035FD6FD7BBEA9FD030091F30B00F9930000B060824039400100358000009000DC47F9800000B4800000B0000C40F9C7FFFF97D8FFFF972000805260820039F30B40F9FD7BC2A8C0035FD6DEFFFF171F2003D5FD7BBEA9FD030091F30B00F9F303002A8000009000403F91BCFFFF971F2003D5E10300AA60060011F30B40F9220040B942040011220000B9FD7BC2A8C0035FD6
+  - Name:            .eh_frame_hdr
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x6B8
+    AddressAlign:    0x4
+    Content:         011B033B3400000005000000F0FEFFFF4C00000020FFFFFF6000000060FFFFFF74000000A8FFFFFF98000000B0FFFFFFB0000000
+  - Name:            .eh_frame
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x6F0
+    AddressAlign:    0x8
+    Content:         1000000000000000017A520004781E011B0C1F0010000000180000009CFEFFFF3000000000000000100000002C000000B8FEFFFF40000000000000002000000040000000E4FEFFFF4800000000410E209D049E034293024EDEDDD30E00000000140000006400000008FFFFFF040000000000000000000000200000007C000000F8FEFFFF4000000000410E209D049E034293024CDEDDD30E0000000000000000
+  - Name:            .tbss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
+    Address:         0x10DE0
+    AddressAlign:    0x4
+    Offset:          0xDE0
+    Size:            0x4
+  - Name:            .dynamic
+    Type:            SHT_DYNAMIC
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x10DF0
+    Link:            .dynstr
+    AddressAlign:    0x8
+    Entries:
+      - Tag:             DT_STRTAB
+        Value:           0x340
+      - Tag:             DT_SYMTAB
+        Value:           0x250
+      - Tag:             DT_RELA
+        Value:           0x400
+      - Tag:             DT_RELASZ
+        Value:           0x30
+      - Tag:             DT_RELAENT
+        Value:           0x18
+      - Tag:             DT_RELACOUNT
+        Value:           0x3
+      - Tag:             DT_NULL
+        Value:           0x0
+  - Name:            .got
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    Address:         0x10FB0
+    AddressAlign:    0x8
+    EntSize:         0x8
+    Content:         F00D010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x8
+    Info:            .text
+    Relocations:
+      - Offset:          0x678
+        Symbol:          t1
+        Type:            R_AARCH64_TLSGD_ADR_PAGE21
+      - Offset:          0x67C
+        Symbol:          t1
+        Type:            R_AARCH64_TLSGD_ADD_LO12_NC
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .dynsym
+      - Name:            .dynstr
+      - Name:            .rela.dyn
+      - Name:            .plt
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .eh_frame_hdr
+      - Name:            .eh_frame
+      - Name:            .tbss
+      - Name:            .dynamic
+      - Name:            .got
+      - Name:            .symtab
+      - Name:            .strtab
+      - Name:            .shstrtab
+Symbols:
+  - Name:            .text
+    Type:            STT_SECTION
+    Section:         .text
+    Value:           0x590
+  - Name:            t1
+    Type:            STT_TLS
+    Section:         .tbss
+    Binding:         STB_GLOBAL
+    Size:            0x4
+DynamicSymbols:
+  - Name:            t1
+    Type:            STT_TLS
+    Section:         .tbss
+    Binding:         STB_GLOBAL
+    Size:            0x4
+...

bolt/test/runtime/AArch64/runtime_relocs.c

+// This test checks dynamic relocations support for aarch64.
+
+// RUN: %clang %cflags -pie -fPIC %S/Inputs/runtime_relocs.c \
+// RUN:    -shared -fuse-ld=lld -o %t.so -Wl,-q -Wl,-soname=rel.so
+// RUN: %clang %cflags -no-pie %s -fuse-ld=lld \
+// RUN:    -o %t.exe -Wl,-q %t.so
+// RUN: llvm-bolt %t.so -o %t.bolt.so -use-old-text=0 -lite=0
+// RUN: llvm-bolt %t.exe -o %t.bolt.exe -use-old-text=0 -lite=0
+// RUN: LD_PRELOAD=%t.bolt.so %t.bolt.exe
+
+// Check relocations in library:
+//
+// RUN: llvm-readelf -r %t.bolt.so | FileCheck %s -check-prefix=CHECKLIB
+//
+// CHECKLIB: 0000000600000401 R_AARCH64_GLOB_DAT     {{.*}} a + 0
+// CHECKLIB: 0000000700000407 R_AARCH64_TLSDESC      {{.*}} t1 + 0
+// CHECKLIB: 0000000600000101 R_AARCH64_ABS64        {{.*}} a + 0
+
+// Check relocations in executable:
+//
+// RUN: llvm-readelf -r %t.bolt.exe | FileCheck %s -check-prefix=CHECKEXE
+//
+// CHECKEXE: 0000000600000406 R_AARCH64_TLS_TPREL64  {{.*}} t1 + 0
+// CHECKEXE: 0000000800000400 R_AARCH64_COPY         {{.*}} a + 0
+// CHECKEXE: 0000000700000402 R_AARCH64_JUMP_SLOT    {{.*}} inc + 0
+
+// Check traditional TLS relocations R_AARCH64_TLS_DTPMOD64 and
+// R_AARCH64_TLS_DTPREL64 emitted correctly after bolt. Since these
+// relocations are obsolete and clang and lld does not support them,
+// the initial binary was built with gcc and ld with -mtls-dialect=trad flag.
+//
+// RUN: yaml2obj %p/Inputs/tls_trad.yaml &> %t.trad.so
+// RUN: llvm-bolt %t.trad.so -o %t.trad.bolt.so -use-old-text=0 -lite=0
+// RUN: llvm-readelf -r %t.trad.so | FileCheck %s -check-prefix=CHECKTRAD
+//
+// CHECKTRAD: 0000000100000404 R_AARCH64_TLS_DTPMOD64 {{.*}} t1 + 0
+// CHECKTRAD: 0000000100000405 R_AARCH64_TLS_DTPREL64 {{.*}} t1 + 0
+
+// The ld linker emits R_AARCH64_TLSDESC to .rela.plt section, check that
+// it is emitted correctly.
+//
+// RUN: yaml2obj %p/Inputs/tls_ld.yaml &> %t.ld.so
+// RUN: llvm-bolt %t.ld.so -o %t.ld.bolt.so -use-old-text=0 -lite=0
+// RUN: llvm-readelf -r %t.ld.bolt.so | FileCheck %s -check-prefix=CHECKLD
+//
+// CHECKLD: 0000000100000407 R_AARCH64_TLSDESC        {{.*}} t1 + 0
+
+extern int a; // R_*_COPY
+
+extern __thread int t1; // R_*_TLS_TPREL64
+
+int inc(int a); // R_*_JUMP_SLOT
+
+int dec(int a) { return a - 1; }
+
+void *resolver() { return dec; }
+
+int ifuncDec(int a) __attribute__((ifunc("resolver"))); // R_*_IRELATIVE
+
+int main() {
+  ++t1;
+  ifuncDec(a);
+  inc(a);
+}