File: | tools/lld/ELF/OutputSections.cpp |
Warning: | line 276, column 24 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- 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" | |||
12 | #include "LinkerScript.h" | |||
13 | #include "SymbolTable.h" | |||
14 | #include "SyntheticSections.h" | |||
15 | #include "Target.h" | |||
16 | #include "lld/Common/Memory.h" | |||
17 | #include "lld/Common/Strings.h" | |||
18 | #include "lld/Common/Threads.h" | |||
19 | #include "llvm/BinaryFormat/Dwarf.h" | |||
20 | #include "llvm/Support/Compression.h" | |||
21 | #include "llvm/Support/MD5.h" | |||
22 | #include "llvm/Support/MathExtras.h" | |||
23 | #include "llvm/Support/SHA1.h" | |||
24 | ||||
25 | using namespace llvm; | |||
26 | using namespace llvm::dwarf; | |||
27 | using namespace llvm::object; | |||
28 | using namespace llvm::ELF; | |||
29 | ||||
30 | using namespace lld; | |||
31 | using namespace lld::elf; | |||
32 | ||||
33 | uint8_t Out::First; | |||
34 | PhdrEntry *Out::TlsPhdr; | |||
35 | OutputSection *Out::ElfHeader; | |||
36 | OutputSection *Out::ProgramHeaders; | |||
37 | OutputSection *Out::PreinitArray; | |||
38 | OutputSection *Out::InitArray; | |||
39 | OutputSection *Out::FiniArray; | |||
40 | ||||
41 | std::vector<OutputSection *> elf::OutputSections; | |||
42 | ||||
43 | uint32_t OutputSection::getPhdrFlags() const { | |||
44 | uint32_t Ret = 0; | |||
45 | if (Config->EMachine != EM_ARM || !(Flags & SHF_ARM_PURECODE)) | |||
46 | Ret |= PF_R; | |||
47 | if (Flags & SHF_WRITE) | |||
48 | Ret |= PF_W; | |||
49 | if (Flags & SHF_EXECINSTR) | |||
50 | Ret |= PF_X; | |||
51 | return Ret; | |||
52 | } | |||
53 | ||||
54 | template <class ELFT> | |||
55 | void OutputSection::writeHeaderTo(typename ELFT::Shdr *Shdr) { | |||
56 | Shdr->sh_entsize = Entsize; | |||
57 | Shdr->sh_addralign = Alignment; | |||
58 | Shdr->sh_type = Type; | |||
59 | Shdr->sh_offset = Offset; | |||
60 | Shdr->sh_flags = Flags; | |||
61 | Shdr->sh_info = Info; | |||
62 | Shdr->sh_link = Link; | |||
63 | Shdr->sh_addr = Addr; | |||
64 | Shdr->sh_size = Size; | |||
65 | Shdr->sh_name = ShName; | |||
66 | } | |||
67 | ||||
68 | OutputSection::OutputSection(StringRef Name, uint32_t Type, uint64_t Flags) | |||
69 | : BaseCommand(OutputSectionKind), | |||
70 | SectionBase(Output, Name, Flags, /*Entsize*/ 0, /*Alignment*/ 1, Type, | |||
71 | /*Info*/ 0, /*Link*/ 0) { | |||
72 | Live = false; | |||
73 | } | |||
74 | ||||
75 | // We allow sections of types listed below to merged into a | |||
76 | // single progbits section. This is typically done by linker | |||
77 | // scripts. Merging nobits and progbits will force disk space | |||
78 | // to be allocated for nobits sections. Other ones don't require | |||
79 | // any special treatment on top of progbits, so there doesn't | |||
80 | // seem to be a harm in merging them. | |||
81 | static bool canMergeToProgbits(unsigned Type) { | |||
82 | return Type == SHT_NOBITS || Type == SHT_PROGBITS || Type == SHT_INIT_ARRAY || | |||
83 | Type == SHT_PREINIT_ARRAY || Type == SHT_FINI_ARRAY || | |||
84 | Type == SHT_NOTE; | |||
85 | } | |||
86 | ||||
87 | void OutputSection::addSection(InputSection *IS) { | |||
88 | if (!Live) { | |||
89 | // If IS is the first section to be added to this section, | |||
90 | // initialize Type, Entsize and flags from IS. | |||
91 | Live = true; | |||
92 | Type = IS->Type; | |||
93 | Entsize = IS->Entsize; | |||
94 | Flags = IS->Flags; | |||
95 | } else { | |||
96 | // Otherwise, check if new type or flags are compatible with existing ones. | |||
97 | unsigned Mask = SHF_ALLOC | SHF_TLS | SHF_LINK_ORDER; | |||
98 | if ((Flags & Mask) != (IS->Flags & Mask)) | |||
99 | error("incompatible section flags for " + Name + "\n>>> " + toString(IS) + | |||
100 | ": 0x" + utohexstr(IS->Flags) + "\n>>> output section " + Name + | |||
101 | ": 0x" + utohexstr(Flags)); | |||
102 | ||||
103 | if (Type != IS->Type) { | |||
104 | if (!canMergeToProgbits(Type) || !canMergeToProgbits(IS->Type)) | |||
105 | error("section type mismatch for " + IS->Name + "\n>>> " + | |||
106 | toString(IS) + ": " + | |||
107 | getELFSectionTypeName(Config->EMachine, IS->Type) + | |||
108 | "\n>>> output section " + Name + ": " + | |||
109 | getELFSectionTypeName(Config->EMachine, Type)); | |||
110 | Type = SHT_PROGBITS; | |||
111 | } | |||
112 | } | |||
113 | ||||
114 | IS->Parent = this; | |||
115 | uint64_t AndMask = | |||
116 | Config->EMachine == EM_ARM ? (uint64_t)SHF_ARM_PURECODE : 0; | |||
117 | uint64_t OrMask = ~AndMask; | |||
118 | uint64_t AndFlags = (Flags & IS->Flags) & AndMask; | |||
119 | uint64_t OrFlags = (Flags | IS->Flags) & OrMask; | |||
120 | Flags = AndFlags | OrFlags; | |||
121 | ||||
122 | Alignment = std::max(Alignment, IS->Alignment); | |||
123 | ||||
124 | // If this section contains a table of fixed-size entries, sh_entsize | |||
125 | // holds the element size. If it contains elements of different size we | |||
126 | // set sh_entsize to 0. | |||
127 | if (Entsize != IS->Entsize) | |||
128 | Entsize = 0; | |||
129 | ||||
130 | if (!IS->Assigned) { | |||
131 | IS->Assigned = true; | |||
132 | if (SectionCommands.empty() || | |||
133 | !isa<InputSectionDescription>(SectionCommands.back())) | |||
134 | SectionCommands.push_back(make<InputSectionDescription>("")); | |||
135 | auto *ISD = cast<InputSectionDescription>(SectionCommands.back()); | |||
136 | ISD->Sections.push_back(IS); | |||
137 | } | |||
138 | } | |||
139 | ||||
140 | static void sortByOrder(MutableArrayRef<InputSection *> In, | |||
141 | llvm::function_ref<int(InputSectionBase *S)> Order) { | |||
142 | typedef std::pair<int, InputSection *> Pair; | |||
143 | auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; }; | |||
144 | ||||
145 | std::vector<Pair> V; | |||
146 | for (InputSection *S : In) | |||
147 | V.push_back({Order(S), S}); | |||
148 | std::stable_sort(V.begin(), V.end(), Comp); | |||
149 | ||||
150 | for (size_t I = 0; I < V.size(); ++I) | |||
151 | In[I] = V[I].second; | |||
152 | } | |||
153 | ||||
154 | uint64_t elf::getHeaderSize() { | |||
155 | if (Config->OFormatBinary) | |||
156 | return 0; | |||
157 | return Out::ElfHeader->Size + Out::ProgramHeaders->Size; | |||
158 | } | |||
159 | ||||
160 | bool OutputSection::classof(const BaseCommand *C) { | |||
161 | return C->Kind == OutputSectionKind; | |||
162 | } | |||
163 | ||||
164 | void OutputSection::sort(llvm::function_ref<int(InputSectionBase *S)> Order) { | |||
165 | assert(Live)((Live) ? static_cast<void> (0) : __assert_fail ("Live" , "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 165, __PRETTY_FUNCTION__)); | |||
166 | for (BaseCommand *B : SectionCommands) | |||
167 | if (auto *ISD = dyn_cast<InputSectionDescription>(B)) | |||
168 | sortByOrder(ISD->Sections, Order); | |||
169 | } | |||
170 | ||||
171 | // Fill [Buf, Buf + Size) with Filler. | |||
172 | // This is used for linker script "=fillexp" command. | |||
173 | static void fill(uint8_t *Buf, size_t Size, uint32_t Filler) { | |||
174 | size_t I = 0; | |||
175 | for (; I + 4 < Size; I += 4) | |||
176 | memcpy(Buf + I, &Filler, 4); | |||
177 | memcpy(Buf + I, &Filler, Size - I); | |||
178 | } | |||
179 | ||||
180 | // Compress section contents if this section contains debug info. | |||
181 | template <class ELFT> void OutputSection::maybeCompress() { | |||
182 | typedef typename ELFT::Chdr Elf_Chdr; | |||
183 | ||||
184 | // Compress only DWARF debug sections. | |||
185 | if (!Config->CompressDebugSections || (Flags & SHF_ALLOC) || | |||
186 | !Name.startswith(".debug_")) | |||
187 | return; | |||
188 | ||||
189 | // Create a section header. | |||
190 | ZDebugHeader.resize(sizeof(Elf_Chdr)); | |||
191 | auto *Hdr = reinterpret_cast<Elf_Chdr *>(ZDebugHeader.data()); | |||
192 | Hdr->ch_type = ELFCOMPRESS_ZLIB; | |||
193 | Hdr->ch_size = Size; | |||
194 | Hdr->ch_addralign = Alignment; | |||
195 | ||||
196 | // Write section contents to a temporary buffer and compress it. | |||
197 | std::vector<uint8_t> Buf(Size); | |||
198 | writeTo<ELFT>(Buf.data()); | |||
199 | if (Error E = zlib::compress(toStringRef(Buf), CompressedData)) | |||
200 | fatal("compress failed: " + llvm::toString(std::move(E))); | |||
201 | ||||
202 | // Update section headers. | |||
203 | Size = sizeof(Elf_Chdr) + CompressedData.size(); | |||
204 | Flags |= SHF_COMPRESSED; | |||
205 | } | |||
206 | ||||
207 | static void writeInt(uint8_t *Buf, uint64_t Data, uint64_t Size) { | |||
208 | if (Size == 1) | |||
209 | *Buf = Data; | |||
210 | else if (Size == 2) | |||
211 | write16(Buf, Data); | |||
212 | else if (Size == 4) | |||
213 | write32(Buf, Data); | |||
214 | else if (Size == 8) | |||
215 | write64(Buf, Data); | |||
216 | else | |||
217 | llvm_unreachable("unsupported Size argument")::llvm::llvm_unreachable_internal("unsupported Size argument" , "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 217); | |||
218 | } | |||
219 | ||||
220 | template <class ELFT> void OutputSection::writeTo(uint8_t *Buf) { | |||
221 | if (Type == SHT_NOBITS) | |||
222 | return; | |||
223 | ||||
224 | Loc = Buf; | |||
225 | ||||
226 | // If -compress-debug-section is specified and if this is a debug seciton, | |||
227 | // we've already compressed section contents. If that's the case, | |||
228 | // just write it down. | |||
229 | if (!CompressedData.empty()) { | |||
230 | memcpy(Buf, ZDebugHeader.data(), ZDebugHeader.size()); | |||
231 | memcpy(Buf + ZDebugHeader.size(), CompressedData.data(), | |||
232 | CompressedData.size()); | |||
233 | return; | |||
234 | } | |||
235 | ||||
236 | // Write leading padding. | |||
237 | std::vector<InputSection *> Sections = getInputSections(this); | |||
238 | uint32_t Filler = getFiller(); | |||
239 | if (Filler) | |||
240 | fill(Buf, Sections.empty() ? Size : Sections[0]->OutSecOff, Filler); | |||
241 | ||||
242 | parallelForEachN(0, Sections.size(), [&](size_t I) { | |||
243 | InputSection *IS = Sections[I]; | |||
244 | IS->writeTo<ELFT>(Buf); | |||
245 | ||||
246 | // Fill gaps between sections. | |||
247 | if (Filler) { | |||
248 | uint8_t *Start = Buf + IS->OutSecOff + IS->getSize(); | |||
249 | uint8_t *End; | |||
250 | if (I + 1 == Sections.size()) | |||
251 | End = Buf + Size; | |||
252 | else | |||
253 | End = Buf + Sections[I + 1]->OutSecOff; | |||
254 | fill(Start, End - Start, Filler); | |||
255 | } | |||
256 | }); | |||
257 | ||||
258 | // Linker scripts may have BYTE()-family commands with which you | |||
259 | // can write arbitrary bytes to the output. Process them if any. | |||
260 | for (BaseCommand *Base : SectionCommands) | |||
261 | if (auto *Data = dyn_cast<ByteCommand>(Base)) | |||
262 | writeInt(Buf + Data->Offset, Data->Expression().getValue(), Data->Size); | |||
263 | } | |||
264 | ||||
265 | template <class ELFT> | |||
266 | static void finalizeShtGroup(OutputSection *OS, | |||
267 | InputSection *Section) { | |||
268 | assert(Config->Relocatable)((Config->Relocatable) ? static_cast<void> (0) : __assert_fail ("Config->Relocatable", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 268, __PRETTY_FUNCTION__)); | |||
269 | ||||
270 | // sh_link field for SHT_GROUP sections should contain the section index of | |||
271 | // the symbol table. | |||
272 | OS->Link = In.SymTab->getParent()->SectionIndex; | |||
273 | ||||
274 | // sh_info then contain index of an entry in symbol table section which | |||
275 | // provides signature of the section group. | |||
276 | ObjFile<ELFT> *Obj = Section->getFile<ELFT>(); | |||
| ||||
277 | ArrayRef<Symbol *> Symbols = Obj->getSymbols(); | |||
278 | OS->Info = In.SymTab->getSymbolIndex(Symbols[Section->Info]); | |||
279 | } | |||
280 | ||||
281 | template <class ELFT> void OutputSection::finalize() { | |||
282 | if (Type == SHT_NOBITS) | |||
| ||||
283 | for (BaseCommand *Base : SectionCommands) | |||
284 | if (isa<ByteCommand>(Base)) | |||
285 | Type = SHT_PROGBITS; | |||
286 | ||||
287 | std::vector<InputSection *> V = getInputSections(this); | |||
288 | InputSection *First = V.empty() ? nullptr : V[0]; | |||
289 | ||||
290 | if (Flags & SHF_LINK_ORDER) { | |||
291 | // We must preserve the link order dependency of sections with the | |||
292 | // SHF_LINK_ORDER flag. The dependency is indicated by the sh_link field. We | |||
293 | // need to translate the InputSection sh_link to the OutputSection sh_link, | |||
294 | // all InputSections in the OutputSection have the same dependency. | |||
295 | if (auto *D = First->getLinkOrderDep()) | |||
296 | Link = D->getParent()->SectionIndex; | |||
297 | } | |||
298 | ||||
299 | if (Type == SHT_GROUP) { | |||
300 | finalizeShtGroup<ELFT>(this, First); | |||
301 | return; | |||
302 | } | |||
303 | ||||
304 | if (!Config->CopyRelocs || (Type != SHT_RELA && Type != SHT_REL)) | |||
305 | return; | |||
306 | ||||
307 | if (isa<SyntheticSection>(First)) | |||
308 | return; | |||
309 | ||||
310 | Link = In.SymTab->getParent()->SectionIndex; | |||
311 | // sh_info for SHT_REL[A] sections should contain the section header index of | |||
312 | // the section to which the relocation applies. | |||
313 | InputSectionBase *S = First->getRelocatedSection(); | |||
314 | Info = S->getOutputSection()->SectionIndex; | |||
315 | Flags |= SHF_INFO_LINK; | |||
316 | } | |||
317 | ||||
318 | // Returns true if S matches /Filename.?\.o$/. | |||
319 | static bool isCrtBeginEnd(StringRef S, StringRef Filename) { | |||
320 | if (!S.endswith(".o")) | |||
321 | return false; | |||
322 | S = S.drop_back(2); | |||
323 | if (S.endswith(Filename)) | |||
324 | return true; | |||
325 | return !S.empty() && S.drop_back().endswith(Filename); | |||
326 | } | |||
327 | ||||
328 | static bool isCrtbegin(StringRef S) { return isCrtBeginEnd(S, "crtbegin"); } | |||
329 | static bool isCrtend(StringRef S) { return isCrtBeginEnd(S, "crtend"); } | |||
330 | ||||
331 | // .ctors and .dtors are sorted by this priority from highest to lowest. | |||
332 | // | |||
333 | // 1. The section was contained in crtbegin (crtbegin contains | |||
334 | // some sentinel value in its .ctors and .dtors so that the runtime | |||
335 | // can find the beginning of the sections.) | |||
336 | // | |||
337 | // 2. The section has an optional priority value in the form of ".ctors.N" | |||
338 | // or ".dtors.N" where N is a number. Unlike .{init,fini}_array, | |||
339 | // they are compared as string rather than number. | |||
340 | // | |||
341 | // 3. The section is just ".ctors" or ".dtors". | |||
342 | // | |||
343 | // 4. The section was contained in crtend, which contains an end marker. | |||
344 | // | |||
345 | // In an ideal world, we don't need this function because .init_array and | |||
346 | // .ctors are duplicate features (and .init_array is newer.) However, there | |||
347 | // are too many real-world use cases of .ctors, so we had no choice to | |||
348 | // support that with this rather ad-hoc semantics. | |||
349 | static bool compCtors(const InputSection *A, const InputSection *B) { | |||
350 | bool BeginA = isCrtbegin(A->File->getName()); | |||
351 | bool BeginB = isCrtbegin(B->File->getName()); | |||
352 | if (BeginA != BeginB) | |||
353 | return BeginA; | |||
354 | bool EndA = isCrtend(A->File->getName()); | |||
355 | bool EndB = isCrtend(B->File->getName()); | |||
356 | if (EndA != EndB) | |||
357 | return EndB; | |||
358 | StringRef X = A->Name; | |||
359 | StringRef Y = B->Name; | |||
360 | assert(X.startswith(".ctors") || X.startswith(".dtors"))((X.startswith(".ctors") || X.startswith(".dtors")) ? static_cast <void> (0) : __assert_fail ("X.startswith(\".ctors\") || X.startswith(\".dtors\")" , "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 360, __PRETTY_FUNCTION__)); | |||
361 | assert(Y.startswith(".ctors") || Y.startswith(".dtors"))((Y.startswith(".ctors") || Y.startswith(".dtors")) ? static_cast <void> (0) : __assert_fail ("Y.startswith(\".ctors\") || Y.startswith(\".dtors\")" , "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 361, __PRETTY_FUNCTION__)); | |||
362 | X = X.substr(6); | |||
363 | Y = Y.substr(6); | |||
364 | return X < Y; | |||
365 | } | |||
366 | ||||
367 | // Sorts input sections by the special rules for .ctors and .dtors. | |||
368 | // Unfortunately, the rules are different from the one for .{init,fini}_array. | |||
369 | // Read the comment above. | |||
370 | void OutputSection::sortCtorsDtors() { | |||
371 | assert(SectionCommands.size() == 1)((SectionCommands.size() == 1) ? static_cast<void> (0) : __assert_fail ("SectionCommands.size() == 1", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/OutputSections.cpp" , 371, __PRETTY_FUNCTION__)); | |||
372 | auto *ISD = cast<InputSectionDescription>(SectionCommands[0]); | |||
373 | std::stable_sort(ISD->Sections.begin(), ISD->Sections.end(), compCtors); | |||
374 | } | |||
375 | ||||
376 | // If an input string is in the form of "foo.N" where N is a number, | |||
377 | // return N. Otherwise, returns 65536, which is one greater than the | |||
378 | // lowest priority. | |||
379 | int elf::getPriority(StringRef S) { | |||
380 | size_t Pos = S.rfind('.'); | |||
381 | if (Pos == StringRef::npos) | |||
382 | return 65536; | |||
383 | int V; | |||
384 | if (!to_integer(S.substr(Pos + 1), V, 10)) | |||
385 | return 65536; | |||
386 | return V; | |||
387 | } | |||
388 | ||||
389 | std::vector<InputSection *> elf::getInputSections(OutputSection *OS) { | |||
390 | std::vector<InputSection *> Ret; | |||
391 | for (BaseCommand *Base : OS->SectionCommands) | |||
392 | if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) | |||
393 | Ret.insert(Ret.end(), ISD->Sections.begin(), ISD->Sections.end()); | |||
394 | return Ret; | |||
395 | } | |||
396 | ||||
397 | // Sorts input sections by section name suffixes, so that .foo.N comes | |||
398 | // before .foo.M if N < M. Used to sort .{init,fini}_array.N sections. | |||
399 | // We want to keep the original order if the priorities are the same | |||
400 | // because the compiler keeps the original initialization order in a | |||
401 | // translation unit and we need to respect that. | |||
402 | // For more detail, read the section of the GCC's manual about init_priority. | |||
403 | void OutputSection::sortInitFini() { | |||
404 | // Sort sections by priority. | |||
405 | sort([](InputSectionBase *S) { return getPriority(S->Name); }); | |||
406 | } | |||
407 | ||||
408 | uint32_t OutputSection::getFiller() { | |||
409 | if (Filler) | |||
410 | return *Filler; | |||
411 | if (Flags & SHF_EXECINSTR) | |||
412 | return Target->TrapInstr; | |||
413 | return 0; | |||
414 | } | |||
415 | ||||
416 | template void OutputSection::writeHeaderTo<ELF32LE>(ELF32LE::Shdr *Shdr); | |||
417 | template void OutputSection::writeHeaderTo<ELF32BE>(ELF32BE::Shdr *Shdr); | |||
418 | template void OutputSection::writeHeaderTo<ELF64LE>(ELF64LE::Shdr *Shdr); | |||
419 | template void OutputSection::writeHeaderTo<ELF64BE>(ELF64BE::Shdr *Shdr); | |||
420 | ||||
421 | template void OutputSection::writeTo<ELF32LE>(uint8_t *Buf); | |||
422 | template void OutputSection::writeTo<ELF32BE>(uint8_t *Buf); | |||
423 | template void OutputSection::writeTo<ELF64LE>(uint8_t *Buf); | |||
424 | template void OutputSection::writeTo<ELF64BE>(uint8_t *Buf); | |||
425 | ||||
426 | template void OutputSection::maybeCompress<ELF32LE>(); | |||
427 | template void OutputSection::maybeCompress<ELF32BE>(); | |||
428 | template void OutputSection::maybeCompress<ELF64LE>(); | |||
429 | template void OutputSection::maybeCompress<ELF64BE>(); | |||
430 | ||||
431 | template void OutputSection::finalize<ELF32LE>(); | |||
432 | template void OutputSection::finalize<ELF32BE>(); | |||
433 | template void OutputSection::finalize<ELF64LE>(); | |||
434 | template void OutputSection::finalize<ELF64BE>(); |