File: | tools/lld/ELF/Relocations.cpp |
Warning: | line 1299, column 9 3rd function call argument is an uninitialized value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- Relocations.cpp ----------------------------------------------------===// | |||
2 | // | |||
3 | // The LLVM Linker | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This file contains platform-independent functions to process relocations. | |||
11 | // I'll describe the overview of this file here. | |||
12 | // | |||
13 | // Simple relocations are easy to handle for the linker. For example, | |||
14 | // for R_X86_64_PC64 relocs, the linker just has to fix up locations | |||
15 | // with the relative offsets to the target symbols. It would just be | |||
16 | // reading records from relocation sections and applying them to output. | |||
17 | // | |||
18 | // But not all relocations are that easy to handle. For example, for | |||
19 | // R_386_GOTOFF relocs, the linker has to create new GOT entries for | |||
20 | // symbols if they don't exist, and fix up locations with GOT entry | |||
21 | // offsets from the beginning of GOT section. So there is more than | |||
22 | // fixing addresses in relocation processing. | |||
23 | // | |||
24 | // ELF defines a large number of complex relocations. | |||
25 | // | |||
26 | // The functions in this file analyze relocations and do whatever needs | |||
27 | // to be done. It includes, but not limited to, the following. | |||
28 | // | |||
29 | // - create GOT/PLT entries | |||
30 | // - create new relocations in .dynsym to let the dynamic linker resolve | |||
31 | // them at runtime (since ELF supports dynamic linking, not all | |||
32 | // relocations can be resolved at link-time) | |||
33 | // - create COPY relocs and reserve space in .bss | |||
34 | // - replace expensive relocs (in terms of runtime cost) with cheap ones | |||
35 | // - error out infeasible combinations such as PIC and non-relative relocs | |||
36 | // | |||
37 | // Note that the functions in this file don't actually apply relocations | |||
38 | // because it doesn't know about the output file nor the output file buffer. | |||
39 | // It instead stores Relocation objects to InputSection's Relocations | |||
40 | // vector to let it apply later in InputSection::writeTo. | |||
41 | // | |||
42 | //===----------------------------------------------------------------------===// | |||
43 | ||||
44 | #include "Relocations.h" | |||
45 | #include "Config.h" | |||
46 | #include "LinkerScript.h" | |||
47 | #include "OutputSections.h" | |||
48 | #include "SymbolTable.h" | |||
49 | #include "Symbols.h" | |||
50 | #include "SyntheticSections.h" | |||
51 | #include "Target.h" | |||
52 | #include "Thunks.h" | |||
53 | #include "lld/Common/Memory.h" | |||
54 | #include "lld/Common/Strings.h" | |||
55 | #include "llvm/ADT/SmallSet.h" | |||
56 | #include "llvm/Support/Endian.h" | |||
57 | #include "llvm/Support/raw_ostream.h" | |||
58 | #include <algorithm> | |||
59 | ||||
60 | using namespace llvm; | |||
61 | using namespace llvm::ELF; | |||
62 | using namespace llvm::object; | |||
63 | using namespace llvm::support::endian; | |||
64 | ||||
65 | using namespace lld; | |||
66 | using namespace lld::elf; | |||
67 | ||||
68 | // Construct a message in the following format. | |||
69 | // | |||
70 | // >>> defined in /home/alice/src/foo.o | |||
71 | // >>> referenced by bar.c:12 (/home/alice/src/bar.c:12) | |||
72 | // >>> /home/alice/src/bar.o:(.text+0x1) | |||
73 | static std::string getLocation(InputSectionBase &S, const Symbol &Sym, | |||
74 | uint64_t Off) { | |||
75 | std::string Msg = | |||
76 | "\n>>> defined in " + toString(Sym.File) + "\n>>> referenced by "; | |||
77 | std::string Src = S.getSrcMsg(Sym, Off); | |||
78 | if (!Src.empty()) | |||
79 | Msg += Src + "\n>>> "; | |||
80 | return Msg + S.getObjMsg(Off); | |||
81 | } | |||
82 | ||||
83 | // This function is similar to the `handleTlsRelocation`. MIPS does not | |||
84 | // support any relaxations for TLS relocations so by factoring out MIPS | |||
85 | // handling in to the separate function we can simplify the code and do not | |||
86 | // pollute other `handleTlsRelocation` by MIPS `ifs` statements. | |||
87 | // Mips has a custom MipsGotSection that handles the writing of GOT entries | |||
88 | // without dynamic relocations. | |||
89 | static unsigned handleMipsTlsRelocation(RelType Type, Symbol &Sym, | |||
90 | InputSectionBase &C, uint64_t Offset, | |||
91 | int64_t Addend, RelExpr Expr) { | |||
92 | if (Expr == R_MIPS_TLSLD) { | |||
93 | InX::MipsGot->addTlsIndex(*C.File); | |||
94 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
95 | return 1; | |||
96 | } | |||
97 | if (Expr == R_MIPS_TLSGD) { | |||
98 | InX::MipsGot->addDynTlsEntry(*C.File, Sym); | |||
99 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
100 | return 1; | |||
101 | } | |||
102 | return 0; | |||
103 | } | |||
104 | ||||
105 | // This function is similar to the `handleMipsTlsRelocation`. ARM also does not | |||
106 | // support any relaxations for TLS relocations. ARM is logically similar to Mips | |||
107 | // in how it handles TLS, but Mips uses its own custom GOT which handles some | |||
108 | // of the cases that ARM uses GOT relocations for. | |||
109 | // | |||
110 | // We look for TLS global dynamic and local dynamic relocations, these may | |||
111 | // require the generation of a pair of GOT entries that have associated | |||
112 | // dynamic relocations. When the results of the dynamic relocations can be | |||
113 | // resolved at static link time we do so. This is necessary for static linking | |||
114 | // as there will be no dynamic loader to resolve them at load-time. | |||
115 | // | |||
116 | // The pair of GOT entries created are of the form | |||
117 | // GOT[e0] Module Index (Used to find pointer to TLS block at run-time) | |||
118 | // GOT[e1] Offset of symbol in TLS block | |||
119 | template <class ELFT> | |||
120 | static unsigned handleARMTlsRelocation(RelType Type, Symbol &Sym, | |||
121 | InputSectionBase &C, uint64_t Offset, | |||
122 | int64_t Addend, RelExpr Expr) { | |||
123 | // The Dynamic TLS Module Index Relocation for a symbol defined in an | |||
124 | // executable is always 1. If the target Symbol is not preemptible then | |||
125 | // we know the offset into the TLS block at static link time. | |||
126 | bool NeedDynId = Sym.IsPreemptible || Config->Shared; | |||
127 | bool NeedDynOff = Sym.IsPreemptible; | |||
128 | ||||
129 | auto AddTlsReloc = [&](uint64_t Off, RelType Type, Symbol *Dest, bool Dyn) { | |||
130 | if (Dyn) | |||
131 | InX::RelaDyn->addReloc(Type, InX::Got, Off, Dest); | |||
132 | else | |||
133 | InX::Got->Relocations.push_back({R_ABS, Type, Off, 0, Dest}); | |||
134 | }; | |||
135 | ||||
136 | // Local Dynamic is for access to module local TLS variables, while still | |||
137 | // being suitable for being dynamically loaded via dlopen. | |||
138 | // GOT[e0] is the module index, with a special value of 0 for the current | |||
139 | // module. GOT[e1] is unused. There only needs to be one module index entry. | |||
140 | if (Expr == R_TLSLD_PC && InX::Got->addTlsIndex()) { | |||
141 | AddTlsReloc(InX::Got->getTlsIndexOff(), Target->TlsModuleIndexRel, | |||
142 | NeedDynId ? nullptr : &Sym, NeedDynId); | |||
143 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
144 | return 1; | |||
145 | } | |||
146 | ||||
147 | // Global Dynamic is the most general purpose access model. When we know | |||
148 | // the module index and offset of symbol in TLS block we can fill these in | |||
149 | // using static GOT relocations. | |||
150 | if (Expr == R_TLSGD_PC) { | |||
151 | if (InX::Got->addDynTlsEntry(Sym)) { | |||
152 | uint64_t Off = InX::Got->getGlobalDynOffset(Sym); | |||
153 | AddTlsReloc(Off, Target->TlsModuleIndexRel, &Sym, NeedDynId); | |||
154 | AddTlsReloc(Off + Config->Wordsize, Target->TlsOffsetRel, &Sym, | |||
155 | NeedDynOff); | |||
156 | } | |||
157 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
158 | return 1; | |||
159 | } | |||
160 | return 0; | |||
161 | } | |||
162 | ||||
163 | // Returns the number of relocations processed. | |||
164 | template <class ELFT> | |||
165 | static unsigned | |||
166 | handleTlsRelocation(RelType Type, Symbol &Sym, InputSectionBase &C, | |||
167 | typename ELFT::uint Offset, int64_t Addend, RelExpr Expr) { | |||
168 | if (!(C.Flags & SHF_ALLOC)) | |||
169 | return 0; | |||
170 | ||||
171 | if (!Sym.isTls()) | |||
172 | return 0; | |||
173 | ||||
174 | if (Config->EMachine == EM_ARM) | |||
175 | return handleARMTlsRelocation<ELFT>(Type, Sym, C, Offset, Addend, Expr); | |||
176 | if (Config->EMachine == EM_MIPS) | |||
177 | return handleMipsTlsRelocation(Type, Sym, C, Offset, Addend, Expr); | |||
178 | ||||
179 | if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL>(Expr) && | |||
180 | Config->Shared) { | |||
181 | if (InX::Got->addDynTlsEntry(Sym)) { | |||
182 | uint64_t Off = InX::Got->getGlobalDynOffset(Sym); | |||
183 | InX::RelaDyn->addReloc( | |||
184 | {Target->TlsDescRel, InX::Got, Off, !Sym.IsPreemptible, &Sym, 0}); | |||
185 | } | |||
186 | if (Expr != R_TLSDESC_CALL) | |||
187 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
188 | return 1; | |||
189 | } | |||
190 | ||||
191 | if (isRelExprOneOf<R_TLSLD_GOT, R_TLSLD_GOT_FROM_END, R_TLSLD_PC, | |||
192 | R_TLSLD_HINT>(Expr)) { | |||
193 | // Local-Dynamic relocs can be relaxed to Local-Exec. | |||
194 | if (!Config->Shared) { | |||
195 | C.Relocations.push_back( | |||
196 | {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_LD_TO_LE), Type, | |||
197 | Offset, Addend, &Sym}); | |||
198 | return Target->TlsGdRelaxSkip; | |||
199 | } | |||
200 | if (Expr == R_TLSLD_HINT) | |||
201 | return 1; | |||
202 | if (InX::Got->addTlsIndex()) | |||
203 | InX::RelaDyn->addReloc(Target->TlsModuleIndexRel, InX::Got, | |||
204 | InX::Got->getTlsIndexOff(), nullptr); | |||
205 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
206 | return 1; | |||
207 | } | |||
208 | ||||
209 | // Local-Dynamic relocs can be relaxed to Local-Exec. | |||
210 | if (Expr == R_ABS && !Config->Shared) { | |||
211 | C.Relocations.push_back( | |||
212 | {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_LD_TO_LE), Type, | |||
213 | Offset, Addend, &Sym}); | |||
214 | return 1; | |||
215 | } | |||
216 | ||||
217 | // Local-Dynamic sequence where offset of tls variable relative to dynamic | |||
218 | // thread pointer is stored in the got. | |||
219 | if (Expr == R_TLSLD_GOT_OFF) { | |||
220 | // Local-Dynamic relocs can be relaxed to local-exec | |||
221 | if (!Config->Shared) { | |||
222 | C.Relocations.push_back({R_RELAX_TLS_LD_TO_LE, Type, Offset, Addend, &Sym}); | |||
223 | return 1; | |||
224 | } | |||
225 | if (!Sym.isInGot()) { | |||
226 | InX::Got->addEntry(Sym); | |||
227 | uint64_t Off = Sym.getGotOffset(); | |||
228 | InX::Got->Relocations.push_back({R_ABS, Target->TlsOffsetRel, Off, 0, &Sym}); | |||
229 | } | |||
230 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
231 | return 1; | |||
232 | } | |||
233 | ||||
234 | if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD_GOT, | |||
235 | R_TLSGD_GOT_FROM_END, R_TLSGD_PC>(Expr)) { | |||
236 | if (Config->Shared) { | |||
237 | if (InX::Got->addDynTlsEntry(Sym)) { | |||
238 | uint64_t Off = InX::Got->getGlobalDynOffset(Sym); | |||
239 | InX::RelaDyn->addReloc(Target->TlsModuleIndexRel, InX::Got, Off, &Sym); | |||
240 | ||||
241 | // If the symbol is preemptible we need the dynamic linker to write | |||
242 | // the offset too. | |||
243 | uint64_t OffsetOff = Off + Config->Wordsize; | |||
244 | if (Sym.IsPreemptible) | |||
245 | InX::RelaDyn->addReloc(Target->TlsOffsetRel, InX::Got, OffsetOff, | |||
246 | &Sym); | |||
247 | else | |||
248 | InX::Got->Relocations.push_back( | |||
249 | {R_ABS, Target->TlsOffsetRel, OffsetOff, 0, &Sym}); | |||
250 | } | |||
251 | C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
252 | return 1; | |||
253 | } | |||
254 | ||||
255 | // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec | |||
256 | // depending on the symbol being locally defined or not. | |||
257 | if (Sym.IsPreemptible) { | |||
258 | C.Relocations.push_back( | |||
259 | {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_IE), Type, | |||
260 | Offset, Addend, &Sym}); | |||
261 | if (!Sym.isInGot()) { | |||
262 | InX::Got->addEntry(Sym); | |||
263 | InX::RelaDyn->addReloc(Target->TlsGotRel, InX::Got, Sym.getGotOffset(), | |||
264 | &Sym); | |||
265 | } | |||
266 | } else { | |||
267 | C.Relocations.push_back( | |||
268 | {Target->adjustRelaxExpr(Type, nullptr, R_RELAX_TLS_GD_TO_LE), Type, | |||
269 | Offset, Addend, &Sym}); | |||
270 | } | |||
271 | return Target->TlsGdRelaxSkip; | |||
272 | } | |||
273 | ||||
274 | // Initial-Exec relocs can be relaxed to Local-Exec if the symbol is locally | |||
275 | // defined. | |||
276 | if (isRelExprOneOf<R_GOT, R_GOT_FROM_END, R_GOT_PC, R_GOT_PAGE_PC>(Expr) && | |||
277 | !Config->Shared && !Sym.IsPreemptible) { | |||
278 | C.Relocations.push_back({R_RELAX_TLS_IE_TO_LE, Type, Offset, Addend, &Sym}); | |||
279 | return 1; | |||
280 | } | |||
281 | ||||
282 | if (Expr == R_TLSDESC_CALL) | |||
283 | return 1; | |||
284 | return 0; | |||
285 | } | |||
286 | ||||
287 | static RelType getMipsPairType(RelType Type, bool IsLocal) { | |||
288 | switch (Type) { | |||
289 | case R_MIPS_HI16: | |||
290 | return R_MIPS_LO16; | |||
291 | case R_MIPS_GOT16: | |||
292 | // In case of global symbol, the R_MIPS_GOT16 relocation does not | |||
293 | // have a pair. Each global symbol has a unique entry in the GOT | |||
294 | // and a corresponding instruction with help of the R_MIPS_GOT16 | |||
295 | // relocation loads an address of the symbol. In case of local | |||
296 | // symbol, the R_MIPS_GOT16 relocation creates a GOT entry to hold | |||
297 | // the high 16 bits of the symbol's value. A paired R_MIPS_LO16 | |||
298 | // relocations handle low 16 bits of the address. That allows | |||
299 | // to allocate only one GOT entry for every 64 KBytes of local data. | |||
300 | return IsLocal ? R_MIPS_LO16 : R_MIPS_NONE; | |||
301 | case R_MICROMIPS_GOT16: | |||
302 | return IsLocal ? R_MICROMIPS_LO16 : R_MIPS_NONE; | |||
303 | case R_MIPS_PCHI16: | |||
304 | return R_MIPS_PCLO16; | |||
305 | case R_MICROMIPS_HI16: | |||
306 | return R_MICROMIPS_LO16; | |||
307 | default: | |||
308 | return R_MIPS_NONE; | |||
309 | } | |||
310 | } | |||
311 | ||||
312 | // True if non-preemptable symbol always has the same value regardless of where | |||
313 | // the DSO is loaded. | |||
314 | static bool isAbsolute(const Symbol &Sym) { | |||
315 | if (Sym.isUndefWeak()) | |||
316 | return true; | |||
317 | if (const auto *DR = dyn_cast<Defined>(&Sym)) | |||
318 | return DR->Section == nullptr; // Absolute symbol. | |||
319 | return false; | |||
320 | } | |||
321 | ||||
322 | static bool isAbsoluteValue(const Symbol &Sym) { | |||
323 | return isAbsolute(Sym) || Sym.isTls(); | |||
324 | } | |||
325 | ||||
326 | // Returns true if Expr refers a PLT entry. | |||
327 | static bool needsPlt(RelExpr Expr) { | |||
328 | return isRelExprOneOf<R_PLT_PC, R_PPC_CALL_PLT, R_PLT, R_PLT_PAGE_PC>(Expr); | |||
329 | } | |||
330 | ||||
331 | // Returns true if Expr refers a GOT entry. Note that this function | |||
332 | // returns false for TLS variables even though they need GOT, because | |||
333 | // TLS variables uses GOT differently than the regular variables. | |||
334 | static bool needsGot(RelExpr Expr) { | |||
335 | return isRelExprOneOf<R_GOT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOT_OFF, | |||
336 | R_MIPS_GOT_OFF32, R_GOT_PAGE_PC, R_GOT_PC, | |||
337 | R_GOT_FROM_END>(Expr); | |||
338 | } | |||
339 | ||||
340 | // True if this expression is of the form Sym - X, where X is a position in the | |||
341 | // file (PC, or GOT for example). | |||
342 | static bool isRelExpr(RelExpr Expr) { | |||
343 | return isRelExprOneOf<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL, | |||
344 | R_PPC_CALL, R_PPC_CALL_PLT, R_PAGE_PC, | |||
345 | R_RELAX_GOT_PC>(Expr); | |||
346 | } | |||
347 | ||||
348 | // Returns true if a given relocation can be computed at link-time. | |||
349 | // | |||
350 | // For instance, we know the offset from a relocation to its target at | |||
351 | // link-time if the relocation is PC-relative and refers a | |||
352 | // non-interposable function in the same executable. This function | |||
353 | // will return true for such relocation. | |||
354 | // | |||
355 | // If this function returns false, that means we need to emit a | |||
356 | // dynamic relocation so that the relocation will be fixed at load-time. | |||
357 | static bool isStaticLinkTimeConstant(RelExpr E, RelType Type, const Symbol &Sym, | |||
358 | InputSectionBase &S, uint64_t RelOff) { | |||
359 | // These expressions always compute a constant | |||
360 | if (isRelExprOneOf< | |||
361 | R_GOT_FROM_END, R_GOT_OFF, R_TLSLD_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, | |||
362 | R_MIPS_GOTREL, R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, | |||
363 | R_MIPS_TLSGD, R_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, | |||
364 | R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOT_FROM_END, | |||
365 | R_TLSGD_PC, R_PPC_CALL_PLT, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT, | |||
366 | R_TLSLD_HINT>(E)) | |||
367 | return true; | |||
368 | ||||
369 | // These never do, except if the entire file is position dependent or if | |||
370 | // only the low bits are used. | |||
371 | if (E == R_GOT || E == R_PLT || E == R_TLSDESC) | |||
372 | return Target->usesOnlyLowPageBits(Type) || !Config->Pic; | |||
373 | ||||
374 | if (Sym.IsPreemptible) | |||
375 | return false; | |||
376 | if (!Config->Pic) | |||
377 | return true; | |||
378 | ||||
379 | // The size of a non preemptible symbol is a constant. | |||
380 | if (E == R_SIZE) | |||
381 | return true; | |||
382 | ||||
383 | // For the target and the relocation, we want to know if they are | |||
384 | // absolute or relative. | |||
385 | bool AbsVal = isAbsoluteValue(Sym); | |||
386 | bool RelE = isRelExpr(E); | |||
387 | if (AbsVal && !RelE) | |||
388 | return true; | |||
389 | if (!AbsVal && RelE) | |||
390 | return true; | |||
391 | if (!AbsVal && !RelE) | |||
392 | return Target->usesOnlyLowPageBits(Type); | |||
393 | ||||
394 | // Relative relocation to an absolute value. This is normally unrepresentable, | |||
395 | // but if the relocation refers to a weak undefined symbol, we allow it to | |||
396 | // resolve to the image base. This is a little strange, but it allows us to | |||
397 | // link function calls to such symbols. Normally such a call will be guarded | |||
398 | // with a comparison, which will load a zero from the GOT. | |||
399 | // Another special case is MIPS _gp_disp symbol which represents offset | |||
400 | // between start of a function and '_gp' value and defined as absolute just | |||
401 | // to simplify the code. | |||
402 | assert(AbsVal && RelE)(static_cast <bool> (AbsVal && RelE) ? void (0) : __assert_fail ("AbsVal && RelE", "/build/llvm-toolchain-snapshot-7~svn338205/tools/lld/ELF/Relocations.cpp" , 402, __extension__ __PRETTY_FUNCTION__)); | |||
403 | if (Sym.isUndefWeak()) | |||
404 | return true; | |||
405 | ||||
406 | error("relocation " + toString(Type) + " cannot refer to absolute symbol: " + | |||
407 | toString(Sym) + getLocation(S, Sym, RelOff)); | |||
408 | return true; | |||
409 | } | |||
410 | ||||
411 | static RelExpr toPlt(RelExpr Expr) { | |||
412 | switch (Expr) { | |||
413 | case R_PPC_CALL: | |||
414 | return R_PPC_CALL_PLT; | |||
415 | case R_PC: | |||
416 | return R_PLT_PC; | |||
417 | case R_PAGE_PC: | |||
418 | return R_PLT_PAGE_PC; | |||
419 | case R_ABS: | |||
420 | return R_PLT; | |||
421 | default: | |||
422 | return Expr; | |||
423 | } | |||
424 | } | |||
425 | ||||
426 | static RelExpr fromPlt(RelExpr Expr) { | |||
427 | // We decided not to use a plt. Optimize a reference to the plt to a | |||
428 | // reference to the symbol itself. | |||
429 | switch (Expr) { | |||
430 | case R_PLT_PC: | |||
431 | return R_PC; | |||
432 | case R_PPC_CALL_PLT: | |||
433 | return R_PPC_CALL; | |||
434 | case R_PLT: | |||
435 | return R_ABS; | |||
436 | default: | |||
437 | return Expr; | |||
438 | } | |||
439 | } | |||
440 | ||||
441 | // Returns true if a given shared symbol is in a read-only segment in a DSO. | |||
442 | template <class ELFT> static bool isReadOnly(SharedSymbol &SS) { | |||
443 | typedef typename ELFT::Phdr Elf_Phdr; | |||
444 | ||||
445 | // Determine if the symbol is read-only by scanning the DSO's program headers. | |||
446 | const SharedFile<ELFT> &File = SS.getFile<ELFT>(); | |||
447 | for (const Elf_Phdr &Phdr : check(File.getObj().program_headers())) | |||
448 | if ((Phdr.p_type == ELF::PT_LOAD || Phdr.p_type == ELF::PT_GNU_RELRO) && | |||
449 | !(Phdr.p_flags & ELF::PF_W) && SS.Value >= Phdr.p_vaddr && | |||
450 | SS.Value < Phdr.p_vaddr + Phdr.p_memsz) | |||
451 | return true; | |||
452 | return false; | |||
453 | } | |||
454 | ||||
455 | // Returns symbols at the same offset as a given symbol, including SS itself. | |||
456 | // | |||
457 | // If two or more symbols are at the same offset, and at least one of | |||
458 | // them are copied by a copy relocation, all of them need to be copied. | |||
459 | // Otherwise, they would refer to different places at runtime. | |||
460 | template <class ELFT> | |||
461 | static SmallSet<SharedSymbol *, 4> getSymbolsAt(SharedSymbol &SS) { | |||
462 | typedef typename ELFT::Sym Elf_Sym; | |||
463 | ||||
464 | SharedFile<ELFT> &File = SS.getFile<ELFT>(); | |||
465 | ||||
466 | SmallSet<SharedSymbol *, 4> Ret; | |||
467 | for (const Elf_Sym &S : File.getGlobalELFSyms()) { | |||
468 | if (S.st_shndx == SHN_UNDEF || S.st_shndx == SHN_ABS || | |||
469 | S.st_value != SS.Value) | |||
470 | continue; | |||
471 | StringRef Name = check(S.getName(File.getStringTable())); | |||
472 | Symbol *Sym = Symtab->find(Name); | |||
473 | if (auto *Alias = dyn_cast_or_null<SharedSymbol>(Sym)) | |||
474 | Ret.insert(Alias); | |||
475 | } | |||
476 | return Ret; | |||
477 | } | |||
478 | ||||
479 | // When a symbol is copy relocated or we create a canonical plt entry, it is | |||
480 | // effectively a defined symbol. In the case of copy relocation the symbol is | |||
481 | // in .bss and in the case of a canonical plt entry it is in .plt. This function | |||
482 | // replaces the existing symbol with a Defined pointing to the appropriate | |||
483 | // location. | |||
484 | static void replaceWithDefined(Symbol &Sym, SectionBase *Sec, uint64_t Value, | |||
485 | uint64_t Size) { | |||
486 | Symbol Old = Sym; | |||
487 | replaceSymbol<Defined>(&Sym, Sym.File, Sym.getName(), Sym.Binding, | |||
488 | Sym.StOther, Sym.Type, Value, Size, Sec); | |||
489 | Sym.PltIndex = Old.PltIndex; | |||
490 | Sym.GotIndex = Old.GotIndex; | |||
491 | Sym.VerdefIndex = Old.VerdefIndex; | |||
492 | Sym.IsPreemptible = true; | |||
493 | Sym.ExportDynamic = true; | |||
494 | Sym.IsUsedInRegularObj = true; | |||
495 | Sym.Used = true; | |||
496 | } | |||
497 | ||||
498 | // Reserve space in .bss or .bss.rel.ro for copy relocation. | |||
499 | // | |||
500 | // The copy relocation is pretty much a hack. If you use a copy relocation | |||
501 | // in your program, not only the symbol name but the symbol's size, RW/RO | |||
502 | // bit and alignment become part of the ABI. In addition to that, if the | |||
503 | // symbol has aliases, the aliases become part of the ABI. That's subtle, | |||
504 | // but if you violate that implicit ABI, that can cause very counter- | |||
505 | // intuitive consequences. | |||
506 | // | |||
507 | // So, what is the copy relocation? It's for linking non-position | |||
508 | // independent code to DSOs. In an ideal world, all references to data | |||
509 | // exported by DSOs should go indirectly through GOT. But if object files | |||
510 | // are compiled as non-PIC, all data references are direct. There is no | |||
511 | // way for the linker to transform the code to use GOT, as machine | |||
512 | // instructions are already set in stone in object files. This is where | |||
513 | // the copy relocation takes a role. | |||
514 | // | |||
515 | // A copy relocation instructs the dynamic linker to copy data from a DSO | |||
516 | // to a specified address (which is usually in .bss) at load-time. If the | |||
517 | // static linker (that's us) finds a direct data reference to a DSO | |||
518 | // symbol, it creates a copy relocation, so that the symbol can be | |||
519 | // resolved as if it were in .bss rather than in a DSO. | |||
520 | // | |||
521 | // As you can see in this function, we create a copy relocation for the | |||
522 | // dynamic linker, and the relocation contains not only symbol name but | |||
523 | // various other informtion about the symbol. So, such attributes become a | |||
524 | // part of the ABI. | |||
525 | // | |||
526 | // Note for application developers: I can give you a piece of advice if | |||
527 | // you are writing a shared library. You probably should export only | |||
528 | // functions from your library. You shouldn't export variables. | |||
529 | // | |||
530 | // As an example what can happen when you export variables without knowing | |||
531 | // the semantics of copy relocations, assume that you have an exported | |||
532 | // variable of type T. It is an ABI-breaking change to add new members at | |||
533 | // end of T even though doing that doesn't change the layout of the | |||
534 | // existing members. That's because the space for the new members are not | |||
535 | // reserved in .bss unless you recompile the main program. That means they | |||
536 | // are likely to overlap with other data that happens to be laid out next | |||
537 | // to the variable in .bss. This kind of issue is sometimes very hard to | |||
538 | // debug. What's a solution? Instead of exporting a varaible V from a DSO, | |||
539 | // define an accessor getV(). | |||
540 | template <class ELFT> static void addCopyRelSymbol(SharedSymbol &SS) { | |||
541 | // Copy relocation against zero-sized symbol doesn't make sense. | |||
542 | uint64_t SymSize = SS.getSize(); | |||
543 | if (SymSize == 0 || SS.Alignment == 0) | |||
544 | fatal("cannot create a copy relocation for symbol " + toString(SS)); | |||
545 | ||||
546 | // See if this symbol is in a read-only segment. If so, preserve the symbol's | |||
547 | // memory protection by reserving space in the .bss.rel.ro section. | |||
548 | bool IsReadOnly = isReadOnly<ELFT>(SS); | |||
549 | BssSection *Sec = make<BssSection>(IsReadOnly ? ".bss.rel.ro" : ".bss", | |||
550 | SymSize, SS.Alignment); | |||
551 | if (IsReadOnly) | |||
552 | InX::BssRelRo->getParent()->addSection(Sec); | |||
553 | else | |||
554 | InX::Bss->getParent()->addSection(Sec); | |||
555 | ||||
556 | // Look through the DSO's dynamic symbol table for aliases and create a | |||
557 | // dynamic symbol for each one. This causes the copy relocation to correctly | |||
558 | // interpose any aliases. | |||
559 | for (SharedSymbol *Sym : getSymbolsAt<ELFT>(SS)) | |||
560 | replaceWithDefined(*Sym, Sec, 0, Sym->Size); | |||
561 | ||||
562 | InX::RelaDyn->addReloc(Target->CopyRel, Sec, 0, &SS); | |||
563 | } | |||
564 | ||||
565 | // MIPS has an odd notion of "paired" relocations to calculate addends. | |||
566 | // For example, if a relocation is of R_MIPS_HI16, there must be a | |||
567 | // R_MIPS_LO16 relocation after that, and an addend is calculated using | |||
568 | // the two relocations. | |||
569 | template <class ELFT, class RelTy> | |||
570 | static int64_t computeMipsAddend(const RelTy &Rel, const RelTy *End, | |||
571 | InputSectionBase &Sec, RelExpr Expr, | |||
572 | bool IsLocal) { | |||
573 | if (Expr == R_MIPS_GOTREL && IsLocal) | |||
574 | return Sec.getFile<ELFT>()->MipsGp0; | |||
575 | ||||
576 | // The ABI says that the paired relocation is used only for REL. | |||
577 | // See p. 4-17 at ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
578 | if (RelTy::IsRela) | |||
579 | return 0; | |||
580 | ||||
581 | RelType Type = Rel.getType(Config->IsMips64EL); | |||
582 | uint32_t PairTy = getMipsPairType(Type, IsLocal); | |||
583 | if (PairTy == R_MIPS_NONE) | |||
584 | return 0; | |||
585 | ||||
586 | const uint8_t *Buf = Sec.Data.data(); | |||
587 | uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL); | |||
588 | ||||
589 | // To make things worse, paired relocations might not be contiguous in | |||
590 | // the relocation table, so we need to do linear search. *sigh* | |||
591 | for (const RelTy *RI = &Rel; RI != End; ++RI) | |||
592 | if (RI->getType(Config->IsMips64EL) == PairTy && | |||
593 | RI->getSymbol(Config->IsMips64EL) == SymIndex) | |||
594 | return Target->getImplicitAddend(Buf + RI->r_offset, PairTy); | |||
595 | ||||
596 | warn("can't find matching " + toString(PairTy) + " relocation for " + | |||
597 | toString(Type)); | |||
598 | return 0; | |||
599 | } | |||
600 | ||||
601 | // Returns an addend of a given relocation. If it is RELA, an addend | |||
602 | // is in a relocation itself. If it is REL, we need to read it from an | |||
603 | // input section. | |||
604 | template <class ELFT, class RelTy> | |||
605 | static int64_t computeAddend(const RelTy &Rel, const RelTy *End, | |||
606 | InputSectionBase &Sec, RelExpr Expr, | |||
607 | bool IsLocal) { | |||
608 | int64_t Addend; | |||
609 | RelType Type = Rel.getType(Config->IsMips64EL); | |||
610 | ||||
611 | if (RelTy::IsRela) { | |||
612 | Addend = getAddend<ELFT>(Rel); | |||
613 | } else { | |||
614 | const uint8_t *Buf = Sec.Data.data(); | |||
615 | Addend = Target->getImplicitAddend(Buf + Rel.r_offset, Type); | |||
616 | } | |||
617 | ||||
618 | if (Config->EMachine == EM_PPC64 && Config->Pic && Type == R_PPC64_TOC) | |||
619 | Addend += getPPC64TocBase(); | |||
620 | if (Config->EMachine == EM_MIPS) | |||
621 | Addend += computeMipsAddend<ELFT>(Rel, End, Sec, Expr, IsLocal); | |||
622 | ||||
623 | return Addend; | |||
624 | } | |||
625 | ||||
626 | // Report an undefined symbol if necessary. | |||
627 | // Returns true if this function printed out an error message. | |||
628 | static bool maybeReportUndefined(Symbol &Sym, InputSectionBase &Sec, | |||
629 | uint64_t Offset) { | |||
630 | if (Config->UnresolvedSymbols == UnresolvedPolicy::IgnoreAll) | |||
631 | return false; | |||
632 | ||||
633 | if (Sym.isLocal() || !Sym.isUndefined() || Sym.isWeak()) | |||
634 | return false; | |||
635 | ||||
636 | bool CanBeExternal = | |||
637 | Sym.computeBinding() != STB_LOCAL && Sym.Visibility == STV_DEFAULT; | |||
638 | if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore && CanBeExternal) | |||
639 | return false; | |||
640 | ||||
641 | std::string Msg = | |||
642 | "undefined symbol: " + toString(Sym) + "\n>>> referenced by "; | |||
643 | ||||
644 | std::string Src = Sec.getSrcMsg(Sym, Offset); | |||
645 | if (!Src.empty()) | |||
646 | Msg += Src + "\n>>> "; | |||
647 | Msg += Sec.getObjMsg(Offset); | |||
648 | ||||
649 | if ((Config->UnresolvedSymbols == UnresolvedPolicy::Warn && CanBeExternal) || | |||
650 | Config->NoinhibitExec) { | |||
651 | warn(Msg); | |||
652 | return false; | |||
653 | } | |||
654 | ||||
655 | error(Msg); | |||
656 | return true; | |||
657 | } | |||
658 | ||||
659 | // MIPS N32 ABI treats series of successive relocations with the same offset | |||
660 | // as a single relocation. The similar approach used by N64 ABI, but this ABI | |||
661 | // packs all relocations into the single relocation record. Here we emulate | |||
662 | // this for the N32 ABI. Iterate over relocation with the same offset and put | |||
663 | // theirs types into the single bit-set. | |||
664 | template <class RelTy> static RelType getMipsN32RelType(RelTy *&Rel, RelTy *End) { | |||
665 | RelType Type = 0; | |||
666 | uint64_t Offset = Rel->r_offset; | |||
667 | ||||
668 | int N = 0; | |||
669 | while (Rel != End && Rel->r_offset == Offset) | |||
670 | Type |= (Rel++)->getType(Config->IsMips64EL) << (8 * N++); | |||
671 | return Type; | |||
672 | } | |||
673 | ||||
674 | // .eh_frame sections are mergeable input sections, so their input | |||
675 | // offsets are not linearly mapped to output section. For each input | |||
676 | // offset, we need to find a section piece containing the offset and | |||
677 | // add the piece's base address to the input offset to compute the | |||
678 | // output offset. That isn't cheap. | |||
679 | // | |||
680 | // This class is to speed up the offset computation. When we process | |||
681 | // relocations, we access offsets in the monotonically increasing | |||
682 | // order. So we can optimize for that access pattern. | |||
683 | // | |||
684 | // For sections other than .eh_frame, this class doesn't do anything. | |||
685 | namespace { | |||
686 | class OffsetGetter { | |||
687 | public: | |||
688 | explicit OffsetGetter(InputSectionBase &Sec) { | |||
689 | if (auto *Eh = dyn_cast<EhInputSection>(&Sec)) | |||
690 | Pieces = Eh->Pieces; | |||
691 | } | |||
692 | ||||
693 | // Translates offsets in input sections to offsets in output sections. | |||
694 | // Given offset must increase monotonically. We assume that Piece is | |||
695 | // sorted by InputOff. | |||
696 | uint64_t get(uint64_t Off) { | |||
697 | if (Pieces.empty()) | |||
698 | return Off; | |||
699 | ||||
700 | while (I != Pieces.size() && Pieces[I].InputOff + Pieces[I].Size <= Off) | |||
701 | ++I; | |||
702 | if (I == Pieces.size()) | |||
703 | return Off; | |||
704 | ||||
705 | // Pieces must be contiguous, so there must be no holes in between. | |||
706 | assert(Pieces[I].InputOff <= Off && "Relocation not in any piece")(static_cast <bool> (Pieces[I].InputOff <= Off && "Relocation not in any piece") ? void (0) : __assert_fail ("Pieces[I].InputOff <= Off && \"Relocation not in any piece\"" , "/build/llvm-toolchain-snapshot-7~svn338205/tools/lld/ELF/Relocations.cpp" , 706, __extension__ __PRETTY_FUNCTION__)); | |||
707 | ||||
708 | // Offset -1 means that the piece is dead (i.e. garbage collected). | |||
709 | if (Pieces[I].OutputOff == -1) | |||
710 | return -1; | |||
711 | return Pieces[I].OutputOff + Off - Pieces[I].InputOff; | |||
712 | } | |||
713 | ||||
714 | private: | |||
715 | ArrayRef<EhSectionPiece> Pieces; | |||
716 | size_t I = 0; | |||
717 | }; | |||
718 | } // namespace | |||
719 | ||||
720 | static void addRelativeReloc(InputSectionBase *IS, uint64_t OffsetInSec, | |||
721 | Symbol *Sym, int64_t Addend, RelExpr Expr, | |||
722 | RelType Type) { | |||
723 | // Add a relative relocation. If RelrDyn section is enabled, and the | |||
724 | // relocation offset is guaranteed to be even, add the relocation to | |||
725 | // the RelrDyn section, otherwise add it to the RelaDyn section. | |||
726 | // RelrDyn sections don't support odd offsets. Also, RelrDyn sections | |||
727 | // don't store the addend values, so we must write it to the relocated | |||
728 | // address. | |||
729 | if (InX::RelrDyn && IS->Alignment >= 2 && OffsetInSec % 2 == 0) { | |||
730 | IS->Relocations.push_back({Expr, Type, OffsetInSec, Addend, Sym}); | |||
731 | InX::RelrDyn->Relocs.push_back({IS, OffsetInSec}); | |||
732 | return; | |||
733 | } | |||
734 | InX::RelaDyn->addReloc(Target->RelativeRel, IS, OffsetInSec, Sym, Addend, | |||
735 | Expr, Type); | |||
736 | } | |||
737 | ||||
738 | template <class ELFT, class GotPltSection> | |||
739 | static void addPltEntry(PltSection *Plt, GotPltSection *GotPlt, | |||
740 | RelocationBaseSection *Rel, RelType Type, Symbol &Sym) { | |||
741 | Plt->addEntry<ELFT>(Sym); | |||
742 | GotPlt->addEntry(Sym); | |||
743 | Rel->addReloc( | |||
744 | {Type, GotPlt, Sym.getGotPltOffset(), !Sym.IsPreemptible, &Sym, 0}); | |||
745 | } | |||
746 | ||||
747 | template <class ELFT> static void addGotEntry(Symbol &Sym) { | |||
748 | InX::Got->addEntry(Sym); | |||
749 | ||||
750 | RelExpr Expr = Sym.isTls() ? R_TLS : R_ABS; | |||
751 | uint64_t Off = Sym.getGotOffset(); | |||
752 | ||||
753 | // If a GOT slot value can be calculated at link-time, which is now, | |||
754 | // we can just fill that out. | |||
755 | // | |||
756 | // (We don't actually write a value to a GOT slot right now, but we | |||
757 | // add a static relocation to a Relocations vector so that | |||
758 | // InputSection::relocate will do the work for us. We may be able | |||
759 | // to just write a value now, but it is a TODO.) | |||
760 | bool IsLinkTimeConstant = | |||
761 | !Sym.IsPreemptible && (!Config->Pic || isAbsolute(Sym)); | |||
762 | if (IsLinkTimeConstant) { | |||
763 | InX::Got->Relocations.push_back({Expr, Target->GotRel, Off, 0, &Sym}); | |||
764 | return; | |||
765 | } | |||
766 | ||||
767 | // Otherwise, we emit a dynamic relocation to .rel[a].dyn so that | |||
768 | // the GOT slot will be fixed at load-time. | |||
769 | if (!Sym.isTls() && !Sym.IsPreemptible && Config->Pic && !isAbsolute(Sym)) { | |||
770 | addRelativeReloc(InX::Got, Off, &Sym, 0, R_ABS, Target->GotRel); | |||
771 | return; | |||
772 | } | |||
773 | InX::RelaDyn->addReloc(Sym.isTls() ? Target->TlsGotRel : Target->GotRel, | |||
774 | InX::Got, Off, &Sym, 0, | |||
775 | Sym.IsPreemptible ? R_ADDEND : R_ABS, Target->GotRel); | |||
776 | } | |||
777 | ||||
778 | // Return true if we can define a symbol in the executable that | |||
779 | // contains the value/function of a symbol defined in a shared | |||
780 | // library. | |||
781 | static bool canDefineSymbolInExecutable(Symbol &Sym) { | |||
782 | // If the symbol has default visibility the symbol defined in the | |||
783 | // executable will preempt it. | |||
784 | // Note that we want the visibility of the shared symbol itself, not | |||
785 | // the visibility of the symbol in the output file we are producing. That is | |||
786 | // why we use Sym.StOther. | |||
787 | if ((Sym.StOther & 0x3) == STV_DEFAULT) | |||
788 | return true; | |||
789 | ||||
790 | // If we are allowed to break address equality of functions, defining | |||
791 | // a plt entry will allow the program to call the function in the | |||
792 | // .so, but the .so and the executable will no agree on the address | |||
793 | // of the function. Similar logic for objects. | |||
794 | return ((Sym.isFunc() && Config->IgnoreFunctionAddressEquality) || | |||
795 | (Sym.isObject() && Config->IgnoreDataAddressEquality)); | |||
796 | } | |||
797 | ||||
798 | // The reason we have to do this early scan is as follows | |||
799 | // * To mmap the output file, we need to know the size | |||
800 | // * For that, we need to know how many dynamic relocs we will have. | |||
801 | // It might be possible to avoid this by outputting the file with write: | |||
802 | // * Write the allocated output sections, computing addresses. | |||
803 | // * Apply relocations, recording which ones require a dynamic reloc. | |||
804 | // * Write the dynamic relocations. | |||
805 | // * Write the rest of the file. | |||
806 | // This would have some drawbacks. For example, we would only know if .rela.dyn | |||
807 | // is needed after applying relocations. If it is, it will go after rw and rx | |||
808 | // sections. Given that it is ro, we will need an extra PT_LOAD. This | |||
809 | // complicates things for the dynamic linker and means we would have to reserve | |||
810 | // space for the extra PT_LOAD even if we end up not using it. | |||
811 | template <class ELFT, class RelTy> | |||
812 | static void processRelocAux(InputSectionBase &Sec, RelExpr Expr, RelType Type, | |||
813 | uint64_t Offset, Symbol &Sym, const RelTy &Rel, | |||
814 | int64_t Addend) { | |||
815 | if (isStaticLinkTimeConstant(Expr, Type, Sym, Sec, Offset)) { | |||
816 | Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
817 | return; | |||
818 | } | |||
819 | bool CanWrite = (Sec.Flags & SHF_WRITE) || !Config->ZText; | |||
820 | if (CanWrite) { | |||
821 | // R_GOT refers to a position in the got, even if the symbol is preemptible. | |||
822 | bool IsPreemptibleValue = Sym.IsPreemptible && Expr != R_GOT; | |||
823 | ||||
824 | if (!IsPreemptibleValue) { | |||
825 | addRelativeReloc(&Sec, Offset, &Sym, Addend, Expr, Type); | |||
826 | return; | |||
827 | } else if (RelType Rel = Target->getDynRel(Type)) { | |||
828 | InX::RelaDyn->addReloc(Rel, &Sec, Offset, &Sym, Addend, R_ADDEND, Type); | |||
829 | ||||
830 | // MIPS ABI turns using of GOT and dynamic relocations inside out. | |||
831 | // While regular ABI uses dynamic relocations to fill up GOT entries | |||
832 | // MIPS ABI requires dynamic linker to fills up GOT entries using | |||
833 | // specially sorted dynamic symbol table. This affects even dynamic | |||
834 | // relocations against symbols which do not require GOT entries | |||
835 | // creation explicitly, i.e. do not have any GOT-relocations. So if | |||
836 | // a preemptible symbol has a dynamic relocation we anyway have | |||
837 | // to create a GOT entry for it. | |||
838 | // If a non-preemptible symbol has a dynamic relocation against it, | |||
839 | // dynamic linker takes it st_value, adds offset and writes down | |||
840 | // result of the dynamic relocation. In case of preemptible symbol | |||
841 | // dynamic linker performs symbol resolution, writes the symbol value | |||
842 | // to the GOT entry and reads the GOT entry when it needs to perform | |||
843 | // a dynamic relocation. | |||
844 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19 | |||
845 | if (Config->EMachine == EM_MIPS) | |||
846 | InX::MipsGot->addEntry(*Sec.File, Sym, Addend, Expr); | |||
847 | return; | |||
848 | } | |||
849 | } | |||
850 | ||||
851 | // If the relocation is to a weak undef, and we are producing | |||
852 | // executable, give up on it and produce a non preemptible 0. | |||
853 | if (!Config->Shared && Sym.isUndefWeak()) { | |||
854 | Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
855 | return; | |||
856 | } | |||
857 | ||||
858 | if (!CanWrite && (Config->Pic && !isRelExpr(Expr))) { | |||
859 | error( | |||
860 | "can't create dynamic relocation " + toString(Type) + " against " + | |||
861 | (Sym.getName().empty() ? "local symbol" : "symbol: " + toString(Sym)) + | |||
862 | " in readonly segment; recompile object files with -fPIC " | |||
863 | "or pass '-Wl,-z,notext' to allow text relocations in the output" + | |||
864 | getLocation(Sec, Sym, Offset)); | |||
865 | return; | |||
866 | } | |||
867 | ||||
868 | // Copy relocations are only possible if we are creating an executable. | |||
869 | if (Config->Shared) { | |||
870 | errorOrWarn("relocation " + toString(Type) + | |||
871 | " cannot be used against symbol " + toString(Sym) + | |||
872 | "; recompile with -fPIC" + getLocation(Sec, Sym, Offset)); | |||
873 | return; | |||
874 | } | |||
875 | ||||
876 | // If the symbol is undefined we already reported any relevant errors. | |||
877 | if (Sym.isUndefined()) | |||
878 | return; | |||
879 | ||||
880 | if (!canDefineSymbolInExecutable(Sym)) { | |||
881 | error("cannot preempt symbol: " + toString(Sym) + | |||
882 | getLocation(Sec, Sym, Offset)); | |||
883 | return; | |||
884 | } | |||
885 | ||||
886 | if (Sym.isObject()) { | |||
887 | // Produce a copy relocation. | |||
888 | if (auto *SS = dyn_cast<SharedSymbol>(&Sym)) { | |||
889 | if (!Config->ZCopyreloc) | |||
890 | error("unresolvable relocation " + toString(Type) + | |||
891 | " against symbol '" + toString(*SS) + | |||
892 | "'; recompile with -fPIC or remove '-z nocopyreloc'" + | |||
893 | getLocation(Sec, Sym, Offset)); | |||
894 | addCopyRelSymbol<ELFT>(*SS); | |||
895 | } | |||
896 | Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
897 | return; | |||
898 | } | |||
899 | ||||
900 | if (Sym.isFunc()) { | |||
901 | // This handles a non PIC program call to function in a shared library. In | |||
902 | // an ideal world, we could just report an error saying the relocation can | |||
903 | // overflow at runtime. In the real world with glibc, crt1.o has a | |||
904 | // R_X86_64_PC32 pointing to libc.so. | |||
905 | // | |||
906 | // The general idea on how to handle such cases is to create a PLT entry and | |||
907 | // use that as the function value. | |||
908 | // | |||
909 | // For the static linking part, we just return a plt expr and everything | |||
910 | // else will use the PLT entry as the address. | |||
911 | // | |||
912 | // The remaining problem is making sure pointer equality still works. We | |||
913 | // need the help of the dynamic linker for that. We let it know that we have | |||
914 | // a direct reference to a so symbol by creating an undefined symbol with a | |||
915 | // non zero st_value. Seeing that, the dynamic linker resolves the symbol to | |||
916 | // the value of the symbol we created. This is true even for got entries, so | |||
917 | // pointer equality is maintained. To avoid an infinite loop, the only entry | |||
918 | // that points to the real function is a dedicated got entry used by the | |||
919 | // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT, | |||
920 | // R_386_JMP_SLOT, etc). | |||
921 | ||||
922 | // For position independent executable on i386, the plt entry requires ebx | |||
923 | // to be set. This causes two problems: | |||
924 | // * If some code has a direct reference to a function, it was probably | |||
925 | // compiled without -fPIE/-fPIC and doesn't maintain ebx. | |||
926 | // * If a library definition gets preempted to the executable, it will have | |||
927 | // the wrong ebx value. | |||
928 | if (Config->Pie && Config->EMachine == EM_386) | |||
929 | errorOrWarn("symbol '" + toString(Sym) + | |||
930 | "' cannot be preempted; recompile with -fPIE" + | |||
931 | getLocation(Sec, Sym, Offset)); | |||
932 | if (!Sym.isInPlt()) | |||
933 | addPltEntry<ELFT>(InX::Plt, InX::GotPlt, InX::RelaPlt, Target->PltRel, | |||
934 | Sym); | |||
935 | if (!Sym.isDefined()) | |||
936 | replaceWithDefined(Sym, InX::Plt, Sym.getPltOffset(), 0); | |||
937 | Sym.NeedsPltAddr = true; | |||
938 | Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym}); | |||
939 | return; | |||
940 | } | |||
941 | ||||
942 | errorOrWarn("symbol '" + toString(Sym) + "' has no type" + | |||
943 | getLocation(Sec, Sym, Offset)); | |||
944 | } | |||
945 | ||||
946 | template <class ELFT, class RelTy> | |||
947 | static void scanReloc(InputSectionBase &Sec, OffsetGetter &GetOffset, RelTy *&I, | |||
948 | RelTy *End) { | |||
949 | const RelTy &Rel = *I; | |||
950 | Symbol &Sym = Sec.getFile<ELFT>()->getRelocTargetSym(Rel); | |||
951 | RelType Type; | |||
952 | ||||
953 | // Deal with MIPS oddity. | |||
954 | if (Config->MipsN32Abi) { | |||
955 | Type = getMipsN32RelType(I, End); | |||
956 | } else { | |||
957 | Type = Rel.getType(Config->IsMips64EL); | |||
958 | ++I; | |||
959 | } | |||
960 | ||||
961 | // Get an offset in an output section this relocation is applied to. | |||
962 | uint64_t Offset = GetOffset.get(Rel.r_offset); | |||
963 | if (Offset == uint64_t(-1)) | |||
964 | return; | |||
965 | ||||
966 | // Skip if the target symbol is an erroneous undefined symbol. | |||
967 | if (maybeReportUndefined(Sym, Sec, Rel.r_offset)) | |||
968 | return; | |||
969 | ||||
970 | const uint8_t *RelocatedAddr = Sec.Data.begin() + Rel.r_offset; | |||
971 | RelExpr Expr = Target->getRelExpr(Type, Sym, RelocatedAddr); | |||
972 | ||||
973 | // Ignore "hint" relocations because they are only markers for relaxation. | |||
974 | if (isRelExprOneOf<R_HINT, R_NONE>(Expr)) | |||
975 | return; | |||
976 | ||||
977 | // Strenghten or relax relocations. | |||
978 | // | |||
979 | // GNU ifunc symbols must be accessed via PLT because their addresses | |||
980 | // are determined by runtime. | |||
981 | // | |||
982 | // On the other hand, if we know that a PLT entry will be resolved within | |||
983 | // the same ELF module, we can skip PLT access and directly jump to the | |||
984 | // destination function. For example, if we are linking a main exectuable, | |||
985 | // all dynamic symbols that can be resolved within the executable will | |||
986 | // actually be resolved that way at runtime, because the main exectuable | |||
987 | // is always at the beginning of a search list. We can leverage that fact. | |||
988 | if (Sym.isGnuIFunc()) | |||
989 | Expr = toPlt(Expr); | |||
990 | else if (!Sym.IsPreemptible && Expr == R_GOT_PC && !isAbsoluteValue(Sym)) | |||
991 | Expr = Target->adjustRelaxExpr(Type, RelocatedAddr, Expr); | |||
992 | else if (!Sym.IsPreemptible) | |||
993 | Expr = fromPlt(Expr); | |||
994 | ||||
995 | // This relocation does not require got entry, but it is relative to got and | |||
996 | // needs it to be created. Here we request for that. | |||
997 | if (isRelExprOneOf<R_GOTONLY_PC, R_GOTONLY_PC_FROM_END, R_GOTREL, | |||
998 | R_GOTREL_FROM_END, R_PPC_TOC>(Expr)) | |||
999 | InX::Got->HasGotOffRel = true; | |||
1000 | ||||
1001 | // Read an addend. | |||
1002 | int64_t Addend = computeAddend<ELFT>(Rel, End, Sec, Expr, Sym.isLocal()); | |||
1003 | ||||
1004 | // Process some TLS relocations, including relaxing TLS relocations. | |||
1005 | // Note that this function does not handle all TLS relocations. | |||
1006 | if (unsigned Processed = | |||
1007 | handleTlsRelocation<ELFT>(Type, Sym, Sec, Offset, Addend, Expr)) { | |||
1008 | I += (Processed - 1); | |||
1009 | return; | |||
1010 | } | |||
1011 | ||||
1012 | // If a relocation needs PLT, we create PLT and GOTPLT slots for the symbol. | |||
1013 | if (needsPlt(Expr) && !Sym.isInPlt()) { | |||
1014 | if (Sym.isGnuIFunc() && !Sym.IsPreemptible) | |||
1015 | addPltEntry<ELFT>(InX::Iplt, InX::IgotPlt, InX::RelaIplt, | |||
1016 | Target->IRelativeRel, Sym); | |||
1017 | else | |||
1018 | addPltEntry<ELFT>(InX::Plt, InX::GotPlt, InX::RelaPlt, Target->PltRel, | |||
1019 | Sym); | |||
1020 | } | |||
1021 | ||||
1022 | // Create a GOT slot if a relocation needs GOT. | |||
1023 | if (needsGot(Expr)) { | |||
1024 | if (Config->EMachine == EM_MIPS) { | |||
1025 | // MIPS ABI has special rules to process GOT entries and doesn't | |||
1026 | // require relocation entries for them. A special case is TLS | |||
1027 | // relocations. In that case dynamic loader applies dynamic | |||
1028 | // relocations to initialize TLS GOT entries. | |||
1029 | // See "Global Offset Table" in Chapter 5 in the following document | |||
1030 | // for detailed description: | |||
1031 | // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf | |||
1032 | InX::MipsGot->addEntry(*Sec.File, Sym, Addend, Expr); | |||
1033 | } else if (!Sym.isInGot()) { | |||
1034 | addGotEntry<ELFT>(Sym); | |||
1035 | } | |||
1036 | } | |||
1037 | ||||
1038 | processRelocAux<ELFT>(Sec, Expr, Type, Offset, Sym, Rel, Addend); | |||
1039 | } | |||
1040 | ||||
1041 | template <class ELFT, class RelTy> | |||
1042 | static void scanRelocs(InputSectionBase &Sec, ArrayRef<RelTy> Rels) { | |||
1043 | OffsetGetter GetOffset(Sec); | |||
1044 | ||||
1045 | // Not all relocations end up in Sec.Relocations, but a lot do. | |||
1046 | Sec.Relocations.reserve(Rels.size()); | |||
1047 | ||||
1048 | for (auto I = Rels.begin(), End = Rels.end(); I != End;) | |||
1049 | scanReloc<ELFT>(Sec, GetOffset, I, End); | |||
1050 | } | |||
1051 | ||||
1052 | template <class ELFT> void elf::scanRelocations(InputSectionBase &S) { | |||
1053 | if (S.AreRelocsRela) | |||
1054 | scanRelocs<ELFT>(S, S.relas<ELFT>()); | |||
1055 | else | |||
1056 | scanRelocs<ELFT>(S, S.rels<ELFT>()); | |||
1057 | } | |||
1058 | ||||
1059 | // Thunk Implementation | |||
1060 | // | |||
1061 | // Thunks (sometimes called stubs, veneers or branch islands) are small pieces | |||
1062 | // of code that the linker inserts inbetween a caller and a callee. The thunks | |||
1063 | // are added at link time rather than compile time as the decision on whether | |||
1064 | // a thunk is needed, such as the caller and callee being out of range, can only | |||
1065 | // be made at link time. | |||
1066 | // | |||
1067 | // It is straightforward to tell given the current state of the program when a | |||
1068 | // thunk is needed for a particular call. The more difficult part is that | |||
1069 | // the thunk needs to be placed in the program such that the caller can reach | |||
1070 | // the thunk and the thunk can reach the callee; furthermore, adding thunks to | |||
1071 | // the program alters addresses, which can mean more thunks etc. | |||
1072 | // | |||
1073 | // In lld we have a synthetic ThunkSection that can hold many Thunks. | |||
1074 | // The decision to have a ThunkSection act as a container means that we can | |||
1075 | // more easily handle the most common case of a single block of contiguous | |||
1076 | // Thunks by inserting just a single ThunkSection. | |||
1077 | // | |||
1078 | // The implementation of Thunks in lld is split across these areas | |||
1079 | // Relocations.cpp : Framework for creating and placing thunks | |||
1080 | // Thunks.cpp : The code generated for each supported thunk | |||
1081 | // Target.cpp : Target specific hooks that the framework uses to decide when | |||
1082 | // a thunk is used | |||
1083 | // Synthetic.cpp : Implementation of ThunkSection | |||
1084 | // Writer.cpp : Iteratively call framework until no more Thunks added | |||
1085 | // | |||
1086 | // Thunk placement requirements: | |||
1087 | // Mips LA25 thunks. These must be placed immediately before the callee section | |||
1088 | // We can assume that the caller is in range of the Thunk. These are modelled | |||
1089 | // by Thunks that return the section they must precede with | |||
1090 | // getTargetInputSection(). | |||
1091 | // | |||
1092 | // ARM interworking and range extension thunks. These thunks must be placed | |||
1093 | // within range of the caller. All implemented ARM thunks can always reach the | |||
1094 | // callee as they use an indirect jump via a register that has no range | |||
1095 | // restrictions. | |||
1096 | // | |||
1097 | // Thunk placement algorithm: | |||
1098 | // For Mips LA25 ThunkSections; the placement is explicit, it has to be before | |||
1099 | // getTargetInputSection(). | |||
1100 | // | |||
1101 | // For thunks that must be placed within range of the caller there are many | |||
1102 | // possible choices given that the maximum range from the caller is usually | |||
1103 | // much larger than the average InputSection size. Desirable properties include: | |||
1104 | // - Maximize reuse of thunks by multiple callers | |||
1105 | // - Minimize number of ThunkSections to simplify insertion | |||
1106 | // - Handle impact of already added Thunks on addresses | |||
1107 | // - Simple to understand and implement | |||
1108 | // | |||
1109 | // In lld for the first pass, we pre-create one or more ThunkSections per | |||
1110 | // InputSectionDescription at Target specific intervals. A ThunkSection is | |||
1111 | // placed so that the estimated end of the ThunkSection is within range of the | |||
1112 | // start of the InputSectionDescription or the previous ThunkSection. For | |||
1113 | // example: | |||
1114 | // InputSectionDescription | |||
1115 | // Section 0 | |||
1116 | // ... | |||
1117 | // Section N | |||
1118 | // ThunkSection 0 | |||
1119 | // Section N + 1 | |||
1120 | // ... | |||
1121 | // Section N + K | |||
1122 | // Thunk Section 1 | |||
1123 | // | |||
1124 | // The intention is that we can add a Thunk to a ThunkSection that is well | |||
1125 | // spaced enough to service a number of callers without having to do a lot | |||
1126 | // of work. An important principle is that it is not an error if a Thunk cannot | |||
1127 | // be placed in a pre-created ThunkSection; when this happens we create a new | |||
1128 | // ThunkSection placed next to the caller. This allows us to handle the vast | |||
1129 | // majority of thunks simply, but also handle rare cases where the branch range | |||
1130 | // is smaller than the target specific spacing. | |||
1131 | // | |||
1132 | // The algorithm is expected to create all the thunks that are needed in a | |||
1133 | // single pass, with a small number of programs needing a second pass due to | |||
1134 | // the insertion of thunks in the first pass increasing the offset between | |||
1135 | // callers and callees that were only just in range. | |||
1136 | // | |||
1137 | // A consequence of allowing new ThunkSections to be created outside of the | |||
1138 | // pre-created ThunkSections is that in rare cases calls to Thunks that were in | |||
1139 | // range in pass K, are out of range in some pass > K due to the insertion of | |||
1140 | // more Thunks in between the caller and callee. When this happens we retarget | |||
1141 | // the relocation back to the original target and create another Thunk. | |||
1142 | ||||
1143 | // Remove ThunkSections that are empty, this should only be the initial set | |||
1144 | // precreated on pass 0. | |||
1145 | ||||
1146 | // Insert the Thunks for OutputSection OS into their designated place | |||
1147 | // in the Sections vector, and recalculate the InputSection output section | |||
1148 | // offsets. | |||
1149 | // This may invalidate any output section offsets stored outside of InputSection | |||
1150 | void ThunkCreator::mergeThunks(ArrayRef<OutputSection *> OutputSections) { | |||
1151 | forEachInputSectionDescription( | |||
1152 | OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) { | |||
1153 | if (ISD->ThunkSections.empty()) | |||
1154 | return; | |||
1155 | ||||
1156 | // Remove any zero sized precreated Thunks. | |||
1157 | llvm::erase_if(ISD->ThunkSections, | |||
1158 | [](const std::pair<ThunkSection *, uint32_t> &TS) { | |||
1159 | return TS.first->getSize() == 0; | |||
1160 | }); | |||
1161 | // ISD->ThunkSections contains all created ThunkSections, including | |||
1162 | // those inserted in previous passes. Extract the Thunks created this | |||
1163 | // pass and order them in ascending OutSecOff. | |||
1164 | std::vector<ThunkSection *> NewThunks; | |||
1165 | for (const std::pair<ThunkSection *, uint32_t> TS : ISD->ThunkSections) | |||
1166 | if (TS.second == Pass) | |||
1167 | NewThunks.push_back(TS.first); | |||
1168 | std::stable_sort(NewThunks.begin(), NewThunks.end(), | |||
1169 | [](const ThunkSection *A, const ThunkSection *B) { | |||
1170 | return A->OutSecOff < B->OutSecOff; | |||
1171 | }); | |||
1172 | ||||
1173 | // Merge sorted vectors of Thunks and InputSections by OutSecOff | |||
1174 | std::vector<InputSection *> Tmp; | |||
1175 | Tmp.reserve(ISD->Sections.size() + NewThunks.size()); | |||
1176 | auto MergeCmp = [](const InputSection *A, const InputSection *B) { | |||
1177 | // std::merge requires a strict weak ordering. | |||
1178 | if (A->OutSecOff < B->OutSecOff) | |||
1179 | return true; | |||
1180 | if (A->OutSecOff == B->OutSecOff) { | |||
1181 | auto *TA = dyn_cast<ThunkSection>(A); | |||
1182 | auto *TB = dyn_cast<ThunkSection>(B); | |||
1183 | // Check if Thunk is immediately before any specific Target | |||
1184 | // InputSection for example Mips LA25 Thunks. | |||
1185 | if (TA && TA->getTargetInputSection() == B) | |||
1186 | return true; | |||
1187 | if (TA && !TB && !TA->getTargetInputSection()) | |||
1188 | // Place Thunk Sections without specific targets before | |||
1189 | // non-Thunk Sections. | |||
1190 | return true; | |||
1191 | } | |||
1192 | return false; | |||
1193 | }; | |||
1194 | std::merge(ISD->Sections.begin(), ISD->Sections.end(), | |||
1195 | NewThunks.begin(), NewThunks.end(), std::back_inserter(Tmp), | |||
1196 | MergeCmp); | |||
1197 | ISD->Sections = std::move(Tmp); | |||
1198 | }); | |||
1199 | } | |||
1200 | ||||
1201 | // Find or create a ThunkSection within the InputSectionDescription (ISD) that | |||
1202 | // is in range of Src. An ISD maps to a range of InputSections described by a | |||
1203 | // linker script section pattern such as { .text .text.* }. | |||
1204 | ThunkSection *ThunkCreator::getISDThunkSec(OutputSection *OS, InputSection *IS, | |||
1205 | InputSectionDescription *ISD, | |||
1206 | uint32_t Type, uint64_t Src) { | |||
1207 | for (std::pair<ThunkSection *, uint32_t> TP : ISD->ThunkSections) { | |||
1208 | ThunkSection *TS = TP.first; | |||
1209 | uint64_t TSBase = OS->Addr + TS->OutSecOff; | |||
1210 | uint64_t TSLimit = TSBase + TS->getSize(); | |||
1211 | if (Target->inBranchRange(Type, Src, (Src > TSLimit) ? TSBase : TSLimit)) | |||
1212 | return TS; | |||
1213 | } | |||
1214 | ||||
1215 | // No suitable ThunkSection exists. This can happen when there is a branch | |||
1216 | // with lower range than the ThunkSection spacing or when there are too | |||
1217 | // many Thunks. Create a new ThunkSection as close to the InputSection as | |||
1218 | // possible. Error if InputSection is so large we cannot place ThunkSection | |||
1219 | // anywhere in Range. | |||
1220 | uint64_t ThunkSecOff = IS->OutSecOff; | |||
1221 | if (!Target->inBranchRange(Type, Src, OS->Addr + ThunkSecOff)) { | |||
1222 | ThunkSecOff = IS->OutSecOff + IS->getSize(); | |||
1223 | if (!Target->inBranchRange(Type, Src, OS->Addr + ThunkSecOff)) | |||
1224 | fatal("InputSection too large for range extension thunk " + | |||
1225 | IS->getObjMsg(Src - (OS->Addr + IS->OutSecOff))); | |||
1226 | } | |||
1227 | return addThunkSection(OS, ISD, ThunkSecOff); | |||
1228 | } | |||
1229 | ||||
1230 | // Add a Thunk that needs to be placed in a ThunkSection that immediately | |||
1231 | // precedes its Target. | |||
1232 | ThunkSection *ThunkCreator::getISThunkSec(InputSection *IS) { | |||
1233 | ThunkSection *TS = ThunkedSections.lookup(IS); | |||
1234 | if (TS) | |||
1235 | return TS; | |||
1236 | ||||
1237 | // Find InputSectionRange within Target Output Section (TOS) that the | |||
1238 | // InputSection (IS) that we need to precede is in. | |||
1239 | OutputSection *TOS = IS->getParent(); | |||
1240 | for (BaseCommand *BC : TOS->SectionCommands) | |||
1241 | if (auto *ISD = dyn_cast<InputSectionDescription>(BC)) { | |||
1242 | if (ISD->Sections.empty()) | |||
1243 | continue; | |||
1244 | InputSection *first = ISD->Sections.front(); | |||
1245 | InputSection *last = ISD->Sections.back(); | |||
1246 | if (IS->OutSecOff >= first->OutSecOff && | |||
1247 | IS->OutSecOff <= last->OutSecOff) { | |||
1248 | TS = addThunkSection(TOS, ISD, IS->OutSecOff); | |||
1249 | ThunkedSections[IS] = TS; | |||
1250 | break; | |||
1251 | } | |||
1252 | } | |||
1253 | return TS; | |||
1254 | } | |||
1255 | ||||
1256 | // Create one or more ThunkSections per OS that can be used to place Thunks. | |||
1257 | // We attempt to place the ThunkSections using the following desirable | |||
1258 | // properties: | |||
1259 | // - Within range of the maximum number of callers | |||
1260 | // - Minimise the number of ThunkSections | |||
1261 | // | |||
1262 | // We follow a simple but conservative heuristic to place ThunkSections at | |||
1263 | // offsets that are multiples of a Target specific branch range. | |||
1264 | // For an InputSectionDescription that is smaller than the range, a single | |||
1265 | // ThunkSection at the end of the range will do. | |||
1266 | // | |||
1267 | // For an InputSectionDescription that is more than twice the size of the range, | |||
1268 | // we place the last ThunkSection at range bytes from the end of the | |||
1269 | // InputSectionDescription in order to increase the likelihood that the | |||
1270 | // distance from a thunk to its target will be sufficiently small to | |||
1271 | // allow for the creation of a short thunk. | |||
1272 | void ThunkCreator::createInitialThunkSections( | |||
1273 | ArrayRef<OutputSection *> OutputSections) { | |||
1274 | forEachInputSectionDescription( | |||
1275 | OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) { | |||
1276 | if (ISD->Sections.empty()) | |||
| ||||
1277 | return; | |||
1278 | uint32_t ISDBegin = ISD->Sections.front()->OutSecOff; | |||
1279 | uint32_t ISDEnd = | |||
1280 | ISD->Sections.back()->OutSecOff + ISD->Sections.back()->getSize(); | |||
1281 | uint32_t LastThunkLowerBound = -1; | |||
1282 | if (ISDEnd - ISDBegin > Target->ThunkSectionSpacing * 2) | |||
1283 | LastThunkLowerBound = ISDEnd - Target->ThunkSectionSpacing; | |||
1284 | ||||
1285 | uint32_t ISLimit; | |||
1286 | uint32_t PrevISLimit = ISDBegin; | |||
1287 | uint32_t ThunkUpperBound = ISDBegin + Target->ThunkSectionSpacing; | |||
1288 | ||||
1289 | for (const InputSection *IS : ISD->Sections) { | |||
1290 | ISLimit = IS->OutSecOff + IS->getSize(); | |||
1291 | if (ISLimit > ThunkUpperBound) { | |||
1292 | addThunkSection(OS, ISD, PrevISLimit); | |||
1293 | ThunkUpperBound = PrevISLimit + Target->ThunkSectionSpacing; | |||
1294 | } | |||
1295 | if (ISLimit > LastThunkLowerBound) | |||
1296 | break; | |||
1297 | PrevISLimit = ISLimit; | |||
1298 | } | |||
1299 | addThunkSection(OS, ISD, ISLimit); | |||
| ||||
1300 | }); | |||
1301 | } | |||
1302 | ||||
1303 | ThunkSection *ThunkCreator::addThunkSection(OutputSection *OS, | |||
1304 | InputSectionDescription *ISD, | |||
1305 | uint64_t Off) { | |||
1306 | auto *TS = make<ThunkSection>(OS, Off); | |||
1307 | ISD->ThunkSections.push_back(std::make_pair(TS, Pass)); | |||
1308 | return TS; | |||
1309 | } | |||
1310 | ||||
1311 | std::pair<Thunk *, bool> ThunkCreator::getThunk(Symbol &Sym, RelType Type, | |||
1312 | uint64_t Src) { | |||
1313 | std::vector<Thunk *> *ThunkVec = nullptr; | |||
1314 | // We use (section, offset) pair to find the thunk position if possible so | |||
1315 | // that we create only one thunk for aliased symbols or ICFed sections. | |||
1316 | if (auto *D = dyn_cast<Defined>(&Sym)) | |||
1317 | if (!D->isInPlt() && D->Section) | |||
1318 | ThunkVec = &ThunkedSymbolsBySection[{D->Section->Repl, D->Value}]; | |||
1319 | if (!ThunkVec) | |||
1320 | ThunkVec = &ThunkedSymbols[&Sym]; | |||
1321 | // Check existing Thunks for Sym to see if they can be reused | |||
1322 | for (Thunk *ET : *ThunkVec) | |||
1323 | if (ET->isCompatibleWith(Type) && | |||
1324 | Target->inBranchRange(Type, Src, ET->getThunkTargetSym()->getVA())) | |||
1325 | return std::make_pair(ET, false); | |||
1326 | // No existing compatible Thunk in range, create a new one | |||
1327 | Thunk *T = addThunk(Type, Sym); | |||
1328 | ThunkVec->push_back(T); | |||
1329 | return std::make_pair(T, true); | |||
1330 | } | |||
1331 | ||||
1332 | // Call Fn on every executable InputSection accessed via the linker script | |||
1333 | // InputSectionDescription::Sections. | |||
1334 | void ThunkCreator::forEachInputSectionDescription( | |||
1335 | ArrayRef<OutputSection *> OutputSections, | |||
1336 | llvm::function_ref<void(OutputSection *, InputSectionDescription *)> Fn) { | |||
1337 | for (OutputSection *OS : OutputSections) { | |||
1338 | if (!(OS->Flags & SHF_ALLOC) || !(OS->Flags & SHF_EXECINSTR)) | |||
1339 | continue; | |||
1340 | for (BaseCommand *BC : OS->SectionCommands) | |||
1341 | if (auto *ISD = dyn_cast<InputSectionDescription>(BC)) | |||
1342 | Fn(OS, ISD); | |||
1343 | } | |||
1344 | } | |||
1345 | ||||
1346 | // Return true if the relocation target is an in range Thunk. | |||
1347 | // Return false if the relocation is not to a Thunk. If the relocation target | |||
1348 | // was originally to a Thunk, but is no longer in range we revert the | |||
1349 | // relocation back to its original non-Thunk target. | |||
1350 | bool ThunkCreator::normalizeExistingThunk(Relocation &Rel, uint64_t Src) { | |||
1351 | if (Thunk *ET = Thunks.lookup(Rel.Sym)) { | |||
1352 | if (Target->inBranchRange(Rel.Type, Src, Rel.Sym->getVA())) | |||
1353 | return true; | |||
1354 | Rel.Sym = &ET->Destination; | |||
1355 | if (Rel.Sym->isInPlt()) | |||
1356 | Rel.Expr = toPlt(Rel.Expr); | |||
1357 | } | |||
1358 | return false; | |||
1359 | } | |||
1360 | ||||
1361 | // Process all relocations from the InputSections that have been assigned | |||
1362 | // to InputSectionDescriptions and redirect through Thunks if needed. The | |||
1363 | // function should be called iteratively until it returns false. | |||
1364 | // | |||
1365 | // PreConditions: | |||
1366 | // All InputSections that may need a Thunk are reachable from | |||
1367 | // OutputSectionCommands. | |||
1368 | // | |||
1369 | // All OutputSections have an address and all InputSections have an offset | |||
1370 | // within the OutputSection. | |||
1371 | // | |||
1372 | // The offsets between caller (relocation place) and callee | |||
1373 | // (relocation target) will not be modified outside of createThunks(). | |||
1374 | // | |||
1375 | // PostConditions: | |||
1376 | // If return value is true then ThunkSections have been inserted into | |||
1377 | // OutputSections. All relocations that needed a Thunk based on the information | |||
1378 | // available to createThunks() on entry have been redirected to a Thunk. Note | |||
1379 | // that adding Thunks changes offsets between caller and callee so more Thunks | |||
1380 | // may be required. | |||
1381 | // | |||
1382 | // If return value is false then no more Thunks are needed, and createThunks has | |||
1383 | // made no changes. If the target requires range extension thunks, currently | |||
1384 | // ARM, then any future change in offset between caller and callee risks a | |||
1385 | // relocation out of range error. | |||
1386 | bool ThunkCreator::createThunks(ArrayRef<OutputSection *> OutputSections) { | |||
1387 | bool AddressesChanged = false; | |||
1388 | if (Pass == 0 && Target->ThunkSectionSpacing) | |||
1389 | createInitialThunkSections(OutputSections); | |||
1390 | else if (Pass == 10) | |||
1391 | // With Thunk Size much smaller than branch range we expect to | |||
1392 | // converge quickly; if we get to 10 something has gone wrong. | |||
1393 | fatal("thunk creation not converged"); | |||
1394 | ||||
1395 | // Create all the Thunks and insert them into synthetic ThunkSections. The | |||
1396 | // ThunkSections are later inserted back into InputSectionDescriptions. | |||
1397 | // We separate the creation of ThunkSections from the insertion of the | |||
1398 | // ThunkSections as ThunkSections are not always inserted into the same | |||
1399 | // InputSectionDescription as the caller. | |||
1400 | forEachInputSectionDescription( | |||
1401 | OutputSections, [&](OutputSection *OS, InputSectionDescription *ISD) { | |||
1402 | for (InputSection *IS : ISD->Sections) | |||
1403 | for (Relocation &Rel : IS->Relocations) { | |||
1404 | uint64_t Src = IS->getVA(Rel.Offset); | |||
1405 | ||||
1406 | // If we are a relocation to an existing Thunk, check if it is | |||
1407 | // still in range. If not then Rel will be altered to point to its | |||
1408 | // original target so another Thunk can be generated. | |||
1409 | if (Pass > 0 && normalizeExistingThunk(Rel, Src)) | |||
1410 | continue; | |||
1411 | ||||
1412 | if (!Target->needsThunk(Rel.Expr, Rel.Type, IS->File, Src, | |||
1413 | *Rel.Sym)) | |||
1414 | continue; | |||
1415 | Thunk *T; | |||
1416 | bool IsNew; | |||
1417 | std::tie(T, IsNew) = getThunk(*Rel.Sym, Rel.Type, Src); | |||
1418 | if (IsNew) { | |||
1419 | // Find or create a ThunkSection for the new Thunk | |||
1420 | ThunkSection *TS; | |||
1421 | if (auto *TIS = T->getTargetInputSection()) | |||
1422 | TS = getISThunkSec(TIS); | |||
1423 | else | |||
1424 | TS = getISDThunkSec(OS, IS, ISD, Rel.Type, Src); | |||
1425 | TS->addThunk(T); | |||
1426 | Thunks[T->getThunkTargetSym()] = T; | |||
1427 | } | |||
1428 | // Redirect relocation to Thunk, we never go via the PLT to a Thunk | |||
1429 | Rel.Sym = T->getThunkTargetSym(); | |||
1430 | Rel.Expr = fromPlt(Rel.Expr); | |||
1431 | } | |||
1432 | for (auto &P : ISD->ThunkSections) | |||
1433 | AddressesChanged |= P.first->assignOffsets(); | |||
1434 | }); | |||
1435 | for (auto &P : ThunkedSections) | |||
1436 | AddressesChanged |= P.second->assignOffsets(); | |||
1437 | ||||
1438 | // Merge all created synthetic ThunkSections back into OutputSection | |||
1439 | mergeThunks(OutputSections); | |||
1440 | ++Pass; | |||
1441 | return AddressesChanged; | |||
1442 | } | |||
1443 | ||||
1444 | template void elf::scanRelocations<ELF32LE>(InputSectionBase &); | |||
1445 | template void elf::scanRelocations<ELF32BE>(InputSectionBase &); | |||
1446 | template void elf::scanRelocations<ELF64LE>(InputSectionBase &); | |||
1447 | template void elf::scanRelocations<ELF64BE>(InputSectionBase &); |