File: | src/gnu/usr.bin/clang/liblldELF/../../../llvm/lld/ELF/Relocations.cpp |
Warning: | line 1896, column 9 3rd function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- Relocations.cpp ----------------------------------------------------===// | |||
2 | // | |||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
4 | // See https://llvm.org/LICENSE.txt for license information. | |||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
6 | // | |||
7 | //===----------------------------------------------------------------------===// | |||
8 | // | |||
9 | // This file contains platform-independent functions to process relocations. | |||
10 | // I'll describe the overview of this file here. | |||
11 | // | |||
12 | // Simple relocations are easy to handle for the linker. For example, | |||
13 | // for R_X86_64_PC64 relocs, the linker just has to fix up locations | |||
14 | // with the relative offsets to the target symbols. It would just be | |||
15 | // reading records from relocation sections and applying them to output. | |||
16 | // | |||
17 | // But not all relocations are that easy to handle. For example, for | |||
18 | // R_386_GOTOFF relocs, the linker has to create new GOT entries for | |||
19 | // symbols if they don't exist, and fix up locations with GOT entry | |||
20 | // offsets from the beginning of GOT section. So there is more than | |||
21 | // fixing addresses in relocation processing. | |||
22 | // | |||
23 | // ELF defines a large number of complex relocations. | |||
24 | // | |||
25 | // The functions in this file analyze relocations and do whatever needs | |||
26 | // to be done. It includes, but not limited to, the following. | |||
27 | // | |||
28 | // - create GOT/PLT entries | |||
29 | // - create new relocations in .dynsym to let the dynamic linker resolve | |||
30 | // them at runtime (since ELF supports dynamic linking, not all | |||
31 | // relocations can be resolved at link-time) | |||
32 | // - create COPY relocs and reserve space in .bss | |||
33 | // - replace expensive relocs (in terms of runtime cost) with cheap ones | |||
34 | // - error out infeasible combinations such as PIC and non-relative relocs | |||
35 | // | |||
36 | // Note that the functions in this file don't actually apply relocations | |||
37 | // because it doesn't know about the output file nor the output file buffer. | |||
38 | // It instead stores Relocation objects to InputSection's Relocations | |||
39 | // vector to let it apply later in InputSection::writeTo. | |||
40 | // | |||
41 | //===----------------------------------------------------------------------===// | |||
42 | ||||
43 | #include "Relocations.h" | |||
44 | #include "Config.h" | |||
45 | #include "LinkerScript.h" | |||
46 | #include "OutputSections.h" | |||
47 | #include "SymbolTable.h" | |||
48 | #include "Symbols.h" | |||
49 | #include "SyntheticSections.h" | |||
50 | #include "Target.h" | |||
51 | #include "Thunks.h" | |||
52 | #include "lld/Common/ErrorHandler.h" | |||
53 | #include "lld/Common/Memory.h" | |||
54 | #include "lld/Common/Strings.h" | |||
55 | #include "llvm/ADT/SmallSet.h" | |||
56 | #include "llvm/Demangle/Demangle.h" | |||
57 | #include "llvm/Support/Endian.h" | |||
58 | #include "llvm/Support/raw_ostream.h" | |||
59 | #include <algorithm> | |||
60 | ||||
61 | using namespace llvm; | |||
62 | using namespace llvm::ELF; | |||
63 | using namespace llvm::object; | |||
64 | using namespace llvm::support::endian; | |||
65 | using namespace lld; | |||
66 | using namespace lld::elf; | |||
67 | ||||
68 | static Optional<std::string> getLinkerScriptLocation(const Symbol &sym) { | |||
69 | for (BaseCommand *base : script->sectionCommands) | |||
70 | if (auto *cmd = dyn_cast<SymbolAssignment>(base)) | |||
71 | if (cmd->sym == &sym) | |||
72 | return cmd->location; | |||
73 | return None; | |||
74 | } | |||
75 | ||||
76 | static std::string getDefinedLocation(const Symbol &sym) { | |||
77 | const char msg[] = "\n>>> defined in "; | |||
78 | if (sym.file) | |||
79 | return msg + toString(sym.file); | |||
80 | if (Optional<std::string> loc = getLinkerScriptLocation(sym)) | |||
81 | return msg + *loc; | |||
82 | return ""; | |||
83 | } | |||
84 | ||||
85 | // Construct a message in the following format. | |||
86 | // | |||
87 | // >>> defined in /home/alice/src/foo.o | |||
88 | // >>> referenced by bar.c:12 (/home/alice/src/bar.c:12) | |||
89 | // >>> /home/alice/src/bar.o:(.text+0x1) | |||
90 | static std::string getLocation(InputSectionBase &s, const Symbol &sym, | |||
91 | uint64_t off) { | |||
92 | std::string msg = getDefinedLocation(sym) + "\n>>> referenced by "; | |||
93 | std::string src = s.getSrcMsg(sym, off); | |||
94 | if (!src.empty()) | |||
95 | msg += src + "\n>>> "; | |||
96 | return msg + s.getObjMsg(off); | |||
97 | } | |||
98 | ||||
99 | void elf::reportRangeError(uint8_t *loc, const Relocation &rel, const Twine &v, | |||
100 | int64_t min, uint64_t max) { | |||
101 | ErrorPlace errPlace = getErrorPlace(loc); | |||
102 | std::string hint; | |||
103 | if (rel.sym && !rel.sym->isLocal()) | |||
104 | hint = "; references " + lld::toString(*rel.sym) + | |||
105 | getDefinedLocation(*rel.sym); | |||
106 | ||||
107 | if (errPlace.isec && errPlace.isec->name.startswith(".debug")) | |||
108 | hint += "; consider recompiling with -fdebug-types-section to reduce size " | |||
109 | "of debug sections"; | |||
110 | ||||
111 | errorOrWarn(errPlace.loc + "relocation " + lld::toString(rel.type) + | |||
112 | " out of range: " + v.str() + " is not in [" + Twine(min).str() + | |||
113 | ", " + Twine(max).str() + "]" + hint); | |||
114 | } | |||
115 | ||||
116 | void elf::reportRangeError(uint8_t *loc, int64_t v, int n, const Symbol &sym, | |||
117 | const Twine &msg) { | |||
118 | ErrorPlace errPlace = getErrorPlace(loc); | |||
119 | std::string hint; | |||
120 | if (!sym.getName().empty()) | |||
121 | hint = "; references " + lld::toString(sym) + getDefinedLocation(sym); | |||
122 | errorOrWarn(errPlace.loc + msg + " is out of range: " + Twine(v) + | |||
123 | " is not in [" + Twine(llvm::minIntN(n)) + ", " + | |||
124 | Twine(llvm::maxIntN(n)) + "]" + hint); | |||
125 | } | |||
126 | ||||
127 | namespace { | |||
128 | // Build a bitmask with one bit set for each RelExpr. | |||
129 | // | |||
130 | // Constexpr function arguments can't be used in static asserts, so we | |||
131 | // use template arguments to build the mask. | |||
132 | // But function template partial specializations don't exist (needed | |||
133 | // for base case of the recursion), so we need a dummy struct. | |||
134 | template <RelExpr... Exprs> struct RelExprMaskBuilder { | |||
135 | static inline uint64_t build() { return 0; } | |||
136 | }; | |||
137 | ||||
138 | // Specialization for recursive case. | |||
139 | template <RelExpr Head, RelExpr... Tail> | |||
140 | struct RelExprMaskBuilder<Head, Tail...> { | |||
141 | static inline uint64_t build() { | |||
142 | static_assert(0 <= Head && Head < 64, | |||
143 | "RelExpr is too large for 64-bit mask!"); | |||
144 | return (uint64_t(1) << Head) | RelExprMaskBuilder<Tail...>::build(); | |||
145 | } | |||
146 | }; | |||
147 | } // namespace | |||
148 | ||||
149 | // Return true if `Expr` is one of `Exprs`. | |||
150 | // There are fewer than 64 RelExpr's, so we can represent any set of | |||
151 | // RelExpr's as a constant bit mask and test for membership with a | |||
152 | // couple cheap bitwise operations. | |||
153 | template <RelExpr... Exprs> bool oneof(RelExpr expr) { | |||
154 | assert(0 <= expr && (int)expr < 64 &&((void)0) | |||
155 | "RelExpr is too large for 64-bit mask!")((void)0); | |||
156 | return (uint64_t(1) << expr) & RelExprMaskBuilder<Exprs...>::build(); | |||
157 | } | |||
158 | ||||
159 | // This function is similar to the `handleTlsRelocation`. MIPS does not | |||
160 | // support any relaxations for TLS relocations so by factoring out MIPS | |||
161 | // handling in to the separate function we can simplify the code and do not | |||
162 | // pollute other `handleTlsRelocation` by MIPS `ifs` statements. | |||
163 | // Mips has a custom MipsGotSection that handles the writing of GOT entries | |||
164 | // without dynamic relocations. | |||
165 | static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym, | |||
166 | InputSectionBase &c, uint64_t offset, | |||
167 | int64_t addend, RelExpr expr) { | |||
168 | if (expr == R_MIPS_TLSLD) { | |||
169 | in.mipsGot->addTlsIndex(*c.file); | |||
170 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
171 | return 1; | |||
172 | } | |||
173 | if (expr == R_MIPS_TLSGD) { | |||
174 | in.mipsGot->addDynTlsEntry(*c.file, sym); | |||
175 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
176 | return 1; | |||
177 | } | |||
178 | return 0; | |||
179 | } | |||
180 | ||||
181 | // Notes about General Dynamic and Local Dynamic TLS models below. They may | |||
182 | // require the generation of a pair of GOT entries that have associated dynamic | |||
183 | // relocations. The pair of GOT entries created are of the form GOT[e0] Module | |||
184 | // Index (Used to find pointer to TLS block at run-time) GOT[e1] Offset of | |||
185 | // symbol in TLS block. | |||
186 | // | |||
187 | // Returns the number of relocations processed. | |||
188 | template <class ELFT> | |||
189 | static unsigned | |||
190 | handleTlsRelocation(RelType type, Symbol &sym, InputSectionBase &c, | |||
191 | typename ELFT::uint offset, int64_t addend, RelExpr expr) { | |||
192 | if (!sym.isTls()) | |||
193 | return 0; | |||
194 | ||||
195 | if (config->emachine == EM_MIPS) | |||
196 | return handleMipsTlsRelocation(type, sym, c, offset, addend, expr); | |||
197 | ||||
198 | if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC>( | |||
199 | expr) && | |||
200 | config->shared) { | |||
201 | if (in.got->addDynTlsEntry(sym)) { | |||
202 | uint64_t off = in.got->getGlobalDynOffset(sym); | |||
203 | mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible( | |||
204 | target->tlsDescRel, in.got, off, sym, target->tlsDescRel); | |||
205 | } | |||
206 | if (expr != R_TLSDESC_CALL) | |||
207 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
208 | return 1; | |||
209 | } | |||
210 | ||||
211 | // ARM, Hexagon and RISC-V do not support GD/LD to IE/LE relaxation. For | |||
212 | // PPC64, if the file has missing R_PPC64_TLSGD/R_PPC64_TLSLD, disable | |||
213 | // relaxation as well. | |||
214 | bool toExecRelax = !config->shared && config->emachine != EM_ARM && | |||
215 | config->emachine != EM_HEXAGON && | |||
216 | config->emachine != EM_RISCV && | |||
217 | !c.file->ppc64DisableTLSRelax; | |||
218 | ||||
219 | // If we are producing an executable and the symbol is non-preemptable, it | |||
220 | // must be defined and the code sequence can be relaxed to use Local-Exec. | |||
221 | // | |||
222 | // ARM and RISC-V do not support any relaxations for TLS relocations, however, | |||
223 | // we can omit the DTPMOD dynamic relocations and resolve them at link time | |||
224 | // because them are always 1. This may be necessary for static linking as | |||
225 | // DTPMOD may not be expected at load time. | |||
226 | bool isLocalInExecutable = !sym.isPreemptible && !config->shared; | |||
227 | ||||
228 | // Local Dynamic is for access to module local TLS variables, while still | |||
229 | // being suitable for being dynamically loaded via dlopen. GOT[e0] is the | |||
230 | // module index, with a special value of 0 for the current module. GOT[e1] is | |||
231 | // unused. There only needs to be one module index entry. | |||
232 | if (oneof<R_TLSLD_GOT, R_TLSLD_GOTPLT, R_TLSLD_PC, R_TLSLD_HINT>( | |||
233 | expr)) { | |||
234 | // Local-Dynamic relocs can be relaxed to Local-Exec. | |||
235 | if (toExecRelax) { | |||
236 | c.relocations.push_back( | |||
237 | {target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE), type, offset, | |||
238 | addend, &sym}); | |||
239 | return target->getTlsGdRelaxSkip(type); | |||
240 | } | |||
241 | if (expr == R_TLSLD_HINT) | |||
242 | return 1; | |||
243 | if (in.got->addTlsIndex()) { | |||
244 | if (isLocalInExecutable) | |||
245 | in.got->relocations.push_back( | |||
246 | {R_ADDEND, target->symbolicRel, in.got->getTlsIndexOff(), 1, &sym}); | |||
247 | else | |||
248 | mainPart->relaDyn->addReloc( | |||
249 | {target->tlsModuleIndexRel, in.got, in.got->getTlsIndexOff()}); | |||
250 | } | |||
251 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
252 | return 1; | |||
253 | } | |||
254 | ||||
255 | // Local-Dynamic relocs can be relaxed to Local-Exec. | |||
256 | if (expr == R_DTPREL && toExecRelax) { | |||
257 | c.relocations.push_back({target->adjustTlsExpr(type, R_RELAX_TLS_LD_TO_LE), | |||
258 | type, offset, addend, &sym}); | |||
259 | return 1; | |||
260 | } | |||
261 | ||||
262 | // Local-Dynamic sequence where offset of tls variable relative to dynamic | |||
263 | // thread pointer is stored in the got. This cannot be relaxed to Local-Exec. | |||
264 | if (expr == R_TLSLD_GOT_OFF) { | |||
265 | if (!sym.isInGot()) { | |||
266 | in.got->addEntry(sym); | |||
267 | uint64_t off = sym.getGotOffset(); | |||
268 | in.got->relocations.push_back( | |||
269 | {R_ABS, target->tlsOffsetRel, off, 0, &sym}); | |||
270 | } | |||
271 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
272 | return 1; | |||
273 | } | |||
274 | ||||
275 | if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC, | |||
276 | R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(expr)) { | |||
277 | if (!toExecRelax) { | |||
278 | if (in.got->addDynTlsEntry(sym)) { | |||
279 | uint64_t off = in.got->getGlobalDynOffset(sym); | |||
280 | ||||
281 | if (isLocalInExecutable) | |||
282 | // Write one to the GOT slot. | |||
283 | in.got->relocations.push_back( | |||
284 | {R_ADDEND, target->symbolicRel, off, 1, &sym}); | |||
285 | else | |||
286 | mainPart->relaDyn->addSymbolReloc(target->tlsModuleIndexRel, in.got, | |||
287 | off, sym); | |||
288 | ||||
289 | // If the symbol is preemptible we need the dynamic linker to write | |||
290 | // the offset too. | |||
291 | uint64_t offsetOff = off + config->wordsize; | |||
292 | if (sym.isPreemptible) | |||
293 | mainPart->relaDyn->addSymbolReloc(target->tlsOffsetRel, in.got, | |||
294 | offsetOff, sym); | |||
295 | else | |||
296 | in.got->relocations.push_back( | |||
297 | {R_ABS, target->tlsOffsetRel, offsetOff, 0, &sym}); | |||
298 | } | |||
299 | c.relocations.push_back({expr, type, offset, addend, &sym}); | |||
300 | return 1; | |||
301 | } | |||
302 | ||||
303 | // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec | |||
304 | // depending on the symbol being locally defined or not. | |||
305 | if (sym.isPreemptible) { | |||
306 | c.relocations.push_back( | |||
307 | {target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_IE), type, offset, | |||
308 | addend, &sym}); | |||
309 | if (!sym.isInGot()) { | |||
310 | in.got->addEntry(sym); | |||
311 | mainPart->relaDyn->addSymbolReloc(target->tlsGotRel, in.got, | |||
312 | sym.getGotOffset(), sym); | |||
313 | } | |||
314 | } else { | |||
315 | c.relocations.push_back( | |||
316 | {target->adjustTlsExpr(type, R_RELAX_TLS_GD_TO_LE), type, offset, | |||
317 | addend, &sym}); | |||
318 | } | |||
319 | return target->getTlsGdRelaxSkip(type); | |||
320 | } | |||
321 | ||||
322 | // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally | |||
323 | // defined. | |||
324 | if (oneof<R_GOT, R_GOTPLT, R_GOT_PC, R_AARCH64_GOT_PAGE_PC, R_GOT_OFF, | |||
325 | R_TLSIE_HINT>(expr) && | |||
326 | toExecRelax && isLocalInExecutable) { | |||
327 | c.relocations.push_back({R_RELAX_TLS_IE_TO_LE, type, offset, addend, &sym}); | |||
328 | return 1; | |||
329 | } | |||
330 | ||||
331 | if (expr == R_TLSIE_HINT) | |||
332 | return 1; | |||
333 | return 0; | |||
334 | } | |||
335 | ||||
336 | static RelType getMipsPairType(RelType type, bool isLocal) { | |||
337 | switch (type) { | |||
338 | case R_MIPS_HI16: | |||
339 | return R_MIPS_LO16; | |||
340 | case R_MIPS_GOT16: | |||
341 | // In case of global symbol, the R_MIPS_GOT16 relocation does not | |||
342 | // have a pair. Each global symbol has a unique entry in the GOT | |||
343 | // and a corresponding instruction with help of the R_MIPS_GOT16 | |||
344 | // relocation loads an address of the symbol. In case of local | |||
345 | // symbol, the R_MIPS_GOT16 relocation creates a GOT entry to hold | |||
346 | // the high 16 bits of the symbol's value. A paired R_MIPS_LO16 | |||
347 | // relocations handle low 16 bits of the address. That allows | |||
348 | // to allocate only one GOT entry for every 64 KBytes of local data. | |||
349 | return isLocal ? R_MIPS_LO16 : R_MIPS_NONE; | |||
350 | case R_MICROMIPS_GOT16: | |||
351 | return isLocal ? R_MICROMIPS_LO16 : R_MIPS_NONE; | |||
352 | case R_MIPS_PCHI16: | |||
353 | return R_MIPS_PCLO16; | |||
354 | case R_MICROMIPS_HI16: | |||
355 | return R_MICROMIPS_LO16; | |||
356 | default: | |||
357 | return R_MIPS_NONE; | |||
358 | } | |||
359 | } | |||
360 | ||||
361 | // True if non-preemptable symbol always has the same value regardless of where | |||
362 | // the DSO is loaded. | |||
363 | static bool isAbsolute(const Symbol &sym) { | |||
364 | if (sym.isUndefWeak()) | |||
365 | return true; | |||
366 | if (const auto *dr = dyn_cast<Defined>(&sym)) | |||
367 | return dr->section == nullptr; // Absolute symbol. | |||
368 | return false; | |||
369 | } | |||
370 | ||||
371 | static bool isAbsoluteValue(const Symbol &sym) { | |||
372 | return isAbsolute(sym) || sym.isTls(); | |||
373 | } | |||
374 | ||||
375 | // Returns true if Expr refers a PLT entry. | |||
376 | static bool needsPlt(RelExpr expr) { | |||
377 | return oneof<R_PLT_PC, R_PPC32_PLTREL, R_PPC64_CALL_PLT, R_PLT>(expr); | |||
378 | } | |||
379 | ||||
380 | // Returns true if Expr refers a GOT entry. Note that this function | |||
381 | // returns false for TLS variables even though they need GOT, because | |||
382 | // TLS variables uses GOT differently than the regular variables. | |||
383 | static bool needsGot(RelExpr expr) { | |||
384 | return oneof<R_GOT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOT_OFF, | |||
385 | R_MIPS_GOT_OFF32, R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTPLT, | |||
386 | R_AARCH64_GOT_PAGE>(expr); | |||
387 | } | |||
388 | ||||
389 | // True if this expression is of the form Sym - X, where X is a position in the | |||
390 | // file (PC, or GOT for example). | |||
391 | static bool isRelExpr(RelExpr expr) { | |||
392 | return oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC64_CALL, | |||
393 | R_PPC64_RELAX_TOC, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC, | |||
394 | R_RISCV_PC_INDIRECT, R_PPC64_RELAX_GOT_PC>(expr); | |||
395 | } | |||
396 | ||||
397 | // Returns true if a given relocation can be computed at link-time. | |||
398 | // | |||
399 | // For instance, we know the offset from a relocation to its target at | |||
400 | // link-time if the relocation is PC-relative and refers a | |||
401 | // non-interposable function in the same executable. This function | |||
402 | // will return true for such relocation. | |||
403 | // | |||
404 | // If this function returns false, that means we need to emit a | |||
405 | // dynamic relocation so that the relocation will be fixed at load-time. | |||
406 | static bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym, | |||
407 | InputSectionBase &s, uint64_t relOff) { | |||
408 | // These expressions always compute a constant | |||
409 | if (oneof<R_DTPREL, R_GOTPLT, R_GOT_OFF, R_TLSLD_GOT_OFF, | |||
410 | R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL, R_MIPS_GOT_OFF, | |||
411 | R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, R_MIPS_TLSGD, | |||
412 | R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC, | |||
413 | R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC, R_PPC32_PLTREL, | |||
414 | R_PPC64_CALL_PLT, R_PPC64_RELAX_TOC, R_RISCV_ADD, R_TLSDESC_CALL, | |||
415 | R_TLSDESC_PC, R_AARCH64_TLSDESC_PAGE, R_TLSLD_HINT, R_TLSIE_HINT, | |||
416 | R_AARCH64_GOT_PAGE>( | |||
417 | e)) | |||
418 | return true; | |||
419 | ||||
420 | // These never do, except if the entire file is position dependent or if | |||
421 | // only the low bits are used. | |||
422 | if (e == R_GOT || e == R_PLT || e == R_TLSDESC) | |||
423 | return target->usesOnlyLowPageBits(type) || !config->isPic; | |||
424 | ||||
425 | if (sym.isPreemptible) | |||
426 | return false; | |||
427 | if (!config->isPic) | |||
428 | return true; | |||
429 | ||||
430 | // The size of a non preemptible symbol is a constant. | |||
431 | if (e == R_SIZE) | |||
432 | return true; | |||
433 | ||||
434 | // For the target and the relocation, we want to know if they are | |||
435 | // absolute or relative. | |||
436 | bool absVal = isAbsoluteValue(sym); | |||
437 | bool relE = isRelExpr(e); | |||
438 | if (absVal && !relE) | |||
439 | return true; | |||
440 | if (!absVal && relE) | |||
441 | return true; | |||
442 | if (!absVal && !relE) | |||
443 | return target->usesOnlyLowPageBits(type); | |||
444 | ||||
445 | assert(absVal && relE)((void)0); | |||
446 | ||||
447 | // Allow R_PLT_PC (optimized to R_PC here) to a hidden undefined weak symbol | |||
448 | // in PIC mode. This is a little strange, but it allows us to link function | |||
449 | // calls to such symbols (e.g. glibc/stdlib/exit.c:__run_exit_handlers). | |||
450 | // Normally such a call will be guarded with a comparison, which will load a | |||
451 | // zero from the GOT. | |||
452 | if (sym.isUndefWeak()) | |||
453 | return true; | |||
454 | ||||
455 | // We set the final symbols values for linker script defined symbols later. | |||
456 | // They always can be computed as a link time constant. | |||
457 | if (sym.scriptDefined) | |||
458 | return true; | |||
459 | ||||
460 | error("relocation " + toString(type) + " cannot refer to absolute symbol: " + | |||
461 | toString(sym) + getLocation(s, sym, relOff)); | |||
462 | return true; | |||
463 | } | |||
464 | ||||
465 | static RelExpr toPlt(RelExpr expr) { | |||
466 | switch (expr) { | |||
467 | case R_PPC64_CALL: | |||
468 | return R_PPC64_CALL_PLT; | |||
469 | case R_PC: | |||
470 | return R_PLT_PC; | |||
471 | case R_ABS: | |||
472 | return R_PLT; | |||
473 | default: | |||
474 | return expr; | |||
475 | } | |||
476 | } | |||
477 | ||||
478 | static RelExpr fromPlt(RelExpr expr) { | |||
479 | // We decided not to use a plt. Optimize a reference to the plt to a | |||
480 | // reference to the symbol itself. | |||
481 | switch (expr) { | |||
482 | case R_PLT_PC: | |||
483 | case R_PPC32_PLTREL: | |||
484 | return R_PC; | |||
485 | case R_PPC64_CALL_PLT: | |||
486 | return R_PPC64_CALL; | |||
487 | case R_PLT: | |||
488 | return R_ABS; | |||
489 | default: | |||
490 | return expr; | |||
491 | } | |||
492 | } | |||
493 | ||||
494 | // Returns true if a given shared symbol is in a read-only segment in a DSO. | |||
495 | template <class ELFT> static bool isReadOnly(SharedSymbol &ss) { | |||
496 | using Elf_Phdr = typename ELFT::Phdr; | |||
497 | ||||
498 | // Determine if the symbol is read-only by scanning the DSO's program headers. | |||
499 | const SharedFile &file = ss.getFile(); | |||
500 | for (const Elf_Phdr &phdr : | |||
501 | check(file.template getObj<ELFT>().program_headers())) | |||
502 | if ((phdr.p_type == ELF::PT_LOAD || phdr.p_type == ELF::PT_GNU_RELRO) && | |||
503 | !(phdr.p_flags & ELF::PF_W) && ss.value >= phdr.p_vaddr && | |||
504 | ss.value < phdr.p_vaddr + phdr.p_memsz) | |||
505 | return true; | |||
506 | return false; | |||
507 | } | |||
508 | ||||
509 | // Returns symbols at the same offset as a given symbol, including SS itself. | |||
510 | // | |||
511 | // If two or more symbols are at the same offset, and at least one of | |||
512 | // them are copied by a copy relocation, all of them need to be copied. | |||
513 | // Otherwise, they would refer to different places at runtime. | |||
514 | template <class ELFT> | |||
515 | static SmallSet<SharedSymbol *, 4> getSymbolsAt(SharedSymbol &ss) { | |||
516 | using Elf_Sym = typename ELFT::Sym; | |||
517 | ||||
518 | SharedFile &file = ss.getFile(); | |||
519 | ||||
520 | SmallSet<SharedSymbol *, 4> ret; | |||
521 | for (const Elf_Sym &s : file.template getGlobalELFSyms<ELFT>()) { | |||
522 | if (s.st_shndx == SHN_UNDEF || s.st_shndx == SHN_ABS || | |||
523 | s.getType() == STT_TLS || s.st_value != ss.value) | |||
524 | continue; | |||
525 | StringRef name = check(s.getName(file.getStringTable())); | |||
526 | Symbol *sym = symtab->find(name); | |||
527 | if (auto *alias = dyn_cast_or_null<SharedSymbol>(sym)) | |||
528 | ret.insert(alias); | |||
529 | } | |||
530 | ||||
531 | // The loop does not check SHT_GNU_verneed, so ret does not contain | |||
532 | // non-default version symbols. If ss has a non-default version, ret won't | |||
533 | // contain ss. Just add ss unconditionally. If a non-default version alias is | |||
534 | // separately copy relocated, it and ss will have different addresses. | |||
535 | // Fortunately this case is impractical and fails with GNU ld as well. | |||
536 | ret.insert(&ss); | |||
537 | return ret; | |||
538 | } | |||
539 | ||||
540 | // When a symbol is copy relocated or we create a canonical plt entry, it is | |||
541 | // effectively a defined symbol. In the case of copy relocation the symbol is | |||
542 | // in .bss and in the case of a canonical plt entry it is in .plt. This function | |||
543 | // replaces the existing symbol with a Defined pointing to the appropriate | |||
544 | // location. | |||
545 | static void replaceWithDefined(Symbol &sym, SectionBase *sec, uint64_t value, | |||
546 | uint64_t size) { | |||
547 | Symbol old = sym; | |||
548 | ||||
549 | sym.replace(Defined{sym.file, sym.getName(), sym.binding, sym.stOther, | |||
550 | sym.type, value, size, sec}); | |||
551 | ||||
552 | sym.pltIndex = old.pltIndex; | |||
553 | sym.gotIndex = old.gotIndex; | |||
554 | sym.verdefIndex = old.verdefIndex; | |||
555 | sym.exportDynamic = true; | |||
556 | sym.isUsedInRegularObj = true; | |||
557 | } | |||
558 | ||||
559 | // Reserve space in .bss or .bss.rel.ro for copy relocation. | |||
560 | // | |||
561 | // The copy relocation is pretty much a hack. If you use a copy relocation | |||
562 | // in your program, not only the symbol name but the symbol's size, RW/RO | |||
563 | // bit and alignment become part of the ABI. In addition to that, if the | |||
564 | // symbol has aliases, the aliases become part of the ABI. That's subtle, | |||
565 | // but if you violate that implicit ABI, that can cause very counter- | |||
566 | // intuitive consequences. | |||
567 | // | |||
568 | // So, what is the copy relocation? It's for linking non-position | |||
569 | // independent code to DSOs. In an ideal world, all references to data | |||
570 | // exported by DSOs should go indirectly through GOT. But if object files | |||
571 | // are compiled as non-PIC, all data references are direct. There is no | |||
572 | // way for the linker to transform the code to use GOT, as machine | |||
573 | // instructions are already set in stone in object files. This is where | |||
574 | // the copy relocation takes a role. | |||
575 | // | |||
576 | // A copy relocation instructs the dynamic linker to copy data from a DSO | |||
577 | // to a specified address (which is usually in .bss) at load-time. If the | |||
578 | // static linker (that's us) finds a direct data reference to a DSO | |||
579 | // symbol, it creates a copy relocation, so that the symbol can be | |||
580 | // resolved as if it were in .bss rather than in a DSO. | |||
581 | // | |||
582 | // As you can see in this function, we create a copy relocation for the | |||
583 | // dynamic linker, and the relocation contains not only symbol name but | |||
584 | // various other information about the symbol. So, such attributes become a | |||
585 | // part of the ABI. | |||
586 | // | |||
587 | // Note for application developers: I can give you a piece of advice if | |||
588 | // you are writing a shared library. You probably should export only | |||
589 | // functions from your library. You shouldn't export variables. | |||
590 | // | |||
591 | // As an example what can happen when you export variables without knowing | |||
592 | // the semantics of copy relocations, assume that you have an exported | |||
593 | // variable of type T. It is an ABI-breaking change to add new members at | |||
594 | // end of T even though doing that doesn't change the layout of the | |||
595 | // existing members. That's because the space for the new members are not | |||
596 | // reserved in .bss unless you recompile the main program. That means they | |||
597 | // are likely to overlap with other data that happens to be laid out next | |||
598 | // to the variable in .bss. This kind of issue is sometimes very hard to | |||
599 | // debug. What's a solution? Instead of exporting a variable V from a DSO, | |||
600 | // define an accessor getV(). | |||
601 | template <class ELFT> static void addCopyRelSymbol(SharedSymbol &ss) { | |||
602 | // Copy relocation against zero-sized symbol doesn't make sense. | |||
603 | uint64_t symSize = ss.getSize(); | |||
604 | if (symSize == 0 || ss.alignment == 0) | |||
605 | fatal("cannot create a copy relocation for symbol " + toString(ss)); | |||
606 | ||||
607 | // See if this symbol is in a read-only segment. If so, preserve the symbol's | |||
608 | // memory protection by reserving space in the .bss.rel.ro section. | |||
609 | bool isRO = isReadOnly<ELFT>(ss); | |||
610 | BssSection *sec = | |||
611 | make<BssSection>(isRO ? ".bss.rel.ro" : ".bss", symSize, ss.alignment); | |||
612 | OutputSection *osec = (isRO ? in.bssRelRo : in.bss)->getParent(); | |||
613 | ||||
614 | // At this point, sectionBases has been migrated to sections. Append sec to | |||
615 | // sections. | |||
616 | if (osec->sectionCommands.empty() || | |||
617 | !isa<InputSectionDescription>(osec->sectionCommands.back())) | |||
618 | osec->sectionCommands.push_back(make<InputSectionDescription>("")); | |||
619 | auto *isd = cast<InputSectionDescription>(osec->sectionCommands.back()); | |||
620 | isd->sections.push_back(sec); | |||
621 | osec->commitSection(sec); | |||
622 | ||||
623 | // Look through the DSO's dynamic symbol table for aliases and create a | |||
624 | // dynamic symbol for each one. This causes the copy relocation to correctly | |||
625 | // interpose any aliases. | |||
626 | for (SharedSymbol *sym : getSymbolsAt<ELFT>(ss)) | |||
627 | replaceWithDefined(*sym, sec, 0, sym->size); | |||
628 | ||||
629 | mainPart->relaDyn->addSymbolReloc(target->copyRel, sec, 0, ss); | |||
630 | } | |||
631 | ||||
632 | // MIPS has an odd notion of "paired" relocations to calculate addends. | |||
633 | // For example, if a relocation is of R_MIPS_HI16, there must be a | |||
634 | // R_MIPS_LO16 relocation after that, and an addend is calculated using | |||
635 | // the two relocations. | |||
636 | template <class ELFT, class RelTy> | |||
637 | static int64_t computeMipsAddend(const RelTy &rel, const RelTy *end, | |||
638 | InputSectionBase &sec, RelExpr expr, | |||
639 | bool isLocal) { | |||
640 | if (expr == R_MIPS_GOTREL && isLocal) | |||
641 | return sec.getFile<ELFT>()->mipsGp0; | |||
642 | ||||
643 | // The ABI says that the paired relocation is used only for REL. | |||
644 | // See p. 4-17 at ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
645 | if (RelTy::IsRela) | |||
646 | return 0; | |||
647 | ||||
648 | RelType type = rel.getType(config->isMips64EL); | |||
649 | uint32_t pairTy = getMipsPairType(type, isLocal); | |||
650 | if (pairTy == R_MIPS_NONE) | |||
651 | return 0; | |||
652 | ||||
653 | const uint8_t *buf = sec.data().data(); | |||
654 | uint32_t symIndex = rel.getSymbol(config->isMips64EL); | |||
655 | ||||
656 | // To make things worse, paired relocations might not be contiguous in | |||
657 | // the relocation table, so we need to do linear search. *sigh* | |||
658 | for (const RelTy *ri = &rel; ri != end; ++ri) | |||
659 | if (ri->getType(config->isMips64EL) == pairTy && | |||
660 | ri->getSymbol(config->isMips64EL) == symIndex) | |||
661 | return target->getImplicitAddend(buf + ri->r_offset, pairTy); | |||
662 | ||||
663 | warn("can't find matching " + toString(pairTy) + " relocation for " + | |||
664 | toString(type)); | |||
665 | return 0; | |||
666 | } | |||
667 | ||||
668 | // Returns an addend of a given relocation. If it is RELA, an addend | |||
669 | // is in a relocation itself. If it is REL, we need to read it from an | |||
670 | // input section. | |||
671 | template <class ELFT, class RelTy> | |||
672 | static int64_t computeAddend(const RelTy &rel, const RelTy *end, | |||
673 | InputSectionBase &sec, RelExpr expr, | |||
674 | bool isLocal) { | |||
675 | int64_t addend; | |||
676 | RelType type = rel.getType(config->isMips64EL); | |||
677 | ||||
678 | if (RelTy::IsRela) { | |||
679 | addend = getAddend<ELFT>(rel); | |||
680 | } else { | |||
681 | const uint8_t *buf = sec.data().data(); | |||
682 | addend = target->getImplicitAddend(buf + rel.r_offset, type); | |||
683 | } | |||
684 | ||||
685 | if (config->emachine == EM_PPC64 && config->isPic && type == R_PPC64_TOC) | |||
686 | addend += getPPC64TocBase(); | |||
687 | if (config->emachine == EM_MIPS) | |||
688 | addend += computeMipsAddend<ELFT>(rel, end, sec, expr, isLocal); | |||
689 | ||||
690 | return addend; | |||
691 | } | |||
692 | ||||
693 | // Custom error message if Sym is defined in a discarded section. | |||
694 | template <class ELFT> | |||
695 | static std::string maybeReportDiscarded(Undefined &sym) { | |||
696 | auto *file = dyn_cast_or_null<ObjFile<ELFT>>(sym.file); | |||
697 | if (!file || !sym.discardedSecIdx || | |||
698 | file->getSections()[sym.discardedSecIdx] != &InputSection::discarded) | |||
699 | return ""; | |||
700 | ArrayRef<Elf_Shdr_Impl<ELFT>> objSections = | |||
701 | CHECK(file->getObj().sections(), file)check2((file->getObj().sections()), [&] { return toString (file); }); | |||
702 | ||||
703 | std::string msg; | |||
704 | if (sym.type == ELF::STT_SECTION) { | |||
705 | msg = "relocation refers to a discarded section: "; | |||
706 | msg += CHECK(check2((file->getObj().getSectionName(objSections[sym.discardedSecIdx ])), [&] { return toString(file); }) | |||
707 | file->getObj().getSectionName(objSections[sym.discardedSecIdx]), file)check2((file->getObj().getSectionName(objSections[sym.discardedSecIdx ])), [&] { return toString(file); }); | |||
708 | } else { | |||
709 | msg = "relocation refers to a symbol in a discarded section: " + | |||
710 | toString(sym); | |||
711 | } | |||
712 | msg += "\n>>> defined in " + toString(file); | |||
713 | ||||
714 | Elf_Shdr_Impl<ELFT> elfSec = objSections[sym.discardedSecIdx - 1]; | |||
715 | if (elfSec.sh_type != SHT_GROUP) | |||
716 | return msg; | |||
717 | ||||
718 | // If the discarded section is a COMDAT. | |||
719 | StringRef signature = file->getShtGroupSignature(objSections, elfSec); | |||
720 | if (const InputFile *prevailing = | |||
721 | symtab->comdatGroups.lookup(CachedHashStringRef(signature))) | |||
722 | msg += "\n>>> section group signature: " + signature.str() + | |||
723 | "\n>>> prevailing definition is in " + toString(prevailing); | |||
724 | return msg; | |||
725 | } | |||
726 | ||||
727 | // Undefined diagnostics are collected in a vector and emitted once all of | |||
728 | // them are known, so that some postprocessing on the list of undefined symbols | |||
729 | // can happen before lld emits diagnostics. | |||
730 | struct UndefinedDiag { | |||
731 | Symbol *sym; | |||
732 | struct Loc { | |||
733 | InputSectionBase *sec; | |||
734 | uint64_t offset; | |||
735 | }; | |||
736 | std::vector<Loc> locs; | |||
737 | bool isWarning; | |||
738 | }; | |||
739 | ||||
740 | static std::vector<UndefinedDiag> undefs; | |||
741 | ||||
742 | // Check whether the definition name def is a mangled function name that matches | |||
743 | // the reference name ref. | |||
744 | static bool canSuggestExternCForCXX(StringRef ref, StringRef def) { | |||
745 | llvm::ItaniumPartialDemangler d; | |||
746 | std::string name = def.str(); | |||
747 | if (d.partialDemangle(name.c_str())) | |||
748 | return false; | |||
749 | char *buf = d.getFunctionName(nullptr, nullptr); | |||
750 | if (!buf) | |||
751 | return false; | |||
752 | bool ret = ref == buf; | |||
753 | free(buf); | |||
754 | return ret; | |||
755 | } | |||
756 | ||||
757 | // Suggest an alternative spelling of an "undefined symbol" diagnostic. Returns | |||
758 | // the suggested symbol, which is either in the symbol table, or in the same | |||
759 | // file of sym. | |||
760 | template <class ELFT> | |||
761 | static const Symbol *getAlternativeSpelling(const Undefined &sym, | |||
762 | std::string &pre_hint, | |||
763 | std::string &post_hint) { | |||
764 | DenseMap<StringRef, const Symbol *> map; | |||
765 | if (auto *file = dyn_cast_or_null<ObjFile<ELFT>>(sym.file)) { | |||
766 | // If sym is a symbol defined in a discarded section, maybeReportDiscarded() | |||
767 | // will give an error. Don't suggest an alternative spelling. | |||
768 | if (file && sym.discardedSecIdx != 0 && | |||
769 | file->getSections()[sym.discardedSecIdx] == &InputSection::discarded) | |||
770 | return nullptr; | |||
771 | ||||
772 | // Build a map of local defined symbols. | |||
773 | for (const Symbol *s : sym.file->getSymbols()) | |||
774 | if (s->isLocal() && s->isDefined() && !s->getName().empty()) | |||
775 | map.try_emplace(s->getName(), s); | |||
776 | } | |||
777 | ||||
778 | auto suggest = [&](StringRef newName) -> const Symbol * { | |||
779 | // If defined locally. | |||
780 | if (const Symbol *s = map.lookup(newName)) | |||
781 | return s; | |||
782 | ||||
783 | // If in the symbol table and not undefined. | |||
784 | if (const Symbol *s = symtab->find(newName)) | |||
785 | if (!s->isUndefined()) | |||
786 | return s; | |||
787 | ||||
788 | return nullptr; | |||
789 | }; | |||
790 | ||||
791 | // This loop enumerates all strings of Levenshtein distance 1 as typo | |||
792 | // correction candidates and suggests the one that exists as a non-undefined | |||
793 | // symbol. | |||
794 | StringRef name = sym.getName(); | |||
795 | for (size_t i = 0, e = name.size(); i != e + 1; ++i) { | |||
796 | // Insert a character before name[i]. | |||
797 | std::string newName = (name.substr(0, i) + "0" + name.substr(i)).str(); | |||
798 | for (char c = '0'; c <= 'z'; ++c) { | |||
799 | newName[i] = c; | |||
800 | if (const Symbol *s = suggest(newName)) | |||
801 | return s; | |||
802 | } | |||
803 | if (i == e) | |||
804 | break; | |||
805 | ||||
806 | // Substitute name[i]. | |||
807 | newName = std::string(name); | |||
808 | for (char c = '0'; c <= 'z'; ++c) { | |||
809 | newName[i] = c; | |||
810 | if (const Symbol *s = suggest(newName)) | |||
811 | return s; | |||
812 | } | |||
813 | ||||
814 | // Transpose name[i] and name[i+1]. This is of edit distance 2 but it is | |||
815 | // common. | |||
816 | if (i + 1 < e) { | |||
817 | newName[i] = name[i + 1]; | |||
818 | newName[i + 1] = name[i]; | |||
819 | if (const Symbol *s = suggest(newName)) | |||
820 | return s; | |||
821 | } | |||
822 | ||||
823 | // Delete name[i]. | |||
824 | newName = (name.substr(0, i) + name.substr(i + 1)).str(); | |||
825 | if (const Symbol *s = suggest(newName)) | |||
826 | return s; | |||
827 | } | |||
828 | ||||
829 | // Case mismatch, e.g. Foo vs FOO. | |||
830 | for (auto &it : map) | |||
831 | if (name.equals_insensitive(it.first)) | |||
832 | return it.second; | |||
833 | for (Symbol *sym : symtab->symbols()) | |||
834 | if (!sym->isUndefined() && name.equals_insensitive(sym->getName())) | |||
835 | return sym; | |||
836 | ||||
837 | // The reference may be a mangled name while the definition is not. Suggest a | |||
838 | // missing extern "C". | |||
839 | if (name.startswith("_Z")) { | |||
840 | std::string buf = name.str(); | |||
841 | llvm::ItaniumPartialDemangler d; | |||
842 | if (!d.partialDemangle(buf.c_str())) | |||
843 | if (char *buf = d.getFunctionName(nullptr, nullptr)) { | |||
844 | const Symbol *s = suggest(buf); | |||
845 | free(buf); | |||
846 | if (s) { | |||
847 | pre_hint = ": extern \"C\" "; | |||
848 | return s; | |||
849 | } | |||
850 | } | |||
851 | } else { | |||
852 | const Symbol *s = nullptr; | |||
853 | for (auto &it : map) | |||
854 | if (canSuggestExternCForCXX(name, it.first)) { | |||
855 | s = it.second; | |||
856 | break; | |||
857 | } | |||
858 | if (!s) | |||
859 | for (Symbol *sym : symtab->symbols()) | |||
860 | if (canSuggestExternCForCXX(name, sym->getName())) { | |||
861 | s = sym; | |||
862 | break; | |||
863 | } | |||
864 | if (s) { | |||
865 | pre_hint = " to declare "; | |||
866 | post_hint = " as extern \"C\"?"; | |||
867 | return s; | |||
868 | } | |||
869 | } | |||
870 | ||||
871 | return nullptr; | |||
872 | } | |||
873 | ||||
874 | template <class ELFT> | |||
875 | static void reportUndefinedSymbol(const UndefinedDiag &undef, | |||
876 | bool correctSpelling) { | |||
877 | Symbol &sym = *undef.sym; | |||
878 | ||||
879 | auto visibility = [&]() -> std::string { | |||
880 | switch (sym.visibility) { | |||
881 | case STV_INTERNAL: | |||
882 | return "internal "; | |||
883 | case STV_HIDDEN: | |||
884 | return "hidden "; | |||
885 | case STV_PROTECTED: | |||
886 | return "protected "; | |||
887 | default: | |||
888 | return ""; | |||
889 | } | |||
890 | }; | |||
891 | ||||
892 | std::string msg = maybeReportDiscarded<ELFT>(cast<Undefined>(sym)); | |||
893 | if (msg.empty()) | |||
894 | msg = "undefined " + visibility() + "symbol: " + toString(sym); | |||
895 | ||||
896 | const size_t maxUndefReferences = 3; | |||
897 | size_t i = 0; | |||
898 | for (UndefinedDiag::Loc l : undef.locs) { | |||
899 | if (i >= maxUndefReferences) | |||
900 | break; | |||
901 | InputSectionBase &sec = *l.sec; | |||
902 | uint64_t offset = l.offset; | |||
903 | ||||
904 | msg += "\n>>> referenced by "; | |||
905 | std::string src = sec.getSrcMsg(sym, offset); | |||
906 | if (!src.empty()) | |||
907 | msg += src + "\n>>> "; | |||
908 | msg += sec.getObjMsg(offset); | |||
909 | i++; | |||
910 | } | |||
911 | ||||
912 | if (i < undef.locs.size()) | |||
913 | msg += ("\n>>> referenced " + Twine(undef.locs.size() - i) + " more times") | |||
914 | .str(); | |||
915 | ||||
916 | if (correctSpelling) { | |||
917 | std::string pre_hint = ": ", post_hint; | |||
918 | if (const Symbol *corrected = getAlternativeSpelling<ELFT>( | |||
919 | cast<Undefined>(sym), pre_hint, post_hint)) { | |||
920 | msg += "\n>>> did you mean" + pre_hint + toString(*corrected) + post_hint; | |||
921 | if (corrected->file) | |||
922 | msg += "\n>>> defined in: " + toString(corrected->file); | |||
923 | } | |||
924 | } | |||
925 | ||||
926 | if (sym.getName().startswith("_ZTV")) | |||
927 | msg += | |||
928 | "\n>>> the vtable symbol may be undefined because the class is missing " | |||
929 | "its key function (see https://lld.llvm.org/missingkeyfunction)"; | |||
930 | ||||
931 | if (undef.isWarning) | |||
932 | warn(msg); | |||
933 | else | |||
934 | error(msg, ErrorTag::SymbolNotFound, {sym.getName()}); | |||
935 | } | |||
936 | ||||
937 | template <class ELFT> void elf::reportUndefinedSymbols() { | |||
938 | // Find the first "undefined symbol" diagnostic for each diagnostic, and | |||
939 | // collect all "referenced from" lines at the first diagnostic. | |||
940 | DenseMap<Symbol *, UndefinedDiag *> firstRef; | |||
941 | for (UndefinedDiag &undef : undefs) { | |||
942 | assert(undef.locs.size() == 1)((void)0); | |||
943 | if (UndefinedDiag *canon = firstRef.lookup(undef.sym)) { | |||
944 | canon->locs.push_back(undef.locs[0]); | |||
945 | undef.locs.clear(); | |||
946 | } else | |||
947 | firstRef[undef.sym] = &undef; | |||
948 | } | |||
949 | ||||
950 | // Enable spell corrector for the first 2 diagnostics. | |||
951 | for (auto it : enumerate(undefs)) | |||
952 | if (!it.value().locs.empty()) | |||
953 | reportUndefinedSymbol<ELFT>(it.value(), it.index() < 2); | |||
954 | undefs.clear(); | |||
955 | } | |||
956 | ||||
957 | // Report an undefined symbol if necessary. | |||
958 | // Returns true if the undefined symbol will produce an error message. | |||
959 | static bool maybeReportUndefined(Symbol &sym, InputSectionBase &sec, | |||
960 | uint64_t offset) { | |||
961 | if (!sym.isUndefined()) | |||
962 | return false; | |||
963 | // If versioned, issue an error (even if the symbol is weak) because we don't | |||
964 | // know the defining filename which is required to construct a Verneed entry. | |||
965 | if (*sym.getVersionSuffix() == '@') { | |||
966 | undefs.push_back({&sym, {{&sec, offset}}, false}); | |||
967 | return true; | |||
968 | } | |||
969 | if (sym.isWeak()) | |||
970 | return false; | |||
971 | ||||
972 | bool canBeExternal = !sym.isLocal() && sym.visibility == STV_DEFAULT; | |||
973 | if (config->unresolvedSymbols == UnresolvedPolicy::Ignore && canBeExternal) | |||
974 | return false; | |||
975 | ||||
976 | // clang (as of 2019-06-12) / gcc (as of 8.2.1) PPC64 may emit a .rela.toc | |||
977 | // which references a switch table in a discarded .rodata/.text section. The | |||
978 | // .toc and the .rela.toc are incorrectly not placed in the comdat. The ELF | |||
979 | // spec says references from outside the group to a STB_LOCAL symbol are not | |||
980 | // allowed. Work around the bug. | |||
981 | // | |||
982 | // PPC32 .got2 is similar but cannot be fixed. Multiple .got2 is infeasible | |||
983 | // because .LC0-.LTOC is not representable if the two labels are in different | |||
984 | // .got2 | |||
985 | if (cast<Undefined>(sym).discardedSecIdx != 0 && | |||
986 | (sec.name == ".got2" || sec.name == ".toc")) | |||
987 | return false; | |||
988 | ||||
989 | bool isWarning = | |||
990 | (config->unresolvedSymbols == UnresolvedPolicy::Warn && canBeExternal) || | |||
991 | config->noinhibitExec; | |||
992 | undefs.push_back({&sym, {{&sec, offset}}, isWarning}); | |||
993 | return !isWarning; | |||
994 | } | |||
995 | ||||
996 | // MIPS N32 ABI treats series of successive relocations with the same offset | |||
997 | // as a single relocation. The similar approach used by N64 ABI, but this ABI | |||
998 | // packs all relocations into the single relocation record. Here we emulate | |||
999 | // this for the N32 ABI. Iterate over relocation with the same offset and put | |||
1000 | // theirs types into the single bit-set. | |||
1001 | template <class RelTy> static RelType getMipsN32RelType(RelTy *&rel, RelTy *end) { | |||
1002 | RelType type = 0; | |||
1003 | uint64_t offset = rel->r_offset; | |||
1004 | ||||
1005 | int n = 0; | |||
1006 | while (rel != end && rel->r_offset == offset) | |||
1007 | type |= (rel++)->getType(config->isMips64EL) << (8 * n++); | |||
1008 | return type; | |||
1009 | } | |||
1010 | ||||
1011 | // .eh_frame sections are mergeable input sections, so their input | |||
1012 | // offsets are not linearly mapped to output section. For each input | |||
1013 | // offset, we need to find a section piece containing the offset and | |||
1014 | // add the piece's base address to the input offset to compute the | |||
1015 | // output offset. That isn't cheap. | |||
1016 | // | |||
1017 | // This class is to speed up the offset computation. When we process | |||
1018 | // relocations, we access offsets in the monotonically increasing | |||
1019 | // order. So we can optimize for that access pattern. | |||
1020 | // | |||
1021 | // For sections other than .eh_frame, this class doesn't do anything. | |||
1022 | namespace { | |||
1023 | class OffsetGetter { | |||
1024 | public: | |||
1025 | explicit OffsetGetter(InputSectionBase &sec) { | |||
1026 | if (auto *eh = dyn_cast<EhInputSection>(&sec)) | |||
1027 | pieces = eh->pieces; | |||
1028 | } | |||
1029 | ||||
1030 | // Translates offsets in input sections to offsets in output sections. | |||
1031 | // Given offset must increase monotonically. We assume that Piece is | |||
1032 | // sorted by inputOff. | |||
1033 | uint64_t get(uint64_t off) { | |||
1034 | if (pieces.empty()) | |||
1035 | return off; | |||
1036 | ||||
1037 | while (i != pieces.size() && pieces[i].inputOff + pieces[i].size <= off) | |||
1038 | ++i; | |||
1039 | if (i == pieces.size()) | |||
1040 | fatal(".eh_frame: relocation is not in any piece"); | |||
1041 | ||||
1042 | // Pieces must be contiguous, so there must be no holes in between. | |||
1043 | assert(pieces[i].inputOff <= off && "Relocation not in any piece")((void)0); | |||
1044 | ||||
1045 | // Offset -1 means that the piece is dead (i.e. garbage collected). | |||
1046 | if (pieces[i].outputOff == -1) | |||
1047 | return -1; | |||
1048 | return pieces[i].outputOff + off - pieces[i].inputOff; | |||
1049 | } | |||
1050 | ||||
1051 | private: | |||
1052 | ArrayRef<EhSectionPiece> pieces; | |||
1053 | size_t i = 0; | |||
1054 | }; | |||
1055 | } // namespace | |||
1056 | ||||
1057 | static void addRelativeReloc(InputSectionBase *isec, uint64_t offsetInSec, | |||
1058 | Symbol &sym, int64_t addend, RelExpr expr, | |||
1059 | RelType type) { | |||
1060 | Partition &part = isec->getPartition(); | |||
1061 | ||||
1062 | // Add a relative relocation. If relrDyn section is enabled, and the | |||
1063 | // relocation offset is guaranteed to be even, add the relocation to | |||
1064 | // the relrDyn section, otherwise add it to the relaDyn section. | |||
1065 | // relrDyn sections don't support odd offsets. Also, relrDyn sections | |||
1066 | // don't store the addend values, so we must write it to the relocated | |||
1067 | // address. | |||
1068 | if (part.relrDyn && isec->alignment >= 2 && offsetInSec % 2 == 0) { | |||
1069 | isec->relocations.push_back({expr, type, offsetInSec, addend, &sym}); | |||
1070 | part.relrDyn->relocs.push_back({isec, offsetInSec}); | |||
1071 | return; | |||
1072 | } | |||
1073 | part.relaDyn->addRelativeReloc(target->relativeRel, isec, offsetInSec, sym, | |||
1074 | addend, type, expr); | |||
1075 | } | |||
1076 | ||||
1077 | template <class PltSection, class GotPltSection> | |||
1078 | static void addPltEntry(PltSection *plt, GotPltSection *gotPlt, | |||
1079 | RelocationBaseSection *rel, RelType type, Symbol &sym) { | |||
1080 | plt->addEntry(sym); | |||
1081 | gotPlt->addEntry(sym); | |||
1082 | rel->addReloc({type, gotPlt, sym.getGotPltOffset(), | |||
1083 | sym.isPreemptible ? DynamicReloc::AgainstSymbol | |||
1084 | : DynamicReloc::AddendOnlyWithTargetVA, | |||
1085 | sym, 0, R_ABS}); | |||
1086 | } | |||
1087 | ||||
1088 | static void addGotEntry(Symbol &sym) { | |||
1089 | in.got->addEntry(sym); | |||
1090 | ||||
1091 | RelExpr expr = sym.isTls() ? R_TPREL : R_ABS; | |||
1092 | uint64_t off = sym.getGotOffset(); | |||
1093 | ||||
1094 | // If a GOT slot value can be calculated at link-time, which is now, | |||
1095 | // we can just fill that out. | |||
1096 | // | |||
1097 | // (We don't actually write a value to a GOT slot right now, but we | |||
1098 | // add a static relocation to a Relocations vector so that | |||
1099 | // InputSection::relocate will do the work for us. We may be able | |||
1100 | // to just write a value now, but it is a TODO.) | |||
1101 | bool isLinkTimeConstant = | |||
1102 | !sym.isPreemptible && (!config->isPic || isAbsolute(sym)); | |||
1103 | if (isLinkTimeConstant) { | |||
1104 | in.got->relocations.push_back({expr, target->symbolicRel, off, 0, &sym}); | |||
1105 | return; | |||
1106 | } | |||
1107 | ||||
1108 | // Otherwise, we emit a dynamic relocation to .rel[a].dyn so that | |||
1109 | // the GOT slot will be fixed at load-time. | |||
1110 | if (!sym.isTls() && !sym.isPreemptible && config->isPic) { | |||
1111 | addRelativeReloc(in.got, off, sym, 0, R_ABS, target->symbolicRel); | |||
1112 | return; | |||
1113 | } | |||
1114 | mainPart->relaDyn->addAddendOnlyRelocIfNonPreemptible( | |||
1115 | sym.isTls() ? target->tlsGotRel : target->gotRel, in.got, off, sym, | |||
1116 | target->symbolicRel); | |||
1117 | } | |||
1118 | ||||
1119 | // Return true if we can define a symbol in the executable that | |||
1120 | // contains the value/function of a symbol defined in a shared | |||
1121 | // library. | |||
1122 | static bool canDefineSymbolInExecutable(Symbol &sym) { | |||
1123 | // If the symbol has default visibility the symbol defined in the | |||
1124 | // executable will preempt it. | |||
1125 | // Note that we want the visibility of the shared symbol itself, not | |||
1126 | // the visibility of the symbol in the output file we are producing. That is | |||
1127 | // why we use Sym.stOther. | |||
1128 | if ((sym.stOther & 0x3) == STV_DEFAULT) | |||
1129 | return true; | |||
1130 | ||||
1131 | // If we are allowed to break address equality of functions, defining | |||
1132 | // a plt entry will allow the program to call the function in the | |||
1133 | // .so, but the .so and the executable will no agree on the address | |||
1134 | // of the function. Similar logic for objects. | |||
1135 | return ((sym.isFunc() && config->ignoreFunctionAddressEquality) || | |||
1136 | (sym.isObject() && config->ignoreDataAddressEquality)); | |||
1137 | } | |||
1138 | ||||
1139 | // The reason we have to do this early scan is as follows | |||
1140 | // * To mmap the output file, we need to know the size | |||
1141 | // * For that, we need to know how many dynamic relocs we will have. | |||
1142 | // It might be possible to avoid this by outputting the file with write: | |||
1143 | // * Write the allocated output sections, computing addresses. | |||
1144 | // * Apply relocations, recording which ones require a dynamic reloc. | |||
1145 | // * Write the dynamic relocations. | |||
1146 | // * Write the rest of the file. | |||
1147 | // This would have some drawbacks. For example, we would only know if .rela.dyn | |||
1148 | // is needed after applying relocations. If it is, it will go after rw and rx | |||
1149 | // sections. Given that it is ro, we will need an extra PT_LOAD. This | |||
1150 | // complicates things for the dynamic linker and means we would have to reserve | |||
1151 | // space for the extra PT_LOAD even if we end up not using it. | |||
1152 | template <class ELFT, class RelTy> | |||
1153 | static void processRelocAux(InputSectionBase &sec, RelExpr expr, RelType type, | |||
1154 | uint64_t offset, Symbol &sym, const RelTy &rel, | |||
1155 | int64_t addend) { | |||
1156 | // If the relocation is known to be a link-time constant, we know no dynamic | |||
1157 | // relocation will be created, pass the control to relocateAlloc() or | |||
1158 | // relocateNonAlloc() to resolve it. | |||
1159 | // | |||
1160 | // The behavior of an undefined weak reference is implementation defined. For | |||
1161 | // non-link-time constants, we resolve relocations statically (let | |||
1162 | // relocate{,Non}Alloc() resolve them) for -no-pie and try producing dynamic | |||
1163 | // relocations for -pie and -shared. | |||
1164 | // | |||
1165 | // The general expectation of -no-pie static linking is that there is no | |||
1166 | // dynamic relocation (except IRELATIVE). Emitting dynamic relocations for | |||
1167 | // -shared matches the spirit of its -z undefs default. -pie has freedom on | |||
1168 | // choices, and we choose dynamic relocations to be consistent with the | |||
1169 | // handling of GOT-generating relocations. | |||
1170 | if (isStaticLinkTimeConstant(expr, type, sym, sec, offset) || | |||
1171 | (!config->isPic && sym.isUndefWeak())) { | |||
1172 | sec.relocations.push_back({expr, type, offset, addend, &sym}); | |||
1173 | return; | |||
1174 | } | |||
1175 | ||||
1176 | bool canWrite = (sec.flags & SHF_WRITE) || !config->zText; | |||
1177 | if (canWrite) { | |||
1178 | RelType rel = target->getDynRel(type); | |||
1179 | if (expr == R_GOT || (rel == target->symbolicRel && !sym.isPreemptible)) { | |||
1180 | addRelativeReloc(&sec, offset, sym, addend, expr, type); | |||
1181 | return; | |||
1182 | } else if (rel != 0) { | |||
1183 | if (config->emachine == EM_MIPS && rel == target->symbolicRel) | |||
1184 | rel = target->relativeRel; | |||
1185 | sec.getPartition().relaDyn->addSymbolReloc(rel, &sec, offset, sym, addend, | |||
1186 | type); | |||
1187 | ||||
1188 | // MIPS ABI turns using of GOT and dynamic relocations inside out. | |||
1189 | // While regular ABI uses dynamic relocations to fill up GOT entries | |||
1190 | // MIPS ABI requires dynamic linker to fills up GOT entries using | |||
1191 | // specially sorted dynamic symbol table. This affects even dynamic | |||
1192 | // relocations against symbols which do not require GOT entries | |||
1193 | // creation explicitly, i.e. do not have any GOT-relocations. So if | |||
1194 | // a preemptible symbol has a dynamic relocation we anyway have | |||
1195 | // to create a GOT entry for it. | |||
1196 | // If a non-preemptible symbol has a dynamic relocation against it, | |||
1197 | // dynamic linker takes it st_value, adds offset and writes down | |||
1198 | // result of the dynamic relocation. In case of preemptible symbol | |||
1199 | // dynamic linker performs symbol resolution, writes the symbol value | |||
1200 | // to the GOT entry and reads the GOT entry when it needs to perform | |||
1201 | // a dynamic relocation. | |||
1202 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19 | |||
1203 | if (config->emachine == EM_MIPS) | |||
1204 | in.mipsGot->addEntry(*sec.file, sym, addend, expr); | |||
1205 | return; | |||
1206 | } | |||
1207 | } | |||
1208 | ||||
1209 | // When producing an executable, we can perform copy relocations (for | |||
1210 | // STT_OBJECT) and canonical PLT (for STT_FUNC). | |||
1211 | if (!config->shared) { | |||
1212 | if (!canDefineSymbolInExecutable(sym)) { | |||
1213 | errorOrWarn("cannot preempt symbol: " + toString(sym) + | |||
1214 | getLocation(sec, sym, offset)); | |||
1215 | return; | |||
1216 | } | |||
1217 | ||||
1218 | if (sym.isObject()) { | |||
1219 | // Produce a copy relocation. | |||
1220 | if (auto *ss = dyn_cast<SharedSymbol>(&sym)) { | |||
1221 | if (!config->zCopyreloc) | |||
1222 | error("unresolvable relocation " + toString(type) + | |||
1223 | " against symbol '" + toString(*ss) + | |||
1224 | "'; recompile with -fPIC or remove '-z nocopyreloc'" + | |||
1225 | getLocation(sec, sym, offset)); | |||
1226 | addCopyRelSymbol<ELFT>(*ss); | |||
1227 | } | |||
1228 | sec.relocations.push_back({expr, type, offset, addend, &sym}); | |||
1229 | return; | |||
1230 | } | |||
1231 | ||||
1232 | // This handles a non PIC program call to function in a shared library. In | |||
1233 | // an ideal world, we could just report an error saying the relocation can | |||
1234 | // overflow at runtime. In the real world with glibc, crt1.o has a | |||
1235 | // R_X86_64_PC32 pointing to libc.so. | |||
1236 | // | |||
1237 | // The general idea on how to handle such cases is to create a PLT entry and | |||
1238 | // use that as the function value. | |||
1239 | // | |||
1240 | // For the static linking part, we just return a plt expr and everything | |||
1241 | // else will use the PLT entry as the address. | |||
1242 | // | |||
1243 | // The remaining problem is making sure pointer equality still works. We | |||
1244 | // need the help of the dynamic linker for that. We let it know that we have | |||
1245 | // a direct reference to a so symbol by creating an undefined symbol with a | |||
1246 | // non zero st_value. Seeing that, the dynamic linker resolves the symbol to | |||
1247 | // the value of the symbol we created. This is true even for got entries, so | |||
1248 | // pointer equality is maintained. To avoid an infinite loop, the only entry | |||
1249 | // that points to the real function is a dedicated got entry used by the | |||
1250 | // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT, | |||
1251 | // R_386_JMP_SLOT, etc). | |||
1252 | ||||
1253 | // For position independent executable on i386, the plt entry requires ebx | |||
1254 | // to be set. This causes two problems: | |||
1255 | // * If some code has a direct reference to a function, it was probably | |||
1256 | // compiled without -fPIE/-fPIC and doesn't maintain ebx. | |||
1257 | // * If a library definition gets preempted to the executable, it will have | |||
1258 | // the wrong ebx value. | |||
1259 | if (sym.isFunc()) { | |||
1260 | if (config->pie && config->emachine == EM_386) | |||
1261 | errorOrWarn("symbol '" + toString(sym) + | |||
1262 | "' cannot be preempted; recompile with -fPIE" + | |||
1263 | getLocation(sec, sym, offset)); | |||
1264 | if (!sym.isInPlt()) | |||
1265 | addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel, sym); | |||
1266 | if (!sym.isDefined()) { | |||
1267 | replaceWithDefined( | |||
1268 | sym, in.plt, | |||
1269 | target->pltHeaderSize + target->pltEntrySize * sym.pltIndex, 0); | |||
1270 | if (config->emachine == EM_PPC) { | |||
1271 | // PPC32 canonical PLT entries are at the beginning of .glink | |||
1272 | cast<Defined>(sym).value = in.plt->headerSize; | |||
1273 | in.plt->headerSize += 16; | |||
1274 | cast<PPC32GlinkSection>(in.plt)->canonical_plts.push_back(&sym); | |||
1275 | } | |||
1276 | } | |||
1277 | sym.needsPltAddr = true; | |||
1278 | sec.relocations.push_back({expr, type, offset, addend, &sym}); | |||
1279 | return; | |||
1280 | } | |||
1281 | } | |||
1282 | ||||
1283 | if (config->isPic) { | |||
1284 | if (!canWrite && !isRelExpr(expr)) | |||
1285 | errorOrWarn( | |||
1286 | "can't create dynamic relocation " + toString(type) + " against " + | |||
1287 | (sym.getName().empty() ? "local symbol" | |||
1288 | : "symbol: " + toString(sym)) + | |||
1289 | " in readonly segment; recompile object files with -fPIC " | |||
1290 | "or pass '-Wl,-z,notext' to allow text relocations in the output" + | |||
1291 | getLocation(sec, sym, offset)); | |||
1292 | else | |||
1293 | errorOrWarn( | |||
1294 | "relocation " + toString(type) + " cannot be used against " + | |||
1295 | (sym.getName().empty() ? "local symbol" : "symbol " + toString(sym)) + | |||
1296 | "; recompile with -fPIC" + getLocation(sec, sym, offset)); | |||
1297 | return; | |||
1298 | } | |||
1299 | ||||
1300 | errorOrWarn("symbol '" + toString(sym) + "' has no type" + | |||
1301 | getLocation(sec, sym, offset)); | |||
1302 | } | |||
1303 | ||||
1304 | template <class ELFT, class RelTy> | |||
1305 | static void scanReloc(InputSectionBase &sec, OffsetGetter &getOffset, RelTy *&i, | |||
1306 | RelTy *start, RelTy *end) { | |||
1307 | const RelTy &rel = *i; | |||
1308 | uint32_t symIndex = rel.getSymbol(config->isMips64EL); | |||
1309 | Symbol &sym = sec.getFile<ELFT>()->getSymbol(symIndex); | |||
1310 | RelType type; | |||
1311 | ||||
1312 | // Deal with MIPS oddity. | |||
1313 | if (config->mipsN32Abi) { | |||
1314 | type = getMipsN32RelType(i, end); | |||
1315 | } else { | |||
1316 | type = rel.getType(config->isMips64EL); | |||
1317 | ++i; | |||
1318 | } | |||
1319 | ||||
1320 | // Get an offset in an output section this relocation is applied to. | |||
1321 | uint64_t offset = getOffset.get(rel.r_offset); | |||
1322 | if (offset == uint64_t(-1)) | |||
1323 | return; | |||
1324 | ||||
1325 | // Error if the target symbol is undefined. Symbol index 0 may be used by | |||
1326 | // marker relocations, e.g. R_*_NONE and R_ARM_V4BX. Don't error on them. | |||
1327 | if (symIndex != 0 && maybeReportUndefined(sym, sec, rel.r_offset)) | |||
1328 | return; | |||
1329 | ||||
1330 | const uint8_t *relocatedAddr = sec.data().begin() + rel.r_offset; | |||
1331 | RelExpr expr = target->getRelExpr(type, sym, relocatedAddr); | |||
1332 | ||||
1333 | // Ignore R_*_NONE and other marker relocations. | |||
1334 | if (expr == R_NONE) | |||
1335 | return; | |||
1336 | ||||
1337 | // Read an addend. | |||
1338 | int64_t addend = computeAddend<ELFT>(rel, end, sec, expr, sym.isLocal()); | |||
1339 | ||||
1340 | if (config->emachine == EM_PPC64) { | |||
1341 | // We can separate the small code model relocations into 2 categories: | |||
1342 | // 1) Those that access the compiler generated .toc sections. | |||
1343 | // 2) Those that access the linker allocated got entries. | |||
1344 | // lld allocates got entries to symbols on demand. Since we don't try to | |||
1345 | // sort the got entries in any way, we don't have to track which objects | |||
1346 | // have got-based small code model relocs. The .toc sections get placed | |||
1347 | // after the end of the linker allocated .got section and we do sort those | |||
1348 | // so sections addressed with small code model relocations come first. | |||
1349 | if (isPPC64SmallCodeModelTocReloc(type)) | |||
1350 | sec.file->ppc64SmallCodeModelTocRelocs = true; | |||
1351 | ||||
1352 | // Record the TOC entry (.toc + addend) as not relaxable. See the comment in | |||
1353 | // InputSectionBase::relocateAlloc(). | |||
1354 | if (type == R_PPC64_TOC16_LO && sym.isSection() && isa<Defined>(sym) && | |||
1355 | cast<Defined>(sym).section->name == ".toc") | |||
1356 | ppc64noTocRelax.insert({&sym, addend}); | |||
1357 | ||||
1358 | if ((type == R_PPC64_TLSGD && expr == R_TLSDESC_CALL) || | |||
1359 | (type == R_PPC64_TLSLD && expr == R_TLSLD_HINT)) { | |||
1360 | if (i == end) { | |||
1361 | errorOrWarn("R_PPC64_TLSGD/R_PPC64_TLSLD may not be the last " | |||
1362 | "relocation" + | |||
1363 | getLocation(sec, sym, offset)); | |||
1364 | return; | |||
1365 | } | |||
1366 | ||||
1367 | // Offset the 4-byte aligned R_PPC64_TLSGD by one byte in the NOTOC case, | |||
1368 | // so we can discern it later from the toc-case. | |||
1369 | if (i->getType(/*isMips64EL=*/false) == R_PPC64_REL24_NOTOC) | |||
1370 | ++offset; | |||
1371 | } | |||
1372 | } | |||
1373 | ||||
1374 | // Relax relocations. | |||
1375 | // | |||
1376 | // If we know that a PLT entry will be resolved within the same ELF module, we | |||
1377 | // can skip PLT access and directly jump to the destination function. For | |||
1378 | // example, if we are linking a main executable, all dynamic symbols that can | |||
1379 | // be resolved within the executable will actually be resolved that way at | |||
1380 | // runtime, because the main executable is always at the beginning of a search | |||
1381 | // list. We can leverage that fact. | |||
1382 | if (!sym.isPreemptible && (!sym.isGnuIFunc() || config->zIfuncNoplt)) { | |||
1383 | if (expr != R_GOT_PC) { | |||
1384 | // The 0x8000 bit of r_addend of R_PPC_PLTREL24 is used to choose call | |||
1385 | // stub type. It should be ignored if optimized to R_PC. | |||
1386 | if (config->emachine == EM_PPC && expr == R_PPC32_PLTREL) | |||
1387 | addend &= ~0x8000; | |||
1388 | // R_HEX_GD_PLT_B22_PCREL (call a@GDPLT) is transformed into | |||
1389 | // call __tls_get_addr even if the symbol is non-preemptible. | |||
1390 | if (!(config->emachine == EM_HEXAGON && | |||
1391 | (type == R_HEX_GD_PLT_B22_PCREL || | |||
1392 | type == R_HEX_GD_PLT_B22_PCREL_X || | |||
1393 | type == R_HEX_GD_PLT_B32_PCREL_X))) | |||
1394 | expr = fromPlt(expr); | |||
1395 | } else if (!isAbsoluteValue(sym)) { | |||
1396 | expr = target->adjustGotPcExpr(type, addend, relocatedAddr); | |||
1397 | } | |||
1398 | } | |||
1399 | ||||
1400 | // If the relocation does not emit a GOT or GOTPLT entry but its computation | |||
1401 | // uses their addresses, we need GOT or GOTPLT to be created. | |||
1402 | // | |||
1403 | // The 4 types that relative GOTPLT are all x86 and x86-64 specific. | |||
1404 | if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_TLSGD_GOTPLT>(expr)) { | |||
1405 | in.gotPlt->hasGotPltOffRel = true; | |||
1406 | } else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC32_PLTREL, R_PPC64_TOCBASE, | |||
1407 | R_PPC64_RELAX_TOC>(expr)) { | |||
1408 | in.got->hasGotOffRel = true; | |||
1409 | } | |||
1410 | ||||
1411 | // Process TLS relocations, including relaxing TLS relocations. Note that | |||
1412 | // R_TPREL and R_TPREL_NEG relocations are resolved in processRelocAux. | |||
1413 | if (expr == R_TPREL || expr == R_TPREL_NEG) { | |||
1414 | if (config->shared) { | |||
1415 | errorOrWarn("relocation " + toString(type) + " against " + toString(sym) + | |||
1416 | " cannot be used with -shared" + | |||
1417 | getLocation(sec, sym, offset)); | |||
1418 | return; | |||
1419 | } | |||
1420 | } else if (unsigned processed = handleTlsRelocation<ELFT>( | |||
1421 | type, sym, sec, offset, addend, expr)) { | |||
1422 | i += (processed - 1); | |||
1423 | return; | |||
1424 | } | |||
1425 | ||||
1426 | // We were asked not to generate PLT entries for ifuncs. Instead, pass the | |||
1427 | // direct relocation on through. | |||
1428 | if (sym.isGnuIFunc() && config->zIfuncNoplt) { | |||
1429 | sym.exportDynamic = true; | |||
1430 | mainPart->relaDyn->addSymbolReloc(type, &sec, offset, sym, addend, type); | |||
1431 | return; | |||
1432 | } | |||
1433 | ||||
1434 | // Non-preemptible ifuncs require special handling. First, handle the usual | |||
1435 | // case where the symbol isn't one of these. | |||
1436 | if (!sym.isGnuIFunc() || sym.isPreemptible) { | |||
1437 | // If a relocation needs PLT, we create PLT and GOTPLT slots for the symbol. | |||
1438 | if (needsPlt(expr) && !sym.isInPlt()) | |||
1439 | addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel, sym); | |||
1440 | ||||
1441 | // Create a GOT slot if a relocation needs GOT. | |||
1442 | if (needsGot(expr)) { | |||
1443 | if (config->emachine == EM_MIPS) { | |||
1444 | // MIPS ABI has special rules to process GOT entries and doesn't | |||
1445 | // require relocation entries for them. A special case is TLS | |||
1446 | // relocations. In that case dynamic loader applies dynamic | |||
1447 | // relocations to initialize TLS GOT entries. | |||
1448 | // See "Global Offset Table" in Chapter 5 in the following document | |||
1449 | // for detailed description: | |||
1450 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
1451 | in.mipsGot->addEntry(*sec.file, sym, addend, expr); | |||
1452 | } else if (!sym.isInGot()) { | |||
1453 | addGotEntry(sym); | |||
1454 | } | |||
1455 | } | |||
1456 | } else { | |||
1457 | // Handle a reference to a non-preemptible ifunc. These are special in a | |||
1458 | // few ways: | |||
1459 | // | |||
1460 | // - Unlike most non-preemptible symbols, non-preemptible ifuncs do not have | |||
1461 | // a fixed value. But assuming that all references to the ifunc are | |||
1462 | // GOT-generating or PLT-generating, the handling of an ifunc is | |||
1463 | // relatively straightforward. We create a PLT entry in Iplt, which is | |||
1464 | // usually at the end of .plt, which makes an indirect call using a | |||
1465 | // matching GOT entry in igotPlt, which is usually at the end of .got.plt. | |||
1466 | // The GOT entry is relocated using an IRELATIVE relocation in relaIplt, | |||
1467 | // which is usually at the end of .rela.plt. Unlike most relocations in | |||
1468 | // .rela.plt, which may be evaluated lazily without -z now, dynamic | |||
1469 | // loaders evaluate IRELATIVE relocs eagerly, which means that for | |||
1470 | // IRELATIVE relocs only, GOT-generating relocations can point directly to | |||
1471 | // .got.plt without requiring a separate GOT entry. | |||
1472 | // | |||
1473 | // - Despite the fact that an ifunc does not have a fixed value, compilers | |||
1474 | // that are not passed -fPIC will assume that they do, and will emit | |||
1475 | // direct (non-GOT-generating, non-PLT-generating) relocations to the | |||
1476 | // symbol. This means that if a direct relocation to the symbol is | |||
1477 | // seen, the linker must set a value for the symbol, and this value must | |||
1478 | // be consistent no matter what type of reference is made to the symbol. | |||
1479 | // This can be done by creating a PLT entry for the symbol in the way | |||
1480 | // described above and making it canonical, that is, making all references | |||
1481 | // point to the PLT entry instead of the resolver. In lld we also store | |||
1482 | // the address of the PLT entry in the dynamic symbol table, which means | |||
1483 | // that the symbol will also have the same value in other modules. | |||
1484 | // Because the value loaded from the GOT needs to be consistent with | |||
1485 | // the value computed using a direct relocation, a non-preemptible ifunc | |||
1486 | // may end up with two GOT entries, one in .got.plt that points to the | |||
1487 | // address returned by the resolver and is used only by the PLT entry, | |||
1488 | // and another in .got that points to the PLT entry and is used by | |||
1489 | // GOT-generating relocations. | |||
1490 | // | |||
1491 | // - The fact that these symbols do not have a fixed value makes them an | |||
1492 | // exception to the general rule that a statically linked executable does | |||
1493 | // not require any form of dynamic relocation. To handle these relocations | |||
1494 | // correctly, the IRELATIVE relocations are stored in an array which a | |||
1495 | // statically linked executable's startup code must enumerate using the | |||
1496 | // linker-defined symbols __rela?_iplt_{start,end}. | |||
1497 | if (!sym.isInPlt()) { | |||
1498 | // Create PLT and GOTPLT slots for the symbol. | |||
1499 | sym.isInIplt = true; | |||
1500 | ||||
1501 | // Create a copy of the symbol to use as the target of the IRELATIVE | |||
1502 | // relocation in the igotPlt. This is in case we make the PLT canonical | |||
1503 | // later, which would overwrite the original symbol. | |||
1504 | // | |||
1505 | // FIXME: Creating a copy of the symbol here is a bit of a hack. All | |||
1506 | // that's really needed to create the IRELATIVE is the section and value, | |||
1507 | // so ideally we should just need to copy those. | |||
1508 | auto *directSym = make<Defined>(cast<Defined>(sym)); | |||
1509 | addPltEntry(in.iplt, in.igotPlt, in.relaIplt, target->iRelativeRel, | |||
1510 | *directSym); | |||
1511 | sym.pltIndex = directSym->pltIndex; | |||
1512 | } | |||
1513 | if (needsGot(expr)) { | |||
1514 | // Redirect GOT accesses to point to the Igot. | |||
1515 | // | |||
1516 | // This field is also used to keep track of whether we ever needed a GOT | |||
1517 | // entry. If we did and we make the PLT canonical later, we'll need to | |||
1518 | // create a GOT entry pointing to the PLT entry for Sym. | |||
1519 | sym.gotInIgot = true; | |||
1520 | } else if (!needsPlt(expr)) { | |||
1521 | // Make the ifunc's PLT entry canonical by changing the value of its | |||
1522 | // symbol to redirect all references to point to it. | |||
1523 | auto &d = cast<Defined>(sym); | |||
1524 | d.section = in.iplt; | |||
1525 | d.value = sym.pltIndex * target->ipltEntrySize; | |||
1526 | d.size = 0; | |||
1527 | // It's important to set the symbol type here so that dynamic loaders | |||
1528 | // don't try to call the PLT as if it were an ifunc resolver. | |||
1529 | d.type = STT_FUNC; | |||
1530 | ||||
1531 | if (sym.gotInIgot) { | |||
1532 | // We previously encountered a GOT generating reference that we | |||
1533 | // redirected to the Igot. Now that the PLT entry is canonical we must | |||
1534 | // clear the redirection to the Igot and add a GOT entry. As we've | |||
1535 | // changed the symbol type to STT_FUNC future GOT generating references | |||
1536 | // will naturally use this GOT entry. | |||
1537 | // | |||
1538 | // We don't need to worry about creating a MIPS GOT here because ifuncs | |||
1539 | // aren't a thing on MIPS. | |||
1540 | sym.gotInIgot = false; | |||
1541 | addGotEntry(sym); | |||
1542 | } | |||
1543 | } | |||
1544 | } | |||
1545 | ||||
1546 | processRelocAux<ELFT>(sec, expr, type, offset, sym, rel, addend); | |||
1547 | } | |||
1548 | ||||
1549 | // R_PPC64_TLSGD/R_PPC64_TLSLD is required to mark `bl __tls_get_addr` for | |||
1550 | // General Dynamic/Local Dynamic code sequences. If a GD/LD GOT relocation is | |||
1551 | // found but no R_PPC64_TLSGD/R_PPC64_TLSLD is seen, we assume that the | |||
1552 | // instructions are generated by very old IBM XL compilers. Work around the | |||
1553 | // issue by disabling GD/LD to IE/LE relaxation. | |||
1554 | template <class RelTy> | |||
1555 | static void checkPPC64TLSRelax(InputSectionBase &sec, ArrayRef<RelTy> rels) { | |||
1556 | // Skip if sec is synthetic (sec.file is null) or if sec has been marked. | |||
1557 | if (!sec.file || sec.file->ppc64DisableTLSRelax) | |||
1558 | return; | |||
1559 | bool hasGDLD = false; | |||
1560 | for (const RelTy &rel : rels) { | |||
1561 | RelType type = rel.getType(false); | |||
1562 | switch (type) { | |||
1563 | case R_PPC64_TLSGD: | |||
1564 | case R_PPC64_TLSLD: | |||
1565 | return; // Found a marker | |||
1566 | case R_PPC64_GOT_TLSGD16: | |||
1567 | case R_PPC64_GOT_TLSGD16_HA: | |||
1568 | case R_PPC64_GOT_TLSGD16_HI: | |||
1569 | case R_PPC64_GOT_TLSGD16_LO: | |||
1570 | case R_PPC64_GOT_TLSLD16: | |||
1571 | case R_PPC64_GOT_TLSLD16_HA: | |||
1572 | case R_PPC64_GOT_TLSLD16_HI: | |||
1573 | case R_PPC64_GOT_TLSLD16_LO: | |||
1574 | hasGDLD = true; | |||
1575 | break; | |||
1576 | } | |||
1577 | } | |||
1578 | if (hasGDLD) { | |||
1579 | sec.file->ppc64DisableTLSRelax = true; | |||
1580 | warn(toString(sec.file) + | |||
1581 | ": disable TLS relaxation due to R_PPC64_GOT_TLS* relocations without " | |||
1582 | "R_PPC64_TLSGD/R_PPC64_TLSLD relocations"); | |||
1583 | } | |||
1584 | } | |||
1585 | ||||
1586 | template <class ELFT, class RelTy> | |||
1587 | static void scanRelocs(InputSectionBase &sec, ArrayRef<RelTy> rels) { | |||
1588 | OffsetGetter getOffset(sec); | |||
1589 | ||||
1590 | // Not all relocations end up in Sec.Relocations, but a lot do. | |||
1591 | sec.relocations.reserve(rels.size()); | |||
1592 | ||||
1593 | if (config->emachine == EM_PPC64) | |||
1594 | checkPPC64TLSRelax<RelTy>(sec, rels); | |||
1595 | ||||
1596 | // For EhInputSection, OffsetGetter expects the relocations to be sorted by | |||
1597 | // r_offset. In rare cases (.eh_frame pieces are reordered by a linker | |||
1598 | // script), the relocations may be unordered. | |||
1599 | SmallVector<RelTy, 0> storage; | |||
1600 | if (isa<EhInputSection>(sec)) | |||
1601 | rels = sortRels(rels, storage); | |||
1602 | ||||
1603 | for (auto i = rels.begin(), end = rels.end(); i != end;) | |||
1604 | scanReloc<ELFT>(sec, getOffset, i, rels.begin(), end); | |||
1605 | ||||
1606 | // Sort relocations by offset for more efficient searching for | |||
1607 | // R_RISCV_PCREL_HI20 and R_PPC64_ADDR64. | |||
1608 | if (config->emachine == EM_RISCV || | |||
1609 | (config->emachine == EM_PPC64 && sec.name == ".toc")) | |||
1610 | llvm::stable_sort(sec.relocations, | |||
1611 | [](const Relocation &lhs, const Relocation &rhs) { | |||
1612 | return lhs.offset < rhs.offset; | |||
1613 | }); | |||
1614 | } | |||
1615 | ||||
1616 | template <class ELFT> void elf::scanRelocations(InputSectionBase &s) { | |||
1617 | if (s.areRelocsRela) | |||
1618 | scanRelocs<ELFT>(s, s.relas<ELFT>()); | |||
1619 | else | |||
1620 | scanRelocs<ELFT>(s, s.rels<ELFT>()); | |||
1621 | } | |||
1622 | ||||
1623 | static bool mergeCmp(const InputSection *a, const InputSection *b) { | |||
1624 | // std::merge requires a strict weak ordering. | |||
1625 | if (a->outSecOff < b->outSecOff) | |||
1626 | return true; | |||
1627 | ||||
1628 | if (a->outSecOff == b->outSecOff) { | |||
1629 | auto *ta = dyn_cast<ThunkSection>(a); | |||
1630 | auto *tb = dyn_cast<ThunkSection>(b); | |||
1631 | ||||
1632 | // Check if Thunk is immediately before any specific Target | |||
1633 | // InputSection for example Mips LA25 Thunks. | |||
1634 | if (ta && ta->getTargetInputSection() == b) | |||
1635 | return true; | |||
1636 | ||||
1637 | // Place Thunk Sections without specific targets before | |||
1638 | // non-Thunk Sections. | |||
1639 | if (ta && !tb && !ta->getTargetInputSection()) | |||
1640 | return true; | |||
1641 | } | |||
1642 | ||||
1643 | return false; | |||
1644 | } | |||
1645 | ||||
1646 | // Call Fn on every executable InputSection accessed via the linker script | |||
1647 | // InputSectionDescription::Sections. | |||
1648 | static void forEachInputSectionDescription( | |||
1649 | ArrayRef<OutputSection *> outputSections, | |||
1650 | llvm::function_ref<void(OutputSection *, InputSectionDescription *)> fn) { | |||
1651 | for (OutputSection *os : outputSections) { | |||
1652 | if (!(os->flags & SHF_ALLOC) || !(os->flags & SHF_EXECINSTR)) | |||
1653 | continue; | |||
1654 | for (BaseCommand *bc : os->sectionCommands) | |||
1655 | if (auto *isd = dyn_cast<InputSectionDescription>(bc)) | |||
1656 | fn(os, isd); | |||
1657 | } | |||
1658 | } | |||
1659 | ||||
1660 | // Thunk Implementation | |||
1661 | // | |||
1662 | // Thunks (sometimes called stubs, veneers or branch islands) are small pieces | |||
1663 | // of code that the linker inserts inbetween a caller and a callee. The thunks | |||
1664 | // are added at link time rather than compile time as the decision on whether | |||
1665 | // a thunk is needed, such as the caller and callee being out of range, can only | |||
1666 | // be made at link time. | |||
1667 | // | |||
1668 | // It is straightforward to tell given the current state of the program when a | |||
1669 | // thunk is needed for a particular call. The more difficult part is that | |||
1670 | // the thunk needs to be placed in the program such that the caller can reach | |||
1671 | // the thunk and the thunk can reach the callee; furthermore, adding thunks to | |||
1672 | // the program alters addresses, which can mean more thunks etc. | |||
1673 | // | |||
1674 | // In lld we have a synthetic ThunkSection that can hold many Thunks. | |||
1675 | // The decision to have a ThunkSection act as a container means that we can | |||
1676 | // more easily handle the most common case of a single block of contiguous | |||
1677 | // Thunks by inserting just a single ThunkSection. | |||
1678 | // | |||
1679 | // The implementation of Thunks in lld is split across these areas | |||
1680 | // Relocations.cpp : Framework for creating and placing thunks | |||
1681 | // Thunks.cpp : The code generated for each supported thunk | |||
1682 | // Target.cpp : Target specific hooks that the framework uses to decide when | |||
1683 | // a thunk is used | |||
1684 | // Synthetic.cpp : Implementation of ThunkSection | |||
1685 | // Writer.cpp : Iteratively call framework until no more Thunks added | |||
1686 | // | |||
1687 | // Thunk placement requirements: | |||
1688 | // Mips LA25 thunks. These must be placed immediately before the callee section | |||
1689 | // We can assume that the caller is in range of the Thunk. These are modelled | |||
1690 | // by Thunks that return the section they must precede with | |||
1691 | // getTargetInputSection(). | |||
1692 | // | |||
1693 | // ARM interworking and range extension thunks. These thunks must be placed | |||
1694 | // within range of the caller. All implemented ARM thunks can always reach the | |||
1695 | // callee as they use an indirect jump via a register that has no range | |||
1696 | // restrictions. | |||
1697 | // | |||
1698 | // Thunk placement algorithm: | |||
1699 | // For Mips LA25 ThunkSections; the placement is explicit, it has to be before | |||
1700 | // getTargetInputSection(). | |||
1701 | // | |||
1702 | // For thunks that must be placed within range of the caller there are many | |||
1703 | // possible choices given that the maximum range from the caller is usually | |||
1704 | // much larger than the average InputSection size. Desirable properties include: | |||
1705 | // - Maximize reuse of thunks by multiple callers | |||
1706 | // - Minimize number of ThunkSections to simplify insertion | |||
1707 | // - Handle impact of already added Thunks on addresses | |||
1708 | // - Simple to understand and implement | |||
1709 | // | |||
1710 | // In lld for the first pass, we pre-create one or more ThunkSections per | |||
1711 | // InputSectionDescription at Target specific intervals. A ThunkSection is | |||
1712 | // placed so that the estimated end of the ThunkSection is within range of the | |||
1713 | // start of the InputSectionDescription or the previous ThunkSection. For | |||
1714 | // example: | |||
1715 | // InputSectionDescription | |||
1716 | // Section 0 | |||
1717 | // ... | |||
1718 | // Section N | |||
1719 | // ThunkSection 0 | |||
1720 | // Section N + 1 | |||
1721 | // ... | |||
1722 | // Section N + K | |||
1723 | // Thunk Section 1 | |||
1724 | // | |||
1725 | // The intention is that we can add a Thunk to a ThunkSection that is well | |||
1726 | // spaced enough to service a number of callers without having to do a lot | |||
1727 | // of work. An important principle is that it is not an error if a Thunk cannot | |||
1728 | // be placed in a pre-created ThunkSection; when this happens we create a new | |||
1729 | // ThunkSection placed next to the caller. This allows us to handle the vast | |||
1730 | // majority of thunks simply, but also handle rare cases where the branch range | |||
1731 | // is smaller than the target specific spacing. | |||
1732 | // | |||
1733 | // The algorithm is expected to create all the thunks that are needed in a | |||
1734 | // single pass, with a small number of programs needing a second pass due to | |||
1735 | // the insertion of thunks in the first pass increasing the offset between | |||
1736 | // callers and callees that were only just in range. | |||
1737 | // | |||
1738 | // A consequence of allowing new ThunkSections to be created outside of the | |||
1739 | // pre-created ThunkSections is that in rare cases calls to Thunks that were in | |||
1740 | // range in pass K, are out of range in some pass > K due to the insertion of | |||
1741 | // more Thunks in between the caller and callee. When this happens we retarget | |||
1742 | // the relocation back to the original target and create another Thunk. | |||
1743 | ||||
1744 | // Remove ThunkSections that are empty, this should only be the initial set | |||
1745 | // precreated on pass 0. | |||
1746 | ||||
1747 | // Insert the Thunks for OutputSection OS into their designated place | |||
1748 | // in the Sections vector, and recalculate the InputSection output section | |||
1749 | // offsets. | |||
1750 | // This may invalidate any output section offsets stored outside of InputSection | |||
1751 | void ThunkCreator::mergeThunks(ArrayRef<OutputSection *> outputSections) { | |||
1752 | forEachInputSectionDescription( | |||
1753 | outputSections, [&](OutputSection *os, InputSectionDescription *isd) { | |||
1754 | if (isd->thunkSections.empty()) | |||
1755 | return; | |||
1756 | ||||
1757 | // Remove any zero sized precreated Thunks. | |||
1758 | llvm::erase_if(isd->thunkSections, | |||
1759 | [](const std::pair<ThunkSection *, uint32_t> &ts) { | |||
1760 | return ts.first->getSize() == 0; | |||
1761 | }); | |||
1762 | ||||
1763 | // ISD->ThunkSections contains all created ThunkSections, including | |||
1764 | // those inserted in previous passes. Extract the Thunks created this | |||
1765 | // pass and order them in ascending outSecOff. | |||
1766 | std::vector<ThunkSection *> newThunks; | |||
1767 | for (std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections) | |||
1768 | if (ts.second == pass) | |||
1769 | newThunks.push_back(ts.first); | |||
1770 | llvm::stable_sort(newThunks, | |||
1771 | [](const ThunkSection *a, const ThunkSection *b) { | |||
1772 | return a->outSecOff < b->outSecOff; | |||
1773 | }); | |||
1774 | ||||
1775 | // Merge sorted vectors of Thunks and InputSections by outSecOff | |||
1776 | std::vector<InputSection *> tmp; | |||
1777 | tmp.reserve(isd->sections.size() + newThunks.size()); | |||
1778 | ||||
1779 | std::merge(isd->sections.begin(), isd->sections.end(), | |||
1780 | newThunks.begin(), newThunks.end(), std::back_inserter(tmp), | |||
1781 | mergeCmp); | |||
1782 | ||||
1783 | isd->sections = std::move(tmp); | |||
1784 | }); | |||
1785 | } | |||
1786 | ||||
1787 | // Find or create a ThunkSection within the InputSectionDescription (ISD) that | |||
1788 | // is in range of Src. An ISD maps to a range of InputSections described by a | |||
1789 | // linker script section pattern such as { .text .text.* }. | |||
1790 | ThunkSection *ThunkCreator::getISDThunkSec(OutputSection *os, | |||
1791 | InputSection *isec, | |||
1792 | InputSectionDescription *isd, | |||
1793 | const Relocation &rel, | |||
1794 | uint64_t src) { | |||
1795 | for (std::pair<ThunkSection *, uint32_t> tp : isd->thunkSections) { | |||
1796 | ThunkSection *ts = tp.first; | |||
1797 | uint64_t tsBase = os->addr + ts->outSecOff + rel.addend; | |||
1798 | uint64_t tsLimit = tsBase + ts->getSize() + rel.addend; | |||
1799 | if (target->inBranchRange(rel.type, src, | |||
1800 | (src > tsLimit) ? tsBase : tsLimit)) | |||
1801 | return ts; | |||
1802 | } | |||
1803 | ||||
1804 | // No suitable ThunkSection exists. This can happen when there is a branch | |||
1805 | // with lower range than the ThunkSection spacing or when there are too | |||
1806 | // many Thunks. Create a new ThunkSection as close to the InputSection as | |||
1807 | // possible. Error if InputSection is so large we cannot place ThunkSection | |||
1808 | // anywhere in Range. | |||
1809 | uint64_t thunkSecOff = isec->outSecOff; | |||
1810 | if (!target->inBranchRange(rel.type, src, | |||
1811 | os->addr + thunkSecOff + rel.addend)) { | |||
1812 | thunkSecOff = isec->outSecOff + isec->getSize(); | |||
1813 | if (!target->inBranchRange(rel.type, src, | |||
1814 | os->addr + thunkSecOff + rel.addend)) | |||
1815 | fatal("InputSection too large for range extension thunk " + | |||
1816 | isec->getObjMsg(src - (os->addr + isec->outSecOff))); | |||
1817 | } | |||
1818 | return addThunkSection(os, isd, thunkSecOff); | |||
1819 | } | |||
1820 | ||||
1821 | // Add a Thunk that needs to be placed in a ThunkSection that immediately | |||
1822 | // precedes its Target. | |||
1823 | ThunkSection *ThunkCreator::getISThunkSec(InputSection *isec) { | |||
1824 | ThunkSection *ts = thunkedSections.lookup(isec); | |||
1825 | if (ts) | |||
1826 | return ts; | |||
1827 | ||||
1828 | // Find InputSectionRange within Target Output Section (TOS) that the | |||
1829 | // InputSection (IS) that we need to precede is in. | |||
1830 | OutputSection *tos = isec->getParent(); | |||
1831 | for (BaseCommand *bc : tos->sectionCommands) { | |||
1832 | auto *isd = dyn_cast<InputSectionDescription>(bc); | |||
1833 | if (!isd || isd->sections.empty()) | |||
1834 | continue; | |||
1835 | ||||
1836 | InputSection *first = isd->sections.front(); | |||
1837 | InputSection *last = isd->sections.back(); | |||
1838 | ||||
1839 | if (isec->outSecOff < first->outSecOff || last->outSecOff < isec->outSecOff) | |||
1840 | continue; | |||
1841 | ||||
1842 | ts = addThunkSection(tos, isd, isec->outSecOff); | |||
1843 | thunkedSections[isec] = ts; | |||
1844 | return ts; | |||
1845 | } | |||
1846 | ||||
1847 | return nullptr; | |||
1848 | } | |||
1849 | ||||
1850 | // Create one or more ThunkSections per OS that can be used to place Thunks. | |||
1851 | // We attempt to place the ThunkSections using the following desirable | |||
1852 | // properties: | |||
1853 | // - Within range of the maximum number of callers | |||
1854 | // - Minimise the number of ThunkSections | |||
1855 | // | |||
1856 | // We follow a simple but conservative heuristic to place ThunkSections at | |||
1857 | // offsets that are multiples of a Target specific branch range. | |||
1858 | // For an InputSectionDescription that is smaller than the range, a single | |||
1859 | // ThunkSection at the end of the range will do. | |||
1860 | // | |||
1861 | // For an InputSectionDescription that is more than twice the size of the range, | |||
1862 | // we place the last ThunkSection at range bytes from the end of the | |||
1863 | // InputSectionDescription in order to increase the likelihood that the | |||
1864 | // distance from a thunk to its target will be sufficiently small to | |||
1865 | // allow for the creation of a short thunk. | |||
1866 | void ThunkCreator::createInitialThunkSections( | |||
1867 | ArrayRef<OutputSection *> outputSections) { | |||
1868 | uint32_t thunkSectionSpacing = target->getThunkSectionSpacing(); | |||
1869 | ||||
1870 | forEachInputSectionDescription( | |||
1871 | outputSections, [&](OutputSection *os, InputSectionDescription *isd) { | |||
1872 | if (isd->sections.empty()) | |||
| ||||
1873 | return; | |||
1874 | ||||
1875 | uint32_t isdBegin = isd->sections.front()->outSecOff; | |||
1876 | uint32_t isdEnd = | |||
1877 | isd->sections.back()->outSecOff + isd->sections.back()->getSize(); | |||
1878 | uint32_t lastThunkLowerBound = -1; | |||
1879 | if (isdEnd - isdBegin > thunkSectionSpacing * 2) | |||
1880 | lastThunkLowerBound = isdEnd - thunkSectionSpacing; | |||
1881 | ||||
1882 | uint32_t isecLimit; | |||
1883 | uint32_t prevIsecLimit = isdBegin; | |||
1884 | uint32_t thunkUpperBound = isdBegin + thunkSectionSpacing; | |||
1885 | ||||
1886 | for (const InputSection *isec : isd->sections) { | |||
1887 | isecLimit = isec->outSecOff + isec->getSize(); | |||
1888 | if (isecLimit > thunkUpperBound) { | |||
1889 | addThunkSection(os, isd, prevIsecLimit); | |||
1890 | thunkUpperBound = prevIsecLimit + thunkSectionSpacing; | |||
1891 | } | |||
1892 | if (isecLimit > lastThunkLowerBound) | |||
1893 | break; | |||
1894 | prevIsecLimit = isecLimit; | |||
1895 | } | |||
1896 | addThunkSection(os, isd, isecLimit); | |||
| ||||
1897 | }); | |||
1898 | } | |||
1899 | ||||
1900 | ThunkSection *ThunkCreator::addThunkSection(OutputSection *os, | |||
1901 | InputSectionDescription *isd, | |||
1902 | uint64_t off) { | |||
1903 | auto *ts = make<ThunkSection>(os, off); | |||
1904 | ts->partition = os->partition; | |||
1905 | if ((config->fixCortexA53Errata843419 || config->fixCortexA8) && | |||
1906 | !isd->sections.empty()) { | |||
1907 | // The errata fixes are sensitive to addresses modulo 4 KiB. When we add | |||
1908 | // thunks we disturb the base addresses of sections placed after the thunks | |||
1909 | // this makes patches we have generated redundant, and may cause us to | |||
1910 | // generate more patches as different instructions are now in sensitive | |||
1911 | // locations. When we generate more patches we may force more branches to | |||
1912 | // go out of range, causing more thunks to be generated. In pathological | |||
1913 | // cases this can cause the address dependent content pass not to converge. | |||
1914 | // We fix this by rounding up the size of the ThunkSection to 4KiB, this | |||
1915 | // limits the insertion of a ThunkSection on the addresses modulo 4 KiB, | |||
1916 | // which means that adding Thunks to the section does not invalidate | |||
1917 | // errata patches for following code. | |||
1918 | // Rounding up the size to 4KiB has consequences for code-size and can | |||
1919 | // trip up linker script defined assertions. For example the linux kernel | |||
1920 | // has an assertion that what LLD represents as an InputSectionDescription | |||
1921 | // does not exceed 4 KiB even if the overall OutputSection is > 128 Mib. | |||
1922 | // We use the heuristic of rounding up the size when both of the following | |||
1923 | // conditions are true: | |||
1924 | // 1.) The OutputSection is larger than the ThunkSectionSpacing. This | |||
1925 | // accounts for the case where no single InputSectionDescription is | |||
1926 | // larger than the OutputSection size. This is conservative but simple. | |||
1927 | // 2.) The InputSectionDescription is larger than 4 KiB. This will prevent | |||
1928 | // any assertion failures that an InputSectionDescription is < 4 KiB | |||
1929 | // in size. | |||
1930 | uint64_t isdSize = isd->sections.back()->outSecOff + | |||
1931 | isd->sections.back()->getSize() - | |||
1932 | isd->sections.front()->outSecOff; | |||
1933 | if (os->size > target->getThunkSectionSpacing() && isdSize > 4096) | |||
1934 | ts->roundUpSizeForErrata = true; | |||
1935 | } | |||
1936 | isd->thunkSections.push_back({ts, pass}); | |||
1937 | return ts; | |||
1938 | } | |||
1939 | ||||
1940 | static bool isThunkSectionCompatible(InputSection *source, | |||
1941 | SectionBase *target) { | |||
1942 | // We can't reuse thunks in different loadable partitions because they might | |||
1943 | // not be loaded. But partition 1 (the main partition) will always be loaded. | |||
1944 | if (source->partition != target->partition) | |||
1945 | return target->partition == 1; | |||
1946 | return true; | |||
1947 | } | |||
1948 | ||||
1949 | static int64_t getPCBias(RelType type) { | |||
1950 | if (config->emachine != EM_ARM) | |||
1951 | return 0; | |||
1952 | switch (type) { | |||
1953 | case R_ARM_THM_JUMP19: | |||
1954 | case R_ARM_THM_JUMP24: | |||
1955 | case R_ARM_THM_CALL: | |||
1956 | return 4; | |||
1957 | default: | |||
1958 | return 8; | |||
1959 | } | |||
1960 | } | |||
1961 | ||||
1962 | std::pair<Thunk *, bool> ThunkCreator::getThunk(InputSection *isec, | |||
1963 | Relocation &rel, uint64_t src) { | |||
1964 | std::vector<Thunk *> *thunkVec = nullptr; | |||
1965 | // Arm and Thumb have a PC Bias of 8 and 4 respectively, this is cancelled | |||
1966 | // out in the relocation addend. We compensate for the PC bias so that | |||
1967 | // an Arm and Thumb relocation to the same destination get the same keyAddend, | |||
1968 | // which is usually 0. | |||
1969 | int64_t keyAddend = rel.addend + getPCBias(rel.type); | |||
1970 | ||||
1971 | // We use a ((section, offset), addend) pair to find the thunk position if | |||
1972 | // possible so that we create only one thunk for aliased symbols or ICFed | |||
1973 | // sections. There may be multiple relocations sharing the same (section, | |||
1974 | // offset + addend) pair. We may revert the relocation back to its original | |||
1975 | // non-Thunk target, so we cannot fold offset + addend. | |||
1976 | if (auto *d = dyn_cast<Defined>(rel.sym)) | |||
1977 | if (!d->isInPlt() && d->section) | |||
1978 | thunkVec = &thunkedSymbolsBySectionAndAddend[{ | |||
1979 | {d->section->repl, d->value}, keyAddend}]; | |||
1980 | if (!thunkVec) | |||
1981 | thunkVec = &thunkedSymbols[{rel.sym, keyAddend}]; | |||
1982 | ||||
1983 | // Check existing Thunks for Sym to see if they can be reused | |||
1984 | for (Thunk *t : *thunkVec) | |||
1985 | if (isThunkSectionCompatible(isec, t->getThunkTargetSym()->section) && | |||
1986 | t->isCompatibleWith(*isec, rel) && | |||
1987 | target->inBranchRange(rel.type, src, | |||
1988 | t->getThunkTargetSym()->getVA(rel.addend))) | |||
1989 | return std::make_pair(t, false); | |||
1990 | ||||
1991 | // No existing compatible Thunk in range, create a new one | |||
1992 | Thunk *t = addThunk(*isec, rel); | |||
1993 | thunkVec->push_back(t); | |||
1994 | return std::make_pair(t, true); | |||
1995 | } | |||
1996 | ||||
1997 | // Return true if the relocation target is an in range Thunk. | |||
1998 | // Return false if the relocation is not to a Thunk. If the relocation target | |||
1999 | // was originally to a Thunk, but is no longer in range we revert the | |||
2000 | // relocation back to its original non-Thunk target. | |||
2001 | bool ThunkCreator::normalizeExistingThunk(Relocation &rel, uint64_t src) { | |||
2002 | if (Thunk *t = thunks.lookup(rel.sym)) { | |||
2003 | if (target->inBranchRange(rel.type, src, rel.sym->getVA(rel.addend))) | |||
2004 | return true; | |||
2005 | rel.sym = &t->destination; | |||
2006 | rel.addend = t->addend; | |||
2007 | if (rel.sym->isInPlt()) | |||
2008 | rel.expr = toPlt(rel.expr); | |||
2009 | } | |||
2010 | return false; | |||
2011 | } | |||
2012 | ||||
2013 | // Process all relocations from the InputSections that have been assigned | |||
2014 | // to InputSectionDescriptions and redirect through Thunks if needed. The | |||
2015 | // function should be called iteratively until it returns false. | |||
2016 | // | |||
2017 | // PreConditions: | |||
2018 | // All InputSections that may need a Thunk are reachable from | |||
2019 | // OutputSectionCommands. | |||
2020 | // | |||
2021 | // All OutputSections have an address and all InputSections have an offset | |||
2022 | // within the OutputSection. | |||
2023 | // | |||
2024 | // The offsets between caller (relocation place) and callee | |||
2025 | // (relocation target) will not be modified outside of createThunks(). | |||
2026 | // | |||
2027 | // PostConditions: | |||
2028 | // If return value is true then ThunkSections have been inserted into | |||
2029 | // OutputSections. All relocations that needed a Thunk based on the information | |||
2030 | // available to createThunks() on entry have been redirected to a Thunk. Note | |||
2031 | // that adding Thunks changes offsets between caller and callee so more Thunks | |||
2032 | // may be required. | |||
2033 | // | |||
2034 | // If return value is false then no more Thunks are needed, and createThunks has | |||
2035 | // made no changes. If the target requires range extension thunks, currently | |||
2036 | // ARM, then any future change in offset between caller and callee risks a | |||
2037 | // relocation out of range error. | |||
2038 | bool ThunkCreator::createThunks(ArrayRef<OutputSection *> outputSections) { | |||
2039 | bool addressesChanged = false; | |||
2040 | ||||
2041 | if (pass == 0 && target->getThunkSectionSpacing()) | |||
2042 | createInitialThunkSections(outputSections); | |||
2043 | ||||
2044 | // Create all the Thunks and insert them into synthetic ThunkSections. The | |||
2045 | // ThunkSections are later inserted back into InputSectionDescriptions. | |||
2046 | // We separate the creation of ThunkSections from the insertion of the | |||
2047 | // ThunkSections as ThunkSections are not always inserted into the same | |||
2048 | // InputSectionDescription as the caller. | |||
2049 | forEachInputSectionDescription( | |||
2050 | outputSections, [&](OutputSection *os, InputSectionDescription *isd) { | |||
2051 | for (InputSection *isec : isd->sections) | |||
2052 | for (Relocation &rel : isec->relocations) { | |||
2053 | uint64_t src = isec->getVA(rel.offset); | |||
2054 | ||||
2055 | // If we are a relocation to an existing Thunk, check if it is | |||
2056 | // still in range. If not then Rel will be altered to point to its | |||
2057 | // original target so another Thunk can be generated. | |||
2058 | if (pass > 0 && normalizeExistingThunk(rel, src)) | |||
2059 | continue; | |||
2060 | ||||
2061 | if (!target->needsThunk(rel.expr, rel.type, isec->file, src, | |||
2062 | *rel.sym, rel.addend)) | |||
2063 | continue; | |||
2064 | ||||
2065 | Thunk *t; | |||
2066 | bool isNew; | |||
2067 | std::tie(t, isNew) = getThunk(isec, rel, src); | |||
2068 | ||||
2069 | if (isNew) { | |||
2070 | // Find or create a ThunkSection for the new Thunk | |||
2071 | ThunkSection *ts; | |||
2072 | if (auto *tis = t->getTargetInputSection()) | |||
2073 | ts = getISThunkSec(tis); | |||
2074 | else | |||
2075 | ts = getISDThunkSec(os, isec, isd, rel, src); | |||
2076 | ts->addThunk(t); | |||
2077 | thunks[t->getThunkTargetSym()] = t; | |||
2078 | } | |||
2079 | ||||
2080 | // Redirect relocation to Thunk, we never go via the PLT to a Thunk | |||
2081 | rel.sym = t->getThunkTargetSym(); | |||
2082 | rel.expr = fromPlt(rel.expr); | |||
2083 | ||||
2084 | // On AArch64 and PPC, a jump/call relocation may be encoded as | |||
2085 | // STT_SECTION + non-zero addend, clear the addend after | |||
2086 | // redirection. | |||
2087 | if (config->emachine != EM_MIPS) | |||
2088 | rel.addend = -getPCBias(rel.type); | |||
2089 | } | |||
2090 | ||||
2091 | for (auto &p : isd->thunkSections) | |||
2092 | addressesChanged |= p.first->assignOffsets(); | |||
2093 | }); | |||
2094 | ||||
2095 | for (auto &p : thunkedSections) | |||
2096 | addressesChanged |= p.second->assignOffsets(); | |||
2097 | ||||
2098 | // Merge all created synthetic ThunkSections back into OutputSection | |||
2099 | mergeThunks(outputSections); | |||
2100 | ++pass; | |||
2101 | return addressesChanged; | |||
2102 | } | |||
2103 | ||||
2104 | // The following aid in the conversion of call x@GDPLT to call __tls_get_addr | |||
2105 | // hexagonNeedsTLSSymbol scans for relocations would require a call to | |||
2106 | // __tls_get_addr. | |||
2107 | // hexagonTLSSymbolUpdate rebinds the relocation to __tls_get_addr. | |||
2108 | bool elf::hexagonNeedsTLSSymbol(ArrayRef<OutputSection *> outputSections) { | |||
2109 | bool needTlsSymbol = false; | |||
2110 | forEachInputSectionDescription( | |||
2111 | outputSections, [&](OutputSection *os, InputSectionDescription *isd) { | |||
2112 | for (InputSection *isec : isd->sections) | |||
2113 | for (Relocation &rel : isec->relocations) | |||
2114 | if (rel.sym->type == llvm::ELF::STT_TLS && rel.expr == R_PLT_PC) { | |||
2115 | needTlsSymbol = true; | |||
2116 | return; | |||
2117 | } | |||
2118 | }); | |||
2119 | return needTlsSymbol; | |||
2120 | } | |||
2121 | ||||
2122 | void elf::hexagonTLSSymbolUpdate(ArrayRef<OutputSection *> outputSections) { | |||
2123 | Symbol *sym = symtab->find("__tls_get_addr"); | |||
2124 | if (!sym) | |||
2125 | return; | |||
2126 | bool needEntry = true; | |||
2127 | forEachInputSectionDescription( | |||
2128 | outputSections, [&](OutputSection *os, InputSectionDescription *isd) { | |||
2129 | for (InputSection *isec : isd->sections) | |||
2130 | for (Relocation &rel : isec->relocations) | |||
2131 | if (rel.sym->type == llvm::ELF::STT_TLS && rel.expr == R_PLT_PC) { | |||
2132 | if (needEntry) { | |||
2133 | addPltEntry(in.plt, in.gotPlt, in.relaPlt, target->pltRel, | |||
2134 | *sym); | |||
2135 | needEntry = false; | |||
2136 | } | |||
2137 | rel.sym = sym; | |||
2138 | } | |||
2139 | }); | |||
2140 | } | |||
2141 | ||||
2142 | template void elf::scanRelocations<ELF32LE>(InputSectionBase &); | |||
2143 | template void elf::scanRelocations<ELF32BE>(InputSectionBase &); | |||
2144 | template void elf::scanRelocations<ELF64LE>(InputSectionBase &); | |||
2145 | template void elf::scanRelocations<ELF64BE>(InputSectionBase &); | |||
2146 | template void elf::reportUndefinedSymbols<ELF32LE>(); | |||
2147 | template void elf::reportUndefinedSymbols<ELF32BE>(); | |||
2148 | template void elf::reportUndefinedSymbols<ELF64LE>(); | |||
2149 | template void elf::reportUndefinedSymbols<ELF64BE>(); |