blob: c8c622ca4959190fc5171d15cc6ebf8f151b218b [file] [log] [blame]
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001//===- OutputSections.cpp -------------------------------------------------===//
2//
3// The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "OutputSections.h"
11#include "Config.h"
Rui Ueyamaf5febef2016-05-24 02:55:45 +000012#include "EhFrame.h"
George Rimar58fa5242016-10-20 09:19:48 +000013#include "GdbIndex.h"
Rui Ueyama95642b92016-11-01 23:09:07 +000014#include "LinkerScript.h"
15#include "Memory.h"
Rui Ueyamafbbde542016-06-29 09:08:02 +000016#include "Strings.h"
Rafael Espindola5805c4f2015-09-21 21:38:08 +000017#include "SymbolTable.h"
Rui Ueyamae8a61022016-11-05 23:05:47 +000018#include "SyntheticSections.h"
Rafael Espindola01205f72015-09-22 18:19:46 +000019#include "Target.h"
Rui Ueyamae9809502016-03-11 04:23:12 +000020#include "lld/Core/Parallel.h"
George Rimarf6bc65a2016-01-15 13:34:52 +000021#include "llvm/Support/Dwarf.h"
Rui Ueyama3a41be22016-04-07 22:49:21 +000022#include "llvm/Support/MD5.h"
Igor Kudrin1b0d7062015-10-22 08:21:35 +000023#include "llvm/Support/MathExtras.h"
Rafael Espindolaa42b3bc2016-09-27 16:43:49 +000024#include "llvm/Support/SHA1.h"
Rafael Espindola5805c4f2015-09-21 21:38:08 +000025
Rafael Espindola5805c4f2015-09-21 21:38:08 +000026using namespace llvm;
Rui Ueyamadbcfedb2016-02-09 21:46:11 +000027using namespace llvm::dwarf;
Rafael Espindola5805c4f2015-09-21 21:38:08 +000028using namespace llvm::object;
Rafael Espindolaa6627382015-10-06 23:56:53 +000029using namespace llvm::support::endian;
Rafael Espindola5805c4f2015-09-21 21:38:08 +000030using namespace llvm::ELF;
31
32using namespace lld;
Rafael Espindolae0df00b2016-02-28 00:25:54 +000033using namespace lld::elf;
Rafael Espindola5805c4f2015-09-21 21:38:08 +000034
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +000035template <class ELFT>
Rui Ueyamad97e5c42016-01-07 18:33:11 +000036OutputSectionBase<ELFT>::OutputSectionBase(StringRef Name, uint32_t Type,
37 uintX_t Flags)
Rafael Espindola5805c4f2015-09-21 21:38:08 +000038 : Name(Name) {
Rafael Espindola04a2e342016-11-09 01:42:41 +000039 this->Type = Type;
40 this->Flags = Flags;
41 this->Addralign = 1;
Rafael Espindola5805c4f2015-09-21 21:38:08 +000042}
43
Rafael Espindola0b113672016-07-27 14:10:56 +000044template <class ELFT> uint32_t OutputSectionBase<ELFT>::getPhdrFlags() const {
Rafael Espindola0b113672016-07-27 14:10:56 +000045 uint32_t Ret = PF_R;
46 if (Flags & SHF_WRITE)
47 Ret |= PF_W;
48 if (Flags & SHF_EXECINSTR)
49 Ret |= PF_X;
50 return Ret;
51}
52
Rafael Espindola35c6af32015-09-25 17:19:10 +000053template <class ELFT>
Rui Ueyamac63c1db2016-03-13 06:50:33 +000054void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *Shdr) {
Rafael Espindola04a2e342016-11-09 01:42:41 +000055 Shdr->sh_entsize = Entsize;
56 Shdr->sh_addralign = Addralign;
57 Shdr->sh_type = Type;
58 Shdr->sh_offset = Offset;
59 Shdr->sh_flags = Flags;
60 Shdr->sh_info = Info;
61 Shdr->sh_link = Link;
62 Shdr->sh_addr = Addr;
63 Shdr->sh_size = Size;
64 Shdr->sh_name = ShName;
Rui Ueyamac63c1db2016-03-13 06:50:33 +000065}
66
67template <class ELFT>
George Rimar58fa5242016-10-20 09:19:48 +000068GdbIndexSection<ELFT>::GdbIndexSection()
69 : OutputSectionBase<ELFT>(".gdb_index", SHT_PROGBITS, 0) {}
70
71template <class ELFT> void GdbIndexSection<ELFT>::parseDebugSections() {
72 std::vector<InputSection<ELFT> *> &IS =
73 static_cast<OutputSection<ELFT> *>(Out<ELFT>::DebugInfo)->Sections;
74
75 for (InputSection<ELFT> *I : IS)
76 readDwarf(I);
77}
78
79template <class ELFT>
80void GdbIndexSection<ELFT>::readDwarf(InputSection<ELFT> *I) {
81 std::vector<std::pair<uintX_t, uintX_t>> CuList = readCuList(I);
82 CompilationUnits.insert(CompilationUnits.end(), CuList.begin(), CuList.end());
83}
84
85template <class ELFT> void GdbIndexSection<ELFT>::finalize() {
86 parseDebugSections();
87
88 // GdbIndex header consist from version fields
89 // and 5 more fields with different kinds of offsets.
90 CuTypesOffset = CuListOffset + CompilationUnits.size() * CompilationUnitSize;
Rafael Espindola04a2e342016-11-09 01:42:41 +000091 this->Size = CuTypesOffset;
George Rimar58fa5242016-10-20 09:19:48 +000092}
93
94template <class ELFT> void GdbIndexSection<ELFT>::writeTo(uint8_t *Buf) {
95 write32le(Buf, 7); // Write Version
96 write32le(Buf + 4, CuListOffset); // CU list offset
97 write32le(Buf + 8, CuTypesOffset); // Types CU list offset
98 write32le(Buf + 12, CuTypesOffset); // Address area offset
99 write32le(Buf + 16, CuTypesOffset); // Symbol table offset
100 write32le(Buf + 20, CuTypesOffset); // Constant pool offset
101 Buf += 24;
102
103 // Write the CU list.
104 for (std::pair<uintX_t, uintX_t> CU : CompilationUnits) {
105 write64le(Buf, CU.first);
106 write64le(Buf + 8, CU.second);
107 Buf += 16;
108 }
109}
110
111template <class ELFT>
George Rimar648a2c32015-10-20 08:54:27 +0000112GotPltSection<ELFT>::GotPltSection()
Rui Ueyamacf07a312016-01-06 22:53:58 +0000113 : OutputSectionBase<ELFT>(".got.plt", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000114 this->Addralign = Target->GotPltEntrySize;
George Rimar648a2c32015-10-20 08:54:27 +0000115}
116
Rafael Espindola67d72c02016-03-11 12:06:30 +0000117template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
118 Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
119 Entries.push_back(&Sym);
George Rimar648a2c32015-10-20 08:54:27 +0000120}
121
122template <class ELFT> bool GotPltSection<ELFT>::empty() const {
Igor Kudrin351b41d2015-11-16 17:44:08 +0000123 return Entries.empty();
George Rimar648a2c32015-10-20 08:54:27 +0000124}
125
George Rimar648a2c32015-10-20 08:54:27 +0000126template <class ELFT> void GotPltSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000127 this->Size = (Target->GotPltHeaderEntriesNum + Entries.size()) *
128 Target->GotPltEntrySize;
George Rimar648a2c32015-10-20 08:54:27 +0000129}
130
131template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
Rui Ueyamac516ae12016-01-29 02:33:45 +0000132 Target->writeGotPltHeader(Buf);
Rui Ueyama803b1202016-07-13 18:55:14 +0000133 Buf += Target->GotPltHeaderEntriesNum * Target->GotPltEntrySize;
George Rimar648a2c32015-10-20 08:54:27 +0000134 for (const SymbolBody *B : Entries) {
Rui Ueyamac9fee5f2016-06-16 16:14:50 +0000135 Target->writeGotPlt(Buf, *B);
George Rimar648a2c32015-10-20 08:54:27 +0000136 Buf += sizeof(uintX_t);
137 }
138}
139
140template <class ELFT>
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000141GotSection<ELFT>::GotSection()
Rui Ueyamacf07a312016-01-06 22:53:58 +0000142 : OutputSectionBase<ELFT>(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
Igor Kudrin15cd9ff2015-11-06 07:43:03 +0000143 if (Config->EMachine == EM_MIPS)
Rafael Espindola04a2e342016-11-09 01:42:41 +0000144 this->Flags |= SHF_MIPS_GPREL;
145 this->Addralign = Target->GotEntrySize;
Rafael Espindola35c6af32015-09-25 17:19:10 +0000146}
147
George Rimara4c7e742016-10-20 08:36:42 +0000148template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
Rafael Espindola67d72c02016-03-11 12:06:30 +0000149 Sym.GotIndex = Entries.size();
150 Entries.push_back(&Sym);
George Rimar687138c2015-11-13 16:28:53 +0000151}
152
Simon Atanasyan41325112016-06-19 21:39:37 +0000153template <class ELFT>
154void GotSection<ELFT>::addMipsEntry(SymbolBody &Sym, uintX_t Addend,
155 RelExpr Expr) {
156 // For "true" local symbols which can be referenced from the same module
157 // only compiler creates two instructions for address loading:
158 //
159 // lw $8, 0($gp) # R_MIPS_GOT16
160 // addi $8, $8, 0 # R_MIPS_LO16
161 //
162 // The first instruction loads high 16 bits of the symbol address while
163 // the second adds an offset. That allows to reduce number of required
164 // GOT entries because only one global offset table entry is necessary
165 // for every 64 KBytes of local data. So for local symbols we need to
166 // allocate number of GOT entries to hold all required "page" addresses.
167 //
168 // All global symbols (hidden and regular) considered by compiler uniformly.
169 // It always generates a single `lw` instruction and R_MIPS_GOT16 relocation
170 // to load address of the symbol. So for each such symbol we need to
171 // allocate dedicated GOT entry to store its address.
172 //
173 // If a symbol is preemptible we need help of dynamic linker to get its
174 // final address. The corresponding GOT entries are allocated in the
175 // "global" part of GOT. Entries for non preemptible global symbol allocated
176 // in the "local" part of GOT.
177 //
178 // See "Global Offset Table" in Chapter 5:
179 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
180 if (Expr == R_MIPS_GOT_LOCAL_PAGE) {
181 // At this point we do not know final symbol value so to reduce number
182 // of allocated GOT entries do the following trick. Save all output
183 // sections referenced by GOT relocations. Then later in the `finalize`
184 // method calculate number of "pages" required to cover all saved output
185 // section and allocate appropriate number of GOT entries.
186 auto *OutSec = cast<DefinedRegular<ELFT>>(&Sym)->Section->OutSec;
187 MipsOutSections.insert(OutSec);
188 return;
189 }
Simon Atanasyan002e2442016-06-23 15:26:31 +0000190 if (Sym.isTls()) {
191 // GOT entries created for MIPS TLS relocations behave like
192 // almost GOT entries from other ABIs. They go to the end
193 // of the global offset table.
194 Sym.GotIndex = Entries.size();
195 Entries.push_back(&Sym);
196 return;
197 }
Simon Atanasyan41325112016-06-19 21:39:37 +0000198 auto AddEntry = [&](SymbolBody &S, uintX_t A, MipsGotEntries &Items) {
199 if (S.isInGot() && !A)
200 return;
201 size_t NewIndex = Items.size();
202 if (!MipsGotMap.insert({{&S, A}, NewIndex}).second)
203 return;
204 Items.emplace_back(&S, A);
205 if (!A)
206 S.GotIndex = NewIndex;
207 };
208 if (Sym.isPreemptible()) {
209 // Ignore addends for preemptible symbols. They got single GOT entry anyway.
210 AddEntry(Sym, 0, MipsGlobal);
211 Sym.IsInGlobalMipsGot = true;
Simon Atanasyanbed04bf2016-10-21 07:22:30 +0000212 } else if (Expr == R_MIPS_GOT_OFF32) {
213 AddEntry(Sym, Addend, MipsLocal32);
214 Sym.Is32BitMipsGot = true;
215 } else {
216 // Hold local GOT entries accessed via a 16-bit index separately.
217 // That allows to write them in the beginning of the GOT and keep
218 // their indexes as less as possible to escape relocation's overflow.
Simon Atanasyan41325112016-06-19 21:39:37 +0000219 AddEntry(Sym, Addend, MipsLocal);
Simon Atanasyanbed04bf2016-10-21 07:22:30 +0000220 }
Simon Atanasyan41325112016-06-19 21:39:37 +0000221}
222
Rafael Espindola67d72c02016-03-11 12:06:30 +0000223template <class ELFT> bool GotSection<ELFT>::addDynTlsEntry(SymbolBody &Sym) {
Rafael Espindola6211d9a2016-06-05 19:03:28 +0000224 if (Sym.GlobalDynIndex != -1U)
George Rimar90cd0a82015-12-01 19:20:26 +0000225 return false;
Rafael Espindola6211d9a2016-06-05 19:03:28 +0000226 Sym.GlobalDynIndex = Entries.size();
Michael J. Spencer627ae702015-11-13 00:28:34 +0000227 // Global Dynamic TLS entries take two GOT slots.
George Rimar687138c2015-11-13 16:28:53 +0000228 Entries.push_back(nullptr);
Rafael Espindolaa8777c22016-06-08 21:31:59 +0000229 Entries.push_back(&Sym);
George Rimar90cd0a82015-12-01 19:20:26 +0000230 return true;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000231}
232
Rui Ueyama0e53c7d2016-02-05 00:10:02 +0000233// Reserves TLS entries for a TLS module ID and a TLS block offset.
234// In total it takes two GOT slots.
235template <class ELFT> bool GotSection<ELFT>::addTlsIndex() {
236 if (TlsIndexOff != uint32_t(-1))
George Rimarb17f7392015-12-01 18:24:07 +0000237 return false;
Rui Ueyama0e53c7d2016-02-05 00:10:02 +0000238 TlsIndexOff = Entries.size() * sizeof(uintX_t);
Michael J. Spencer1e225612015-11-11 01:00:24 +0000239 Entries.push_back(nullptr);
240 Entries.push_back(nullptr);
George Rimarb17f7392015-12-01 18:24:07 +0000241 return true;
Michael J. Spencer1e225612015-11-11 01:00:24 +0000242}
243
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000244template <class ELFT>
245typename GotSection<ELFT>::uintX_t
Rafael Espindola58cd5db2016-04-19 22:46:03 +0000246GotSection<ELFT>::getMipsLocalPageOffset(uintX_t EntryValue) {
Simon Atanasyan56ab5f02016-01-21 05:33:23 +0000247 // Initialize the entry by the %hi(EntryValue) expression
248 // but without right-shifting.
Simon Atanasyan41325112016-06-19 21:39:37 +0000249 EntryValue = (EntryValue + 0x8000) & ~0xffff;
Simon Atanasyan1ef1bf82016-04-25 20:25:05 +0000250 // Take into account MIPS GOT header.
251 // See comment in the GotSection::writeTo.
252 size_t NewIndex = MipsLocalGotPos.size() + 2;
Simon Atanasyan56ab5f02016-01-21 05:33:23 +0000253 auto P = MipsLocalGotPos.insert(std::make_pair(EntryValue, NewIndex));
Simon Atanasyan41325112016-06-19 21:39:37 +0000254 assert(!P.second || MipsLocalGotPos.size() <= MipsPageEntries);
George Rimar71e64b22016-05-11 09:41:15 +0000255 return (uintX_t)P.first->second * sizeof(uintX_t) - MipsGPOffset;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000256}
257
Igor Kudrin304860a2015-11-12 04:39:49 +0000258template <class ELFT>
George Rimar90cd0a82015-12-01 19:20:26 +0000259typename GotSection<ELFT>::uintX_t
Simon Atanasyan41325112016-06-19 21:39:37 +0000260GotSection<ELFT>::getMipsGotOffset(const SymbolBody &B, uintX_t Addend) const {
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000261 // Calculate offset of the GOT entries block: TLS, global, local.
262 uintX_t GotBlockOff;
Simon Atanasyan002e2442016-06-23 15:26:31 +0000263 if (B.isTls())
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000264 GotBlockOff = getMipsTlsOffset();
Simon Atanasyan002e2442016-06-23 15:26:31 +0000265 else if (B.IsInGlobalMipsGot)
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000266 GotBlockOff = getMipsLocalEntriesNum() * sizeof(uintX_t);
Simon Atanasyanbed04bf2016-10-21 07:22:30 +0000267 else if (B.Is32BitMipsGot)
268 GotBlockOff = (MipsPageEntries + MipsLocal.size()) * sizeof(uintX_t);
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000269 else
270 GotBlockOff = MipsPageEntries * sizeof(uintX_t);
271 // Calculate index of the GOT entry in the block.
272 uintX_t GotIndex;
273 if (B.isInGot())
274 GotIndex = B.GotIndex;
Simon Atanasyan41325112016-06-19 21:39:37 +0000275 else {
276 auto It = MipsGotMap.find({&B, Addend});
277 assert(It != MipsGotMap.end());
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000278 GotIndex = It->second;
Simon Atanasyan41325112016-06-19 21:39:37 +0000279 }
Simon Atanasyanf4415a32016-10-20 17:53:55 +0000280 return GotBlockOff + GotIndex * sizeof(uintX_t) - MipsGPOffset;
Simon Atanasyan41325112016-06-19 21:39:37 +0000281}
282
283template <class ELFT>
Simon Atanasyanbc946932016-10-19 17:13:43 +0000284typename GotSection<ELFT>::uintX_t GotSection<ELFT>::getMipsTlsOffset() const {
Simon Atanasyanbadd5b32016-10-20 17:53:59 +0000285 return (getMipsLocalEntriesNum() + MipsGlobal.size()) * sizeof(uintX_t);
Simon Atanasyan002e2442016-06-23 15:26:31 +0000286}
287
288template <class ELFT>
Simon Atanasyan41325112016-06-19 21:39:37 +0000289typename GotSection<ELFT>::uintX_t
George Rimar90cd0a82015-12-01 19:20:26 +0000290GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000291 return this->Addr + B.GlobalDynIndex * sizeof(uintX_t);
George Rimar90cd0a82015-12-01 19:20:26 +0000292}
293
294template <class ELFT>
Rafael Espindola74031ba2016-04-07 15:20:56 +0000295typename GotSection<ELFT>::uintX_t
296GotSection<ELFT>::getGlobalDynOffset(const SymbolBody &B) const {
Rafael Espindola6211d9a2016-06-05 19:03:28 +0000297 return B.GlobalDynIndex * sizeof(uintX_t);
Rafael Espindola74031ba2016-04-07 15:20:56 +0000298}
299
300template <class ELFT>
Igor Kudrin304860a2015-11-12 04:39:49 +0000301const SymbolBody *GotSection<ELFT>::getMipsFirstGlobalEntry() const {
Simon Atanasyan41325112016-06-19 21:39:37 +0000302 return MipsGlobal.empty() ? nullptr : MipsGlobal.front().first;
Igor Kudrin304860a2015-11-12 04:39:49 +0000303}
304
305template <class ELFT>
306unsigned GotSection<ELFT>::getMipsLocalEntriesNum() const {
Simon Atanasyanbed04bf2016-10-21 07:22:30 +0000307 return MipsPageEntries + MipsLocal.size() + MipsLocal32.size();
Igor Kudrin304860a2015-11-12 04:39:49 +0000308}
309
Igor Kudrin15cd9ff2015-11-06 07:43:03 +0000310template <class ELFT> void GotSection<ELFT>::finalize() {
Simon Atanasyan311b4b12016-06-10 12:26:28 +0000311 size_t EntriesNum = Entries.size();
312 if (Config->EMachine == EM_MIPS) {
Simon Atanasyan1ef1bf82016-04-25 20:25:05 +0000313 // Take into account MIPS GOT header.
314 // See comment in the GotSection::writeTo.
Simon Atanasyan41325112016-06-19 21:39:37 +0000315 MipsPageEntries += 2;
Simon Atanasyan311b4b12016-06-10 12:26:28 +0000316 for (const OutputSectionBase<ELFT> *OutSec : MipsOutSections) {
317 // Calculate an upper bound of MIPS GOT entries required to store page
318 // addresses of local symbols. We assume the worst case - each 64kb
319 // page of the output section has at least one GOT relocation against it.
320 // Add 0x8000 to the section's size because the page address stored
321 // in the GOT entry is calculated as (value + 0x8000) & ~0xffff.
Rafael Espindola04a2e342016-11-09 01:42:41 +0000322 MipsPageEntries += (OutSec->Size + 0x8000 + 0xfffe) / 0xffff;
Simon Atanasyan311b4b12016-06-10 12:26:28 +0000323 }
Simon Atanasyanbadd5b32016-10-20 17:53:59 +0000324 EntriesNum += getMipsLocalEntriesNum() + MipsGlobal.size();
Simon Atanasyand2980d32016-03-29 14:07:22 +0000325 }
Rafael Espindola04a2e342016-11-09 01:42:41 +0000326 this->Size = EntriesNum * sizeof(uintX_t);
Igor Kudrin15cd9ff2015-11-06 07:43:03 +0000327}
328
Rui Ueyamac442cff2016-09-08 21:46:21 +0000329template <class ELFT>
330static void writeUint(uint8_t *Buf, typename ELFT::uint Val) {
331 typedef typename ELFT::uint uintX_t;
332 write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Buf, Val);
333}
334
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000335template <class ELFT> void GotSection<ELFT>::writeMipsGot(uint8_t *Buf) {
Simon Atanasyan41325112016-06-19 21:39:37 +0000336 // Set the MSB of the second GOT slot. This is not required by any
337 // MIPS ABI documentation, though.
338 //
339 // There is a comment in glibc saying that "The MSB of got[1] of a
340 // gnu object is set to identify gnu objects," and in GNU gold it
341 // says "the second entry will be used by some runtime loaders".
342 // But how this field is being used is unclear.
343 //
344 // We are not really willing to mimic other linkers behaviors
345 // without understanding why they do that, but because all files
346 // generated by GNU tools have this special GOT value, and because
347 // we've been doing this for years, it is probably a safe bet to
348 // keep doing this for now. We really need to revisit this to see
349 // if we had to do this.
350 auto *P = reinterpret_cast<typename ELFT::Off *>(Buf);
351 P[1] = uintX_t(1) << (ELFT::Is64Bits ? 63 : 31);
352 // Write 'page address' entries to the local part of the GOT.
353 for (std::pair<uintX_t, size_t> &L : MipsLocalGotPos) {
354 uint8_t *Entry = Buf + L.second * sizeof(uintX_t);
Rui Ueyamac442cff2016-09-08 21:46:21 +0000355 writeUint<ELFT>(Entry, L.first);
Simon Atanasyan1ef1bf82016-04-25 20:25:05 +0000356 }
Simon Atanasyan41325112016-06-19 21:39:37 +0000357 Buf += MipsPageEntries * sizeof(uintX_t);
358 auto AddEntry = [&](const MipsGotEntry &SA) {
359 uint8_t *Entry = Buf;
360 Buf += sizeof(uintX_t);
George Rimara4c7e742016-10-20 08:36:42 +0000361 const SymbolBody *Body = SA.first;
George Rimar06e930d2016-06-20 10:01:50 +0000362 uintX_t VA = Body->template getVA<ELFT>(SA.second);
Rui Ueyamac442cff2016-09-08 21:46:21 +0000363 writeUint<ELFT>(Entry, VA);
Simon Atanasyan41325112016-06-19 21:39:37 +0000364 };
365 std::for_each(std::begin(MipsLocal), std::end(MipsLocal), AddEntry);
Simon Atanasyanbed04bf2016-10-21 07:22:30 +0000366 std::for_each(std::begin(MipsLocal32), std::end(MipsLocal32), AddEntry);
Simon Atanasyan41325112016-06-19 21:39:37 +0000367 std::for_each(std::begin(MipsGlobal), std::end(MipsGlobal), AddEntry);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000368 // Initialize TLS-related GOT entries. If the entry has a corresponding
369 // dynamic relocations, leave it initialized by zero. Write down adjusted
370 // TLS symbol's values otherwise. To calculate the adjustments use offsets
371 // for thread-local storage.
372 // https://www.linux-mips.org/wiki/NPTL
373 if (TlsIndexOff != -1U && !Config->Pic)
Rui Ueyamac442cff2016-09-08 21:46:21 +0000374 writeUint<ELFT>(Buf + TlsIndexOff, 1);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000375 for (const SymbolBody *B : Entries) {
376 if (!B || B->isPreemptible())
377 continue;
378 uintX_t VA = B->getVA<ELFT>();
379 if (B->GotIndex != -1U) {
380 uint8_t *Entry = Buf + B->GotIndex * sizeof(uintX_t);
Rui Ueyamac442cff2016-09-08 21:46:21 +0000381 writeUint<ELFT>(Entry, VA - 0x7000);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000382 }
383 if (B->GlobalDynIndex != -1U) {
384 uint8_t *Entry = Buf + B->GlobalDynIndex * sizeof(uintX_t);
Rui Ueyamac442cff2016-09-08 21:46:21 +0000385 writeUint<ELFT>(Entry, 1);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000386 Entry += sizeof(uintX_t);
Rui Ueyamac442cff2016-09-08 21:46:21 +0000387 writeUint<ELFT>(Entry, VA - 0x8000);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000388 }
389 }
Simon Atanasyan41325112016-06-19 21:39:37 +0000390}
391
392template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000393 if (Config->EMachine == EM_MIPS) {
Simon Atanasyan41325112016-06-19 21:39:37 +0000394 writeMipsGot(Buf);
Simon Atanasyan919a58c2016-09-08 09:07:19 +0000395 return;
396 }
Rafael Espindolaa6627382015-10-06 23:56:53 +0000397 for (const SymbolBody *B : Entries) {
Rafael Espindolae782f672015-10-07 03:56:05 +0000398 uint8_t *Entry = Buf;
399 Buf += sizeof(uintX_t);
Michael J. Spencer1e225612015-11-11 01:00:24 +0000400 if (!B)
401 continue;
Simon Atanasyan41325112016-06-19 21:39:37 +0000402 if (B->isPreemptible())
Rafael Espindolaa6627382015-10-06 23:56:53 +0000403 continue; // The dynamic linker will take care of it.
Rui Ueyamab5a69702016-02-01 21:00:35 +0000404 uintX_t VA = B->getVA<ELFT>();
Rui Ueyamac442cff2016-09-08 21:46:21 +0000405 writeUint<ELFT>(Entry, VA);
Rafael Espindolaa6627382015-10-06 23:56:53 +0000406 }
407}
408
Rafael Espindola35c6af32015-09-25 17:19:10 +0000409template <class ELFT>
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000410PltSection<ELFT>::PltSection()
Rui Ueyamacf07a312016-01-06 22:53:58 +0000411 : OutputSectionBase<ELFT>(".plt", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000412 this->Addralign = 16;
Rafael Espindola35c6af32015-09-25 17:19:10 +0000413}
414
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000415template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
Rafael Espindolae4c86d832016-05-18 21:03:36 +0000416 // At beginning of PLT, we have code to call the dynamic linker
417 // to resolve dynsyms at runtime. Write such code.
Rui Ueyama4a90f572016-06-16 16:28:50 +0000418 Target->writePltHeader(Buf);
419 size_t Off = Target->PltHeaderSize;
Rui Ueyamaf57a5902016-05-20 21:39:07 +0000420
George Rimarfb5d7f22015-11-26 19:58:51 +0000421 for (auto &I : Entries) {
Rui Ueyama9398f862016-01-29 04:15:02 +0000422 const SymbolBody *B = I.first;
George Rimar77b77792015-11-25 22:15:01 +0000423 unsigned RelOff = I.second;
Rafael Espindolae4c86d832016-05-18 21:03:36 +0000424 uint64_t Got = B->getGotPltVA<ELFT>();
Rafael Espindola04a2e342016-11-09 01:42:41 +0000425 uint64_t Plt = this->Addr + Off;
Rui Ueyama9398f862016-01-29 04:15:02 +0000426 Target->writePlt(Buf + Off, Got, Plt, B->PltIndex, RelOff);
Rui Ueyama724d6252016-01-29 01:49:32 +0000427 Off += Target->PltEntrySize;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000428 }
429}
430
Rafael Espindola67d72c02016-03-11 12:06:30 +0000431template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody &Sym) {
432 Sym.PltIndex = Entries.size();
Rafael Espindolae4c86d832016-05-18 21:03:36 +0000433 unsigned RelOff = Out<ELFT>::RelaPlt->getRelocOffset();
Rafael Espindola67d72c02016-03-11 12:06:30 +0000434 Entries.push_back(std::make_pair(&Sym, RelOff));
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000435}
436
George Rimar648a2c32015-10-20 08:54:27 +0000437template <class ELFT> void PltSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000438 this->Size = Target->PltHeaderSize + Entries.size() * Target->PltEntrySize;
Hal Finkel6c2a3b82015-10-08 21:51:31 +0000439}
440
441template <class ELFT>
George Rimarc191acf2016-05-10 15:47:57 +0000442RelocationSection<ELFT>::RelocationSection(StringRef Name, bool Sort)
Rui Ueyama6c5638b2016-03-13 20:10:20 +0000443 : OutputSectionBase<ELFT>(Name, Config->Rela ? SHT_RELA : SHT_REL,
George Rimarc191acf2016-05-10 15:47:57 +0000444 SHF_ALLOC),
445 Sort(Sort) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000446 this->Entsize = Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
447 this->Addralign = sizeof(uintX_t);
Rafael Espindola35c6af32015-09-25 17:19:10 +0000448}
449
George Rimar5828c232015-11-30 17:49:19 +0000450template <class ELFT>
Rafael Espindolad30eb7d2016-02-05 15:03:10 +0000451void RelocationSection<ELFT>::addReloc(const DynamicReloc<ELFT> &Reloc) {
Eugene Leviantaa498192016-08-31 08:51:39 +0000452 if (Reloc.Type == Target->RelativeRel)
453 ++NumRelativeRelocs;
Rafael Espindolad30eb7d2016-02-05 15:03:10 +0000454 Relocs.push_back(Reloc);
455}
456
George Rimarc191acf2016-05-10 15:47:57 +0000457template <class ELFT, class RelTy>
458static bool compRelocations(const RelTy &A, const RelTy &B) {
Eugene Leviantaa498192016-08-31 08:51:39 +0000459 bool AIsRel = A.getType(Config->Mips64EL) == Target->RelativeRel;
460 bool BIsRel = B.getType(Config->Mips64EL) == Target->RelativeRel;
461 if (AIsRel != BIsRel)
462 return AIsRel;
463
George Rimarc191acf2016-05-10 15:47:57 +0000464 return A.getSymbol(Config->Mips64EL) < B.getSymbol(Config->Mips64EL);
465}
466
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000467template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
George Rimarc191acf2016-05-10 15:47:57 +0000468 uint8_t *BufBegin = Buf;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000469 for (const DynamicReloc<ELFT> &Rel : Relocs) {
Rui Ueyama614be592016-03-13 05:23:40 +0000470 auto *P = reinterpret_cast<Elf_Rela *>(Buf);
Rui Ueyama6c5638b2016-03-13 20:10:20 +0000471 Buf += Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
Rui Ueyamab0210e832016-01-26 00:24:57 +0000472
Rui Ueyama6c5638b2016-03-13 20:10:20 +0000473 if (Config->Rela)
Rui Ueyama809d8e22016-06-23 04:33:42 +0000474 P->r_addend = Rel.getAddend();
475 P->r_offset = Rel.getOffset();
Simon Atanasyan002e2442016-06-23 15:26:31 +0000476 if (Config->EMachine == EM_MIPS && Rel.getOutputSec() == Out<ELFT>::Got)
477 // Dynamic relocation against MIPS GOT section make deal TLS entries
478 // allocated in the end of the GOT. We need to adjust the offset to take
479 // in account 'local' and 'global' GOT entries.
480 P->r_offset += Out<ELFT>::Got->getMipsTlsOffset();
Rui Ueyama809d8e22016-06-23 04:33:42 +0000481 P->setSymbolAndType(Rel.getSymIndex(), Rel.Type, Config->Mips64EL);
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000482 }
George Rimarc191acf2016-05-10 15:47:57 +0000483
484 if (Sort) {
485 if (Config->Rela)
486 std::stable_sort((Elf_Rela *)BufBegin,
487 (Elf_Rela *)BufBegin + Relocs.size(),
488 compRelocations<ELFT, Elf_Rela>);
489 else
490 std::stable_sort((Elf_Rel *)BufBegin, (Elf_Rel *)BufBegin + Relocs.size(),
491 compRelocations<ELFT, Elf_Rel>);
492 }
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000493}
494
George Rimar77b77792015-11-25 22:15:01 +0000495template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000496 return this->Entsize * Relocs.size();
George Rimar77b77792015-11-25 22:15:01 +0000497}
498
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000499template <class ELFT> void RelocationSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000500 this->Link = Out<ELFT>::DynSymTab ? Out<ELFT>::DynSymTab->SectionIndex
501 : Out<ELFT>::SymTab->SectionIndex;
502 this->Size = Relocs.size() * this->Entsize;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000503}
504
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +0000505template <class ELFT>
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000506HashTableSection<ELFT>::HashTableSection()
Rui Ueyamacf07a312016-01-06 22:53:58 +0000507 : OutputSectionBase<ELFT>(".hash", SHT_HASH, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000508 this->Entsize = sizeof(Elf_Word);
509 this->Addralign = sizeof(Elf_Word);
Rafael Espindola35c6af32015-09-25 17:19:10 +0000510}
511
Rui Ueyama0db335f2015-10-07 16:58:54 +0000512template <class ELFT> void HashTableSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000513 this->Link = Out<ELFT>::DynSymTab->SectionIndex;
Rui Ueyama0db335f2015-10-07 16:58:54 +0000514
George Rimare9e1d322016-02-18 15:17:01 +0000515 unsigned NumEntries = 2; // nbucket and nchain.
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000516 NumEntries += Out<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
Rui Ueyama0db335f2015-10-07 16:58:54 +0000517
518 // Create as many buckets as there are symbols.
519 // FIXME: This is simplistic. We can try to optimize it, but implementing
520 // support for SHT_GNU_HASH is probably even more profitable.
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000521 NumEntries += Out<ELFT>::DynSymTab->getNumSymbols();
Rafael Espindola04a2e342016-11-09 01:42:41 +0000522 this->Size = NumEntries * sizeof(Elf_Word);
Rui Ueyama0db335f2015-10-07 16:58:54 +0000523}
524
525template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000526 unsigned NumSymbols = Out<ELFT>::DynSymTab->getNumSymbols();
Rui Ueyama0db335f2015-10-07 16:58:54 +0000527 auto *P = reinterpret_cast<Elf_Word *>(Buf);
528 *P++ = NumSymbols; // nbucket
529 *P++ = NumSymbols; // nchain
530
531 Elf_Word *Buckets = P;
532 Elf_Word *Chains = P + NumSymbols;
533
Michael J. Spencerf8a81482016-10-19 23:49:27 +0000534 for (const SymbolTableEntry &S : Out<ELFT>::DynSymTab->getSymbols()) {
535 SymbolBody *Body = S.Symbol;
Igor Kudrinab665fc2015-10-20 21:47:58 +0000536 StringRef Name = Body->getName();
Rui Ueyama572a6f72016-01-29 01:49:33 +0000537 unsigned I = Body->DynsymIndex;
Davide Italianoe7fd0be2016-11-07 21:56:56 +0000538 uint32_t Hash = hashSysV(Name) % NumSymbols;
Rui Ueyama0db335f2015-10-07 16:58:54 +0000539 Chains[I] = Buckets[Hash];
540 Buckets[Hash] = I;
541 }
542}
543
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000544static uint32_t hashGnu(StringRef Name) {
545 uint32_t H = 5381;
546 for (uint8_t C : Name)
547 H = (H << 5) + H + C;
548 return H;
549}
550
551template <class ELFT>
552GnuHashTableSection<ELFT>::GnuHashTableSection()
Rui Ueyamacf07a312016-01-06 22:53:58 +0000553 : OutputSectionBase<ELFT>(".gnu.hash", SHT_GNU_HASH, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000554 this->Entsize = ELFT::Is64Bits ? 0 : 4;
555 this->Addralign = sizeof(uintX_t);
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000556}
557
558template <class ELFT>
559unsigned GnuHashTableSection<ELFT>::calcNBuckets(unsigned NumHashed) {
560 if (!NumHashed)
561 return 0;
562
563 // These values are prime numbers which are not greater than 2^(N-1) + 1.
564 // In result, for any particular NumHashed we return a prime number
565 // which is not greater than NumHashed.
566 static const unsigned Primes[] = {
567 1, 1, 3, 3, 7, 13, 31, 61, 127, 251,
568 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071};
569
570 return Primes[std::min<unsigned>(Log2_32_Ceil(NumHashed),
571 array_lengthof(Primes) - 1)];
572}
573
574// Bloom filter estimation: at least 8 bits for each hashed symbol.
575// GNU Hash table requirement: it should be a power of 2,
576// the minimum value is 1, even for an empty table.
577// Expected results for a 32-bit target:
578// calcMaskWords(0..4) = 1
579// calcMaskWords(5..8) = 2
580// calcMaskWords(9..16) = 4
581// For a 64-bit target:
582// calcMaskWords(0..8) = 1
583// calcMaskWords(9..16) = 2
584// calcMaskWords(17..32) = 4
585template <class ELFT>
586unsigned GnuHashTableSection<ELFT>::calcMaskWords(unsigned NumHashed) {
587 if (!NumHashed)
588 return 1;
589 return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
590}
591
592template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000593 unsigned NumHashed = Symbols.size();
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000594 NBuckets = calcNBuckets(NumHashed);
595 MaskWords = calcMaskWords(NumHashed);
596 // Second hash shift estimation: just predefined values.
597 Shift2 = ELFT::Is64Bits ? 6 : 5;
598
Rafael Espindola04a2e342016-11-09 01:42:41 +0000599 this->Link = Out<ELFT>::DynSymTab->SectionIndex;
600 this->Size = sizeof(Elf_Word) * 4 // Header
601 + sizeof(Elf_Off) * MaskWords // Bloom Filter
602 + sizeof(Elf_Word) * NBuckets // Hash Buckets
603 + sizeof(Elf_Word) * NumHashed; // Hash Values
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000604}
605
606template <class ELFT> void GnuHashTableSection<ELFT>::writeTo(uint8_t *Buf) {
607 writeHeader(Buf);
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000608 if (Symbols.empty())
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000609 return;
610 writeBloomFilter(Buf);
611 writeHashTable(Buf);
612}
613
614template <class ELFT>
615void GnuHashTableSection<ELFT>::writeHeader(uint8_t *&Buf) {
616 auto *P = reinterpret_cast<Elf_Word *>(Buf);
617 *P++ = NBuckets;
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000618 *P++ = Out<ELFT>::DynSymTab->getNumSymbols() - Symbols.size();
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000619 *P++ = MaskWords;
620 *P++ = Shift2;
621 Buf = reinterpret_cast<uint8_t *>(P);
622}
623
624template <class ELFT>
625void GnuHashTableSection<ELFT>::writeBloomFilter(uint8_t *&Buf) {
626 unsigned C = sizeof(Elf_Off) * 8;
627
628 auto *Masks = reinterpret_cast<Elf_Off *>(Buf);
Rui Ueyama861c7312016-02-17 05:40:03 +0000629 for (const SymbolData &Sym : Symbols) {
630 size_t Pos = (Sym.Hash / C) & (MaskWords - 1);
631 uintX_t V = (uintX_t(1) << (Sym.Hash % C)) |
632 (uintX_t(1) << ((Sym.Hash >> Shift2) % C));
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000633 Masks[Pos] |= V;
634 }
635 Buf += sizeof(Elf_Off) * MaskWords;
636}
637
638template <class ELFT>
639void GnuHashTableSection<ELFT>::writeHashTable(uint8_t *Buf) {
640 Elf_Word *Buckets = reinterpret_cast<Elf_Word *>(Buf);
641 Elf_Word *Values = Buckets + NBuckets;
642
643 int PrevBucket = -1;
644 int I = 0;
Rui Ueyama861c7312016-02-17 05:40:03 +0000645 for (const SymbolData &Sym : Symbols) {
646 int Bucket = Sym.Hash % NBuckets;
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000647 assert(PrevBucket <= Bucket);
648 if (Bucket != PrevBucket) {
Rui Ueyama861c7312016-02-17 05:40:03 +0000649 Buckets[Bucket] = Sym.Body->DynsymIndex;
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000650 PrevBucket = Bucket;
651 if (I > 0)
652 Values[I - 1] |= 1;
653 }
Rui Ueyama861c7312016-02-17 05:40:03 +0000654 Values[I] = Sym.Hash & ~1;
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000655 ++I;
656 }
657 if (I > 0)
658 Values[I - 1] |= 1;
659}
660
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000661// Add symbols to this symbol hash table. Note that this function
662// destructively sort a given vector -- which is needed because
663// GNU-style hash table places some sorting requirements.
Rafael Espindola35c6af32015-09-25 17:19:10 +0000664template <class ELFT>
Michael J. Spencerf8a81482016-10-19 23:49:27 +0000665void GnuHashTableSection<ELFT>::addSymbols(std::vector<SymbolTableEntry> &V) {
Davide Italianob4b68b62016-07-04 19:49:55 +0000666 // Ideally this will just be 'auto' but GCC 6.1 is not able
667 // to deduce it correctly.
Michael J. Spencerf8a81482016-10-19 23:49:27 +0000668 std::vector<SymbolTableEntry>::iterator Mid =
669 std::stable_partition(V.begin(), V.end(), [](const SymbolTableEntry &S) {
670 return S.Symbol->isUndefined();
671 });
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000672 if (Mid == V.end())
Igor Kudrinf1d60292015-10-28 07:05:56 +0000673 return;
Davide Italianof8591cf2016-07-06 17:41:55 +0000674 for (auto I = Mid, E = V.end(); I != E; ++I) {
Michael J. Spencerf8a81482016-10-19 23:49:27 +0000675 SymbolBody *B = I->Symbol;
Reid Kleckner2918d0b2016-10-20 00:13:34 +0000676 size_t StrOff = I->StrTabOffset;
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000677 Symbols.push_back({B, StrOff, hashGnu(B->getName())});
678 }
Igor Kudrinf1d60292015-10-28 07:05:56 +0000679
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000680 unsigned NBuckets = calcNBuckets(Symbols.size());
681 std::stable_sort(Symbols.begin(), Symbols.end(),
Rui Ueyama861c7312016-02-17 05:40:03 +0000682 [&](const SymbolData &L, const SymbolData &R) {
Igor Kudrinf1d60292015-10-28 07:05:56 +0000683 return L.Hash % NBuckets < R.Hash % NBuckets;
684 });
685
Rui Ueyama91c0a5d2016-02-17 05:40:01 +0000686 V.erase(Mid, V.end());
Rui Ueyama861c7312016-02-17 05:40:03 +0000687 for (const SymbolData &Sym : Symbols)
688 V.push_back({Sym.Body, Sym.STName});
Igor Kudrinf1d60292015-10-28 07:05:56 +0000689}
690
George Rimard3566302016-06-20 11:55:12 +0000691// Returns the number of version definition entries. Because the first entry
692// is for the version definition itself, it is the number of versioned symbols
693// plus one. Note that we don't support multiple versions yet.
Rui Ueyamaaf469d42016-07-16 04:09:27 +0000694static unsigned getVerDefNum() { return Config->VersionDefinitions.size() + 1; }
George Rimard3566302016-06-20 11:55:12 +0000695
Igor Kudrinf1d60292015-10-28 07:05:56 +0000696template <class ELFT>
Rui Ueyamaace4f902016-05-24 04:25:47 +0000697DynamicSection<ELFT>::DynamicSection()
698 : OutputSectionBase<ELFT>(".dynamic", SHT_DYNAMIC, SHF_ALLOC | SHF_WRITE) {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000699 this->Addralign = sizeof(uintX_t);
700 this->Entsize = ELFT::Is64Bits ? 16 : 8;
Igor Kudrin304860a2015-11-12 04:39:49 +0000701
702 // .dynamic section is not writable on MIPS.
703 // See "Special Section" in Chapter 4 in the following document:
704 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
705 if (Config->EMachine == EM_MIPS)
Rafael Espindola04a2e342016-11-09 01:42:41 +0000706 this->Flags = SHF_ALLOC;
Rui Ueyamaa9593932016-11-02 02:18:01 +0000707
708 addEntries();
Rafael Espindola35c6af32015-09-25 17:19:10 +0000709}
710
Rui Ueyamaa9593932016-11-02 02:18:01 +0000711// There are some dynamic entries that don't depend on other sections.
712// Such entries can be set early.
713template <class ELFT> void DynamicSection<ELFT>::addEntries() {
714 // Add strings to .dynstr early so that .dynstr's size will be
715 // fixed early.
George Rimarb952ece2016-09-02 09:13:05 +0000716 for (StringRef S : Config->AuxiliaryList)
717 Add({DT_AUXILIARY, Out<ELFT>::DynStrTab->addString(S)});
Rafael Espindolade069362016-01-25 21:32:04 +0000718 if (!Config->RPath.empty())
Rafael Espindolae2c24612016-01-29 01:24:25 +0000719 Add({Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
720 Out<ELFT>::DynStrTab->addString(Config->RPath)});
Rui Ueyama38dbd3e2016-09-14 00:05:51 +0000721 for (SharedFile<ELFT> *F : Symtab<ELFT>::X->getSharedFiles())
Rafael Espindolade069362016-01-25 21:32:04 +0000722 if (F->isNeeded())
Rafael Espindolae2c24612016-01-29 01:24:25 +0000723 Add({DT_NEEDED, Out<ELFT>::DynStrTab->addString(F->getSoName())});
724 if (!Config->SoName.empty())
725 Add({DT_SONAME, Out<ELFT>::DynStrTab->addString(Config->SoName)});
726
Rui Ueyamaa9593932016-11-02 02:18:01 +0000727 // Set DT_FLAGS and DT_FLAGS_1.
728 uint32_t DtFlags = 0;
729 uint32_t DtFlags1 = 0;
730 if (Config->Bsymbolic)
731 DtFlags |= DF_SYMBOLIC;
732 if (Config->ZNodelete)
733 DtFlags1 |= DF_1_NODELETE;
734 if (Config->ZNow) {
735 DtFlags |= DF_BIND_NOW;
736 DtFlags1 |= DF_1_NOW;
737 }
738 if (Config->ZOrigin) {
739 DtFlags |= DF_ORIGIN;
740 DtFlags1 |= DF_1_ORIGIN;
741 }
742
743 if (DtFlags)
744 Add({DT_FLAGS, DtFlags});
745 if (DtFlags1)
746 Add({DT_FLAGS_1, DtFlags1});
747
748 if (!Config->Entry.empty())
749 Add({DT_DEBUG, (uint64_t)0});
750}
751
752// Add remaining entries to complete .dynamic contents.
753template <class ELFT> void DynamicSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000754 if (this->Size)
Rui Ueyamaa9593932016-11-02 02:18:01 +0000755 return; // Already finalized.
756
Rafael Espindola04a2e342016-11-09 01:42:41 +0000757 this->Link = Out<ELFT>::DynStrTab->SectionIndex;
Rafael Espindolade069362016-01-25 21:32:04 +0000758
Rui Ueyama15ef5e12015-10-07 19:18:16 +0000759 if (Out<ELFT>::RelaDyn->hasRelocs()) {
Rui Ueyama6c5638b2016-03-13 20:10:20 +0000760 bool IsRela = Config->Rela;
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000761 Add({IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn});
Rafael Espindola04a2e342016-11-09 01:42:41 +0000762 Add({IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->Size});
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000763 Add({IsRela ? DT_RELAENT : DT_RELENT,
764 uintX_t(IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel))});
Eugene Leviantaa498192016-08-31 08:51:39 +0000765
Simon Atanasyan65b24612016-09-04 17:40:12 +0000766 // MIPS dynamic loader does not support RELCOUNT tag.
767 // The problem is in the tight relation between dynamic
768 // relocations and GOT. So do not emit this tag on MIPS.
769 if (Config->EMachine != EM_MIPS) {
770 size_t NumRelativeRels = Out<ELFT>::RelaDyn->getRelativeRelocCount();
771 if (Config->ZCombreloc && NumRelativeRels)
772 Add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
773 }
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000774 }
George Rimar648a2c32015-10-20 08:54:27 +0000775 if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000776 Add({DT_JMPREL, Out<ELFT>::RelaPlt});
Rafael Espindola04a2e342016-11-09 01:42:41 +0000777 Add({DT_PLTRELSZ, Out<ELFT>::RelaPlt->Size});
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000778 Add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
779 Out<ELFT>::GotPlt});
Rui Ueyama6c5638b2016-03-13 20:10:20 +0000780 Add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
George Rimar648a2c32015-10-20 08:54:27 +0000781 }
782
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000783 Add({DT_SYMTAB, Out<ELFT>::DynSymTab});
784 Add({DT_SYMENT, sizeof(Elf_Sym)});
785 Add({DT_STRTAB, Out<ELFT>::DynStrTab});
Rafael Espindola04a2e342016-11-09 01:42:41 +0000786 Add({DT_STRSZ, Out<ELFT>::DynStrTab->Size});
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000787 if (Out<ELFT>::GnuHashTab)
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000788 Add({DT_GNU_HASH, Out<ELFT>::GnuHashTab});
Igor Kudrin1b0d7062015-10-22 08:21:35 +0000789 if (Out<ELFT>::HashTab)
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000790 Add({DT_HASH, Out<ELFT>::HashTab});
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000791
Rui Ueyamaa8f6fea2016-08-09 04:25:20 +0000792 if (Out<ELFT>::PreinitArray) {
793 Add({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
George Rimar03e05602016-08-19 15:23:39 +0000794 Add({DT_PREINIT_ARRAYSZ, Out<ELFT>::PreinitArray, Entry::SecSize});
Rafael Espindolade069362016-01-25 21:32:04 +0000795 }
Rui Ueyamaa8f6fea2016-08-09 04:25:20 +0000796 if (Out<ELFT>::InitArray) {
797 Add({DT_INIT_ARRAY, Out<ELFT>::InitArray});
George Rimar03e05602016-08-19 15:23:39 +0000798 Add({DT_INIT_ARRAYSZ, Out<ELFT>::InitArray, Entry::SecSize});
Rafael Espindolade069362016-01-25 21:32:04 +0000799 }
Rui Ueyamaa8f6fea2016-08-09 04:25:20 +0000800 if (Out<ELFT>::FiniArray) {
801 Add({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
George Rimar03e05602016-08-19 15:23:39 +0000802 Add({DT_FINI_ARRAYSZ, Out<ELFT>::FiniArray, Entry::SecSize});
Rui Ueyama7de3f372015-10-01 19:36:04 +0000803 }
804
Rui Ueyamaace4f902016-05-24 04:25:47 +0000805 if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Init))
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000806 Add({DT_INIT, B});
Rui Ueyamaace4f902016-05-24 04:25:47 +0000807 if (SymbolBody *B = Symtab<ELFT>::X->find(Config->Fini))
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000808 Add({DT_FINI, B});
Rui Ueyamac96d0dd2015-10-21 17:47:10 +0000809
George Rimard3566302016-06-20 11:55:12 +0000810 bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
811 if (HasVerNeed || Out<ELFT>::VerDef)
Peter Collingbourne21a12fc2016-04-27 20:22:31 +0000812 Add({DT_VERSYM, Out<ELFT>::VerSym});
George Rimard3566302016-06-20 11:55:12 +0000813 if (Out<ELFT>::VerDef) {
814 Add({DT_VERDEF, Out<ELFT>::VerDef});
815 Add({DT_VERDEFNUM, getVerDefNum()});
816 }
817 if (HasVerNeed) {
Peter Collingbourne21a12fc2016-04-27 20:22:31 +0000818 Add({DT_VERNEED, Out<ELFT>::VerNeed});
George Rimard3566302016-06-20 11:55:12 +0000819 Add({DT_VERNEEDNUM, Out<ELFT>::VerNeed->getNeedNum()});
Peter Collingbourne21a12fc2016-04-27 20:22:31 +0000820 }
821
Igor Kudrin304860a2015-11-12 04:39:49 +0000822 if (Config->EMachine == EM_MIPS) {
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000823 Add({DT_MIPS_RLD_VERSION, 1});
824 Add({DT_MIPS_FLAGS, RHF_NOTPOT});
Rui Ueyamacafc0f2e2016-07-14 17:40:18 +0000825 Add({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000826 Add({DT_MIPS_SYMTABNO, Out<ELFT>::DynSymTab->getNumSymbols()});
827 Add({DT_MIPS_LOCAL_GOTNO, Out<ELFT>::Got->getMipsLocalEntriesNum()});
Rafael Espindolade069362016-01-25 21:32:04 +0000828 if (const SymbolBody *B = Out<ELFT>::Got->getMipsFirstGlobalEntry())
Rui Ueyama572a6f72016-01-29 01:49:33 +0000829 Add({DT_MIPS_GOTSYM, B->DynsymIndex});
Rafael Espindolade069362016-01-25 21:32:04 +0000830 else
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000831 Add({DT_MIPS_GOTSYM, Out<ELFT>::DynSymTab->getNumSymbols()});
832 Add({DT_PLTGOT, Out<ELFT>::Got});
Igor Kudrin304860a2015-11-12 04:39:49 +0000833 if (Out<ELFT>::MipsRldMap)
Rui Ueyamaac9fb452016-01-25 23:38:34 +0000834 Add({DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap});
Igor Kudrin304860a2015-11-12 04:39:49 +0000835 }
836
Rafael Espindolade069362016-01-25 21:32:04 +0000837 // +1 for DT_NULL
Rafael Espindola04a2e342016-11-09 01:42:41 +0000838 this->Size = (Entries.size() + 1) * this->Entsize;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000839}
840
841template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000842 auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
843
Rafael Espindolade069362016-01-25 21:32:04 +0000844 for (const Entry &E : Entries) {
845 P->d_tag = E.Tag;
846 switch (E.Kind) {
847 case Entry::SecAddr:
Rafael Espindola04a2e342016-11-09 01:42:41 +0000848 P->d_un.d_ptr = E.OutSec->Addr;
Rafael Espindolade069362016-01-25 21:32:04 +0000849 break;
George Rimar03e05602016-08-19 15:23:39 +0000850 case Entry::SecSize:
Rafael Espindola04a2e342016-11-09 01:42:41 +0000851 P->d_un.d_val = E.OutSec->Size;
George Rimar03e05602016-08-19 15:23:39 +0000852 break;
Rafael Espindolade069362016-01-25 21:32:04 +0000853 case Entry::SymAddr:
Rui Ueyamab5a69702016-02-01 21:00:35 +0000854 P->d_un.d_ptr = E.Sym->template getVA<ELFT>();
Rafael Espindolade069362016-01-25 21:32:04 +0000855 break;
856 case Entry::PlainInt:
857 P->d_un.d_val = E.Val;
858 break;
859 }
Rui Ueyama8c205d52015-10-02 01:33:31 +0000860 ++P;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000861 }
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000862}
863
864template <class ELFT>
George Rimarf6bc65a2016-01-15 13:34:52 +0000865EhFrameHeader<ELFT>::EhFrameHeader()
Rui Ueyamade9777a2016-05-23 16:30:41 +0000866 : OutputSectionBase<ELFT>(".eh_frame_hdr", SHT_PROGBITS, SHF_ALLOC) {}
George Rimarf6bc65a2016-01-15 13:34:52 +0000867
Rui Ueyama95a232e2016-05-23 01:45:05 +0000868// .eh_frame_hdr contains a binary search table of pointers to FDEs.
869// Each entry of the search table consists of two values,
870// the starting PC from where FDEs covers, and the FDE's address.
871// It is sorted by PC.
George Rimarf6bc65a2016-01-15 13:34:52 +0000872template <class ELFT> void EhFrameHeader<ELFT>::writeTo(uint8_t *Buf) {
873 const endianness E = ELFT::TargetEndianness;
874
Rui Ueyamae75e9332016-05-23 03:00:33 +0000875 // Sort the FDE list by their PC and uniqueify. Usually there is only
876 // one FDE for a PC (i.e. function), but if ICF merges two functions
877 // into one, there can be more than one FDEs pointing to the address.
878 auto Less = [](const FdeData &A, const FdeData &B) { return A.Pc < B.Pc; };
879 std::stable_sort(Fdes.begin(), Fdes.end(), Less);
880 auto Eq = [](const FdeData &A, const FdeData &B) { return A.Pc == B.Pc; };
881 Fdes.erase(std::unique(Fdes.begin(), Fdes.end(), Eq), Fdes.end());
Peter Collingbournec98de132016-04-11 16:40:08 +0000882
Rui Ueyama1b2936f2016-05-23 01:31:10 +0000883 Buf[0] = 1;
884 Buf[1] = DW_EH_PE_pcrel | DW_EH_PE_sdata4;
885 Buf[2] = DW_EH_PE_udata4;
886 Buf[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
Rafael Espindola04a2e342016-11-09 01:42:41 +0000887 write32<E>(Buf + 4, Out<ELFT>::EhFrame->Addr - this->Addr - 4);
Rui Ueyamae75e9332016-05-23 03:00:33 +0000888 write32<E>(Buf + 8, Fdes.size());
George Rimarf6bc65a2016-01-15 13:34:52 +0000889 Buf += 12;
890
Rafael Espindola04a2e342016-11-09 01:42:41 +0000891 uintX_t VA = this->Addr;
Rui Ueyamae75e9332016-05-23 03:00:33 +0000892 for (FdeData &Fde : Fdes) {
893 write32<E>(Buf, Fde.Pc - VA);
894 write32<E>(Buf + 4, Fde.FdeVA - VA);
George Rimarf6bc65a2016-01-15 13:34:52 +0000895 Buf += 8;
896 }
897}
898
Rui Ueyamade9777a2016-05-23 16:30:41 +0000899template <class ELFT> void EhFrameHeader<ELFT>::finalize() {
900 // .eh_frame_hdr has a 12 bytes header followed by an array of FDEs.
Rafael Espindola04a2e342016-11-09 01:42:41 +0000901 this->Size = 12 + Out<ELFT>::EhFrame->NumFdes * 8;
Rui Ueyamade9777a2016-05-23 16:30:41 +0000902}
903
George Rimarf6bc65a2016-01-15 13:34:52 +0000904template <class ELFT>
Rui Ueyamae75e9332016-05-23 03:00:33 +0000905void EhFrameHeader<ELFT>::addFde(uint32_t Pc, uint32_t FdeVA) {
906 Fdes.push_back({Pc, FdeVA});
George Rimarf6bc65a2016-01-15 13:34:52 +0000907}
908
George Rimarf6bc65a2016-01-15 13:34:52 +0000909template <class ELFT>
George Rimar58941ee2016-02-25 08:23:37 +0000910OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t Type, uintX_t Flags)
911 : OutputSectionBase<ELFT>(Name, Type, Flags) {
912 if (Type == SHT_RELA)
Rafael Espindola04a2e342016-11-09 01:42:41 +0000913 this->Entsize = sizeof(Elf_Rela);
George Rimar58941ee2016-02-25 08:23:37 +0000914 else if (Type == SHT_REL)
Rafael Espindola04a2e342016-11-09 01:42:41 +0000915 this->Entsize = sizeof(Elf_Rel);
George Rimar58941ee2016-02-25 08:23:37 +0000916}
917
918template <class ELFT> void OutputSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000919 uint32_t Type = this->Type;
920 if (this->Flags & SHF_LINK_ORDER) {
Peter Smith580ba952016-10-21 11:25:33 +0000921 if (!Config->Relocatable) {
922 // SHF_LINK_ORDER only has meaning in relocatable objects
Rafael Espindola04a2e342016-11-09 01:42:41 +0000923 this->Flags &= ~SHF_LINK_ORDER;
Peter Smith580ba952016-10-21 11:25:33 +0000924 }
925 else if (!this->Sections.empty()) {
926 // When doing a relocatable link we must preserve the link order
927 // dependency of sections with the SHF_LINK_ORDER flag. The dependency
928 // is indicated by the sh_link field. We need to translate the
929 // InputSection sh_link to the OutputSection sh_link, all InputSections
930 // in the OutputSection have the same dependency.
931 if (auto *D = this->Sections.front()->getLinkOrderDep())
Rafael Espindola04a2e342016-11-09 01:42:41 +0000932 this->Link = D->OutSec->SectionIndex;
Peter Smith580ba952016-10-21 11:25:33 +0000933 }
934 }
George Rimar58941ee2016-02-25 08:23:37 +0000935 if (Type != SHT_RELA && Type != SHT_REL)
936 return;
Rafael Espindola04a2e342016-11-09 01:42:41 +0000937 this->Link = Out<ELFT>::SymTab->SectionIndex;
George Rimar58941ee2016-02-25 08:23:37 +0000938 // sh_info for SHT_REL[A] sections should contain the section header index of
939 // the section to which the relocation applies.
940 InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
Rafael Espindola04a2e342016-11-09 01:42:41 +0000941 this->Info = S->OutSec->SectionIndex;
George Rimar58941ee2016-02-25 08:23:37 +0000942}
Rafael Espindola35c6af32015-09-25 17:19:10 +0000943
944template <class ELFT>
Rui Ueyama40845e62015-12-26 05:51:07 +0000945void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
Rui Ueyama0b289522016-02-25 18:43:51 +0000946 assert(C->Live);
Rui Ueyama40845e62015-12-26 05:51:07 +0000947 auto *S = cast<InputSection<ELFT>>(C);
948 Sections.push_back(S);
949 S->OutSec = this;
Rui Ueyama424b4082016-06-17 01:18:46 +0000950 this->updateAlignment(S->Alignment);
Simon Atanasyan02b9c3f2016-10-05 07:49:18 +0000951 // Keep sh_entsize value of the input section to be able to perform merging
952 // later during a final linking using the generated relocatable object.
Rafael Espindola1854a8e2016-10-26 12:36:56 +0000953 if (Config->Relocatable && (S->Flags & SHF_MERGE))
Rafael Espindola04a2e342016-11-09 01:42:41 +0000954 this->Entsize = S->Entsize;
Rafael Espindola5805c4f2015-09-21 21:38:08 +0000955}
956
Rui Ueyama809d8e22016-06-23 04:33:42 +0000957// This function is called after we sort input sections
958// and scan relocations to setup sections' offsets.
959template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
Rafael Espindola04a2e342016-11-09 01:42:41 +0000960 uintX_t Off = this->Size;
Rui Ueyama809d8e22016-06-23 04:33:42 +0000961 for (InputSection<ELFT> *S : Sections) {
962 Off = alignTo(Off, S->Alignment);
963 S->OutSecOff = Off;
964 Off += S->getSize();
965 }
Rafael Espindola04a2e342016-11-09 01:42:41 +0000966 this->Size = Off;
Rui Ueyama5af83682016-02-11 23:41:38 +0000967}
968
Rui Ueyamac4185702016-02-10 23:20:42 +0000969// Sorts input sections by section name suffixes, so that .foo.N comes
970// before .foo.M if N < M. Used to sort .{init,fini}_array.N sections.
Rui Ueyama5af83682016-02-11 23:41:38 +0000971// We want to keep the original order if the priorities are the same
972// because the compiler keeps the original initialization order in a
973// translation unit and we need to respect that.
Rui Ueyamac4185702016-02-10 23:20:42 +0000974// For more detail, read the section of the GCC's manual about init_priority.
Rui Ueyama5af83682016-02-11 23:41:38 +0000975template <class ELFT> void OutputSection<ELFT>::sortInitFini() {
Rui Ueyamac4185702016-02-10 23:20:42 +0000976 // Sort sections by priority.
977 typedef std::pair<int, InputSection<ELFT> *> Pair;
Rui Ueyama704da022016-02-10 23:43:16 +0000978 auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; };
979
Rui Ueyamac4185702016-02-10 23:20:42 +0000980 std::vector<Pair> V;
981 for (InputSection<ELFT> *S : Sections)
Rafael Espindola042a3f22016-09-08 14:06:08 +0000982 V.push_back({getPriority(S->Name), S});
Rui Ueyama704da022016-02-10 23:43:16 +0000983 std::stable_sort(V.begin(), V.end(), Comp);
Rui Ueyamac4185702016-02-10 23:20:42 +0000984 Sections.clear();
985 for (Pair &P : V)
986 Sections.push_back(P.second);
Rui Ueyama5af83682016-02-11 23:41:38 +0000987}
Rui Ueyamac4185702016-02-10 23:20:42 +0000988
Rui Ueyama5af83682016-02-11 23:41:38 +0000989// Returns true if S matches /Filename.?\.o$/.
990static bool isCrtBeginEnd(StringRef S, StringRef Filename) {
991 if (!S.endswith(".o"))
992 return false;
993 S = S.drop_back(2);
994 if (S.endswith(Filename))
995 return true;
996 return !S.empty() && S.drop_back().endswith(Filename);
997}
998
999static bool isCrtbegin(StringRef S) { return isCrtBeginEnd(S, "crtbegin"); }
1000static bool isCrtend(StringRef S) { return isCrtBeginEnd(S, "crtend"); }
1001
1002// .ctors and .dtors are sorted by this priority from highest to lowest.
1003//
1004// 1. The section was contained in crtbegin (crtbegin contains
1005// some sentinel value in its .ctors and .dtors so that the runtime
1006// can find the beginning of the sections.)
1007//
1008// 2. The section has an optional priority value in the form of ".ctors.N"
1009// or ".dtors.N" where N is a number. Unlike .{init,fini}_array,
1010// they are compared as string rather than number.
1011//
1012// 3. The section is just ".ctors" or ".dtors".
1013//
1014// 4. The section was contained in crtend, which contains an end marker.
1015//
1016// In an ideal world, we don't need this function because .init_array and
1017// .ctors are duplicate features (and .init_array is newer.) However, there
1018// are too many real-world use cases of .ctors, so we had no choice to
1019// support that with this rather ad-hoc semantics.
1020template <class ELFT>
1021static bool compCtors(const InputSection<ELFT> *A,
1022 const InputSection<ELFT> *B) {
1023 bool BeginA = isCrtbegin(A->getFile()->getName());
1024 bool BeginB = isCrtbegin(B->getFile()->getName());
1025 if (BeginA != BeginB)
1026 return BeginA;
1027 bool EndA = isCrtend(A->getFile()->getName());
1028 bool EndB = isCrtend(B->getFile()->getName());
1029 if (EndA != EndB)
1030 return EndB;
Rafael Espindola042a3f22016-09-08 14:06:08 +00001031 StringRef X = A->Name;
1032 StringRef Y = B->Name;
Rui Ueyama5af83682016-02-11 23:41:38 +00001033 assert(X.startswith(".ctors") || X.startswith(".dtors"));
1034 assert(Y.startswith(".ctors") || Y.startswith(".dtors"));
1035 X = X.substr(6);
1036 Y = Y.substr(6);
Rui Ueyama24b794e2016-02-12 00:38:46 +00001037 if (X.empty() && Y.empty())
1038 return false;
Rui Ueyama5af83682016-02-11 23:41:38 +00001039 return X < Y;
1040}
1041
1042// Sorts input sections by the special rules for .ctors and .dtors.
1043// Unfortunately, the rules are different from the one for .{init,fini}_array.
1044// Read the comment above.
1045template <class ELFT> void OutputSection<ELFT>::sortCtorsDtors() {
1046 std::stable_sort(Sections.begin(), Sections.end(), compCtors<ELFT>);
Rui Ueyamac4185702016-02-10 23:20:42 +00001047}
1048
George Rimare2ee72b2016-02-26 14:48:31 +00001049static void fill(uint8_t *Buf, size_t Size, ArrayRef<uint8_t> A) {
1050 size_t I = 0;
1051 for (; I + A.size() < Size; I += A.size())
1052 memcpy(Buf + I, A.data(), A.size());
1053 memcpy(Buf + I, A.data(), Size - I);
1054}
1055
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001056template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
Rui Ueyama07320e42016-04-20 20:13:41 +00001057 ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
George Rimare2ee72b2016-02-26 14:48:31 +00001058 if (!Filler.empty())
Rafael Espindola04a2e342016-11-09 01:42:41 +00001059 fill(Buf, this->Size, Filler);
Rui Ueyamaeb943e82016-11-04 18:22:36 +00001060 if (Config->Threads) {
1061 parallel_for_each(Sections.begin(), Sections.end(),
1062 [=](InputSection<ELFT> *C) { C->writeTo(Buf); });
1063 } else {
1064 for (InputSection<ELFT> *C : Sections)
1065 C->writeTo(Buf);
1066 }
George Rimare38cbab2016-09-26 19:22:50 +00001067 // Linker scripts may have BYTE()-family commands with which you
1068 // can write arbitrary bytes to the output. Process them if any.
1069 Script<ELFT>::X->writeDataBytes(this->Name, Buf);
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001070}
1071
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +00001072template <class ELFT>
Rui Ueyamaf86cb902016-05-23 15:12:41 +00001073EhOutputSection<ELFT>::EhOutputSection()
Rui Ueyama3b31e672016-05-23 16:24:16 +00001074 : OutputSectionBase<ELFT>(".eh_frame", SHT_PROGBITS, SHF_ALLOC) {}
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001075
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001076// Search for an existing CIE record or create a new one.
1077// CIE records from input object files are uniquified by their contents
1078// and where their relocations point to.
1079template <class ELFT>
1080template <class RelTy>
Rafael Espindola2deeb602016-07-21 20:18:30 +00001081CieRecord *EhOutputSection<ELFT>::addCie(EhSectionPiece &Piece,
Rui Ueyama0b9a9032016-05-24 04:19:20 +00001082 EhInputSection<ELFT> *Sec,
Rafael Espindola2deeb602016-07-21 20:18:30 +00001083 ArrayRef<RelTy> Rels) {
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001084 const endianness E = ELFT::TargetEndianness;
Rui Ueyamad8849272016-05-25 16:37:01 +00001085 if (read32<E>(Piece.data().data() + 4) != 0)
Rafael Espindola042a3f22016-09-08 14:06:08 +00001086 fatal("CIE expected at beginning of .eh_frame: " + Sec->Name);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001087
1088 SymbolBody *Personality = nullptr;
Rafael Espindola2deeb602016-07-21 20:18:30 +00001089 unsigned FirstRelI = Piece.FirstRelocation;
1090 if (FirstRelI != (unsigned)-1)
1091 Personality = &Sec->getFile()->getRelocTargetSym(Rels[FirstRelI]);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001092
1093 // Search for an existing CIE by CIE contents/relocation target pair.
Rui Ueyamad8849272016-05-25 16:37:01 +00001094 CieRecord *Cie = &CieMap[{Piece.data(), Personality}];
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001095
1096 // If not found, create a new one.
Rui Ueyamae2060aa2016-05-22 23:52:56 +00001097 if (Cie->Piece == nullptr) {
1098 Cie->Piece = &Piece;
Rui Ueyamae2060aa2016-05-22 23:52:56 +00001099 Cies.push_back(Cie);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001100 }
1101 return Cie;
1102}
1103
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001104// There is one FDE per function. Returns true if a given FDE
1105// points to a live function.
1106template <class ELFT>
1107template <class RelTy>
Rafael Espindola2deeb602016-07-21 20:18:30 +00001108bool EhOutputSection<ELFT>::isFdeLive(EhSectionPiece &Piece,
Rui Ueyama0b9a9032016-05-24 04:19:20 +00001109 EhInputSection<ELFT> *Sec,
Rafael Espindola2deeb602016-07-21 20:18:30 +00001110 ArrayRef<RelTy> Rels) {
1111 unsigned FirstRelI = Piece.FirstRelocation;
1112 if (FirstRelI == (unsigned)-1)
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001113 fatal("FDE doesn't reference another section");
Rafael Espindola2deeb602016-07-21 20:18:30 +00001114 const RelTy &Rel = Rels[FirstRelI];
1115 SymbolBody &B = Sec->getFile()->getRelocTargetSym(Rel);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001116 auto *D = dyn_cast<DefinedRegular<ELFT>>(&B);
1117 if (!D || !D->Section)
1118 return false;
1119 InputSectionBase<ELFT> *Target = D->Section->Repl;
1120 return Target && Target->Live;
1121}
1122
1123// .eh_frame is a sequence of CIE or FDE records. In general, there
1124// is one CIE record per input object file which is followed by
1125// a list of FDEs. This function searches an existing CIE or create a new
1126// one and associates FDEs to the CIE.
Rui Ueyamac0c92602016-02-05 22:56:03 +00001127template <class ELFT>
Rui Ueyamafc467e72016-03-13 05:06:50 +00001128template <class RelTy>
Rui Ueyama0b9a9032016-05-24 04:19:20 +00001129void EhOutputSection<ELFT>::addSectionAux(EhInputSection<ELFT> *Sec,
Rafael Espindola0f7ccc32016-04-05 14:47:28 +00001130 ArrayRef<RelTy> Rels) {
Rafael Espindola1f5696f2016-05-24 16:03:27 +00001131 const endianness E = ELFT::TargetEndianness;
Rafael Espindola820f4bb2016-05-24 15:17:47 +00001132
Rafael Espindola1f5696f2016-05-24 16:03:27 +00001133 DenseMap<size_t, CieRecord *> OffsetToCie;
Rafael Espindola2deeb602016-07-21 20:18:30 +00001134 for (EhSectionPiece &Piece : Sec->Pieces) {
Rafael Espindola1f5696f2016-05-24 16:03:27 +00001135 // The empty record is the end marker.
Rui Ueyamad8849272016-05-25 16:37:01 +00001136 if (Piece.size() == 4)
Rafael Espindola5ee9e7f2016-05-24 19:14:09 +00001137 return;
Rafael Espindola1f5696f2016-05-24 16:03:27 +00001138
1139 size_t Offset = Piece.InputOff;
Rui Ueyamad8849272016-05-25 16:37:01 +00001140 uint32_t ID = read32<E>(Piece.data().data() + 4);
Rafael Espindola1f5696f2016-05-24 16:03:27 +00001141 if (ID == 0) {
1142 OffsetToCie[Offset] = addCie(Piece, Sec, Rels);
1143 continue;
1144 }
1145
1146 uint32_t CieOffset = Offset + 4 - ID;
1147 CieRecord *Cie = OffsetToCie[CieOffset];
1148 if (!Cie)
1149 fatal("invalid CIE reference");
1150
1151 if (!isFdeLive(Piece, Sec, Rels))
1152 continue;
1153 Cie->FdePieces.push_back(&Piece);
Rui Ueyamade9777a2016-05-23 16:30:41 +00001154 NumFdes++;
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001155 }
1156}
1157
1158template <class ELFT>
Rui Ueyama1e479c22016-05-23 15:07:59 +00001159void EhOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
Rui Ueyama0b9a9032016-05-24 04:19:20 +00001160 auto *Sec = cast<EhInputSection<ELFT>>(C);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001161 Sec->OutSec = this;
Rui Ueyama424b4082016-06-17 01:18:46 +00001162 this->updateAlignment(Sec->Alignment);
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001163 Sections.push_back(Sec);
1164
1165 // .eh_frame is a sequence of CIE or FDE records. This function
1166 // splits it into pieces so that we can call
1167 // SplitInputSection::getSectionPiece on the section.
Rui Ueyama88abd9b2016-05-22 23:53:00 +00001168 Sec->split();
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001169 if (Sec->Pieces.empty())
1170 return;
1171
1172 if (const Elf_Shdr *RelSec = Sec->RelocSection) {
Rafael Espindolae19abab2016-11-03 20:44:50 +00001173 ELFFile<ELFT> Obj = Sec->getFile()->getObj();
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001174 if (RelSec->sh_type == SHT_RELA)
Rafael Espindola454fe152016-11-03 19:07:44 +00001175 addSectionAux(Sec, check(Obj.relas(RelSec)));
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001176 else
Rafael Espindola454fe152016-11-03 19:07:44 +00001177 addSectionAux(Sec, check(Obj.rels(RelSec)));
Rui Ueyama0de86c12016-01-27 22:23:44 +00001178 return;
1179 }
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001180 addSectionAux(Sec, makeArrayRef<Elf_Rela>(nullptr, nullptr));
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001181}
1182
Rafael Espindola91bd48a2015-12-24 20:44:06 +00001183template <class ELFT>
Rui Ueyama644ac652016-05-22 00:17:11 +00001184static void writeCieFde(uint8_t *Buf, ArrayRef<uint8_t> D) {
1185 memcpy(Buf, D.data(), D.size());
Rui Ueyamac0449a62016-05-21 18:10:13 +00001186
1187 // Fix the size field. -4 since size does not include the size field itself.
Rafael Espindola91bd48a2015-12-24 20:44:06 +00001188 const endianness E = ELFT::TargetEndianness;
Rui Ueyama644ac652016-05-22 00:17:11 +00001189 write32<E>(Buf, alignTo(D.size(), sizeof(typename ELFT::uint)) - 4);
Rafael Espindola56004c52016-04-07 14:22:09 +00001190}
1191
Rui Ueyama1e479c22016-05-23 15:07:59 +00001192template <class ELFT> void EhOutputSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001193 if (this->Size)
Rui Ueyamae9381bd2016-07-16 02:47:42 +00001194 return; // Already finalized.
Rafael Espindola56004c52016-04-07 14:22:09 +00001195
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001196 size_t Off = 0;
1197 for (CieRecord *Cie : Cies) {
1198 Cie->Piece->OutputOff = Off;
1199 Off += alignTo(Cie->Piece->size(), sizeof(uintX_t));
Rafael Espindola56004c52016-04-07 14:22:09 +00001200
Rafael Espindola113860b2016-10-20 10:55:58 +00001201 for (EhSectionPiece *Fde : Cie->FdePieces) {
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001202 Fde->OutputOff = Off;
1203 Off += alignTo(Fde->size(), sizeof(uintX_t));
Rafael Espindola56004c52016-04-07 14:22:09 +00001204 }
1205 }
Rafael Espindola04a2e342016-11-09 01:42:41 +00001206 this->Size = Off;
Rafael Espindola91bd48a2015-12-24 20:44:06 +00001207}
1208
Rui Ueyamae75e9332016-05-23 03:00:33 +00001209template <class ELFT> static uint64_t readFdeAddr(uint8_t *Buf, int Size) {
1210 const endianness E = ELFT::TargetEndianness;
1211 switch (Size) {
1212 case DW_EH_PE_udata2:
1213 return read16<E>(Buf);
1214 case DW_EH_PE_udata4:
1215 return read32<E>(Buf);
1216 case DW_EH_PE_udata8:
1217 return read64<E>(Buf);
1218 case DW_EH_PE_absptr:
1219 if (ELFT::Is64Bits)
1220 return read64<E>(Buf);
1221 return read32<E>(Buf);
1222 }
1223 fatal("unknown FDE size encoding");
1224}
1225
1226// Returns the VA to which a given FDE (on a mmap'ed buffer) is applied to.
1227// We need it to create .eh_frame_hdr section.
1228template <class ELFT>
Rui Ueyama1e479c22016-05-23 15:07:59 +00001229typename ELFT::uint EhOutputSection<ELFT>::getFdePc(uint8_t *Buf, size_t FdeOff,
Rui Ueyamae75e9332016-05-23 03:00:33 +00001230 uint8_t Enc) {
Rui Ueyama2ab3d202016-05-23 16:36:47 +00001231 // The starting address to which this FDE applies is
Rui Ueyamae75e9332016-05-23 03:00:33 +00001232 // stored at FDE + 8 byte.
1233 size_t Off = FdeOff + 8;
1234 uint64_t Addr = readFdeAddr<ELFT>(Buf + Off, Enc & 0x7);
1235 if ((Enc & 0x70) == DW_EH_PE_absptr)
1236 return Addr;
1237 if ((Enc & 0x70) == DW_EH_PE_pcrel)
Rafael Espindola04a2e342016-11-09 01:42:41 +00001238 return Addr + this->Addr + Off;
Rui Ueyamae75e9332016-05-23 03:00:33 +00001239 fatal("unknown FDE size relative encoding");
1240}
1241
Rui Ueyama1e479c22016-05-23 15:07:59 +00001242template <class ELFT> void EhOutputSection<ELFT>::writeTo(uint8_t *Buf) {
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001243 const endianness E = ELFT::TargetEndianness;
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001244 for (CieRecord *Cie : Cies) {
1245 size_t CieOffset = Cie->Piece->OutputOff;
Rui Ueyamad8849272016-05-25 16:37:01 +00001246 writeCieFde<ELFT>(Buf + CieOffset, Cie->Piece->data());
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001247
Rafael Espindola32aca872016-10-05 18:40:00 +00001248 for (EhSectionPiece *Fde : Cie->FdePieces) {
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001249 size_t Off = Fde->OutputOff;
Rui Ueyamad8849272016-05-25 16:37:01 +00001250 writeCieFde<ELFT>(Buf + Off, Fde->data());
Rafael Espindola56004c52016-04-07 14:22:09 +00001251
Rui Ueyamaf8b285c2016-05-22 23:16:14 +00001252 // FDE's second word should have the offset to an associated CIE.
1253 // Write it.
1254 write32<E>(Buf + Off + 4, Off + 4 - CieOffset);
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001255 }
1256 }
1257
Rui Ueyama0b9a9032016-05-24 04:19:20 +00001258 for (EhInputSection<ELFT> *S : Sections)
Rafael Espindola22ef9562016-04-13 01:40:19 +00001259 S->relocate(Buf, nullptr);
Rui Ueyamae75e9332016-05-23 03:00:33 +00001260
1261 // Construct .eh_frame_hdr. .eh_frame_hdr is a binary search table
Rui Ueyama2ab3d202016-05-23 16:36:47 +00001262 // to get a FDE from an address to which FDE is applied. So here
Rui Ueyamae75e9332016-05-23 03:00:33 +00001263 // we obtain two addresses and pass them to EhFrameHdr object.
Rui Ueyama3b31e672016-05-23 16:24:16 +00001264 if (Out<ELFT>::EhFrameHdr) {
1265 for (CieRecord *Cie : Cies) {
Rui Ueyamad8849272016-05-25 16:37:01 +00001266 uint8_t Enc = getFdeEncoding<ELFT>(Cie->Piece->data());
Rui Ueyama3b31e672016-05-23 16:24:16 +00001267 for (SectionPiece *Fde : Cie->FdePieces) {
Rui Ueyama6de2e682016-05-24 02:08:38 +00001268 uintX_t Pc = getFdePc(Buf, Fde->OutputOff, Enc);
Rafael Espindola04a2e342016-11-09 01:42:41 +00001269 uintX_t FdeVA = this->Addr + Fde->OutputOff;
Rui Ueyama3b31e672016-05-23 16:24:16 +00001270 Out<ELFT>::EhFrameHdr->addFde(Pc, FdeVA);
1271 }
Rui Ueyamae75e9332016-05-23 03:00:33 +00001272 }
1273 }
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001274}
1275
1276template <class ELFT>
Rui Ueyamad97e5c42016-01-07 18:33:11 +00001277MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t Type,
Rafael Espindola7efa5be2016-02-19 14:17:40 +00001278 uintX_t Flags, uintX_t Alignment)
1279 : OutputSectionBase<ELFT>(Name, Type, Flags),
Rui Ueyama818bb2f2016-07-16 18:55:47 +00001280 Builder(StringTableBuilder::RAW, Alignment) {}
Rafael Espindolac159c962015-10-19 21:00:02 +00001281
1282template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
Rafael Espindola259d6452016-10-04 22:43:38 +00001283 Builder.write(Buf);
Rafael Espindolaf82ed2a2015-10-24 22:51:01 +00001284}
1285
Rafael Espindolac159c962015-10-19 21:00:02 +00001286template <class ELFT>
Rui Ueyama40845e62015-12-26 05:51:07 +00001287void MergeOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
Rui Ueyama10803512016-05-22 00:25:30 +00001288 auto *Sec = cast<MergeInputSection<ELFT>>(C);
1289 Sec->OutSec = this;
Rui Ueyama424b4082016-06-17 01:18:46 +00001290 this->updateAlignment(Sec->Alignment);
Rafael Espindola04a2e342016-11-09 01:42:41 +00001291 this->Entsize = Sec->Entsize;
Rui Ueyama406b4692016-05-27 14:39:13 +00001292 Sections.push_back(Sec);
Rafael Espindolac159c962015-10-19 21:00:02 +00001293
Rafael Espindola113860b2016-10-20 10:55:58 +00001294 auto HashI = Sec->Hashes.begin();
1295 for (auto I = Sec->Pieces.begin(), E = Sec->Pieces.end(); I != E; ++I) {
1296 SectionPiece &Piece = *I;
1297 uint32_t Hash = *HashI;
1298 ++HashI;
Rui Ueyama3ea87272016-05-22 00:13:04 +00001299 if (!Piece.Live)
Rafael Espindola0b9531c2016-04-22 22:09:35 +00001300 continue;
Rafael Espindola113860b2016-10-20 10:55:58 +00001301 StringRef Data = toStringRef(Sec->getData(I));
1302 CachedHashStringRef V(Data, Hash);
Rafael Espindola5fc2b1d2016-10-05 19:36:02 +00001303 uintX_t OutputOffset = Builder.add(V);
Rafael Espindola7b8bb532016-10-05 15:35:18 +00001304 if (!shouldTailMerge())
Rui Ueyamac6ebb022016-05-22 01:03:41 +00001305 Piece.OutputOff = OutputOffset;
Rafael Espindolac159c962015-10-19 21:00:02 +00001306 }
Rafael Espindolac159c962015-10-19 21:00:02 +00001307}
1308
1309template <class ELFT>
Justin Lebaree34a732016-10-17 22:24:36 +00001310unsigned MergeOutputSection<ELFT>::getOffset(CachedHashStringRef Val) {
Rafael Espindolaf82ed2a2015-10-24 22:51:01 +00001311 return Builder.getOffset(Val);
1312}
1313
1314template <class ELFT> bool MergeOutputSection<ELFT>::shouldTailMerge() const {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001315 return Config->Optimize >= 2 && this->Flags & SHF_STRINGS;
Rafael Espindolaf82ed2a2015-10-24 22:51:01 +00001316}
1317
1318template <class ELFT> void MergeOutputSection<ELFT>::finalize() {
1319 if (shouldTailMerge())
1320 Builder.finalize();
Rafael Espindola259d6452016-10-04 22:43:38 +00001321 else
1322 Builder.finalizeInOrder();
Rafael Espindola04a2e342016-11-09 01:42:41 +00001323 this->Size = Builder.getSize();
Rafael Espindolac159c962015-10-19 21:00:02 +00001324}
1325
Rui Ueyama406b4692016-05-27 14:39:13 +00001326template <class ELFT> void MergeOutputSection<ELFT>::finalizePieces() {
1327 for (MergeInputSection<ELFT> *Sec : Sections)
1328 Sec->finalizePieces();
1329}
1330
Rafael Espindolac159c962015-10-19 21:00:02 +00001331template <class ELFT>
George Rimar0f5ac9f2015-10-20 17:21:35 +00001332StringTableSection<ELFT>::StringTableSection(StringRef Name, bool Dynamic)
Rui Ueyama6ffb42a2016-01-07 20:53:30 +00001333 : OutputSectionBase<ELFT>(Name, SHT_STRTAB,
1334 Dynamic ? (uintX_t)SHF_ALLOC : 0),
Rafael Espindola08113852016-11-08 20:25:44 +00001335 Dynamic(Dynamic) {
1336 // ELF string tables start with a NUL byte, so 1.
Rafael Espindola04a2e342016-11-09 01:42:41 +00001337 this->Size = 1;
Rafael Espindola08113852016-11-08 20:25:44 +00001338}
Rafael Espindola35c6af32015-09-25 17:19:10 +00001339
Rafael Espindolae2c24612016-01-29 01:24:25 +00001340// Adds a string to the string table. If HashIt is true we hash and check for
1341// duplicates. It is optional because the name of global symbols are already
1342// uniqued and hashing them again has a big cost for a small value: uniquing
1343// them with some other string that happens to be the same.
1344template <class ELFT>
1345unsigned StringTableSection<ELFT>::addString(StringRef S, bool HashIt) {
1346 if (HashIt) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001347 auto R = StringMap.insert(std::make_pair(S, this->Size));
Rafael Espindolae2c24612016-01-29 01:24:25 +00001348 if (!R.second)
1349 return R.first->second;
1350 }
Rafael Espindola04a2e342016-11-09 01:42:41 +00001351 unsigned Ret = this->Size;
1352 this->Size = this->Size + S.size() + 1;
Rui Ueyama76c00632016-01-07 02:35:32 +00001353 Strings.push_back(S);
Rafael Espindolae2c24612016-01-29 01:24:25 +00001354 return Ret;
Rui Ueyama76c00632016-01-07 02:35:32 +00001355}
1356
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +00001357template <class ELFT> void StringTableSection<ELFT>::writeTo(uint8_t *Buf) {
Rui Ueyama76c00632016-01-07 02:35:32 +00001358 // ELF string tables start with NUL byte, so advance the pointer by one.
1359 ++Buf;
1360 for (StringRef S : Strings) {
1361 memcpy(Buf, S.data(), S.size());
1362 Buf += S.size() + 1;
1363 }
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001364}
1365
Rafael Espindolad1cf4212015-10-05 16:25:43 +00001366template <class ELFT>
Rui Ueyama809d8e22016-06-23 04:33:42 +00001367typename ELFT::uint DynamicReloc<ELFT>::getOffset() const {
1368 if (OutputSec)
Rafael Espindola04a2e342016-11-09 01:42:41 +00001369 return OutputSec->Addr + OffsetInSec;
1370 return InputSec->OutSec->Addr + InputSec->getOffset(OffsetInSec);
Rui Ueyama809d8e22016-06-23 04:33:42 +00001371}
1372
1373template <class ELFT>
1374typename ELFT::uint DynamicReloc<ELFT>::getAddend() const {
1375 if (UseSymVA)
1376 return Sym->getVA<ELFT>(Addend);
1377 return Addend;
1378}
1379
1380template <class ELFT> uint32_t DynamicReloc<ELFT>::getSymIndex() const {
1381 if (Sym && !UseSymVA)
1382 return Sym->DynsymIndex;
1383 return 0;
1384}
1385
1386template <class ELFT>
Rafael Espindola35c6af32015-09-25 17:19:10 +00001387SymbolTableSection<ELFT>::SymbolTableSection(
Rui Ueyamaace4f902016-05-24 04:25:47 +00001388 StringTableSection<ELFT> &StrTabSec)
Rui Ueyamacf07a312016-01-06 22:53:58 +00001389 : OutputSectionBase<ELFT>(StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
1390 StrTabSec.isDynamic() ? SHT_DYNSYM : SHT_SYMTAB,
Rui Ueyama6ffb42a2016-01-07 20:53:30 +00001391 StrTabSec.isDynamic() ? (uintX_t)SHF_ALLOC : 0),
Rui Ueyamaace4f902016-05-24 04:25:47 +00001392 StrTabSec(StrTabSec) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001393 this->Entsize = sizeof(Elf_Sym);
1394 this->Addralign = sizeof(uintX_t);
Rafael Espindola35c6af32015-09-25 17:19:10 +00001395}
1396
Igor Kudrinf4cdfe882015-11-12 04:08:12 +00001397// Orders symbols according to their positions in the GOT,
1398// in compliance with MIPS ABI rules.
1399// See "Global Offset Table" in Chapter 5 in the following document
1400// for detailed description:
1401// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001402static bool sortMipsSymbols(const SymbolBody *L, const SymbolBody *R) {
Simon Atanasyand2980d32016-03-29 14:07:22 +00001403 // Sort entries related to non-local preemptible symbols by GOT indexes.
1404 // All other entries go to the first part of GOT in arbitrary order.
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001405 bool LIsInLocalGot = !L->IsInGlobalMipsGot;
1406 bool RIsInLocalGot = !R->IsInGlobalMipsGot;
Simon Atanasyan7b8481b2016-06-20 11:37:56 +00001407 if (LIsInLocalGot || RIsInLocalGot)
1408 return !RIsInLocalGot;
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001409 return L->GotIndex < R->GotIndex;
Igor Kudrinf4cdfe882015-11-12 04:08:12 +00001410}
1411
Rafael Espindolabadd3972016-04-08 15:30:56 +00001412static uint8_t getSymbolBinding(SymbolBody *Body) {
Peter Collingbourne4f952702016-05-01 04:55:03 +00001413 Symbol *S = Body->symbol();
George Rimar11f83b72016-08-19 08:31:02 +00001414 if (Config->Relocatable)
1415 return S->Binding;
Rafael Espindola9e32e4f2016-04-26 13:50:46 +00001416 uint8_t Visibility = S->Visibility;
Rafael Espindolabadd3972016-04-08 15:30:56 +00001417 if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
1418 return STB_LOCAL;
Rafael Espindola9e32e4f2016-04-26 13:50:46 +00001419 if (Config->NoGnuUnique && S->Binding == STB_GNU_UNIQUE)
Rafael Espindolabadd3972016-04-08 15:30:56 +00001420 return STB_GLOBAL;
Rafael Espindola9e32e4f2016-04-26 13:50:46 +00001421 return S->Binding;
Rafael Espindolabadd3972016-04-08 15:30:56 +00001422}
1423
Rui Ueyama0db335f2015-10-07 16:58:54 +00001424template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001425 if (this->Size)
Igor Kudrin2169b1b2015-11-02 10:46:14 +00001426 return; // Already finalized.
1427
Rafael Espindola04a2e342016-11-09 01:42:41 +00001428 this->Size = getNumSymbols() * sizeof(Elf_Sym);
1429 this->Link = StrTabSec.SectionIndex;
1430 this->Info = NumLocals + 1;
Igor Kudrinab665fc2015-10-20 21:47:58 +00001431
George Rimar58941ee2016-02-25 08:23:37 +00001432 if (Config->Relocatable) {
1433 size_t I = NumLocals;
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001434 for (const SymbolTableEntry &S : Symbols)
1435 S.Symbol->DynsymIndex = ++I;
George Rimar58941ee2016-02-25 08:23:37 +00001436 return;
1437 }
1438
Igor Kudrinab665fc2015-10-20 21:47:58 +00001439 if (!StrTabSec.isDynamic()) {
1440 std::stable_sort(Symbols.begin(), Symbols.end(),
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001441 [](const SymbolTableEntry &L, const SymbolTableEntry &R) {
1442 return getSymbolBinding(L.Symbol) == STB_LOCAL &&
1443 getSymbolBinding(R.Symbol) != STB_LOCAL;
Igor Kudrinab665fc2015-10-20 21:47:58 +00001444 });
1445 return;
1446 }
Igor Kudrinf1d60292015-10-28 07:05:56 +00001447 if (Out<ELFT>::GnuHashTab)
1448 // NB: It also sorts Symbols to meet the GNU hash table requirements.
1449 Out<ELFT>::GnuHashTab->addSymbols(Symbols);
Igor Kudrinf4cdfe882015-11-12 04:08:12 +00001450 else if (Config->EMachine == EM_MIPS)
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001451 std::stable_sort(Symbols.begin(), Symbols.end(),
1452 [](const SymbolTableEntry &L, const SymbolTableEntry &R) {
1453 return sortMipsSymbols(L.Symbol, R.Symbol);
1454 });
Igor Kudrinab665fc2015-10-20 21:47:58 +00001455 size_t I = 0;
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001456 for (const SymbolTableEntry &S : Symbols)
1457 S.Symbol->DynsymIndex = ++I;
Igor Kudrinab665fc2015-10-20 21:47:58 +00001458}
1459
George Rimara4c7e742016-10-20 08:36:42 +00001460template <class ELFT> void SymbolTableSection<ELFT>::addSymbol(SymbolBody *B) {
Rui Ueyamac2e863a2016-02-17 05:06:40 +00001461 Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
Rui Ueyama0db335f2015-10-07 16:58:54 +00001462}
1463
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001464template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001465 Buf += sizeof(Elf_Sym);
1466
1467 // All symbols with STB_LOCAL binding precede the weak and global symbols.
1468 // .dynsym only contains global symbols.
George Rimar9503f6d2016-08-31 08:46:30 +00001469 if (Config->Discard != DiscardPolicy::All && !StrTabSec.isDynamic())
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001470 writeLocalSymbols(Buf);
1471
1472 writeGlobalSymbols(Buf);
1473}
1474
1475template <class ELFT>
1476void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
1477 // Iterate over all input object files to copy their local symbols
1478 // to the output symbol table pointed by Buf.
Rui Ueyama38dbd3e2016-09-14 00:05:51 +00001479 for (ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
Rafael Espindolaccfe3cb2016-04-04 14:04:16 +00001480 for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
1481 File->KeptLocalSyms) {
1482 const DefinedRegular<ELFT> &Body = *P.first;
1483 InputSectionBase<ELFT> *Section = Body.Section;
Rui Ueyamac55733e2015-09-30 00:54:29 +00001484 auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
Rafael Espindolaccfe3cb2016-04-04 14:04:16 +00001485
1486 if (!Section) {
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001487 ESym->st_shndx = SHN_ABS;
Rafael Espindolaccfe3cb2016-04-04 14:04:16 +00001488 ESym->st_value = Body.Value;
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001489 } else {
Rafael Espindolac159c962015-10-19 21:00:02 +00001490 const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
1491 ESym->st_shndx = OutSec->SectionIndex;
Rafael Espindola04a2e342016-11-09 01:42:41 +00001492 ESym->st_value = OutSec->Addr + Section->getOffset(Body);
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001493 }
Rafael Espindolae2c24612016-01-29 01:24:25 +00001494 ESym->st_name = P.second;
Rafael Espindolaccfe3cb2016-04-04 14:04:16 +00001495 ESym->st_size = Body.template getSize<ELFT>();
Rafael Espindola9e32e4f2016-04-26 13:50:46 +00001496 ESym->setBindingAndType(STB_LOCAL, Body.Type);
Rui Ueyamac4aaed92015-10-22 18:49:53 +00001497 Buf += sizeof(*ESym);
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001498 }
1499 }
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001500}
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001501
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001502template <class ELFT>
Igor Kudrinea6a8352015-10-19 08:01:51 +00001503void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
Rui Ueyama8ddfa812015-09-30 00:32:10 +00001504 // Write the internal symbol table contents to the output symbol table
1505 // pointed by Buf.
Igor Kudrinab665fc2015-10-20 21:47:58 +00001506 auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001507 for (const SymbolTableEntry &S : Symbols) {
1508 SymbolBody *Body = S.Symbol;
1509 size_t StrOff = S.StrTabOffset;
Rui Ueyamac4aaed92015-10-22 18:49:53 +00001510
Rafael Espindolaccfe3cb2016-04-04 14:04:16 +00001511 uint8_t Type = Body->Type;
1512 uintX_t Size = Body->getSize<ELFT>();
Rafael Espindola8614c562015-10-06 14:33:58 +00001513
Igor Kudrin853b88d2015-10-20 20:52:14 +00001514 ESym->setBindingAndType(getSymbolBinding(Body), Type);
Rafael Espindola8614c562015-10-06 14:33:58 +00001515 ESym->st_size = Size;
Rui Ueyamac2e863a2016-02-17 05:06:40 +00001516 ESym->st_name = StrOff;
Peter Collingbourne4f952702016-05-01 04:55:03 +00001517 ESym->setVisibility(Body->symbol()->Visibility);
Rui Ueyamab5a69702016-02-01 21:00:35 +00001518 ESym->st_value = Body->getVA<ELFT>();
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001519
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001520 if (const OutputSectionBase<ELFT> *OutSec = getOutputSection(Body))
Rui Ueyama2317d0d2015-10-15 20:55:22 +00001521 ESym->st_shndx = OutSec->SectionIndex;
Rafael Espindola02ce26a2015-12-24 14:22:24 +00001522 else if (isa<DefinedRegular<ELFT>>(Body))
1523 ESym->st_shndx = SHN_ABS;
Simon Atanasyand040a582016-02-25 16:19:15 +00001524
Simon Atanasyanf967f092016-09-29 12:58:36 +00001525 if (Config->EMachine == EM_MIPS) {
1526 // On MIPS we need to mark symbol which has a PLT entry and requires
1527 // pointer equality by STO_MIPS_PLT flag. That is necessary to help
1528 // dynamic linker distinguish such symbols and MIPS lazy-binding stubs.
1529 // https://sourceware.org/ml/binutils/2008-07/txt00000.txt
1530 if (Body->isInPlt() && Body->NeedsCopyOrPltAddr)
1531 ESym->st_other |= STO_MIPS_PLT;
1532 if (Config->Relocatable) {
1533 auto *D = dyn_cast<DefinedRegular<ELFT>>(Body);
1534 if (D && D->isMipsPIC())
1535 ESym->st_other |= STO_MIPS_PIC;
1536 }
1537 }
Igor Kudrinab665fc2015-10-20 21:47:58 +00001538 ++ESym;
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001539 }
1540}
1541
Igor Kudrin853b88d2015-10-20 20:52:14 +00001542template <class ELFT>
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001543const OutputSectionBase<ELFT> *
1544SymbolTableSection<ELFT>::getOutputSection(SymbolBody *Sym) {
1545 switch (Sym->kind()) {
1546 case SymbolBody::DefinedSyntheticKind:
Peter Collingbourne6a422592016-05-03 01:21:08 +00001547 return cast<DefinedSynthetic<ELFT>>(Sym)->Section;
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001548 case SymbolBody::DefinedRegularKind: {
Rafael Espindola5ffa13c2016-04-15 00:15:02 +00001549 auto &D = cast<DefinedRegular<ELFT>>(*Sym);
Rafael Espindola67d72c02016-03-11 12:06:30 +00001550 if (D.Section)
1551 return D.Section->OutSec;
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001552 break;
1553 }
1554 case SymbolBody::DefinedCommonKind:
Rui Ueyamae8a61022016-11-05 23:05:47 +00001555 return In<ELFT>::Common->OutSec;
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001556 case SymbolBody::SharedKind:
1557 if (cast<SharedSymbol<ELFT>>(Sym)->needsCopy())
1558 return Out<ELFT>::Bss;
1559 break;
Peter Collingbourne60976ed2016-04-27 00:05:06 +00001560 case SymbolBody::UndefinedKind:
Rui Ueyamaf8baa662016-04-07 19:24:51 +00001561 case SymbolBody::LazyArchiveKind:
1562 case SymbolBody::LazyObjectKind:
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001563 break;
Rui Ueyama874e7ae2016-02-17 04:56:44 +00001564 }
1565 return nullptr;
1566}
1567
1568template <class ELFT>
George Rimard3566302016-06-20 11:55:12 +00001569VersionDefinitionSection<ELFT>::VersionDefinitionSection()
Rui Ueyamaf5244642016-07-16 02:36:00 +00001570 : OutputSectionBase<ELFT>(".gnu.version_d", SHT_GNU_verdef, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001571 this->Addralign = sizeof(uint32_t);
Rui Ueyamaf5244642016-07-16 02:36:00 +00001572}
George Rimard3566302016-06-20 11:55:12 +00001573
1574static StringRef getFileDefName() {
1575 if (!Config->SoName.empty())
1576 return Config->SoName;
1577 return Config->OutputFile;
1578}
1579
1580template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
1581 FileDefNameOff = Out<ELFT>::DynStrTab->addString(getFileDefName());
Rui Ueyamaaf469d42016-07-16 04:09:27 +00001582 for (VersionDefinition &V : Config->VersionDefinitions)
George Rimard3566302016-06-20 11:55:12 +00001583 V.NameOff = Out<ELFT>::DynStrTab->addString(V.Name);
1584
Rafael Espindola04a2e342016-11-09 01:42:41 +00001585 this->Size = (sizeof(Elf_Verdef) + sizeof(Elf_Verdaux)) * getVerDefNum();
1586 this->Link = Out<ELFT>::DynStrTab->SectionIndex;
George Rimard3566302016-06-20 11:55:12 +00001587
1588 // sh_info should be set to the number of definitions. This fact is missed in
1589 // documentation, but confirmed by binutils community:
1590 // https://sourceware.org/ml/binutils/2014-11/msg00355.html
Rafael Espindola04a2e342016-11-09 01:42:41 +00001591 this->Info = getVerDefNum();
George Rimard3566302016-06-20 11:55:12 +00001592}
1593
Rui Ueyama9f619642016-07-16 02:29:45 +00001594template <class ELFT>
1595void VersionDefinitionSection<ELFT>::writeOne(uint8_t *Buf, uint32_t Index,
1596 StringRef Name, size_t NameOff) {
1597 auto *Verdef = reinterpret_cast<Elf_Verdef *>(Buf);
George Rimard3566302016-06-20 11:55:12 +00001598 Verdef->vd_version = 1;
George Rimar33b9de42016-07-01 11:45:10 +00001599 Verdef->vd_cnt = 1;
Rui Ueyama9f619642016-07-16 02:29:45 +00001600 Verdef->vd_aux = sizeof(Elf_Verdef);
1601 Verdef->vd_next = sizeof(Elf_Verdef) + sizeof(Elf_Verdaux);
1602 Verdef->vd_flags = (Index == 1 ? VER_FLG_BASE : 0);
George Rimard3566302016-06-20 11:55:12 +00001603 Verdef->vd_ndx = Index;
Davide Italianoe7fd0be2016-11-07 21:56:56 +00001604 Verdef->vd_hash = hashSysV(Name);
George Rimard3566302016-06-20 11:55:12 +00001605
Rui Ueyama9f619642016-07-16 02:29:45 +00001606 auto *Verdaux = reinterpret_cast<Elf_Verdaux *>(Buf + sizeof(Elf_Verdef));
1607 Verdaux->vda_name = NameOff;
George Rimard3566302016-06-20 11:55:12 +00001608 Verdaux->vda_next = 0;
George Rimard3566302016-06-20 11:55:12 +00001609}
1610
1611template <class ELFT>
1612void VersionDefinitionSection<ELFT>::writeTo(uint8_t *Buf) {
Rui Ueyama9f619642016-07-16 02:29:45 +00001613 writeOne(Buf, 1, getFileDefName(), FileDefNameOff);
1614
Rui Ueyamaaf469d42016-07-16 04:09:27 +00001615 for (VersionDefinition &V : Config->VersionDefinitions) {
Rui Ueyama9f619642016-07-16 02:29:45 +00001616 Buf += sizeof(Elf_Verdef) + sizeof(Elf_Verdaux);
1617 writeOne(Buf, V.Id, V.Name, V.NameOff);
1618 }
1619
1620 // Need to terminate the last version definition.
George Rimard3566302016-06-20 11:55:12 +00001621 Elf_Verdef *Verdef = reinterpret_cast<Elf_Verdef *>(Buf);
Rui Ueyama9f619642016-07-16 02:29:45 +00001622 Verdef->vd_next = 0;
George Rimard3566302016-06-20 11:55:12 +00001623}
1624
1625template <class ELFT>
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001626VersionTableSection<ELFT>::VersionTableSection()
Rafael Espindolaeaaec4a2016-04-29 17:19:45 +00001627 : OutputSectionBase<ELFT>(".gnu.version", SHT_GNU_versym, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001628 this->Addralign = sizeof(uint16_t);
Rafael Espindolaeaaec4a2016-04-29 17:19:45 +00001629}
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001630
1631template <class ELFT> void VersionTableSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001632 this->Size =
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001633 sizeof(Elf_Versym) * (Out<ELFT>::DynSymTab->getSymbols().size() + 1);
Rafael Espindola04a2e342016-11-09 01:42:41 +00001634 this->Entsize = sizeof(Elf_Versym);
George Rimar8b3c5f22016-06-06 08:04:53 +00001635 // At the moment of june 2016 GNU docs does not mention that sh_link field
1636 // should be set, but Sun docs do. Also readelf relies on this field.
Rafael Espindola04a2e342016-11-09 01:42:41 +00001637 this->Link = Out<ELFT>::DynSymTab->SectionIndex;
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001638}
1639
1640template <class ELFT> void VersionTableSection<ELFT>::writeTo(uint8_t *Buf) {
1641 auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf) + 1;
Michael J. Spencerf8a81482016-10-19 23:49:27 +00001642 for (const SymbolTableEntry &S : Out<ELFT>::DynSymTab->getSymbols()) {
1643 OutVersym->vs_index = S.Symbol->symbol()->VersionId;
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001644 ++OutVersym;
1645 }
1646}
1647
1648template <class ELFT>
1649VersionNeedSection<ELFT>::VersionNeedSection()
Rafael Espindolaeaaec4a2016-04-29 17:19:45 +00001650 : OutputSectionBase<ELFT>(".gnu.version_r", SHT_GNU_verneed, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001651 this->Addralign = sizeof(uint32_t);
George Rimard3566302016-06-20 11:55:12 +00001652
1653 // Identifiers in verneed section start at 2 because 0 and 1 are reserved
1654 // for VER_NDX_LOCAL and VER_NDX_GLOBAL.
1655 // First identifiers are reserved by verdef section if it exist.
1656 NextIndex = getVerDefNum() + 1;
Rafael Espindolaeaaec4a2016-04-29 17:19:45 +00001657}
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001658
1659template <class ELFT>
1660void VersionNeedSection<ELFT>::addSymbol(SharedSymbol<ELFT> *SS) {
1661 if (!SS->Verdef) {
George Rimard3566302016-06-20 11:55:12 +00001662 SS->symbol()->VersionId = VER_NDX_GLOBAL;
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001663 return;
1664 }
Rui Ueyama434b5612016-07-17 03:11:46 +00001665 SharedFile<ELFT> *F = SS->file();
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001666 // If we don't already know that we need an Elf_Verneed for this DSO, prepare
1667 // to create one by adding it to our needed list and creating a dynstr entry
1668 // for the soname.
1669 if (F->VerdefMap.empty())
1670 Needed.push_back({F, Out<ELFT>::DynStrTab->addString(F->getSoName())});
1671 typename SharedFile<ELFT>::NeededVer &NV = F->VerdefMap[SS->Verdef];
1672 // If we don't already know that we need an Elf_Vernaux for this Elf_Verdef,
1673 // prepare to create one by allocating a version identifier and creating a
1674 // dynstr entry for the version name.
1675 if (NV.Index == 0) {
1676 NV.StrTab = Out<ELFT>::DynStrTab->addString(
Rui Ueyama434b5612016-07-17 03:11:46 +00001677 SS->file()->getStringTable().data() + SS->Verdef->getAux()->vda_name);
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001678 NV.Index = NextIndex++;
1679 }
George Rimard3566302016-06-20 11:55:12 +00001680 SS->symbol()->VersionId = NV.Index;
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001681}
1682
1683template <class ELFT> void VersionNeedSection<ELFT>::writeTo(uint8_t *Buf) {
1684 // The Elf_Verneeds need to appear first, followed by the Elf_Vernauxs.
1685 auto *Verneed = reinterpret_cast<Elf_Verneed *>(Buf);
1686 auto *Vernaux = reinterpret_cast<Elf_Vernaux *>(Verneed + Needed.size());
1687
1688 for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed) {
1689 // Create an Elf_Verneed for this DSO.
1690 Verneed->vn_version = 1;
1691 Verneed->vn_cnt = P.first->VerdefMap.size();
1692 Verneed->vn_file = P.second;
1693 Verneed->vn_aux =
1694 reinterpret_cast<char *>(Vernaux) - reinterpret_cast<char *>(Verneed);
1695 Verneed->vn_next = sizeof(Elf_Verneed);
1696 ++Verneed;
1697
1698 // Create the Elf_Vernauxs for this Elf_Verneed. The loop iterates over
1699 // VerdefMap, which will only contain references to needed version
1700 // definitions. Each Elf_Vernaux is based on the information contained in
1701 // the Elf_Verdef in the source DSO. This loop iterates over a std::map of
1702 // pointers, but is deterministic because the pointers refer to Elf_Verdef
1703 // data structures within a single input file.
1704 for (auto &NV : P.first->VerdefMap) {
1705 Vernaux->vna_hash = NV.first->vd_hash;
1706 Vernaux->vna_flags = 0;
1707 Vernaux->vna_other = NV.second.Index;
1708 Vernaux->vna_name = NV.second.StrTab;
1709 Vernaux->vna_next = sizeof(Elf_Vernaux);
1710 ++Vernaux;
1711 }
1712
1713 Vernaux[-1].vna_next = 0;
1714 }
1715 Verneed[-1].vn_next = 0;
1716}
1717
1718template <class ELFT> void VersionNeedSection<ELFT>::finalize() {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001719 this->Link = Out<ELFT>::DynStrTab->SectionIndex;
1720 this->Info = Needed.size();
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001721 unsigned Size = Needed.size() * sizeof(Elf_Verneed);
1722 for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed)
1723 Size += P.first->VerdefMap.size() * sizeof(Elf_Vernaux);
Rafael Espindola04a2e342016-11-09 01:42:41 +00001724 this->Size = Size;
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00001725}
1726
1727template <class ELFT>
Simon Atanasyan1d7df402015-12-20 10:57:34 +00001728MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
1729 : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001730 this->Addralign = 4;
1731 this->Entsize = sizeof(Elf_Mips_RegInfo);
1732 this->Size = sizeof(Elf_Mips_RegInfo);
Simon Atanasyan1d7df402015-12-20 10:57:34 +00001733}
1734
1735template <class ELFT>
1736void MipsReginfoOutputSection<ELFT>::writeTo(uint8_t *Buf) {
1737 auto *R = reinterpret_cast<Elf_Mips_RegInfo *>(Buf);
Simon Atanasyan353fc1e92016-09-29 12:58:48 +00001738 if (Config->Relocatable)
1739 R->ri_gp_value = 0;
1740 else
Rafael Espindola04a2e342016-11-09 01:42:41 +00001741 R->ri_gp_value = Out<ELFT>::Got->Addr + MipsGPOffset;
Rui Ueyama70eed362016-01-06 22:42:43 +00001742 R->ri_gprmask = GprMask;
Simon Atanasyan1d7df402015-12-20 10:57:34 +00001743}
1744
1745template <class ELFT>
Rui Ueyama40845e62015-12-26 05:51:07 +00001746void MipsReginfoOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
Rui Ueyama70eed362016-01-06 22:42:43 +00001747 // Copy input object file's .reginfo gprmask to output.
Rui Ueyama40845e62015-12-26 05:51:07 +00001748 auto *S = cast<MipsReginfoInputSection<ELFT>>(C);
Rui Ueyama70eed362016-01-06 22:42:43 +00001749 GprMask |= S->Reginfo->ri_gprmask;
Simon Atanasyan84bb3552016-05-26 20:46:01 +00001750 S->OutSec = this;
Simon Atanasyan1d7df402015-12-20 10:57:34 +00001751}
1752
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001753template <class ELFT>
1754MipsOptionsOutputSection<ELFT>::MipsOptionsOutputSection()
1755 : OutputSectionBase<ELFT>(".MIPS.options", SHT_MIPS_OPTIONS,
1756 SHF_ALLOC | SHF_MIPS_NOSTRIP) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001757 this->Addralign = 8;
1758 this->Entsize = 1;
1759 this->Size = sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001760}
1761
1762template <class ELFT>
1763void MipsOptionsOutputSection<ELFT>::writeTo(uint8_t *Buf) {
1764 auto *Opt = reinterpret_cast<Elf_Mips_Options *>(Buf);
1765 Opt->kind = ODK_REGINFO;
Rafael Espindola04a2e342016-11-09 01:42:41 +00001766 Opt->size = this->Size;
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001767 Opt->section = 0;
1768 Opt->info = 0;
1769 auto *Reg = reinterpret_cast<Elf_Mips_RegInfo *>(Buf + sizeof(*Opt));
Simon Atanasyan353fc1e92016-09-29 12:58:48 +00001770 if (Config->Relocatable)
1771 Reg->ri_gp_value = 0;
1772 else
Rafael Espindola04a2e342016-11-09 01:42:41 +00001773 Reg->ri_gp_value = Out<ELFT>::Got->Addr + MipsGPOffset;
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001774 Reg->ri_gprmask = GprMask;
1775}
1776
1777template <class ELFT>
1778void MipsOptionsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
1779 auto *S = cast<MipsOptionsInputSection<ELFT>>(C);
1780 if (S->Reginfo)
1781 GprMask |= S->Reginfo->ri_gprmask;
Simon Atanasyan84bb3552016-05-26 20:46:01 +00001782 S->OutSec = this;
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001783}
1784
George Rimar6892afa2016-07-12 09:49:43 +00001785template <class ELFT>
Simon Atanasyan85c6b442016-08-12 06:28:49 +00001786MipsAbiFlagsOutputSection<ELFT>::MipsAbiFlagsOutputSection()
1787 : OutputSectionBase<ELFT>(".MIPS.abiflags", SHT_MIPS_ABIFLAGS, SHF_ALLOC) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001788 this->Addralign = 8;
1789 this->Entsize = sizeof(Elf_Mips_ABIFlags);
1790 this->Size = sizeof(Elf_Mips_ABIFlags);
Simon Atanasyan85c6b442016-08-12 06:28:49 +00001791 memset(&Flags, 0, sizeof(Flags));
1792}
1793
1794template <class ELFT>
1795void MipsAbiFlagsOutputSection<ELFT>::writeTo(uint8_t *Buf) {
1796 memcpy(Buf, &Flags, sizeof(Flags));
1797}
1798
1799template <class ELFT>
1800void MipsAbiFlagsOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
1801 // Check compatibility and merge fields from input .MIPS.abiflags
1802 // to the output one.
1803 auto *S = cast<MipsAbiFlagsInputSection<ELFT>>(C);
1804 S->OutSec = this;
1805 if (S->Flags->version != 0) {
1806 error(getFilename(S->getFile()) + ": unexpected .MIPS.abiflags version " +
1807 Twine(S->Flags->version));
1808 return;
1809 }
1810 // LLD checks ISA compatibility in getMipsEFlags(). Here we just
1811 // select the highest number of ISA/Rev/Ext.
1812 Flags.isa_level = std::max(Flags.isa_level, S->Flags->isa_level);
1813 Flags.isa_rev = std::max(Flags.isa_rev, S->Flags->isa_rev);
1814 Flags.isa_ext = std::max(Flags.isa_ext, S->Flags->isa_ext);
1815 Flags.gpr_size = std::max(Flags.gpr_size, S->Flags->gpr_size);
1816 Flags.cpr1_size = std::max(Flags.cpr1_size, S->Flags->cpr1_size);
1817 Flags.cpr2_size = std::max(Flags.cpr2_size, S->Flags->cpr2_size);
1818 Flags.ases |= S->Flags->ases;
1819 Flags.flags1 |= S->Flags->flags1;
1820 Flags.flags2 |= S->Flags->flags2;
1821 Flags.fp_abi = elf::getMipsFpAbiFlag(Flags.fp_abi, S->Flags->fp_abi,
1822 getFilename(S->getFile()));
1823}
1824
1825template <class ELFT>
Rafael Espindola10897f12016-09-13 14:23:14 +00001826static typename ELFT::uint getOutFlags(InputSectionBase<ELFT> *S) {
Rafael Espindola1854a8e2016-10-26 12:36:56 +00001827 return S->Flags & ~SHF_GROUP & ~SHF_COMPRESSED;
Rafael Espindola10897f12016-09-13 14:23:14 +00001828}
1829
1830template <class ELFT>
Rafael Espindola17c35832016-09-13 12:25:30 +00001831static SectionKey<ELFT::Is64Bits> createKey(InputSectionBase<ELFT> *C,
1832 StringRef OutsecName) {
Rafael Espindola17c35832016-09-13 12:25:30 +00001833 typedef typename ELFT::uint uintX_t;
Rafael Espindola10897f12016-09-13 14:23:14 +00001834 uintX_t Flags = getOutFlags(C);
Rafael Espindola17c35832016-09-13 12:25:30 +00001835
1836 // For SHF_MERGE we create different output sections for each alignment.
1837 // This makes each output section simple and keeps a single level mapping from
1838 // input to output.
Simon Atanasyan02b9c3f2016-10-05 07:49:18 +00001839 // In case of relocatable object generation we do not try to perform merging
1840 // and treat SHF_MERGE sections as regular ones, but also create different
1841 // output sections for them to allow merging at final linking stage.
Rafael Espindola17c35832016-09-13 12:25:30 +00001842 uintX_t Alignment = 0;
Simon Atanasyan02b9c3f2016-10-05 07:49:18 +00001843 if (isa<MergeInputSection<ELFT>>(C) ||
Rafael Espindola1854a8e2016-10-26 12:36:56 +00001844 (Config->Relocatable && (C->Flags & SHF_MERGE)))
1845 Alignment = std::max<uintX_t>(C->Alignment, C->Entsize);
Rafael Espindola17c35832016-09-13 12:25:30 +00001846
Rafael Espindola1854a8e2016-10-26 12:36:56 +00001847 return SectionKey<ELFT::Is64Bits>{OutsecName, C->Type, Flags, Alignment};
Rafael Espindola17c35832016-09-13 12:25:30 +00001848}
1849
1850template <class ELFT>
George Rimar6892afa2016-07-12 09:49:43 +00001851std::pair<OutputSectionBase<ELFT> *, bool>
1852OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
1853 StringRef OutsecName) {
1854 SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
Rafael Espindola10897f12016-09-13 14:23:14 +00001855 return create(Key, C);
1856}
George Rimar6892afa2016-07-12 09:49:43 +00001857
Rafael Espindola10897f12016-09-13 14:23:14 +00001858template <class ELFT>
1859std::pair<OutputSectionBase<ELFT> *, bool>
1860OutputSectionFactory<ELFT>::create(const SectionKey<ELFT::Is64Bits> &Key,
1861 InputSectionBase<ELFT> *C) {
1862 uintX_t Flags = getOutFlags(C);
1863 OutputSectionBase<ELFT> *&Sec = Map[Key];
1864 if (Sec) {
Rafael Espindola04a2e342016-11-09 01:42:41 +00001865 Sec->Flags |= Flags;
Rafael Espindola10897f12016-09-13 14:23:14 +00001866 return {Sec, false};
1867 }
1868
Rafael Espindola1854a8e2016-10-26 12:36:56 +00001869 uint32_t Type = C->Type;
Rafael Espindola16853bb2016-09-08 12:33:41 +00001870 switch (C->kind()) {
George Rimar6892afa2016-07-12 09:49:43 +00001871 case InputSectionBase<ELFT>::Regular:
Rui Ueyama95642b92016-11-01 23:09:07 +00001872 Sec = make<OutputSection<ELFT>>(Key.Name, Type, Flags);
George Rimar6892afa2016-07-12 09:49:43 +00001873 break;
1874 case InputSectionBase<ELFT>::EHFrame:
1875 return {Out<ELFT>::EhFrame, false};
1876 case InputSectionBase<ELFT>::Merge:
Rui Ueyama95642b92016-11-01 23:09:07 +00001877 Sec = make<MergeOutputSection<ELFT>>(Key.Name, Type, Flags, Key.Alignment);
George Rimar6892afa2016-07-12 09:49:43 +00001878 break;
1879 case InputSectionBase<ELFT>::MipsReginfo:
Rui Ueyama95642b92016-11-01 23:09:07 +00001880 Sec = make<MipsReginfoOutputSection<ELFT>>();
George Rimar6892afa2016-07-12 09:49:43 +00001881 break;
1882 case InputSectionBase<ELFT>::MipsOptions:
Rui Ueyama95642b92016-11-01 23:09:07 +00001883 Sec = make<MipsOptionsOutputSection<ELFT>>();
George Rimar6892afa2016-07-12 09:49:43 +00001884 break;
Simon Atanasyan85c6b442016-08-12 06:28:49 +00001885 case InputSectionBase<ELFT>::MipsAbiFlags:
Rui Ueyama95642b92016-11-01 23:09:07 +00001886 Sec = make<MipsAbiFlagsOutputSection<ELFT>>();
Simon Atanasyan85c6b442016-08-12 06:28:49 +00001887 break;
George Rimar6892afa2016-07-12 09:49:43 +00001888 }
1889 return {Sec, true};
1890}
1891
George Rimar6892afa2016-07-12 09:49:43 +00001892template <bool Is64Bits>
1893typename lld::elf::SectionKey<Is64Bits>
1894DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getEmptyKey() {
1895 return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getEmptyKey(), 0, 0, 0};
1896}
1897
1898template <bool Is64Bits>
1899typename lld::elf::SectionKey<Is64Bits>
1900DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getTombstoneKey() {
1901 return SectionKey<Is64Bits>{DenseMapInfo<StringRef>::getTombstoneKey(), 0, 0,
1902 0};
1903}
1904
1905template <bool Is64Bits>
1906unsigned
1907DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::getHashValue(const Key &Val) {
1908 return hash_combine(Val.Name, Val.Type, Val.Flags, Val.Alignment);
1909}
1910
1911template <bool Is64Bits>
1912bool DenseMapInfo<lld::elf::SectionKey<Is64Bits>>::isEqual(const Key &LHS,
1913 const Key &RHS) {
1914 return DenseMapInfo<StringRef>::isEqual(LHS.Name, RHS.Name) &&
1915 LHS.Type == RHS.Type && LHS.Flags == RHS.Flags &&
1916 LHS.Alignment == RHS.Alignment;
1917}
1918
1919namespace llvm {
1920template struct DenseMapInfo<SectionKey<true>>;
1921template struct DenseMapInfo<SectionKey<false>>;
1922}
1923
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001924namespace lld {
Rafael Espindolae0df00b2016-02-28 00:25:54 +00001925namespace elf {
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +00001926template class OutputSectionBase<ELF32LE>;
1927template class OutputSectionBase<ELF32BE>;
1928template class OutputSectionBase<ELF64LE>;
1929template class OutputSectionBase<ELF64BE>;
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001930
George Rimarf6bc65a2016-01-15 13:34:52 +00001931template class EhFrameHeader<ELF32LE>;
1932template class EhFrameHeader<ELF32BE>;
1933template class EhFrameHeader<ELF64LE>;
1934template class EhFrameHeader<ELF64BE>;
1935
George Rimar648a2c32015-10-20 08:54:27 +00001936template class GotPltSection<ELF32LE>;
1937template class GotPltSection<ELF32BE>;
1938template class GotPltSection<ELF64LE>;
1939template class GotPltSection<ELF64BE>;
1940
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001941template class GotSection<ELF32LE>;
1942template class GotSection<ELF32BE>;
1943template class GotSection<ELF64LE>;
1944template class GotSection<ELF64BE>;
1945
1946template class PltSection<ELF32LE>;
1947template class PltSection<ELF32BE>;
1948template class PltSection<ELF64LE>;
1949template class PltSection<ELF64BE>;
1950
1951template class RelocationSection<ELF32LE>;
1952template class RelocationSection<ELF32BE>;
1953template class RelocationSection<ELF64LE>;
1954template class RelocationSection<ELF64BE>;
1955
Igor Kudrin1b0d7062015-10-22 08:21:35 +00001956template class GnuHashTableSection<ELF32LE>;
1957template class GnuHashTableSection<ELF32BE>;
1958template class GnuHashTableSection<ELF64LE>;
1959template class GnuHashTableSection<ELF64BE>;
1960
Rafael Espindola5805c4f2015-09-21 21:38:08 +00001961template class HashTableSection<ELF32LE>;
1962template class HashTableSection<ELF32BE>;
1963template class HashTableSection<ELF64LE>;
1964template class HashTableSection<ELF64BE>;
1965
1966template class DynamicSection<ELF32LE>;
1967template class DynamicSection<ELF32BE>;
1968template class DynamicSection<ELF64LE>;
1969template class DynamicSection<ELF64BE>;
1970
1971template class OutputSection<ELF32LE>;
1972template class OutputSection<ELF32BE>;
1973template class OutputSection<ELF64LE>;
1974template class OutputSection<ELF64BE>;
1975
Rui Ueyama1e479c22016-05-23 15:07:59 +00001976template class EhOutputSection<ELF32LE>;
1977template class EhOutputSection<ELF32BE>;
1978template class EhOutputSection<ELF64LE>;
1979template class EhOutputSection<ELF64BE>;
Rafael Espindola0c6a4f12015-11-11 19:54:14 +00001980
Simon Atanasyan1d7df402015-12-20 10:57:34 +00001981template class MipsReginfoOutputSection<ELF32LE>;
1982template class MipsReginfoOutputSection<ELF32BE>;
1983template class MipsReginfoOutputSection<ELF64LE>;
1984template class MipsReginfoOutputSection<ELF64BE>;
1985
Simon Atanasyanadd74f32016-05-04 10:07:38 +00001986template class MipsOptionsOutputSection<ELF32LE>;
1987template class MipsOptionsOutputSection<ELF32BE>;
1988template class MipsOptionsOutputSection<ELF64LE>;
1989template class MipsOptionsOutputSection<ELF64BE>;
1990
Simon Atanasyan85c6b442016-08-12 06:28:49 +00001991template class MipsAbiFlagsOutputSection<ELF32LE>;
1992template class MipsAbiFlagsOutputSection<ELF32BE>;
1993template class MipsAbiFlagsOutputSection<ELF64LE>;
1994template class MipsAbiFlagsOutputSection<ELF64BE>;
1995
Rafael Espindolac159c962015-10-19 21:00:02 +00001996template class MergeOutputSection<ELF32LE>;
1997template class MergeOutputSection<ELF32BE>;
1998template class MergeOutputSection<ELF64LE>;
1999template class MergeOutputSection<ELF64BE>;
2000
Rui Ueyamac7cc6ec2015-10-15 22:27:29 +00002001template class StringTableSection<ELF32LE>;
2002template class StringTableSection<ELF32BE>;
2003template class StringTableSection<ELF64LE>;
2004template class StringTableSection<ELF64BE>;
Rafael Espindola5805c4f2015-09-21 21:38:08 +00002005
2006template class SymbolTableSection<ELF32LE>;
2007template class SymbolTableSection<ELF32BE>;
2008template class SymbolTableSection<ELF64LE>;
2009template class SymbolTableSection<ELF64BE>;
Rui Ueyama634ddf02016-03-11 20:51:53 +00002010
Peter Collingbourne21a12fc2016-04-27 20:22:31 +00002011template class VersionTableSection<ELF32LE>;
2012template class VersionTableSection<ELF32BE>;
2013template class VersionTableSection<ELF64LE>;
2014template class VersionTableSection<ELF64BE>;
2015
2016template class VersionNeedSection<ELF32LE>;
2017template class VersionNeedSection<ELF32BE>;
2018template class VersionNeedSection<ELF64LE>;
2019template class VersionNeedSection<ELF64BE>;
2020
George Rimard3566302016-06-20 11:55:12 +00002021template class VersionDefinitionSection<ELF32LE>;
2022template class VersionDefinitionSection<ELF32BE>;
2023template class VersionDefinitionSection<ELF64LE>;
2024template class VersionDefinitionSection<ELF64BE>;
2025
George Rimar58fa5242016-10-20 09:19:48 +00002026template class GdbIndexSection<ELF32LE>;
2027template class GdbIndexSection<ELF32BE>;
2028template class GdbIndexSection<ELF64LE>;
2029template class GdbIndexSection<ELF64BE>;
2030
George Rimar6892afa2016-07-12 09:49:43 +00002031template class OutputSectionFactory<ELF32LE>;
2032template class OutputSectionFactory<ELF32BE>;
2033template class OutputSectionFactory<ELF64LE>;
2034template class OutputSectionFactory<ELF64BE>;
Rafael Espindola5805c4f2015-09-21 21:38:08 +00002035}
2036}