Index: ELF/InputSection.cpp =================================================================== --- ELF/InputSection.cpp +++ ELF/InputSection.cpp @@ -205,6 +205,18 @@ continue; } + // TLS descriptor lazy relocations are specific. They + // uses two words in the .got.plt. A single relocation is to be used to + // compute the value of the two words of the TLS descriptor. + // Overall design can be found in + // "Thread-Local Storage Descriptors for IA32 and AMD64/EM64T" + // http://www.fsfla.org/~lxoliva/writeups/TLS/RFC-TLSDESC-x86.txt + if (Target->isTlsDescRel(Type, *Body)) { + Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, + Body->getGotPltVA() + getAddend(RI)); + continue; + } + uintX_t SymVA = Body->getVA(); if (Target->needsPlt(Type, *Body)) { SymVA = Body->getPltVA(); Index: ELF/OutputSections.h =================================================================== --- ELF/OutputSections.h +++ ELF/OutputSections.h @@ -113,6 +113,7 @@ void addEntry(SymbolBody *Sym); void addMipsLocalEntry(); bool addDynTlsEntry(SymbolBody *Sym); + void addTlsDescEntry(); bool addTlsIndex(); bool empty() const { return MipsLocalEntries == 0 && Entries.empty(); } uintX_t getMipsLocalFullAddr(const SymbolBody &B); @@ -131,10 +132,13 @@ unsigned getMipsLocalEntriesNum() const; uintX_t getTlsIndexVA() { return Base::getVA() + TlsIndexOff; } + uintX_t getTlsDescEntryVA() const { return Base::getVA() + TlsDescEntryOff; } + bool hasTlsDescEntry() const { return TlsDescEntryOff != (uintX_t)-1; } private: std::vector Entries; uint32_t TlsIndexOff = -1; + uintX_t TlsDescEntryOff = -1; uint32_t MipsLocalEntries = 0; llvm::DenseMap MipsLocalGotPos; @@ -150,6 +154,7 @@ void finalize() override; void writeTo(uint8_t *Buf) override; void addEntry(SymbolBody *Sym); + void addTlsDescEntry(SymbolBody *Sym); bool empty() const; private: @@ -165,7 +170,8 @@ void finalize() override; void writeTo(uint8_t *Buf) override; void addEntry(SymbolBody *Sym); - bool empty() const { return Entries.empty(); } + bool empty() const; + uintX_t getTlsDescEntryVA() const; private: std::vector> Entries; @@ -439,7 +445,9 @@ // The .dynamic section contains information for the dynamic linker. // The section consists of fixed size entries, which consist of // type and value fields. Value are one of plain integers, symbol - // addresses, or section addresses. This struct represents the entry. + // addresses, or section addresses. Also value can be of special type. + // Such ones are handled depending on Tag value in writeTo(). This struct + // represents the entry. struct Entry { int32_t Tag; union { @@ -447,12 +455,13 @@ uint64_t Val; const SymbolBody *Sym; }; - enum KindT { SecAddr, SymAddr, PlainInt } Kind; + enum KindT { SecAddr, SymAddr, PlainInt, Special } Kind; Entry(int32_t Tag, OutputSectionBase *OutSec) : Tag(Tag), OutSec(OutSec), Kind(SecAddr) {} Entry(int32_t Tag, uint64_t Val) : Tag(Tag), Val(Val), Kind(PlainInt) {} Entry(int32_t Tag, const SymbolBody *Sym) : Tag(Tag), Sym(Sym), Kind(SymAddr) {} + Entry(int32_t Tag) : Tag(Tag), Kind(Special) {} }; // finalize() fills this vector with the section contents. finalize() Index: ELF/OutputSections.cpp =================================================================== --- ELF/OutputSections.cpp +++ ELF/OutputSections.cpp @@ -44,6 +44,13 @@ Entries.push_back(Sym); } +template +void GotPltSection::addTlsDescEntry(SymbolBody *Sym) { + Sym->GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size(); + Entries.push_back(nullptr); + Entries.push_back(nullptr); +} + template bool GotPltSection::empty() const { return Entries.empty(); } @@ -57,7 +64,8 @@ Target->writeGotPltHeader(Buf); Buf += Target->GotPltHeaderEntriesNum * sizeof(uintX_t); for (const SymbolBody *B : Entries) { - Target->writeGotPlt(Buf, B->getPltVA()); + if (B) // This might be TLS descriptor entry. + Target->writeGotPlt(Buf, B->getPltVA()); Buf += sizeof(uintX_t); } } @@ -89,6 +97,13 @@ return true; } +template void GotSection::addTlsDescEntry() { + if (TlsDescEntryOff != uintX_t(-1)) + return; + Entries.push_back(nullptr); + TlsDescEntryOff = (Entries.size() - 1) * sizeof(uintX_t); +} + // Reserves TLS entries for a TLS module ID and a TLS block offset. // In total it takes two GOT slots. template bool GotSection::addTlsIndex() { @@ -193,6 +208,15 @@ Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff); Off += Target->PltEntrySize; } + + // If module uses TLS descriptor relocations, it requires .got entry + // and a special .plt entry as well. This plt entry is used for TLS descriptor + // resolver calls, and also dynamic entry DT_TLSDESC_PLT should be created to + // hold it's address. + if (Out::Got->hasTlsDescEntry()) + Target->writePltTlsDescEntry(Buf + Off, this->getVA() + Off, + Out::Got->getTlsDescEntryVA(), + Out::GotPlt->getVA()); } template void PltSection::addEntry(SymbolBody *Sym) { @@ -203,9 +227,21 @@ Entries.push_back(std::make_pair(Sym, RelOff)); } +template bool PltSection::empty() const { + return Entries.empty() && !Out::Got->hasTlsDescEntry(); +} + +template +typename PltSection::uintX_t PltSection::getTlsDescEntryVA() const { + return this->getVA() + Target->PltZeroSize + + Entries.size() * Target->PltEntrySize; +} + template void PltSection::finalize() { this->Header.sh_size = Target->PltZeroSize + Entries.size() * Target->PltEntrySize; + if (Out::Got->hasTlsDescEntry()) + this->Header.sh_size += Target->PltTlsDescSize; } template @@ -548,6 +584,11 @@ Add({DT_PLTREL, uint64_t(Out::RelaPlt->isRela() ? DT_RELA : DT_REL)}); } + if (Out::Got->hasTlsDescEntry()) { + Add({DT_TLSDESC_GOT}); + Add({DT_TLSDESC_PLT}); + } + Add({DT_SYMTAB, Out::DynSymTab}); Add({DT_SYMENT, sizeof(Elf_Sym)}); Add({DT_STRTAB, Out::DynStrTab}); @@ -617,6 +658,20 @@ Header.sh_size = (Entries.size() + 1) * Header.sh_entsize; } +template +static void handleSpecialDynamic(const Entry &E, ElfDyn *P) { + switch (E.Tag) { + case DT_TLSDESC_GOT: + P->d_un.d_ptr = Out::Got->getTlsDescEntryVA(); + break; + case DT_TLSDESC_PLT: + P->d_un.d_ptr = Out::Plt->getTlsDescEntryVA(); + break; + default: + assert(false && "Unknown special dynamic section entry"); + } +} + template void DynamicSection::writeTo(uint8_t *Buf) { auto *P = reinterpret_cast(Buf); @@ -632,6 +687,9 @@ case Entry::PlainInt: P->d_un.d_val = E.Val; break; + case Entry::Special: + handleSpecialDynamic(E, P); + break; } ++P; } Index: ELF/Symbols.h =================================================================== --- ELF/Symbols.h +++ ELF/Symbols.h @@ -99,6 +99,7 @@ uint32_t PltIndex = -1; bool hasGlobalDynIndex() { return GlobalDynIndex != uint32_t(-1); } bool isInGot() const { return GotIndex != -1U; } + bool isInGotPlt() const { return GotPltIndex != -1U; } bool isInPlt() const { return PltIndex != -1U; } template Index: ELF/Target.h =================================================================== --- ELF/Target.h +++ ELF/Target.h @@ -25,6 +25,9 @@ virtual bool isTlsLocalDynamicRel(unsigned Type) const; virtual bool isTlsGlobalDynamicRel(unsigned Type) const; virtual unsigned getDynRel(unsigned Type) const { return Type; } + virtual bool isTlsDescRel(unsigned Type, const SymbolBody &S) const { + return false; + } virtual bool isTlsDynRel(unsigned Type, const SymbolBody &S) const; virtual unsigned getTlsGotRel(unsigned Type) const { return TlsGotRel; } virtual void writeGotHeader(uint8_t *Buf) const {} @@ -40,6 +43,10 @@ uint64_t PltEntryAddr, int32_t Index, unsigned RelOff) const {} + virtual void writePltTlsDescEntry(uint8_t *Buf, uint64_t PltEntryAddr, + uint64_t GotTlsDescEntryAddr, + uint64_t GotPltVA) const {}; + // Returns true if a relocation is just a hint for linker to make for example // some code optimization. Such relocations should not be handled as a regular // ones and lead to dynamic relocation creation etc. @@ -83,10 +90,12 @@ unsigned PltRel; unsigned RelativeRel; unsigned IRelativeRel; + unsigned TlsDescRel; unsigned TlsGotRel = 0; unsigned TlsModuleIndexRel; unsigned TlsOffsetRel; unsigned PltEntrySize = 8; + unsigned PltTlsDescSize = 0; unsigned PltZeroSize = 0; unsigned GotHeaderEntriesNum = 0; unsigned GotPltHeaderEntriesNum = 3; Index: ELF/Target.cpp =================================================================== --- ELF/Target.cpp +++ ELF/Target.cpp @@ -174,11 +174,14 @@ public: AArch64TargetInfo(); unsigned getDynRel(unsigned Type) const override; - bool isTlsGlobalDynamicRel(unsigned Type) const override; + bool isTlsDescRel(unsigned Type, const SymbolBody &S) const override; void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override; void writePltZero(uint8_t *Buf) const override; void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr, int32_t Index, unsigned RelOff) const override; + void writePltTlsDescEntry(uint8_t *Buf, uint64_t PltEntryAddr, + uint64_t GotTlsDescEntryAddr, + uint64_t GotPltVA) const override; unsigned getTlsGotRel(unsigned Type) const override; bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override; bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override; @@ -1191,15 +1194,17 @@ IRelativeRel = R_AARCH64_IRELATIVE; GotRel = R_AARCH64_GLOB_DAT; PltRel = R_AARCH64_JUMP_SLOT; + TlsDescRel = R_AARCH64_TLSDESC; TlsGotRel = R_AARCH64_TLS_TPREL64; TlsModuleIndexRel = R_AARCH64_TLS_DTPMOD64; TlsOffsetRel = R_AARCH64_TLS_DTPREL64; UseLazyBinding = true; PltEntrySize = 16; PltZeroSize = 32; + PltTlsDescSize = 32; } -bool AArch64TargetInfo::isTlsGlobalDynamicRel(unsigned Type) const { +bool AArch64TargetInfo::isTlsDescRel(unsigned Type, const SymbolBody &S) const { return Type == R_AARCH64_TLSDESC_ADR_PAGE21 || Type == R_AARCH64_TLSDESC_LD64_LO12_NC || Type == R_AARCH64_TLSDESC_ADD_LO12_NC || @@ -1261,6 +1266,31 @@ GotEntryAddr); } +void AArch64TargetInfo::writePltTlsDescEntry(uint8_t *Buf, + uint64_t PltEntryAddr, + uint64_t GotTlsDescEntryAddr, + uint64_t GotPltVA) const { + const uint8_t Inst[] = { + 0xe2, 0x0f, 0xbf, 0xa9, // stp x2, x3, [sp, #-16]! + 0x02, 0x00, 0x00, 0x90, // adrp x2, Page(DT_TLSDESC_GOT) + 0x03, 0x00, 0x00, 0x90, // adrp x3, Page(&.got.plt[0]) + 0x42, 0x00, 0x40, 0xf9, // ldr x2, [x2, #0] + 0x63, 0x00, 0x00, 0x91, // add x3, x3, 0 + 0x40, 0x00, 0x1f, 0xd6, // br x2 + 0x1f, 0x20, 0x03, 0xd5, // nop + 0x1f, 0x20, 0x03, 0xd5 // nop + }; + memcpy(Buf, Inst, sizeof(Inst)); + relocateOne(Buf + 4, Buf + 8, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr + 4, + GotTlsDescEntryAddr); + relocateOne(Buf + 8, Buf + 12, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr + 8, + GotPltVA); + relocateOne(Buf + 12, Buf + 16, R_AARCH64_LDST64_ABS_LO12_NC, + PltEntryAddr + 12, GotTlsDescEntryAddr); + relocateOne(Buf + 16, Buf + 20, R_AARCH64_ADD_ABS_LO12_NC, PltEntryAddr + 16, + GotPltVA); +} + unsigned AArch64TargetInfo::getTlsGotRel(unsigned Type) const { assert(Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 || Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC); @@ -1268,11 +1298,7 @@ } bool AArch64TargetInfo::isTlsDynRel(unsigned Type, const SymbolBody &S) const { - return Type == R_AARCH64_TLSDESC_ADR_PAGE21 || - Type == R_AARCH64_TLSDESC_LD64_LO12_NC || - Type == R_AARCH64_TLSDESC_ADD_LO12_NC || - Type == R_AARCH64_TLSDESC_CALL || - Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 || + return Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 || Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC; } @@ -1381,7 +1407,8 @@ break; } case R_AARCH64_ADR_PREL_PG_HI21: - case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: { + case R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: + case R_AARCH64_TLSDESC_ADR_PAGE21: { uint64_t X = getAArch64Page(SA) - getAArch64Page(P); checkInt<33>(X, Type); updateAArch64Addr(Loc, (X >> 12) & 0x1FFFFF); // X[32:12] @@ -1402,6 +1429,7 @@ } case R_AARCH64_LD64_GOT_LO12_NC: case R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: + case R_AARCH64_TLSDESC_LD64_LO12_NC: checkAlignment<8>(SA, Type); or32le(Loc, (SA & 0xFF8) << 7); break; @@ -1412,6 +1440,7 @@ or32le(Loc, (SA & 0x0FFC) << 9); break; case R_AARCH64_LDST8_ABS_LO12_NC: + case R_AARCH64_TLSDESC_ADD_LO12_NC: or32le(Loc, (SA & 0xFFF) << 10); break; case R_AARCH64_LDST32_ABS_LO12_NC: @@ -1448,6 +1477,11 @@ updateAArch64Add(Loc, V & 0xFFF); break; } + case R_AARCH64_TLSDESC_CALL: + // For relaxation only. Must be used to identify a + // BLR instruction which performs an indirect call + // to the TLS descriptor function for S + A. + break; default: fatal("unrecognized reloc " + Twine(Type)); } @@ -1457,10 +1491,10 @@ if (Config->Shared || (S && !S->isTls())) return false; - // Global-Dynamic relocs can be relaxed to Initial-Exec if the target is + // TLS descriptor relocations can be relaxed to Initial-Exec if the target is // an executable. And if the target is local it can also be fully relaxed to // Local-Exec. - if (isTlsGlobalDynamicRel(Type)) + if (isTlsDescRel(Type, *S)) return !canBePreempted(S, true); // Initial-Exec relocs can be relaxed to Local-Exec if the target is a local @@ -1510,6 +1544,9 @@ // nop // nop + // AArch64 uses Variant I of TLS data structures. Thread Control Block is + // placed before data. Read "ELF Handling For Thread-Local Storage, 3. Run + // Time Handling of TLS" by Ulrich Drepper for details. uint64_t TPOff = llvm::alignTo(TcbSize, Out::TlsPhdr->p_align); uint64_t X = SA + TPOff; checkUInt<32>(X, Type); Index: ELF/Writer.cpp =================================================================== --- ELF/Writer.cpp +++ ELF/Writer.cpp @@ -264,6 +264,31 @@ if (!canBePreempted(Body, true)) return true; } + + // If module uses TLS descriptor relocations, + // then special entries are created for module: + // 1) .got entry to be filled in by the dynamic loader with the + // address of the internal function to be used for lazy relocation of TLS + // descriptors. + // 2) Special .plt entry that + // pushes onto the stack the module's link map address, located in the + // GOT portion reserved for the dynamic loader to use, and then jumps to + // the lazy relocation function, using the address stored in the + // TLSDESC_GOT entry. + // For each Body itself two words are allocated in .got.plt instead of + // usual .got, because these relocations are lazy ones. + if (Target->isTlsDescRel(Type, *Body)) { + if (!Target->canRelaxTls(Type, Body)) { + Out::Got->addTlsDescEntry(); + if (Body->isInGotPlt()) + return true; + Out::GotPlt->addTlsDescEntry(Body); + Out::RelaPlt->addReloc( + {Target->TlsDescRel, DynamicReloc::Off_GotPlt, Body}); + return true; + } + } + return !Target->isTlsDynRel(Type, *Body); } Index: test/ELF/aarch64-tls-desc-gdle.s =================================================================== --- test/ELF/aarch64-tls-desc-gdle.s +++ test/ELF/aarch64-tls-desc-gdle.s @@ -0,0 +1,59 @@ +# RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %tmain.o +# RUN: ld.lld %tmain.o -o %tout +# RUN: llvm-objdump -d %tout | FileCheck %s +# RUN: llvm-readobj -s -r -dynamic-table %tout | FileCheck -check-prefix=READOBJ %s +# REQUIRES: aarch64 + +#READOBJ: Section { +#READOBJ-NOT: Name: .plt +#READOBJ-NOT: Name: .got +#READOBJ-NOT: Name: .got.plt +#READOBJ: Relocations [ +#READOBJ-NEXT: ] + +#CHECK: Disassembly of section .text: +#CHECK-NEXT: _start: +#CHECK-NEXT: 11000: 00 00 a0 d2 movz x0, #0, lsl #16 +# 0x20 is alignTo(sizeof(TCB), 2^5) = alignTo(16, 32) = 0x20 +#CHECK-NEXT: 11004: 00 04 80 f2 movk x0, #0x20 +#CHECK-NEXT: 11008: 1f 20 03 d5 nop +#CHECK-NEXT: 1100c: 1f 20 03 d5 nop +#CHECK-NEXT: 11010: 00 00 a0 d2 movz x0, #0, lsl #16 +# 0x24 is 0x20 + sizeof(foo) +#CHECK-NEXT: 11014: 80 04 80 f2 movk x0, #0x24 +#CHECK-NEXT: 11018: 1f 20 03 d5 nop +#CHECK-NEXT: 1101c: 1f 20 03 d5 nop + +.text + .global foo + .section .tdata,"awT",%progbits + .align 5 + .type foo, %object + .size foo, 4 +foo: + .word 5 + .text + +.text + .global bar + .section .tdata,"awT",%progbits + .align 2 + .type bar, %object + .size bar, 4 +bar: + .word 5 + .text + +.globl _start +_start: + adrp x0, :tlsdesc:foo + ldr x2, [x0, #:tlsdesc_lo12:foo] + add x0, x0, :tlsdesc_lo12:foo + .tlsdesccall foo + blr x2 + + adrp x0, :tlsdesc:bar + ldr x2, [x0, #:tlsdesc_lo12:bar] + add x0, x0, :tlsdesc_lo12:bar + .tlsdesccall bar + blr x2 Index: test/ELF/aarch64-tls-desc.s =================================================================== --- test/ELF/aarch64-tls-desc.s +++ test/ELF/aarch64-tls-desc.s @@ -0,0 +1,154 @@ +# RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %tmain.o +# RUN: ld.lld %tmain.o -shared -o %tout +# RUN: llvm-objdump -d %tout | FileCheck %s +# RUN: llvm-readobj -s -r -dynamic-table %tout | FileCheck -check-prefix=READOBJ %s +# REQUIRES: aarch64 + +#READOBJ: Section { +#READOBJ: Index: +#READOBJ: Name: .plt +#READOBJ-NEXT: Type: SHT_PROGBITS +#READOBJ-NEXT: Flags [ +#READOBJ-NEXT: SHF_ALLOC +#READOBJ-NEXT: SHF_EXECINSTR +#READOBJ-NEXT: ] +#READOBJ-NEXT: Address: 0x1020 +#READOBJ-NEXT: Offset: +#READOBJ-NEXT: Size: 64 +#READOBJ-NEXT: Link: +#READOBJ-NEXT: Info: +#READOBJ-NEXT: AddressAlignment: +#READOBJ-NEXT: EntrySize: +#READOBJ-NEXT: } +#READOBJ: Section { +#READOBJ: Index: +#READOBJ: Name: .got +#READOBJ-NEXT: Type: SHT_PROGBITS +#READOBJ-NEXT: Flags [ +#READOBJ-NEXT: SHF_ALLOC +#READOBJ-NEXT: SHF_WRITE +#READOBJ-NEXT: ] +#READOBJ-NEXT: Address: 0x20C8 +#READOBJ-NEXT: Offset: +#READOBJ-NEXT: Size: 8 +#READOBJ-NEXT: Link: +#READOBJ-NEXT: Info: +#READOBJ-NEXT: AddressAlignment: +#READOBJ-NEXT: EntrySize: +#READOBJ-NEXT: } +#READOBJ: Section { +#READOBJ: Index: +#READOBJ: Name: .got.plt +#READOBJ-NEXT: Type: SHT_PROGBITS +#READOBJ-NEXT: Flags [ +#READOBJ-NEXT: SHF_ALLOC +#READOBJ-NEXT: SHF_WRITE +#READOBJ-NEXT: ] +#READOBJ-NEXT: Address: 0x3000 +#READOBJ-NEXT: Offset: 0x3000 +#READOBJ-NEXT: Size: 56 +#READOBJ-NEXT: Link: 0 +#READOBJ-NEXT: Info: 0 +#READOBJ-NEXT: AddressAlignment: 8 +#READOBJ-NEXT: EntrySize: 0 +#READOBJ-NEXT: } +#READOBJ: Relocations [ +#READOBJ-NEXT: Section ({{.*}}) .rela.plt { +# 0x3018 = .got.plt + 0x18 (reserved 3 entries) +# 0x3028 = 0x3018 + double entry size (16) +#READOBJ-NEXT: 0x3018 R_AARCH64_TLSDESC foo 0x0 +#READOBJ-NEXT: 0x3028 R_AARCH64_TLSDESC bar 0x0 +#READOBJ-NEXT: } +#READOBJ-NEXT:] +#READOBJ: DynamicSection [ +#READOBJ-NEXT: Tag Type Name/Value +#READOBJ-NEXT: 0x0000000000000017 JMPREL 0x298 +#READOBJ-NEXT: 0x0000000000000002 PLTRELSZ 48 (bytes) +#READOBJ-NEXT: 0x0000000000000003 PLTGOT 0x3000 +#READOBJ-NEXT: 0x0000000000000014 PLTREL RELA +# 0x20A8 = Location of GOT entry used by TLS descriptor resolver PLT entry +#READOBJ-NEXT: 0x000000006FFFFEF7 TLSDESC_GOT 0x20C8 +# 0x1040 = Location of PLT entry for TLS descriptor resolver calls. +#READOBJ-NEXT: 0x000000006FFFFEF6 TLSDESC_PLT 0x1040 +#READOBJ-NEXT: 0x0000000000000006 SYMTAB 0x200 +#READOBJ-NEXT: 0x000000000000000B SYMENT 24 (bytes) +#READOBJ-NEXT: 0x0000000000000005 STRTAB 0x288 +#READOBJ-NEXT: 0x000000000000000A STRSZ 16 (bytes) +#READOBJ-NEXT: 0x0000000000000004 HASH 0x260 +#READOBJ-NEXT: 0x0000000000000000 NULL 0x0 +#READOBJ-NEXT: ] + +#CHECK: Disassembly of section .text: +#CHECK-NEXT: _start: +# Page(.got.plt[N]) - Page(0x1000) = Page(0x3018) - 0x1000 = +# 0x3000 - 0x1000 = 0x2000 = 8192 +# 0x18 = 24 +#CHECK-NEXT: 1000: {{.*}} adrp x0, #8192 +#CHECK-NEXT: 1004: {{.*}} ldr x2, [x0, #24] +#CHECK-NEXT: 1008: {{.*}} add x0, x0, #24 +#CHECK-NEXT: 100c: {{.*}} blr x2 +# Page(.got.plt[N]) - Page(0x1000) = Page(0x3028) - 0x1000 = +# 0x3000 - 0x1000 = 0x2000 = 8192 +# 0x28 = 40 +#CHECK-NEXT: 1010: {{.*}} adrp x0, #8192 +#CHECK-NEXT: 1014: {{.*}} ldr x2, [x0, #40] +#CHECK-NEXT: 1018: {{.*}} add x0, x0, #40 +#CHECK-NEXT: 101c: {{.*}} blr x2 +#CHECK-NEXT: Disassembly of section .plt: +#CHECK-NEXT: .plt: +#CHECK-NEXT: 1020: {{.*}} stp x16, x30, [sp, #-16]! +#CHECK-NEXT: 1024: {{.*}} adrp x16, #8192 +#CHECK-NEXT: 1028: {{.*}} ldr x17, [x16, #16] +#CHECK-NEXT: 102c: {{.*}} add x16, x16, #16 +#CHECK-NEXT: 1030: {{.*}} br x17 +#CHECK-NEXT: 1034: {{.*}} nop +#CHECK-NEXT: 1038: {{.*}} nop +#CHECK-NEXT: 103c: {{.*}} nop +# Page(.got[N]) - Page(P) = Page(0x20C8) - Page(0x1044) = +# 0x2000 - 0x1000 = 4096 +# Page(.got.plt) - Page(P) = Page(0x3000) - Page(0x1048) = +# 0x3000 - 0x1000 = 8192 +# 0xC8 = 200 +# 0x0 = 0 +#CHECK-NEXT: 1040: {{.*}} stp x2, x3, [sp, #-16]! +#CHECK-NEXT: 1044: {{.*}} adrp x2, #4096 +#CHECK-NEXT: 1048: {{.*}} adrp x3, #8192 +#CHECK-NEXT: 104c: {{.*}} ldr x2, [x2, #200] +#CHECK-NEXT: 1050: {{.*}} add x3, x3, #0 +#CHECK-NEXT: 1054: {{.*}} br x2 +#CHECK-NEXT: 1058: {{.*}} nop +#CHECK-NEXT: 105c: {{.*}} nop + +.text + .global foo + .section .tdata,"awT",%progbits + .align 2 + .type foo, %object + .size foo, 4 +foo: + .word 5 + .text + +.text + .global bar + .section .tdata,"awT",%progbits + .align 2 + .type bar, %object + .size bar, 4 +bar: + .word 5 + .text + +.globl _start +_start: + adrp x0, :tlsdesc:foo + ldr x2, [x0, #:tlsdesc_lo12:foo] + add x0, x0, :tlsdesc_lo12:foo + .tlsdesccall foo + blr x2 + + adrp x0, :tlsdesc:bar + ldr x2, [x0, #:tlsdesc_lo12:bar] + add x0, x0, :tlsdesc_lo12:bar + .tlsdesccall bar + blr x2