1 //===- PPC64.cpp ----------------------------------------------------------===//
2 //
3 // The LLVM Linker
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "Symbols.h"
11 #include "SyntheticSections.h"
12 #include "Target.h"
13 #include "lld/Common/ErrorHandler.h"
14 #include "llvm/Support/Endian.h"
15
16 using namespace llvm;
17 using namespace llvm::object;
18 using namespace llvm::support::endian;
19 using namespace llvm::ELF;
20 using namespace lld;
21 using namespace lld::elf;
22
23 static uint64_t PPC64TocOffset = 0x8000;
24 static uint64_t DynamicThreadPointerOffset = 0x8000;
25
26 // The instruction encoding of bits 21-30 from the ISA for the Xform and Dform
27 // instructions that can be used as part of the initial exec TLS sequence.
28 enum XFormOpcd {
29 LBZX = 87,
30 LHZX = 279,
31 LWZX = 23,
32 LDX = 21,
33 STBX = 215,
34 STHX = 407,
35 STWX = 151,
36 STDX = 149,
37 ADD = 266,
38 };
39
40 enum DFormOpcd {
41 LBZ = 34,
42 LBZU = 35,
43 LHZ = 40,
44 LHZU = 41,
45 LHAU = 43,
46 LWZ = 32,
47 LWZU = 33,
48 LFSU = 49,
49 LD = 58,
50 LFDU = 51,
51 STB = 38,
52 STBU = 39,
53 STH = 44,
54 STHU = 45,
55 STW = 36,
56 STWU = 37,
57 STFSU = 53,
58 STFDU = 55,
59 STD = 62,
60 ADDI = 14
61 };
62
getPPC64TocBase()63 uint64_t elf::getPPC64TocBase() {
64 // The TOC consists of sections .got, .toc, .tocbss, .plt in that order. The
65 // TOC starts where the first of these sections starts. We always create a
66 // .got when we see a relocation that uses it, so for us the start is always
67 // the .got.
68 uint64_t TocVA = In.Got->getVA();
69
70 // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
71 // thus permitting a full 64 Kbytes segment. Note that the glibc startup
72 // code (crt1.o) assumes that you can get from the TOC base to the
73 // start of the .toc section with only a single (signed) 16-bit relocation.
74 return TocVA + PPC64TocOffset;
75 }
76
getPPC64GlobalEntryToLocalEntryOffset(uint8_t StOther)77 unsigned elf::getPPC64GlobalEntryToLocalEntryOffset(uint8_t StOther) {
78 // The offset is encoded into the 3 most significant bits of the st_other
79 // field, with some special values described in section 3.4.1 of the ABI:
80 // 0 --> Zero offset between the GEP and LEP, and the function does NOT use
81 // the TOC pointer (r2). r2 will hold the same value on returning from
82 // the function as it did on entering the function.
83 // 1 --> Zero offset between the GEP and LEP, and r2 should be treated as a
84 // caller-saved register for all callers.
85 // 2-6 --> The binary logarithm of the offset eg:
86 // 2 --> 2^2 = 4 bytes --> 1 instruction.
87 // 6 --> 2^6 = 64 bytes --> 16 instructions.
88 // 7 --> Reserved.
89 uint8_t GepToLep = (StOther >> 5) & 7;
90 if (GepToLep < 2)
91 return 0;
92
93 // The value encoded in the st_other bits is the
94 // log-base-2(offset).
95 if (GepToLep < 7)
96 return 1 << GepToLep;
97
98 error("reserved value of 7 in the 3 most-significant-bits of st_other");
99 return 0;
100 }
101
102 namespace {
103 class PPC64 final : public TargetInfo {
104 public:
105 PPC64();
106 uint32_t calcEFlags() const override;
107 RelExpr getRelExpr(RelType Type, const Symbol &S,
108 const uint8_t *Loc) const override;
109 void writePltHeader(uint8_t *Buf) const override;
110 void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
111 int32_t Index, unsigned RelOff) const override;
112 void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
113 void writeGotHeader(uint8_t *Buf) const override;
114 bool needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
115 uint64_t BranchAddr, const Symbol &S) const override;
116 uint32_t getThunkSectionSpacing() const override;
117 bool inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const override;
118 RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
119 RelExpr Expr) const override;
120 void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
121 void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
122 void relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
123 void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
124
125 bool adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
126 uint8_t StOther) const override;
127 };
128 } // namespace
129
130 // Relocation masks following the #lo(value), #hi(value), #ha(value),
131 // #higher(value), #highera(value), #highest(value), and #highesta(value)
132 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
133 // document.
lo(uint64_t V)134 static uint16_t lo(uint64_t V) { return V; }
hi(uint64_t V)135 static uint16_t hi(uint64_t V) { return V >> 16; }
ha(uint64_t V)136 static uint16_t ha(uint64_t V) { return (V + 0x8000) >> 16; }
higher(uint64_t V)137 static uint16_t higher(uint64_t V) { return V >> 32; }
highera(uint64_t V)138 static uint16_t highera(uint64_t V) { return (V + 0x8000) >> 32; }
highest(uint64_t V)139 static uint16_t highest(uint64_t V) { return V >> 48; }
highesta(uint64_t V)140 static uint16_t highesta(uint64_t V) { return (V + 0x8000) >> 48; }
141
142 // Extracts the 'PO' field of an instruction encoding.
getPrimaryOpCode(uint32_t Encoding)143 static uint8_t getPrimaryOpCode(uint32_t Encoding) { return (Encoding >> 26); }
144
isDQFormInstruction(uint32_t Encoding)145 static bool isDQFormInstruction(uint32_t Encoding) {
146 switch (getPrimaryOpCode(Encoding)) {
147 default:
148 return false;
149 case 56:
150 // The only instruction with a primary opcode of 56 is `lq`.
151 return true;
152 case 61:
153 // There are both DS and DQ instruction forms with this primary opcode.
154 // Namely `lxv` and `stxv` are the DQ-forms that use it.
155 // The DS 'XO' bits being set to 01 is restricted to DQ form.
156 return (Encoding & 3) == 0x1;
157 }
158 }
159
isInstructionUpdateForm(uint32_t Encoding)160 static bool isInstructionUpdateForm(uint32_t Encoding) {
161 switch (getPrimaryOpCode(Encoding)) {
162 default:
163 return false;
164 case LBZU:
165 case LHAU:
166 case LHZU:
167 case LWZU:
168 case LFSU:
169 case LFDU:
170 case STBU:
171 case STHU:
172 case STWU:
173 case STFSU:
174 case STFDU:
175 return true;
176 // LWA has the same opcode as LD, and the DS bits is what differentiates
177 // between LD/LDU/LWA
178 case LD:
179 case STD:
180 return (Encoding & 3) == 1;
181 }
182 }
183
184 // There are a number of places when we either want to read or write an
185 // instruction when handling a half16 relocation type. On big-endian the buffer
186 // pointer is pointing into the middle of the word we want to extract, and on
187 // little-endian it is pointing to the start of the word. These 2 helpers are to
188 // simplify reading and writing in that context.
writeInstrFromHalf16(uint8_t * Loc,uint32_t Instr)189 static void writeInstrFromHalf16(uint8_t *Loc, uint32_t Instr) {
190 write32(Loc - (Config->EKind == ELF64BEKind ? 2 : 0), Instr);
191 }
192
readInstrFromHalf16(const uint8_t * Loc)193 static uint32_t readInstrFromHalf16(const uint8_t *Loc) {
194 return read32(Loc - (Config->EKind == ELF64BEKind ? 2 : 0));
195 }
196
PPC64()197 PPC64::PPC64() {
198 GotRel = R_PPC64_GLOB_DAT;
199 NoneRel = R_PPC64_NONE;
200 PltRel = R_PPC64_JMP_SLOT;
201 RelativeRel = R_PPC64_RELATIVE;
202 IRelativeRel = R_PPC64_IRELATIVE;
203 GotEntrySize = 8;
204 PltEntrySize = 4;
205 GotPltEntrySize = 8;
206 GotBaseSymInGotPlt = false;
207 GotBaseSymOff = 0x8000;
208 GotHeaderEntriesNum = 1;
209 GotPltHeaderEntriesNum = 2;
210 PltHeaderSize = 60;
211 NeedsThunks = true;
212
213 TlsModuleIndexRel = R_PPC64_DTPMOD64;
214 TlsOffsetRel = R_PPC64_DTPREL64;
215
216 TlsGotRel = R_PPC64_TPREL64;
217
218 NeedsMoreStackNonSplit = false;
219
220 // We need 64K pages (at least under glibc/Linux, the loader won't
221 // set different permissions on a finer granularity than that).
222 DefaultMaxPageSize = 65536;
223
224 // The PPC64 ELF ABI v1 spec, says:
225 //
226 // It is normally desirable to put segments with different characteristics
227 // in separate 256 Mbyte portions of the address space, to give the
228 // operating system full paging flexibility in the 64-bit address space.
229 //
230 // And because the lowest non-zero 256M boundary is 0x10000000, PPC64 linkers
231 // use 0x10000000 as the starting address.
232 DefaultImageBase = 0x10000000;
233
234 write32(TrapInstr.data(), 0x7fe00008);
235 }
236
getEFlags(InputFile * File)237 static uint32_t getEFlags(InputFile *File) {
238 if (Config->EKind == ELF64BEKind)
239 return cast<ObjFile<ELF64BE>>(File)->getObj().getHeader()->e_flags;
240 return cast<ObjFile<ELF64LE>>(File)->getObj().getHeader()->e_flags;
241 }
242
243 // This file implements v2 ABI. This function makes sure that all
244 // object files have v2 or an unspecified version as an ABI version.
calcEFlags() const245 uint32_t PPC64::calcEFlags() const {
246 for (InputFile *F : ObjectFiles) {
247 uint32_t Flag = getEFlags(F);
248 if (Flag == 1)
249 error(toString(F) + ": ABI version 1 is not supported");
250 else if (Flag > 2)
251 error(toString(F) + ": unrecognized e_flags: " + Twine(Flag));
252 }
253 return 2;
254 }
255
relaxTlsGdToLe(uint8_t * Loc,RelType Type,uint64_t Val) const256 void PPC64::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
257 // Reference: 3.7.4.2 of the 64-bit ELF V2 abi supplement.
258 // The general dynamic code sequence for a global `x` will look like:
259 // Instruction Relocation Symbol
260 // addis r3, r2, x@got@tlsgd@ha R_PPC64_GOT_TLSGD16_HA x
261 // addi r3, r3, x@got@tlsgd@l R_PPC64_GOT_TLSGD16_LO x
262 // bl __tls_get_addr(x@tlsgd) R_PPC64_TLSGD x
263 // R_PPC64_REL24 __tls_get_addr
264 // nop None None
265
266 // Relaxing to local exec entails converting:
267 // addis r3, r2, x@got@tlsgd@ha into nop
268 // addi r3, r3, x@got@tlsgd@l into addis r3, r13, x@tprel@ha
269 // bl __tls_get_addr(x@tlsgd) into nop
270 // nop into addi r3, r3, x@tprel@l
271
272 switch (Type) {
273 case R_PPC64_GOT_TLSGD16_HA:
274 writeInstrFromHalf16(Loc, 0x60000000); // nop
275 break;
276 case R_PPC64_GOT_TLSGD16:
277 case R_PPC64_GOT_TLSGD16_LO:
278 writeInstrFromHalf16(Loc, 0x3c6d0000); // addis r3, r13
279 relocateOne(Loc, R_PPC64_TPREL16_HA, Val);
280 break;
281 case R_PPC64_TLSGD:
282 write32(Loc, 0x60000000); // nop
283 write32(Loc + 4, 0x38630000); // addi r3, r3
284 // Since we are relocating a half16 type relocation and Loc + 4 points to
285 // the start of an instruction we need to advance the buffer by an extra
286 // 2 bytes on BE.
287 relocateOne(Loc + 4 + (Config->EKind == ELF64BEKind ? 2 : 0),
288 R_PPC64_TPREL16_LO, Val);
289 break;
290 default:
291 llvm_unreachable("unsupported relocation for TLS GD to LE relaxation");
292 }
293 }
294
relaxTlsLdToLe(uint8_t * Loc,RelType Type,uint64_t Val) const295 void PPC64::relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
296 // Reference: 3.7.4.3 of the 64-bit ELF V2 abi supplement.
297 // The local dynamic code sequence for a global `x` will look like:
298 // Instruction Relocation Symbol
299 // addis r3, r2, x@got@tlsld@ha R_PPC64_GOT_TLSLD16_HA x
300 // addi r3, r3, x@got@tlsld@l R_PPC64_GOT_TLSLD16_LO x
301 // bl __tls_get_addr(x@tlsgd) R_PPC64_TLSLD x
302 // R_PPC64_REL24 __tls_get_addr
303 // nop None None
304
305 // Relaxing to local exec entails converting:
306 // addis r3, r2, x@got@tlsld@ha into nop
307 // addi r3, r3, x@got@tlsld@l into addis r3, r13, 0
308 // bl __tls_get_addr(x@tlsgd) into nop
309 // nop into addi r3, r3, 4096
310
311 switch (Type) {
312 case R_PPC64_GOT_TLSLD16_HA:
313 writeInstrFromHalf16(Loc, 0x60000000); // nop
314 break;
315 case R_PPC64_GOT_TLSLD16_LO:
316 writeInstrFromHalf16(Loc, 0x3c6d0000); // addis r3, r13, 0
317 break;
318 case R_PPC64_TLSLD:
319 write32(Loc, 0x60000000); // nop
320 write32(Loc + 4, 0x38631000); // addi r3, r3, 4096
321 break;
322 case R_PPC64_DTPREL16:
323 case R_PPC64_DTPREL16_HA:
324 case R_PPC64_DTPREL16_HI:
325 case R_PPC64_DTPREL16_DS:
326 case R_PPC64_DTPREL16_LO:
327 case R_PPC64_DTPREL16_LO_DS:
328 case R_PPC64_GOT_DTPREL16_HA:
329 case R_PPC64_GOT_DTPREL16_LO_DS:
330 case R_PPC64_GOT_DTPREL16_DS:
331 case R_PPC64_GOT_DTPREL16_HI:
332 relocateOne(Loc, Type, Val);
333 break;
334 default:
335 llvm_unreachable("unsupported relocation for TLS LD to LE relaxation");
336 }
337 }
338
getDFormOp(unsigned SecondaryOp)339 static unsigned getDFormOp(unsigned SecondaryOp) {
340 switch (SecondaryOp) {
341 case LBZX:
342 return LBZ;
343 case LHZX:
344 return LHZ;
345 case LWZX:
346 return LWZ;
347 case LDX:
348 return LD;
349 case STBX:
350 return STB;
351 case STHX:
352 return STH;
353 case STWX:
354 return STW;
355 case STDX:
356 return STD;
357 case ADD:
358 return ADDI;
359 default:
360 error("unrecognized instruction for IE to LE R_PPC64_TLS");
361 return 0;
362 }
363 }
364
relaxTlsIeToLe(uint8_t * Loc,RelType Type,uint64_t Val) const365 void PPC64::relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
366 // The initial exec code sequence for a global `x` will look like:
367 // Instruction Relocation Symbol
368 // addis r9, r2, x@got@tprel@ha R_PPC64_GOT_TPREL16_HA x
369 // ld r9, x@got@tprel@l(r9) R_PPC64_GOT_TPREL16_LO_DS x
370 // add r9, r9, x@tls R_PPC64_TLS x
371
372 // Relaxing to local exec entails converting:
373 // addis r9, r2, x@got@tprel@ha into nop
374 // ld r9, x@got@tprel@l(r9) into addis r9, r13, x@tprel@ha
375 // add r9, r9, x@tls into addi r9, r9, x@tprel@l
376
377 // x@tls R_PPC64_TLS is a relocation which does not compute anything,
378 // it is replaced with r13 (thread pointer).
379
380 // The add instruction in the initial exec sequence has multiple variations
381 // that need to be handled. If we are building an address it will use an add
382 // instruction, if we are accessing memory it will use any of the X-form
383 // indexed load or store instructions.
384
385 unsigned Offset = (Config->EKind == ELF64BEKind) ? 2 : 0;
386 switch (Type) {
387 case R_PPC64_GOT_TPREL16_HA:
388 write32(Loc - Offset, 0x60000000); // nop
389 break;
390 case R_PPC64_GOT_TPREL16_LO_DS:
391 case R_PPC64_GOT_TPREL16_DS: {
392 uint32_t RegNo = read32(Loc - Offset) & 0x03E00000; // bits 6-10
393 write32(Loc - Offset, 0x3C0D0000 | RegNo); // addis RegNo, r13
394 relocateOne(Loc, R_PPC64_TPREL16_HA, Val);
395 break;
396 }
397 case R_PPC64_TLS: {
398 uint32_t PrimaryOp = getPrimaryOpCode(read32(Loc));
399 if (PrimaryOp != 31)
400 error("unrecognized instruction for IE to LE R_PPC64_TLS");
401 uint32_t SecondaryOp = (read32(Loc) & 0x000007FE) >> 1; // bits 21-30
402 uint32_t DFormOp = getDFormOp(SecondaryOp);
403 write32(Loc, ((DFormOp << 26) | (read32(Loc) & 0x03FFFFFF)));
404 relocateOne(Loc + Offset, R_PPC64_TPREL16_LO, Val);
405 break;
406 }
407 default:
408 llvm_unreachable("unknown relocation for IE to LE");
409 break;
410 }
411 }
412
getRelExpr(RelType Type,const Symbol & S,const uint8_t * Loc) const413 RelExpr PPC64::getRelExpr(RelType Type, const Symbol &S,
414 const uint8_t *Loc) const {
415 switch (Type) {
416 case R_PPC64_GOT16:
417 case R_PPC64_GOT16_DS:
418 case R_PPC64_GOT16_HA:
419 case R_PPC64_GOT16_HI:
420 case R_PPC64_GOT16_LO:
421 case R_PPC64_GOT16_LO_DS:
422 return R_GOT_OFF;
423 case R_PPC64_TOC16:
424 case R_PPC64_TOC16_DS:
425 case R_PPC64_TOC16_HA:
426 case R_PPC64_TOC16_HI:
427 case R_PPC64_TOC16_LO:
428 case R_PPC64_TOC16_LO_DS:
429 return R_GOTREL;
430 case R_PPC64_TOC:
431 return R_PPC_TOC;
432 case R_PPC64_REL14:
433 case R_PPC64_REL24:
434 return R_PPC_CALL_PLT;
435 case R_PPC64_REL16_LO:
436 case R_PPC64_REL16_HA:
437 case R_PPC64_REL32:
438 case R_PPC64_REL64:
439 return R_PC;
440 case R_PPC64_GOT_TLSGD16:
441 case R_PPC64_GOT_TLSGD16_HA:
442 case R_PPC64_GOT_TLSGD16_HI:
443 case R_PPC64_GOT_TLSGD16_LO:
444 return R_TLSGD_GOT;
445 case R_PPC64_GOT_TLSLD16:
446 case R_PPC64_GOT_TLSLD16_HA:
447 case R_PPC64_GOT_TLSLD16_HI:
448 case R_PPC64_GOT_TLSLD16_LO:
449 return R_TLSLD_GOT;
450 case R_PPC64_GOT_TPREL16_HA:
451 case R_PPC64_GOT_TPREL16_LO_DS:
452 case R_PPC64_GOT_TPREL16_DS:
453 case R_PPC64_GOT_TPREL16_HI:
454 return R_GOT_OFF;
455 case R_PPC64_GOT_DTPREL16_HA:
456 case R_PPC64_GOT_DTPREL16_LO_DS:
457 case R_PPC64_GOT_DTPREL16_DS:
458 case R_PPC64_GOT_DTPREL16_HI:
459 return R_TLSLD_GOT_OFF;
460 case R_PPC64_TPREL16:
461 case R_PPC64_TPREL16_HA:
462 case R_PPC64_TPREL16_LO:
463 case R_PPC64_TPREL16_HI:
464 case R_PPC64_TPREL16_DS:
465 case R_PPC64_TPREL16_LO_DS:
466 case R_PPC64_TPREL16_HIGHER:
467 case R_PPC64_TPREL16_HIGHERA:
468 case R_PPC64_TPREL16_HIGHEST:
469 case R_PPC64_TPREL16_HIGHESTA:
470 return R_TLS;
471 case R_PPC64_DTPREL16:
472 case R_PPC64_DTPREL16_DS:
473 case R_PPC64_DTPREL16_HA:
474 case R_PPC64_DTPREL16_HI:
475 case R_PPC64_DTPREL16_HIGHER:
476 case R_PPC64_DTPREL16_HIGHERA:
477 case R_PPC64_DTPREL16_HIGHEST:
478 case R_PPC64_DTPREL16_HIGHESTA:
479 case R_PPC64_DTPREL16_LO:
480 case R_PPC64_DTPREL16_LO_DS:
481 case R_PPC64_DTPREL64:
482 return R_ABS;
483 case R_PPC64_TLSGD:
484 return R_TLSDESC_CALL;
485 case R_PPC64_TLSLD:
486 return R_TLSLD_HINT;
487 case R_PPC64_TLS:
488 return R_TLSIE_HINT;
489 default:
490 return R_ABS;
491 }
492 }
493
writeGotHeader(uint8_t * Buf) const494 void PPC64::writeGotHeader(uint8_t *Buf) const {
495 write64(Buf, getPPC64TocBase());
496 }
497
writePltHeader(uint8_t * Buf) const498 void PPC64::writePltHeader(uint8_t *Buf) const {
499 // The generic resolver stub goes first.
500 write32(Buf + 0, 0x7c0802a6); // mflr r0
501 write32(Buf + 4, 0x429f0005); // bcl 20,4*cr7+so,8 <_glink+0x8>
502 write32(Buf + 8, 0x7d6802a6); // mflr r11
503 write32(Buf + 12, 0x7c0803a6); // mtlr r0
504 write32(Buf + 16, 0x7d8b6050); // subf r12, r11, r12
505 write32(Buf + 20, 0x380cffcc); // subi r0,r12,52
506 write32(Buf + 24, 0x7800f082); // srdi r0,r0,62,2
507 write32(Buf + 28, 0xe98b002c); // ld r12,44(r11)
508 write32(Buf + 32, 0x7d6c5a14); // add r11,r12,r11
509 write32(Buf + 36, 0xe98b0000); // ld r12,0(r11)
510 write32(Buf + 40, 0xe96b0008); // ld r11,8(r11)
511 write32(Buf + 44, 0x7d8903a6); // mtctr r12
512 write32(Buf + 48, 0x4e800420); // bctr
513
514 // The 'bcl' instruction will set the link register to the address of the
515 // following instruction ('mflr r11'). Here we store the offset from that
516 // instruction to the first entry in the GotPlt section.
517 int64_t GotPltOffset = In.GotPlt->getVA() - (In.Plt->getVA() + 8);
518 write64(Buf + 52, GotPltOffset);
519 }
520
writePlt(uint8_t * Buf,uint64_t GotPltEntryAddr,uint64_t PltEntryAddr,int32_t Index,unsigned RelOff) const521 void PPC64::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
522 uint64_t PltEntryAddr, int32_t Index,
523 unsigned RelOff) const {
524 int32_t Offset = PltHeaderSize + Index * PltEntrySize;
525 // bl __glink_PLTresolve
526 write32(Buf, 0x48000000 | ((-Offset) & 0x03FFFFFc));
527 }
528
toAddr16Rel(RelType Type,uint64_t Val)529 static std::pair<RelType, uint64_t> toAddr16Rel(RelType Type, uint64_t Val) {
530 // Relocations relative to the toc-base need to be adjusted by the Toc offset.
531 uint64_t TocBiasedVal = Val - PPC64TocOffset;
532 // Relocations relative to dtv[dtpmod] need to be adjusted by the DTP offset.
533 uint64_t DTPBiasedVal = Val - DynamicThreadPointerOffset;
534
535 switch (Type) {
536 // TOC biased relocation.
537 case R_PPC64_GOT16:
538 case R_PPC64_GOT_TLSGD16:
539 case R_PPC64_GOT_TLSLD16:
540 case R_PPC64_TOC16:
541 return {R_PPC64_ADDR16, TocBiasedVal};
542 case R_PPC64_GOT16_DS:
543 case R_PPC64_TOC16_DS:
544 case R_PPC64_GOT_TPREL16_DS:
545 case R_PPC64_GOT_DTPREL16_DS:
546 return {R_PPC64_ADDR16_DS, TocBiasedVal};
547 case R_PPC64_GOT16_HA:
548 case R_PPC64_GOT_TLSGD16_HA:
549 case R_PPC64_GOT_TLSLD16_HA:
550 case R_PPC64_GOT_TPREL16_HA:
551 case R_PPC64_GOT_DTPREL16_HA:
552 case R_PPC64_TOC16_HA:
553 return {R_PPC64_ADDR16_HA, TocBiasedVal};
554 case R_PPC64_GOT16_HI:
555 case R_PPC64_GOT_TLSGD16_HI:
556 case R_PPC64_GOT_TLSLD16_HI:
557 case R_PPC64_GOT_TPREL16_HI:
558 case R_PPC64_GOT_DTPREL16_HI:
559 case R_PPC64_TOC16_HI:
560 return {R_PPC64_ADDR16_HI, TocBiasedVal};
561 case R_PPC64_GOT16_LO:
562 case R_PPC64_GOT_TLSGD16_LO:
563 case R_PPC64_GOT_TLSLD16_LO:
564 case R_PPC64_TOC16_LO:
565 return {R_PPC64_ADDR16_LO, TocBiasedVal};
566 case R_PPC64_GOT16_LO_DS:
567 case R_PPC64_TOC16_LO_DS:
568 case R_PPC64_GOT_TPREL16_LO_DS:
569 case R_PPC64_GOT_DTPREL16_LO_DS:
570 return {R_PPC64_ADDR16_LO_DS, TocBiasedVal};
571
572 // Dynamic Thread pointer biased relocation types.
573 case R_PPC64_DTPREL16:
574 return {R_PPC64_ADDR16, DTPBiasedVal};
575 case R_PPC64_DTPREL16_DS:
576 return {R_PPC64_ADDR16_DS, DTPBiasedVal};
577 case R_PPC64_DTPREL16_HA:
578 return {R_PPC64_ADDR16_HA, DTPBiasedVal};
579 case R_PPC64_DTPREL16_HI:
580 return {R_PPC64_ADDR16_HI, DTPBiasedVal};
581 case R_PPC64_DTPREL16_HIGHER:
582 return {R_PPC64_ADDR16_HIGHER, DTPBiasedVal};
583 case R_PPC64_DTPREL16_HIGHERA:
584 return {R_PPC64_ADDR16_HIGHERA, DTPBiasedVal};
585 case R_PPC64_DTPREL16_HIGHEST:
586 return {R_PPC64_ADDR16_HIGHEST, DTPBiasedVal};
587 case R_PPC64_DTPREL16_HIGHESTA:
588 return {R_PPC64_ADDR16_HIGHESTA, DTPBiasedVal};
589 case R_PPC64_DTPREL16_LO:
590 return {R_PPC64_ADDR16_LO, DTPBiasedVal};
591 case R_PPC64_DTPREL16_LO_DS:
592 return {R_PPC64_ADDR16_LO_DS, DTPBiasedVal};
593 case R_PPC64_DTPREL64:
594 return {R_PPC64_ADDR64, DTPBiasedVal};
595
596 default:
597 return {Type, Val};
598 }
599 }
600
isTocOptType(RelType Type)601 static bool isTocOptType(RelType Type) {
602 switch (Type) {
603 case R_PPC64_GOT16_HA:
604 case R_PPC64_GOT16_LO_DS:
605 case R_PPC64_TOC16_HA:
606 case R_PPC64_TOC16_LO_DS:
607 case R_PPC64_TOC16_LO:
608 return true;
609 default:
610 return false;
611 }
612 }
613
relocateOne(uint8_t * Loc,RelType Type,uint64_t Val) const614 void PPC64::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
615 // We need to save the original relocation type to use in diagnostics, and
616 // use the original type to determine if we should toc-optimize the
617 // instructions being relocated.
618 RelType OriginalType = Type;
619 bool ShouldTocOptimize = isTocOptType(Type);
620 // For dynamic thread pointer relative, toc-relative, and got-indirect
621 // relocations, proceed in terms of the corresponding ADDR16 relocation type.
622 std::tie(Type, Val) = toAddr16Rel(Type, Val);
623
624 switch (Type) {
625 case R_PPC64_ADDR14: {
626 checkAlignment(Loc, Val, 4, Type);
627 // Preserve the AA/LK bits in the branch instruction
628 uint8_t AALK = Loc[3];
629 write16(Loc + 2, (AALK & 3) | (Val & 0xfffc));
630 break;
631 }
632 case R_PPC64_ADDR16:
633 case R_PPC64_TPREL16:
634 checkInt(Loc, Val, 16, OriginalType);
635 write16(Loc, Val);
636 break;
637 case R_PPC64_ADDR16_DS:
638 case R_PPC64_TPREL16_DS: {
639 checkInt(Loc, Val, 16, OriginalType);
640 // DQ-form instructions use bits 28-31 as part of the instruction encoding
641 // DS-form instructions only use bits 30-31.
642 uint16_t Mask = isDQFormInstruction(readInstrFromHalf16(Loc)) ? 0xF : 0x3;
643 checkAlignment(Loc, lo(Val), Mask + 1, OriginalType);
644 write16(Loc, (read16(Loc) & Mask) | lo(Val));
645 } break;
646 case R_PPC64_ADDR16_HA:
647 case R_PPC64_REL16_HA:
648 case R_PPC64_TPREL16_HA:
649 if (Config->TocOptimize && ShouldTocOptimize && ha(Val) == 0)
650 writeInstrFromHalf16(Loc, 0x60000000);
651 else
652 write16(Loc, ha(Val));
653 break;
654 case R_PPC64_ADDR16_HI:
655 case R_PPC64_REL16_HI:
656 case R_PPC64_TPREL16_HI:
657 write16(Loc, hi(Val));
658 break;
659 case R_PPC64_ADDR16_HIGHER:
660 case R_PPC64_TPREL16_HIGHER:
661 write16(Loc, higher(Val));
662 break;
663 case R_PPC64_ADDR16_HIGHERA:
664 case R_PPC64_TPREL16_HIGHERA:
665 write16(Loc, highera(Val));
666 break;
667 case R_PPC64_ADDR16_HIGHEST:
668 case R_PPC64_TPREL16_HIGHEST:
669 write16(Loc, highest(Val));
670 break;
671 case R_PPC64_ADDR16_HIGHESTA:
672 case R_PPC64_TPREL16_HIGHESTA:
673 write16(Loc, highesta(Val));
674 break;
675 case R_PPC64_ADDR16_LO:
676 case R_PPC64_REL16_LO:
677 case R_PPC64_TPREL16_LO:
678 // When the high-adjusted part of a toc relocation evalutes to 0, it is
679 // changed into a nop. The lo part then needs to be updated to use the
680 // toc-pointer register r2, as the base register.
681 if (Config->TocOptimize && ShouldTocOptimize && ha(Val) == 0) {
682 uint32_t Instr = readInstrFromHalf16(Loc);
683 if (isInstructionUpdateForm(Instr))
684 error(getErrorLocation(Loc) +
685 "can't toc-optimize an update instruction: 0x" +
686 utohexstr(Instr));
687 Instr = (Instr & 0xFFE00000) | 0x00020000;
688 writeInstrFromHalf16(Loc, Instr);
689 }
690 write16(Loc, lo(Val));
691 break;
692 case R_PPC64_ADDR16_LO_DS:
693 case R_PPC64_TPREL16_LO_DS: {
694 // DQ-form instructions use bits 28-31 as part of the instruction encoding
695 // DS-form instructions only use bits 30-31.
696 uint32_t Inst = readInstrFromHalf16(Loc);
697 uint16_t Mask = isDQFormInstruction(Inst) ? 0xF : 0x3;
698 checkAlignment(Loc, lo(Val), Mask + 1, OriginalType);
699 if (Config->TocOptimize && ShouldTocOptimize && ha(Val) == 0) {
700 // When the high-adjusted part of a toc relocation evalutes to 0, it is
701 // changed into a nop. The lo part then needs to be updated to use the toc
702 // pointer register r2, as the base register.
703 if (isInstructionUpdateForm(Inst))
704 error(getErrorLocation(Loc) +
705 "Can't toc-optimize an update instruction: 0x" +
706 Twine::utohexstr(Inst));
707 Inst = (Inst & 0xFFE0000F) | 0x00020000;
708 writeInstrFromHalf16(Loc, Inst);
709 }
710 write16(Loc, (read16(Loc) & Mask) | lo(Val));
711 } break;
712 case R_PPC64_ADDR32:
713 case R_PPC64_REL32:
714 checkInt(Loc, Val, 32, Type);
715 write32(Loc, Val);
716 break;
717 case R_PPC64_ADDR64:
718 case R_PPC64_REL64:
719 case R_PPC64_TOC:
720 write64(Loc, Val);
721 break;
722 case R_PPC64_REL14: {
723 uint32_t Mask = 0x0000FFFC;
724 checkInt(Loc, Val, 16, Type);
725 checkAlignment(Loc, Val, 4, Type);
726 write32(Loc, (read32(Loc) & ~Mask) | (Val & Mask));
727 break;
728 }
729 case R_PPC64_REL24: {
730 uint32_t Mask = 0x03FFFFFC;
731 checkInt(Loc, Val, 26, Type);
732 checkAlignment(Loc, Val, 4, Type);
733 write32(Loc, (read32(Loc) & ~Mask) | (Val & Mask));
734 break;
735 }
736 case R_PPC64_DTPREL64:
737 write64(Loc, Val - DynamicThreadPointerOffset);
738 break;
739 default:
740 error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
741 }
742 }
743
needsThunk(RelExpr Expr,RelType Type,const InputFile * File,uint64_t BranchAddr,const Symbol & S) const744 bool PPC64::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
745 uint64_t BranchAddr, const Symbol &S) const {
746 if (Type != R_PPC64_REL14 && Type != R_PPC64_REL24)
747 return false;
748
749 // If a function is in the Plt it needs to be called with a call-stub.
750 if (S.isInPlt())
751 return true;
752
753 // If a symbol is a weak undefined and we are compiling an executable
754 // it doesn't need a range-extending thunk since it can't be called.
755 if (S.isUndefWeak() && !Config->Shared)
756 return false;
757
758 // If the offset exceeds the range of the branch type then it will need
759 // a range-extending thunk.
760 // See the comment in getRelocTargetVA() about R_PPC64_CALL.
761 return !inBranchRange(Type, BranchAddr,
762 S.getVA() +
763 getPPC64GlobalEntryToLocalEntryOffset(S.StOther));
764 }
765
getThunkSectionSpacing() const766 uint32_t PPC64::getThunkSectionSpacing() const {
767 // See comment in Arch/ARM.cpp for a more detailed explanation of
768 // getThunkSectionSpacing(). For PPC64 we pick the constant here based on
769 // R_PPC64_REL24, which is used by unconditional branch instructions.
770 // 0x2000000 = (1 << 24-1) * 4
771 return 0x2000000;
772 }
773
inBranchRange(RelType Type,uint64_t Src,uint64_t Dst) const774 bool PPC64::inBranchRange(RelType Type, uint64_t Src, uint64_t Dst) const {
775 int64_t Offset = Dst - Src;
776 if (Type == R_PPC64_REL14)
777 return isInt<16>(Offset);
778 if (Type == R_PPC64_REL24)
779 return isInt<26>(Offset);
780 llvm_unreachable("unsupported relocation type used in branch");
781 }
782
adjustRelaxExpr(RelType Type,const uint8_t * Data,RelExpr Expr) const783 RelExpr PPC64::adjustRelaxExpr(RelType Type, const uint8_t *Data,
784 RelExpr Expr) const {
785 if (Expr == R_RELAX_TLS_GD_TO_IE)
786 return R_RELAX_TLS_GD_TO_IE_GOT_OFF;
787 if (Expr == R_RELAX_TLS_LD_TO_LE)
788 return R_RELAX_TLS_LD_TO_LE_ABS;
789 return Expr;
790 }
791
792 // Reference: 3.7.4.1 of the 64-bit ELF V2 abi supplement.
793 // The general dynamic code sequence for a global `x` uses 4 instructions.
794 // Instruction Relocation Symbol
795 // addis r3, r2, x@got@tlsgd@ha R_PPC64_GOT_TLSGD16_HA x
796 // addi r3, r3, x@got@tlsgd@l R_PPC64_GOT_TLSGD16_LO x
797 // bl __tls_get_addr(x@tlsgd) R_PPC64_TLSGD x
798 // R_PPC64_REL24 __tls_get_addr
799 // nop None None
800 //
801 // Relaxing to initial-exec entails:
802 // 1) Convert the addis/addi pair that builds the address of the tls_index
803 // struct for 'x' to an addis/ld pair that loads an offset from a got-entry.
804 // 2) Convert the call to __tls_get_addr to a nop.
805 // 3) Convert the nop following the call to an add of the loaded offset to the
806 // thread pointer.
807 // Since the nop must directly follow the call, the R_PPC64_TLSGD relocation is
808 // used as the relaxation hint for both steps 2 and 3.
relaxTlsGdToIe(uint8_t * Loc,RelType Type,uint64_t Val) const809 void PPC64::relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const {
810 switch (Type) {
811 case R_PPC64_GOT_TLSGD16_HA:
812 // This is relaxed from addis rT, r2, sym@got@tlsgd@ha to
813 // addis rT, r2, sym@got@tprel@ha.
814 relocateOne(Loc, R_PPC64_GOT_TPREL16_HA, Val);
815 return;
816 case R_PPC64_GOT_TLSGD16_LO: {
817 // Relax from addi r3, rA, sym@got@tlsgd@l to
818 // ld r3, sym@got@tprel@l(rA)
819 uint32_t InputRegister = (readInstrFromHalf16(Loc) & (0x1f << 16));
820 writeInstrFromHalf16(Loc, 0xE8600000 | InputRegister);
821 relocateOne(Loc, R_PPC64_GOT_TPREL16_LO_DS, Val);
822 return;
823 }
824 case R_PPC64_TLSGD:
825 write32(Loc, 0x60000000); // bl __tls_get_addr(sym@tlsgd) --> nop
826 write32(Loc + 4, 0x7c636A14); // nop --> add r3, r3, r13
827 return;
828 default:
829 llvm_unreachable("unsupported relocation for TLS GD to IE relaxation");
830 }
831 }
832
833 // The prologue for a split-stack function is expected to look roughly
834 // like this:
835 // .Lglobal_entry_point:
836 // # TOC pointer initalization.
837 // ...
838 // .Llocal_entry_point:
839 // # load the __private_ss member of the threads tcbhead.
840 // ld r0,-0x7000-64(r13)
841 // # subtract the functions stack size from the stack pointer.
842 // addis r12, r1, ha(-stack-frame size)
843 // addi r12, r12, l(-stack-frame size)
844 // # compare needed to actual and branch to allocate_more_stack if more
845 // # space is needed, otherwise fallthrough to 'normal' function body.
846 // cmpld cr7,r12,r0
847 // blt- cr7, .Lallocate_more_stack
848 //
849 // -) The allocate_more_stack block might be placed after the split-stack
850 // prologue and the `blt-` replaced with a `bge+ .Lnormal_func_body`
851 // instead.
852 // -) If either the addis or addi is not needed due to the stack size being
853 // smaller then 32K or a multiple of 64K they will be replaced with a nop,
854 // but there will always be 2 instructions the linker can overwrite for the
855 // adjusted stack size.
856 //
857 // The linkers job here is to increase the stack size used in the addis/addi
858 // pair by split-stack-size-adjust.
859 // addis r12, r1, ha(-stack-frame size - split-stack-adjust-size)
860 // addi r12, r12, l(-stack-frame size - split-stack-adjust-size)
adjustPrologueForCrossSplitStack(uint8_t * Loc,uint8_t * End,uint8_t StOther) const861 bool PPC64::adjustPrologueForCrossSplitStack(uint8_t *Loc, uint8_t *End,
862 uint8_t StOther) const {
863 // If the caller has a global entry point adjust the buffer past it. The start
864 // of the split-stack prologue will be at the local entry point.
865 Loc += getPPC64GlobalEntryToLocalEntryOffset(StOther);
866
867 // At the very least we expect to see a load of some split-stack data from the
868 // tcb, and 2 instructions that calculate the ending stack address this
869 // function will require. If there is not enough room for at least 3
870 // instructions it can't be a split-stack prologue.
871 if (Loc + 12 >= End)
872 return false;
873
874 // First instruction must be `ld r0, -0x7000-64(r13)`
875 if (read32(Loc) != 0xe80d8fc0)
876 return false;
877
878 int16_t HiImm = 0;
879 int16_t LoImm = 0;
880 // First instruction can be either an addis if the frame size is larger then
881 // 32K, or an addi if the size is less then 32K.
882 int32_t FirstInstr = read32(Loc + 4);
883 if (getPrimaryOpCode(FirstInstr) == 15) {
884 HiImm = FirstInstr & 0xFFFF;
885 } else if (getPrimaryOpCode(FirstInstr) == 14) {
886 LoImm = FirstInstr & 0xFFFF;
887 } else {
888 return false;
889 }
890
891 // Second instruction is either an addi or a nop. If the first instruction was
892 // an addi then LoImm is set and the second instruction must be a nop.
893 uint32_t SecondInstr = read32(Loc + 8);
894 if (!LoImm && getPrimaryOpCode(SecondInstr) == 14) {
895 LoImm = SecondInstr & 0xFFFF;
896 } else if (SecondInstr != 0x60000000) {
897 return false;
898 }
899
900 // The register operands of the first instruction should be the stack-pointer
901 // (r1) as the input (RA) and r12 as the output (RT). If the second
902 // instruction is not a nop, then it should use r12 as both input and output.
903 auto CheckRegOperands = [](uint32_t Instr, uint8_t ExpectedRT,
904 uint8_t ExpectedRA) {
905 return ((Instr & 0x3E00000) >> 21 == ExpectedRT) &&
906 ((Instr & 0x1F0000) >> 16 == ExpectedRA);
907 };
908 if (!CheckRegOperands(FirstInstr, 12, 1))
909 return false;
910 if (SecondInstr != 0x60000000 && !CheckRegOperands(SecondInstr, 12, 12))
911 return false;
912
913 int32_t StackFrameSize = (HiImm * 65536) + LoImm;
914 // Check that the adjusted size doesn't overflow what we can represent with 2
915 // instructions.
916 if (StackFrameSize < Config->SplitStackAdjustSize + INT32_MIN) {
917 error(getErrorLocation(Loc) + "split-stack prologue adjustment overflows");
918 return false;
919 }
920
921 int32_t AdjustedStackFrameSize =
922 StackFrameSize - Config->SplitStackAdjustSize;
923
924 LoImm = AdjustedStackFrameSize & 0xFFFF;
925 HiImm = (AdjustedStackFrameSize + 0x8000) >> 16;
926 if (HiImm) {
927 write32(Loc + 4, 0x3D810000 | (uint16_t)HiImm);
928 // If the low immediate is zero the second instruction will be a nop.
929 SecondInstr = LoImm ? 0x398C0000 | (uint16_t)LoImm : 0x60000000;
930 write32(Loc + 8, SecondInstr);
931 } else {
932 // addi r12, r1, imm
933 write32(Loc + 4, (0x39810000) | (uint16_t)LoImm);
934 write32(Loc + 8, 0x60000000);
935 }
936
937 return true;
938 }
939
getPPC64TargetInfo()940 TargetInfo *elf::getPPC64TargetInfo() {
941 static PPC64 Target;
942 return &Target;
943 }
944