1 //===- X86.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 "InputFiles.h"
11 #include "Symbols.h"
12 #include "SyntheticSections.h"
13 #include "Target.h"
14 #include "lld/Common/ErrorHandler.h"
15 #include "llvm/Support/Endian.h"
16
17 using namespace llvm;
18 using namespace llvm::support::endian;
19 using namespace llvm::ELF;
20 using namespace lld;
21 using namespace lld::elf;
22
23 namespace {
24 class X86 : public TargetInfo {
25 public:
26 X86();
27 RelExpr getRelExpr(RelType Type, const Symbol &S,
28 const uint8_t *Loc) const override;
29 int64_t getImplicitAddend(const uint8_t *Buf, RelType Type) const override;
30 void writeGotPltHeader(uint8_t *Buf) const override;
31 RelType getDynRel(RelType Type) const override;
32 void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
33 void writeIgotPlt(uint8_t *Buf, const Symbol &S) const override;
34 void writePltHeader(uint8_t *Buf) const override;
35 void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
36 int32_t Index, unsigned RelOff) const override;
37 void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
38
39 RelExpr adjustRelaxExpr(RelType Type, const uint8_t *Data,
40 RelExpr Expr) const override;
41 void relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
42 void relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
43 void relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
44 void relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const override;
45 };
46 } // namespace
47
X86()48 X86::X86() {
49 CopyRel = R_386_COPY;
50 GotRel = R_386_GLOB_DAT;
51 NoneRel = R_386_NONE;
52 PltRel = R_386_JUMP_SLOT;
53 IRelativeRel = R_386_IRELATIVE;
54 RelativeRel = R_386_RELATIVE;
55 TlsGotRel = R_386_TLS_TPOFF;
56 TlsModuleIndexRel = R_386_TLS_DTPMOD32;
57 TlsOffsetRel = R_386_TLS_DTPOFF32;
58 GotEntrySize = 4;
59 GotPltEntrySize = 4;
60 PltEntrySize = 16;
61 PltHeaderSize = 16;
62 TlsGdRelaxSkip = 2;
63 TrapInstr = {0xcc, 0xcc, 0xcc, 0xcc}; // 0xcc = INT3
64
65 // Align to the non-PAE large page size (known as a superpage or huge page).
66 // FreeBSD automatically promotes large, superpage-aligned allocations.
67 DefaultImageBase = 0x400000;
68 }
69
hasBaseReg(uint8_t ModRM)70 static bool hasBaseReg(uint8_t ModRM) { return (ModRM & 0xc7) != 0x5; }
71
getRelExpr(RelType Type,const Symbol & S,const uint8_t * Loc) const72 RelExpr X86::getRelExpr(RelType Type, const Symbol &S,
73 const uint8_t *Loc) const {
74 // There are 4 different TLS variable models with varying degrees of
75 // flexibility and performance. LocalExec and InitialExec models are fast but
76 // less-flexible models. If they are in use, we set DF_STATIC_TLS flag in the
77 // dynamic section to let runtime know about that.
78 if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32 || Type == R_386_TLS_IE ||
79 Type == R_386_TLS_GOTIE)
80 Config->HasStaticTlsModel = true;
81
82 switch (Type) {
83 case R_386_8:
84 case R_386_16:
85 case R_386_32:
86 case R_386_TLS_LDO_32:
87 return R_ABS;
88 case R_386_TLS_GD:
89 return R_TLSGD_GOT_FROM_END;
90 case R_386_TLS_LDM:
91 return R_TLSLD_GOT_FROM_END;
92 case R_386_PLT32:
93 return R_PLT_PC;
94 case R_386_PC8:
95 case R_386_PC16:
96 case R_386_PC32:
97 return R_PC;
98 case R_386_GOTPC:
99 return R_GOTONLY_PC_FROM_END;
100 case R_386_TLS_IE:
101 return R_GOT;
102 case R_386_GOT32:
103 case R_386_GOT32X:
104 // These relocations are arguably mis-designed because their calculations
105 // depend on the instructions they are applied to. This is bad because we
106 // usually don't care about whether the target section contains valid
107 // machine instructions or not. But this is part of the documented ABI, so
108 // we had to implement as the standard requires.
109 //
110 // x86 does not support PC-relative data access. Therefore, in order to
111 // access GOT contents, a GOT address needs to be known at link-time
112 // (which means non-PIC) or compilers have to emit code to get a GOT
113 // address at runtime (which means code is position-independent but
114 // compilers need to emit extra code for each GOT access.) This decision
115 // is made at compile-time. In the latter case, compilers emit code to
116 // load an GOT address to a register, which is usually %ebx.
117 //
118 // So, there are two ways to refer to symbol foo's GOT entry: foo@GOT or
119 // foo@GOT(%reg).
120 //
121 // foo@GOT is not usable in PIC. If we are creating a PIC output and if we
122 // find such relocation, we should report an error. foo@GOT is resolved to
123 // an *absolute* address of foo's GOT entry, because both GOT address and
124 // foo's offset are known. In other words, it's G + A.
125 //
126 // foo@GOT(%reg) needs to be resolved to a *relative* offset from a GOT to
127 // foo's GOT entry in the table, because GOT address is not known but foo's
128 // offset in the table is known. It's G + A - GOT.
129 //
130 // It's unfortunate that compilers emit the same relocation for these
131 // different use cases. In order to distinguish them, we have to read a
132 // machine instruction.
133 //
134 // The following code implements it. We assume that Loc[0] is the first
135 // byte of a displacement or an immediate field of a valid machine
136 // instruction. That means a ModRM byte is at Loc[-1]. By taking a look at
137 // the byte, we can determine whether the instruction is register-relative
138 // (i.e. it was generated for foo@GOT(%reg)) or absolute (i.e. foo@GOT).
139 return hasBaseReg(Loc[-1]) ? R_GOT_FROM_END : R_GOT;
140 case R_386_TLS_GOTIE:
141 return R_GOT_FROM_END;
142 case R_386_GOTOFF:
143 return R_GOTREL_FROM_END;
144 case R_386_TLS_LE:
145 return R_TLS;
146 case R_386_TLS_LE_32:
147 return R_NEG_TLS;
148 case R_386_NONE:
149 return R_NONE;
150 default:
151 return R_INVALID;
152 }
153 }
154
adjustRelaxExpr(RelType Type,const uint8_t * Data,RelExpr Expr) const155 RelExpr X86::adjustRelaxExpr(RelType Type, const uint8_t *Data,
156 RelExpr Expr) const {
157 switch (Expr) {
158 default:
159 return Expr;
160 case R_RELAX_TLS_GD_TO_IE:
161 return R_RELAX_TLS_GD_TO_IE_END;
162 case R_RELAX_TLS_GD_TO_LE:
163 return R_RELAX_TLS_GD_TO_LE_NEG;
164 }
165 }
166
writeGotPltHeader(uint8_t * Buf) const167 void X86::writeGotPltHeader(uint8_t *Buf) const {
168 write32le(Buf, In.Dynamic->getVA());
169 }
170
writeGotPlt(uint8_t * Buf,const Symbol & S) const171 void X86::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
172 // Entries in .got.plt initially points back to the corresponding
173 // PLT entries with a fixed offset to skip the first instruction.
174 write32le(Buf, S.getPltVA() + 6);
175 }
176
writeIgotPlt(uint8_t * Buf,const Symbol & S) const177 void X86::writeIgotPlt(uint8_t *Buf, const Symbol &S) const {
178 // An x86 entry is the address of the ifunc resolver function.
179 write32le(Buf, S.getVA());
180 }
181
getDynRel(RelType Type) const182 RelType X86::getDynRel(RelType Type) const {
183 if (Type == R_386_TLS_LE)
184 return R_386_TLS_TPOFF;
185 if (Type == R_386_TLS_LE_32)
186 return R_386_TLS_TPOFF32;
187 return Type;
188 }
189
writePltHeader(uint8_t * Buf) const190 void X86::writePltHeader(uint8_t *Buf) const {
191 if (Config->Pic) {
192 const uint8_t V[] = {
193 0xff, 0xb3, 0x04, 0x00, 0x00, 0x00, // pushl GOTPLT+4(%ebx)
194 0xff, 0xa3, 0x08, 0x00, 0x00, 0x00, // jmp *GOTPLT+8(%ebx)
195 0x90, 0x90, 0x90, 0x90 // nop
196 };
197 memcpy(Buf, V, sizeof(V));
198
199 uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
200 uint32_t GotPlt = In.GotPlt->getVA() - Ebx;
201 write32le(Buf + 2, GotPlt + 4);
202 write32le(Buf + 8, GotPlt + 8);
203 return;
204 }
205
206 const uint8_t PltData[] = {
207 0xff, 0x35, 0, 0, 0, 0, // pushl (GOTPLT+4)
208 0xff, 0x25, 0, 0, 0, 0, // jmp *(GOTPLT+8)
209 0x90, 0x90, 0x90, 0x90, // nop
210 };
211 memcpy(Buf, PltData, sizeof(PltData));
212 uint32_t GotPlt = In.GotPlt->getVA();
213 write32le(Buf + 2, GotPlt + 4);
214 write32le(Buf + 8, GotPlt + 8);
215 }
216
writePlt(uint8_t * Buf,uint64_t GotPltEntryAddr,uint64_t PltEntryAddr,int32_t Index,unsigned RelOff) const217 void X86::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
218 uint64_t PltEntryAddr, int32_t Index,
219 unsigned RelOff) const {
220 const uint8_t Inst[] = {
221 0xff, 0x00, 0, 0, 0, 0, // jmp *foo_in_GOT or jmp *foo@GOT(%ebx)
222 0x68, 0, 0, 0, 0, // pushl $reloc_offset
223 0xe9, 0, 0, 0, 0, // jmp .PLT0@PC
224 };
225 memcpy(Buf, Inst, sizeof(Inst));
226
227 if (Config->Pic) {
228 // jmp *foo@GOT(%ebx)
229 uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
230 Buf[1] = 0xa3;
231 write32le(Buf + 2, GotPltEntryAddr - Ebx);
232 } else {
233 // jmp *foo_in_GOT
234 Buf[1] = 0x25;
235 write32le(Buf + 2, GotPltEntryAddr);
236 }
237
238 write32le(Buf + 7, RelOff);
239 write32le(Buf + 12, -getPltEntryOffset(Index) - 16);
240 }
241
getImplicitAddend(const uint8_t * Buf,RelType Type) const242 int64_t X86::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
243 switch (Type) {
244 case R_386_8:
245 case R_386_PC8:
246 return SignExtend64<8>(*Buf);
247 case R_386_16:
248 case R_386_PC16:
249 return SignExtend64<16>(read16le(Buf));
250 case R_386_32:
251 case R_386_GOT32:
252 case R_386_GOT32X:
253 case R_386_GOTOFF:
254 case R_386_GOTPC:
255 case R_386_PC32:
256 case R_386_PLT32:
257 case R_386_TLS_LDO_32:
258 case R_386_TLS_LE:
259 return SignExtend64<32>(read32le(Buf));
260 default:
261 return 0;
262 }
263 }
264
relocateOne(uint8_t * Loc,RelType Type,uint64_t Val) const265 void X86::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
266 switch (Type) {
267 case R_386_8:
268 // R_386_{PC,}{8,16} are not part of the i386 psABI, but they are
269 // being used for some 16-bit programs such as boot loaders, so
270 // we want to support them.
271 checkIntUInt(Loc, Val, 8, Type);
272 *Loc = Val;
273 break;
274 case R_386_PC8:
275 checkInt(Loc, Val, 8, Type);
276 *Loc = Val;
277 break;
278 case R_386_16:
279 checkIntUInt(Loc, Val, 16, Type);
280 write16le(Loc, Val);
281 break;
282 case R_386_PC16:
283 // R_386_PC16 is normally used with 16 bit code. In that situation
284 // the PC is 16 bits, just like the addend. This means that it can
285 // point from any 16 bit address to any other if the possibility
286 // of wrapping is included.
287 // The only restriction we have to check then is that the destination
288 // address fits in 16 bits. That is impossible to do here. The problem is
289 // that we are passed the final value, which already had the
290 // current location subtracted from it.
291 // We just check that Val fits in 17 bits. This misses some cases, but
292 // should have no false positives.
293 checkInt(Loc, Val, 17, Type);
294 write16le(Loc, Val);
295 break;
296 case R_386_32:
297 case R_386_GLOB_DAT:
298 case R_386_GOT32:
299 case R_386_GOT32X:
300 case R_386_GOTOFF:
301 case R_386_GOTPC:
302 case R_386_PC32:
303 case R_386_PLT32:
304 case R_386_RELATIVE:
305 case R_386_TLS_DTPMOD32:
306 case R_386_TLS_DTPOFF32:
307 case R_386_TLS_GD:
308 case R_386_TLS_GOTIE:
309 case R_386_TLS_IE:
310 case R_386_TLS_LDM:
311 case R_386_TLS_LDO_32:
312 case R_386_TLS_LE:
313 case R_386_TLS_LE_32:
314 case R_386_TLS_TPOFF:
315 case R_386_TLS_TPOFF32:
316 checkInt(Loc, Val, 32, Type);
317 write32le(Loc, Val);
318 break;
319 default:
320 error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
321 }
322 }
323
relaxTlsGdToLe(uint8_t * Loc,RelType Type,uint64_t Val) const324 void X86::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
325 // Convert
326 // leal x@tlsgd(, %ebx, 1),
327 // call __tls_get_addr@plt
328 // to
329 // movl %gs:0,%eax
330 // subl $x@ntpoff,%eax
331 const uint8_t Inst[] = {
332 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
333 0x81, 0xe8, 0, 0, 0, 0, // subl Val(%ebx), %eax
334 };
335 memcpy(Loc - 3, Inst, sizeof(Inst));
336 write32le(Loc + 5, Val);
337 }
338
relaxTlsGdToIe(uint8_t * Loc,RelType Type,uint64_t Val) const339 void X86::relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const {
340 // Convert
341 // leal x@tlsgd(, %ebx, 1),
342 // call __tls_get_addr@plt
343 // to
344 // movl %gs:0, %eax
345 // addl x@gotntpoff(%ebx), %eax
346 const uint8_t Inst[] = {
347 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
348 0x03, 0x83, 0, 0, 0, 0, // addl Val(%ebx), %eax
349 };
350 memcpy(Loc - 3, Inst, sizeof(Inst));
351 write32le(Loc + 5, Val);
352 }
353
354 // In some conditions, relocations can be optimized to avoid using GOT.
355 // This function does that for Initial Exec to Local Exec case.
relaxTlsIeToLe(uint8_t * Loc,RelType Type,uint64_t Val) const356 void X86::relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
357 // Ulrich's document section 6.2 says that @gotntpoff can
358 // be used with MOVL or ADDL instructions.
359 // @indntpoff is similar to @gotntpoff, but for use in
360 // position dependent code.
361 uint8_t Reg = (Loc[-1] >> 3) & 7;
362
363 if (Type == R_386_TLS_IE) {
364 if (Loc[-1] == 0xa1) {
365 // "movl foo@indntpoff,%eax" -> "movl $foo,%eax"
366 // This case is different from the generic case below because
367 // this is a 5 byte instruction while below is 6 bytes.
368 Loc[-1] = 0xb8;
369 } else if (Loc[-2] == 0x8b) {
370 // "movl foo@indntpoff,%reg" -> "movl $foo,%reg"
371 Loc[-2] = 0xc7;
372 Loc[-1] = 0xc0 | Reg;
373 } else {
374 // "addl foo@indntpoff,%reg" -> "addl $foo,%reg"
375 Loc[-2] = 0x81;
376 Loc[-1] = 0xc0 | Reg;
377 }
378 } else {
379 assert(Type == R_386_TLS_GOTIE);
380 if (Loc[-2] == 0x8b) {
381 // "movl foo@gottpoff(%rip),%reg" -> "movl $foo,%reg"
382 Loc[-2] = 0xc7;
383 Loc[-1] = 0xc0 | Reg;
384 } else {
385 // "addl foo@gotntpoff(%rip),%reg" -> "leal foo(%reg),%reg"
386 Loc[-2] = 0x8d;
387 Loc[-1] = 0x80 | (Reg << 3) | Reg;
388 }
389 }
390 write32le(Loc, Val);
391 }
392
relaxTlsLdToLe(uint8_t * Loc,RelType Type,uint64_t Val) const393 void X86::relaxTlsLdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
394 if (Type == R_386_TLS_LDO_32) {
395 write32le(Loc, Val);
396 return;
397 }
398
399 // Convert
400 // leal foo(%reg),%eax
401 // call ___tls_get_addr
402 // to
403 // movl %gs:0,%eax
404 // nop
405 // leal 0(%esi,1),%esi
406 const uint8_t Inst[] = {
407 0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0,%eax
408 0x90, // nop
409 0x8d, 0x74, 0x26, 0x00, // leal 0(%esi,1),%esi
410 };
411 memcpy(Loc - 2, Inst, sizeof(Inst));
412 }
413
414 namespace {
415 class RetpolinePic : public X86 {
416 public:
417 RetpolinePic();
418 void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
419 void writePltHeader(uint8_t *Buf) const override;
420 void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
421 int32_t Index, unsigned RelOff) const override;
422 };
423
424 class RetpolineNoPic : public X86 {
425 public:
426 RetpolineNoPic();
427 void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
428 void writePltHeader(uint8_t *Buf) const override;
429 void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
430 int32_t Index, unsigned RelOff) const override;
431 };
432 } // namespace
433
RetpolinePic()434 RetpolinePic::RetpolinePic() {
435 PltHeaderSize = 48;
436 PltEntrySize = 32;
437 }
438
writeGotPlt(uint8_t * Buf,const Symbol & S) const439 void RetpolinePic::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
440 write32le(Buf, S.getPltVA() + 17);
441 }
442
writePltHeader(uint8_t * Buf) const443 void RetpolinePic::writePltHeader(uint8_t *Buf) const {
444 const uint8_t Insn[] = {
445 0xff, 0xb3, 0, 0, 0, 0, // 0: pushl GOTPLT+4(%ebx)
446 0x50, // 6: pushl %eax
447 0x8b, 0x83, 0, 0, 0, 0, // 7: mov GOTPLT+8(%ebx), %eax
448 0xe8, 0x0e, 0x00, 0x00, 0x00, // d: call next
449 0xf3, 0x90, // 12: loop: pause
450 0x0f, 0xae, 0xe8, // 14: lfence
451 0xeb, 0xf9, // 17: jmp loop
452 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // 19: int3; .align 16
453 0x89, 0x0c, 0x24, // 20: next: mov %ecx, (%esp)
454 0x8b, 0x4c, 0x24, 0x04, // 23: mov 0x4(%esp), %ecx
455 0x89, 0x44, 0x24, 0x04, // 27: mov %eax ,0x4(%esp)
456 0x89, 0xc8, // 2b: mov %ecx, %eax
457 0x59, // 2d: pop %ecx
458 0xc3, // 2e: ret
459 0xcc, // 2f: int3; padding
460 };
461 memcpy(Buf, Insn, sizeof(Insn));
462
463 uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
464 uint32_t GotPlt = In.GotPlt->getVA() - Ebx;
465 write32le(Buf + 2, GotPlt + 4);
466 write32le(Buf + 9, GotPlt + 8);
467 }
468
writePlt(uint8_t * Buf,uint64_t GotPltEntryAddr,uint64_t PltEntryAddr,int32_t Index,unsigned RelOff) const469 void RetpolinePic::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
470 uint64_t PltEntryAddr, int32_t Index,
471 unsigned RelOff) const {
472 const uint8_t Insn[] = {
473 0x50, // pushl %eax
474 0x8b, 0x83, 0, 0, 0, 0, // mov foo@GOT(%ebx), %eax
475 0xe8, 0, 0, 0, 0, // call plt+0x20
476 0xe9, 0, 0, 0, 0, // jmp plt+0x12
477 0x68, 0, 0, 0, 0, // pushl $reloc_offset
478 0xe9, 0, 0, 0, 0, // jmp plt+0
479 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // int3; padding
480 };
481 memcpy(Buf, Insn, sizeof(Insn));
482
483 uint32_t Ebx = In.Got->getVA() + In.Got->getSize();
484 unsigned Off = getPltEntryOffset(Index);
485 write32le(Buf + 3, GotPltEntryAddr - Ebx);
486 write32le(Buf + 8, -Off - 12 + 32);
487 write32le(Buf + 13, -Off - 17 + 18);
488 write32le(Buf + 18, RelOff);
489 write32le(Buf + 23, -Off - 27);
490 }
491
RetpolineNoPic()492 RetpolineNoPic::RetpolineNoPic() {
493 PltHeaderSize = 48;
494 PltEntrySize = 32;
495 }
496
writeGotPlt(uint8_t * Buf,const Symbol & S) const497 void RetpolineNoPic::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
498 write32le(Buf, S.getPltVA() + 16);
499 }
500
writePltHeader(uint8_t * Buf) const501 void RetpolineNoPic::writePltHeader(uint8_t *Buf) const {
502 const uint8_t Insn[] = {
503 0xff, 0x35, 0, 0, 0, 0, // 0: pushl GOTPLT+4
504 0x50, // 6: pushl %eax
505 0xa1, 0, 0, 0, 0, // 7: mov GOTPLT+8, %eax
506 0xe8, 0x0f, 0x00, 0x00, 0x00, // c: call next
507 0xf3, 0x90, // 11: loop: pause
508 0x0f, 0xae, 0xe8, // 13: lfence
509 0xeb, 0xf9, // 16: jmp loop
510 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // 18: int3
511 0xcc, 0xcc, 0xcc, // 1f: int3; .align 16
512 0x89, 0x0c, 0x24, // 20: next: mov %ecx, (%esp)
513 0x8b, 0x4c, 0x24, 0x04, // 23: mov 0x4(%esp), %ecx
514 0x89, 0x44, 0x24, 0x04, // 27: mov %eax ,0x4(%esp)
515 0x89, 0xc8, // 2b: mov %ecx, %eax
516 0x59, // 2d: pop %ecx
517 0xc3, // 2e: ret
518 0xcc, // 2f: int3; padding
519 };
520 memcpy(Buf, Insn, sizeof(Insn));
521
522 uint32_t GotPlt = In.GotPlt->getVA();
523 write32le(Buf + 2, GotPlt + 4);
524 write32le(Buf + 8, GotPlt + 8);
525 }
526
writePlt(uint8_t * Buf,uint64_t GotPltEntryAddr,uint64_t PltEntryAddr,int32_t Index,unsigned RelOff) const527 void RetpolineNoPic::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
528 uint64_t PltEntryAddr, int32_t Index,
529 unsigned RelOff) const {
530 const uint8_t Insn[] = {
531 0x50, // 0: pushl %eax
532 0xa1, 0, 0, 0, 0, // 1: mov foo_in_GOT, %eax
533 0xe8, 0, 0, 0, 0, // 6: call plt+0x20
534 0xe9, 0, 0, 0, 0, // b: jmp plt+0x11
535 0x68, 0, 0, 0, 0, // 10: pushl $reloc_offset
536 0xe9, 0, 0, 0, 0, // 15: jmp plt+0
537 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, // 1a: int3; padding
538 0xcc, // 1f: int3; padding
539 };
540 memcpy(Buf, Insn, sizeof(Insn));
541
542 unsigned Off = getPltEntryOffset(Index);
543 write32le(Buf + 2, GotPltEntryAddr);
544 write32le(Buf + 7, -Off - 11 + 32);
545 write32le(Buf + 12, -Off - 16 + 17);
546 write32le(Buf + 17, RelOff);
547 write32le(Buf + 22, -Off - 26);
548 }
549
getX86TargetInfo()550 TargetInfo *elf::getX86TargetInfo() {
551 if (Config->ZRetpolineplt) {
552 if (Config->Pic) {
553 static RetpolinePic T;
554 return &T;
555 }
556 static RetpolineNoPic T;
557 return &T;
558 }
559
560 static X86 T;
561 return &T;
562 }
563