projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add support for MIPS .rld_map section.
[deliverable/binutils-gdb.git] / gold / i386.cc
CommitLineData
14bfc3f5
ILT		 1// i386.cc -- i386 target support for gold.
2
6f2750fe 3// Copyright (C) 2006-2016 Free Software Foundation, Inc.
6cb15b7f
ILT		 4// Written by Ian Lance Taylor <iant@google.com>.
5
6// This file is part of gold.
7
8// This program is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 3 of the License, or
11// (at your option) any later version.
12
13// This program is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17
18// You should have received a copy of the GNU General Public License
19// along with this program; if not, write to the Free Software
20// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21// MA 02110-1301, USA.
22
14bfc3f5 23#include "gold.h"
ead1e424
ILT		 24
25#include <cstring>
26
14bfc3f5 27#include "elfcpp.h"
07a60597 28#include "dwarf.h"
7e1edb90 29#include "parameters.h"
92e059d8 30#include "reloc.h"
61ba1cf9
ILT		 31#include "i386.h"
32#include "object.h"
ead1e424 33#include "symtab.h"
92e059d8
ILT		 34#include "layout.h"
35#include "output.h"
12c0daef 36#include "copy-relocs.h"
14bfc3f5 37#include "target.h"
61ba1cf9 38#include "target-reloc.h"
14bfc3f5 39#include "target-select.h"
af6359d5 40#include "tls.h"
36959681 41#include "freebsd.h"
2e702c99 42#include "nacl.h"
f345227a 43#include "gc.h"
14bfc3f5
ILT		 44
45namespace
46{
47
48using namespace gold;
49
57b2284c
CC		 50// A class to handle the .got.plt section.
51
52class Output_data_got_plt_i386 : public Output_section_data_build
53{
54 public:
55 Output_data_got_plt_i386(Layout* layout)
56 : Output_section_data_build(4),
57 layout_(layout)
58 { }
59
60 protected:
61 // Write out the PLT data.
62 void
63 do_write(Output_file*);
64
65 // Write to a map file.
66 void
67 do_print_to_mapfile(Mapfile* mapfile) const
68 { mapfile->print_output_data(this, "** GOT PLT"); }
69
70 private:
71 // A pointer to the Layout class, so that we can find the .dynamic
72 // section when we write out the GOT PLT section.
73 Layout* layout_;
74};
75
7223e9ca 76// A class to handle the PLT data.
2e702c99
RM		 77// This is an abstract base class that handles most of the linker details
78// but does not know the actual contents of PLT entries. The derived
79// classes below fill in those details.
7223e9ca
ILT		 80
81class Output_data_plt_i386 : public Output_section_data
82{
83 public:
84 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;
85
2e702c99 86 Output_data_plt_i386(Layout*, uint64_t addralign,
57b2284c 87 Output_data_got_plt_i386*, Output_data_space*);
7223e9ca
ILT		 88
89 // Add an entry to the PLT.
90 void
67181c72 91 add_entry(Symbol_table*, Layout*, Symbol* gsym);
7223e9ca
ILT		 92
93 // Add an entry to the PLT for a local STT_GNU_IFUNC symbol.
94 unsigned int
67181c72
ILT		 95 add_local_ifunc_entry(Symbol_table*, Layout*,
96 Sized_relobj_file<32, false>* relobj,
7223e9ca
ILT		 97 unsigned int local_sym_index);
98
99 // Return the .rel.plt section data.
100 Reloc_section*
101 rel_plt() const
102 { return this->rel_; }
103
104 // Return where the TLS_DESC relocations should go.
105 Reloc_section*
106 rel_tls_desc(Layout*);
107
67181c72
ILT		 108 // Return where the IRELATIVE relocations should go.
109 Reloc_section*
110 rel_irelative(Symbol_table*, Layout*);
111
112 // Return whether we created a section for IRELATIVE relocations.
113 bool
114 has_irelative_section() const
115 { return this->irelative_rel_ != NULL; }
116
7223e9ca
ILT		 117 // Return the number of PLT entries.
118 unsigned int
119 entry_count() const
67181c72 120 { return this->count_ + this->irelative_count_; }
7223e9ca
ILT		 121
122 // Return the offset of the first non-reserved PLT entry.
2e702c99 123 unsigned int
7223e9ca 124 first_plt_entry_offset()
2e702c99 125 { return this->get_plt_entry_size(); }
7223e9ca
ILT		 126
127 // Return the size of a PLT entry.
2e702c99
RM		 128 unsigned int
129 get_plt_entry_size() const
130 { return this->do_get_plt_entry_size(); }
7223e9ca 131
67181c72
ILT		 132 // Return the PLT address to use for a global symbol.
133 uint64_t
134 address_for_global(const Symbol*);
135
136 // Return the PLT address to use for a local symbol.
137 uint64_t
138 address_for_local(const Relobj*, unsigned int symndx);
139
2e702c99 140 // Add .eh_frame information for the PLT.
7223e9ca 141 void
2e702c99
RM		 142 add_eh_frame(Layout* layout)
143 { this->do_add_eh_frame(layout); }
7223e9ca 144
2e702c99
RM		 145 protected:
146 // Fill the first PLT entry, given the pointer to the PLT section data
147 // and the runtime address of the GOT.
7223e9ca 148 void
2e702c99
RM		 149 fill_first_plt_entry(unsigned char* pov,
150 elfcpp::Elf_types<32>::Elf_Addr got_address)
151 { this->do_fill_first_plt_entry(pov, got_address); }
152
153 // Fill a normal PLT entry, given the pointer to the entry's data in the
154 // section, the runtime address of the GOT, the offset into the GOT of
155 // the corresponding slot, the offset into the relocation section of the
156 // corresponding reloc, and the offset of this entry within the whole
157 // PLT. Return the offset from this PLT entry's runtime address that
158 // should be used to compute the initial value of the GOT slot.
159 unsigned int
160 fill_plt_entry(unsigned char* pov,
161 elfcpp::Elf_types<32>::Elf_Addr got_address,
162 unsigned int got_offset,
163 unsigned int plt_offset,
164 unsigned int plt_rel_offset)
165 {
166 return this->do_fill_plt_entry(pov, got_address, got_offset,
167 plt_offset, plt_rel_offset);
168 }
7223e9ca 169
2e702c99
RM		 170 virtual unsigned int
171 do_get_plt_entry_size() const = 0;
7223e9ca 172
2e702c99
RM		 173 virtual void
174 do_fill_first_plt_entry(unsigned char* pov,
175 elfcpp::Elf_types<32>::Elf_Addr got_address) = 0;
7223e9ca 176
2e702c99
RM		 177 virtual unsigned int
178 do_fill_plt_entry(unsigned char* pov,
179 elfcpp::Elf_types<32>::Elf_Addr got_address,
180 unsigned int got_offset,
181 unsigned int plt_offset,
182 unsigned int plt_rel_offset) = 0;
7223e9ca 183
2e702c99
RM		 184 virtual void
185 do_add_eh_frame(Layout*) = 0;
7223e9ca 186
2e702c99
RM		 187 void
188 do_adjust_output_section(Output_section* os);
189
190 // Write to a map file.
191 void
192 do_print_to_mapfile(Mapfile* mapfile) const
193 { mapfile->print_output_data(this, _("** PLT")); }
07a60597
ILT		 194
195 // The .eh_frame unwind information for the PLT.
2e702c99 196 // The CIE is common across variants of the PLT format.
07a60597 197 static const int plt_eh_frame_cie_size = 16;
07a60597 198 static const unsigned char plt_eh_frame_cie[plt_eh_frame_cie_size];
7223e9ca 199
2e702c99 200 private:
7223e9ca
ILT		 201 // Set the final size.
202 void
203 set_final_data_size()
67181c72
ILT		 204 {
205 this->set_data_size((this->count_ + this->irelative_count_ + 1)
2e702c99 206 * this->get_plt_entry_size());
67181c72 207 }
7223e9ca
ILT		 208
209 // Write out the PLT data.
210 void
211 do_write(Output_file*);
212
213 // We keep a list of global STT_GNU_IFUNC symbols, each with its
214 // offset in the GOT.
215 struct Global_ifunc
216 {
217 Symbol* sym;
218 unsigned int got_offset;
219 };
220
221 // We keep a list of local STT_GNU_IFUNC symbols, each with its
222 // offset in the GOT.
223 struct Local_ifunc
224 {
6fa2a40b 225 Sized_relobj_file<32, false>* object;
7223e9ca
ILT		 226 unsigned int local_sym_index;
227 unsigned int got_offset;
228 };
229
230 // The reloc section.
231 Reloc_section* rel_;
232 // The TLS_DESC relocations, if necessary. These must follow the
233 // regular PLT relocs.
234 Reloc_section* tls_desc_rel_;
67181c72
ILT		 235 // The IRELATIVE relocations, if necessary. These must follow the
236 // regular relocatoins and the TLS_DESC relocations.
237 Reloc_section* irelative_rel_;
7223e9ca 238 // The .got.plt section.
57b2284c 239 Output_data_got_plt_i386* got_plt_;
67181c72
ILT		 240 // The part of the .got.plt section used for IRELATIVE relocs.
241 Output_data_space* got_irelative_;
7223e9ca
ILT		 242 // The number of PLT entries.
243 unsigned int count_;
67181c72
ILT		 244 // Number of PLT entries with R_386_IRELATIVE relocs. These follow
245 // the regular PLT entries.
246 unsigned int irelative_count_;
7223e9ca
ILT		 247 // Global STT_GNU_IFUNC symbols.
248 std::vector<Global_ifunc> global_ifuncs_;
249 // Local STT_GNU_IFUNC symbols.
250 std::vector<Local_ifunc> local_ifuncs_;
251};
a3ad94ed 252
2e702c99
RM		 253// This is an abstract class for the standard PLT layout.
254// The derived classes below handle the actual PLT contents
255// for the executable (non-PIC) and shared-library (PIC) cases.
256// The unwind information is uniform across those two, so it's here.
257
258class Output_data_plt_i386_standard : public Output_data_plt_i386
259{
260 public:
261 Output_data_plt_i386_standard(Layout* layout,
57b2284c 262 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 263 Output_data_space* got_irelative)
264 : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)
265 { }
266
267 protected:
268 virtual unsigned int
269 do_get_plt_entry_size() const
270 { return plt_entry_size; }
271
272 virtual void
273 do_add_eh_frame(Layout* layout)
274 {
275 layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,
276 plt_eh_frame_fde, plt_eh_frame_fde_size);
277 }
278
279 // The size of an entry in the PLT.
280 static const int plt_entry_size = 16;
281
282 // The .eh_frame unwind information for the PLT.
283 static const int plt_eh_frame_fde_size = 32;
284 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
285};
286
287// Actually fill the PLT contents for an executable (non-PIC).
288
289class Output_data_plt_i386_exec : public Output_data_plt_i386_standard
290{
291public:
292 Output_data_plt_i386_exec(Layout* layout,
57b2284c 293 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 294 Output_data_space* got_irelative)
295 : Output_data_plt_i386_standard(layout, got_plt, got_irelative)
296 { }
297
298 protected:
299 virtual void
300 do_fill_first_plt_entry(unsigned char* pov,
301 elfcpp::Elf_types<32>::Elf_Addr got_address);
302
303 virtual unsigned int
304 do_fill_plt_entry(unsigned char* pov,
305 elfcpp::Elf_types<32>::Elf_Addr got_address,
306 unsigned int got_offset,
307 unsigned int plt_offset,
308 unsigned int plt_rel_offset);
309
310 private:
311 // The first entry in the PLT for an executable.
312 static const unsigned char first_plt_entry[plt_entry_size];
313
314 // Other entries in the PLT for an executable.
315 static const unsigned char plt_entry[plt_entry_size];
316};
317
318// Actually fill the PLT contents for a shared library (PIC).
319
320class Output_data_plt_i386_dyn : public Output_data_plt_i386_standard
321{
322 public:
323 Output_data_plt_i386_dyn(Layout* layout,
57b2284c 324 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 325 Output_data_space* got_irelative)
326 : Output_data_plt_i386_standard(layout, got_plt, got_irelative)
327 { }
328
329 protected:
330 virtual void
331 do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);
332
333 virtual unsigned int
334 do_fill_plt_entry(unsigned char* pov,
335 elfcpp::Elf_types<32>::Elf_Addr,
336 unsigned int got_offset,
337 unsigned int plt_offset,
338 unsigned int plt_rel_offset);
339
340 private:
341 // The first entry in the PLT for a shared object.
342 static const unsigned char first_plt_entry[plt_entry_size];
343
344 // Other entries in the PLT for a shared object.
345 static const unsigned char plt_entry[plt_entry_size];
346};
347
14bfc3f5 348// The i386 target class.
e041f13d
ILT		 349// TLS info comes from
350// http://people.redhat.com/drepper/tls.pdf
351// http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
14bfc3f5 352
200b2bb9 353class Target_i386 : public Sized_target<32, false>
14bfc3f5
ILT		 354{
355 public:
5a6f7e2d
ILT		 356 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;
357
2e702c99
RM		 358 Target_i386(const Target::Target_info* info = &i386_info)
359 : Sized_target<32, false>(info),
67181c72
ILT		 360 got_(NULL), plt_(NULL), got_plt_(NULL), got_irelative_(NULL),
361 got_tlsdesc_(NULL), global_offset_table_(NULL), rel_dyn_(NULL),
43819297 362 rel_irelative_(NULL), copy_relocs_(elfcpp::R_386_COPY),
edfbb029 363 got_mod_index_offset_(-1U), tls_base_symbol_defined_(false)
14bfc3f5 364 { }
75f65a3e 365
2e702c99 366 // Process the relocations to determine unreferenced sections for
6d03d481
ST		 367 // garbage collection.
368 void
ad0f2072 369 gc_process_relocs(Symbol_table* symtab,
2e702c99
RM		 370 Layout* layout,
371 Sized_relobj_file<32, false>* object,
372 unsigned int data_shndx,
373 unsigned int sh_type,
374 const unsigned char* prelocs,
375 size_t reloc_count,
376 Output_section* output_section,
377 bool needs_special_offset_handling,
378 size_t local_symbol_count,
379 const unsigned char* plocal_symbols);
6d03d481 380
92e059d8 381 // Scan the relocations to look for symbol adjustments.
61ba1cf9 382 void
ad0f2072 383 scan_relocs(Symbol_table* symtab,
ead1e424 384 Layout* layout,
6fa2a40b 385 Sized_relobj_file<32, false>* object,
a3ad94ed 386 unsigned int data_shndx,
92e059d8
ILT		 387 unsigned int sh_type,
388 const unsigned char* prelocs,
389 size_t reloc_count,
730cdc88
ILT		 390 Output_section* output_section,
391 bool needs_special_offset_handling,
92e059d8 392 size_t local_symbol_count,
730cdc88 393 const unsigned char* plocal_symbols);
61ba1cf9 394
5a6f7e2d
ILT		 395 // Finalize the sections.
396 void
f59f41f3 397 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
5a6f7e2d 398
ab5c9e90
ILT		 399 // Return the value to use for a dynamic which requires special
400 // treatment.
401 uint64_t
402 do_dynsym_value(const Symbol*) const;
403
92e059d8
ILT		 404 // Relocate a section.
405 void
406 relocate_section(const Relocate_info<32, false>*,
407 unsigned int sh_type,
408 const unsigned char* prelocs,
409 size_t reloc_count,
730cdc88
ILT		 410 Output_section* output_section,
411 bool needs_special_offset_handling,
92e059d8
ILT		 412 unsigned char* view,
413 elfcpp::Elf_types<32>::Elf_Addr view_address,
364c7fa5
ILT		 414 section_size_type view_size,
415 const Reloc_symbol_changes*);
92e059d8 416
6a74a719
ILT		 417 // Scan the relocs during a relocatable link.
418 void
ad0f2072 419 scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 420 Layout* layout,
6fa2a40b 421 Sized_relobj_file<32, false>* object,
6a74a719
ILT		 422 unsigned int data_shndx,
423 unsigned int sh_type,
424 const unsigned char* prelocs,
425 size_t reloc_count,
426 Output_section* output_section,
427 bool needs_special_offset_handling,
428 size_t local_symbol_count,
429 const unsigned char* plocal_symbols,
430 Relocatable_relocs*);
431
4d625b70
CC		 432 // Scan the relocs for --emit-relocs.
433 void
434 emit_relocs_scan(Symbol_table* symtab,
435 Layout* layout,
436 Sized_relobj_file<32, false>* object,
437 unsigned int data_shndx,
438 unsigned int sh_type,
439 const unsigned char* prelocs,
440 size_t reloc_count,
441 Output_section* output_section,
442 bool needs_special_offset_handling,
443 size_t local_symbol_count,
444 const unsigned char* plocal_syms,
445 Relocatable_relocs* rr);
446
7404fe1b 447 // Emit relocations for a section.
6a74a719 448 void
7404fe1b
AM		 449 relocate_relocs(const Relocate_info<32, false>*,
450 unsigned int sh_type,
451 const unsigned char* prelocs,
452 size_t reloc_count,
453 Output_section* output_section,
cc928013 454 elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,
7404fe1b
AM		 455 unsigned char* view,
456 elfcpp::Elf_types<32>::Elf_Addr view_address,
457 section_size_type view_size,
458 unsigned char* reloc_view,
459 section_size_type reloc_view_size);
6a74a719 460
c51e6221
ILT		 461 // Return a string used to fill a code section with nops.
462 std::string
8851ecca 463 do_code_fill(section_size_type length) const;
c51e6221 464
9a2d6984
ILT		 465 // Return whether SYM is defined by the ABI.
466 bool
9c2d0ef9 467 do_is_defined_by_abi(const Symbol* sym) const
9a2d6984
ILT		 468 { return strcmp(sym->name(), "___tls_get_addr") == 0; }
469
bb04269c
DK		 470 // Return whether a symbol name implies a local label. The UnixWare
471 // 2.1 cc generates temporary symbols that start with .X, so we
472 // recognize them here. FIXME: do other SVR4 compilers also use .X?.
473 // If so, we should move the .X recognition into
474 // Target::do_is_local_label_name.
475 bool
476 do_is_local_label_name(const char* name) const
477 {
478 if (name[0] == '.' && name[1] == 'X')
479 return true;
480 return Target::do_is_local_label_name(name);
481 }
482
67181c72
ILT		 483 // Return the PLT address to use for a global symbol.
484 uint64_t
485 do_plt_address_for_global(const Symbol* gsym) const
486 { return this->plt_section()->address_for_global(gsym); }
7223e9ca 487
67181c72
ILT		 488 uint64_t
489 do_plt_address_for_local(const Relobj* relobj, unsigned int symndx) const
490 { return this->plt_section()->address_for_local(relobj, symndx); }
7223e9ca 491
b3ce541e
ILT		 492 // We can tell whether we take the address of a function.
493 inline bool
494 do_can_check_for_function_pointers() const
495 { return true; }
496
02d7cd44
ILT		 497 // Return the base for a DW_EH_PE_datarel encoding.
498 uint64_t
499 do_ehframe_datarel_base() const;
500
b6848d3c
ILT		 501 // Return whether SYM is call to a non-split function.
502 bool
bd8d853f
MK		 503 do_is_call_to_non_split(const Symbol* sym, const unsigned char*,
504 const unsigned char*, section_size_type) const;
b6848d3c 505
9b547ce6 506 // Adjust -fsplit-stack code which calls non-split-stack code.
364c7fa5
ILT		 507 void
508 do_calls_non_split(Relobj* object, unsigned int shndx,
509 section_offset_type fnoffset, section_size_type fnsize,
6e0813d3 510 const unsigned char* prelocs, size_t reloc_count,
364c7fa5
ILT		 511 unsigned char* view, section_size_type view_size,
512 std::string* from, std::string* to) const;
513
96f2030e 514 // Return the size of the GOT section.
fe8718a4 515 section_size_type
0e70b911 516 got_size() const
96f2030e
ILT		 517 {
518 gold_assert(this->got_ != NULL);
519 return this->got_->data_size();
520 }
521
0e70b911
CC		 522 // Return the number of entries in the GOT.
523 unsigned int
524 got_entry_count() const
525 {
526 if (this->got_ == NULL)
527 return 0;
528 return this->got_size() / 4;
529 }
530
531 // Return the number of entries in the PLT.
532 unsigned int
533 plt_entry_count() const;
534
535 // Return the offset of the first non-reserved PLT entry.
536 unsigned int
537 first_plt_entry_offset() const;
538
539 // Return the size of each PLT entry.
540 unsigned int
541 plt_entry_size() const;
542
2e702c99
RM		 543 protected:
544 // Instantiate the plt_ member.
545 // This chooses the right PLT flavor for an executable or a shared object.
546 Output_data_plt_i386*
547 make_data_plt(Layout* layout,
57b2284c 548 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 549 Output_data_space* got_irelative,
550 bool dyn)
551 { return this->do_make_data_plt(layout, got_plt, got_irelative, dyn); }
552
553 virtual Output_data_plt_i386*
554 do_make_data_plt(Layout* layout,
57b2284c 555 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 556 Output_data_space* got_irelative,
557 bool dyn)
558 {
559 if (dyn)
560 return new Output_data_plt_i386_dyn(layout, got_plt, got_irelative);
561 else
562 return new Output_data_plt_i386_exec(layout, got_plt, got_irelative);
563 }
564
92e059d8
ILT		 565 private:
566 // The class which scans relocations.
567 struct Scan
61ba1cf9 568 {
95a2c8d6
RS		 569 static inline int
570
571 get_reference_flags(unsigned int r_type);
572
61ba1cf9 573 inline void
ad0f2072 574 local(Symbol_table* symtab, Layout* layout, Target_i386* target,
6fa2a40b 575 Sized_relobj_file<32, false>* object,
a3ad94ed 576 unsigned int data_shndx,
07f397ab 577 Output_section* output_section,
92e059d8 578 const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
bfdfa4cd
AM		 579 const elfcpp::Sym<32, false>& lsym,
580 bool is_discarded);
61ba1cf9 581
92e059d8 582 inline void
ad0f2072 583 global(Symbol_table* symtab, Layout* layout, Target_i386* target,
6fa2a40b 584 Sized_relobj_file<32, false>* object,
a3ad94ed 585 unsigned int data_shndx,
07f397ab 586 Output_section* output_section,
92e059d8
ILT		 587 const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
588 Symbol* gsym);
af6359d5 589
21bb3914 590 inline bool
0897ed3b 591 local_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
2e702c99
RM		 592 Target_i386* target,
593 Sized_relobj_file<32, false>* object,
594 unsigned int data_shndx,
595 Output_section* output_section,
596 const elfcpp::Rel<32, false>& reloc,
0897ed3b 597 unsigned int r_type,
2e702c99 598 const elfcpp::Sym<32, false>& lsym);
0897ed3b
ST		 599
600 inline bool
601 global_reloc_may_be_function_pointer(Symbol_table* symtab, Layout* layout,
602 Target_i386* target,
2e702c99
RM		 603 Sized_relobj_file<32, false>* object,
604 unsigned int data_shndx,
605 Output_section* output_section,
0897ed3b
ST		 606 const elfcpp::Rel<32, false>& reloc,
607 unsigned int r_type,
2e702c99 608 Symbol* gsym);
21bb3914
ST		 609
610 inline bool
0897ed3b 611 possible_function_pointer_reloc(unsigned int r_type);
21bb3914 612
7223e9ca 613 bool
6fa2a40b
CC		 614 reloc_needs_plt_for_ifunc(Sized_relobj_file<32, false>*,
615 unsigned int r_type);
7223e9ca 616
af6359d5 617 static void
6fa2a40b 618 unsupported_reloc_local(Sized_relobj_file<32, false>*, unsigned int r_type);
af6359d5
ILT		 619
620 static void
6fa2a40b 621 unsupported_reloc_global(Sized_relobj_file<32, false>*, unsigned int r_type,
af6359d5 622 Symbol*);
61ba1cf9
ILT		 623 };
624
92e059d8
ILT		 625 // The class which implements relocation.
626 class Relocate
627 {
628 public:
ead1e424 629 Relocate()
46cf9fa2 630 : skip_call_tls_get_addr_(false),
82bb573a 631 local_dynamic_type_(LOCAL_DYNAMIC_NONE)
ead1e424
ILT		 632 { }
633
634 ~Relocate()
635 {
636 if (this->skip_call_tls_get_addr_)
637 {
638 // FIXME: This needs to specify the location somehow.
75f2446e 639 gold_error(_("missing expected TLS relocation"));
ead1e424
ILT		 640 }
641 }
642
86849f1f
ILT		 643 // Return whether the static relocation needs to be applied.
644 inline bool
645 should_apply_static_reloc(const Sized_symbol<32>* gsym,
2e702c99
RM		 646 unsigned int r_type,
647 bool is_32bit,
031cdbed 648 Output_section* output_section);
86849f1f 649
ead1e424
ILT		 650 // Do a relocation. Return false if the caller should not issue
651 // any warnings about this relocation.
652 inline bool
91a65d2f
AM		 653 relocate(const Relocate_info<32, false>*, unsigned int,
654 Target_i386*, Output_section*, size_t, const unsigned char*,
655 const Sized_symbol<32>*, const Symbol_value<32>*,
92e059d8 656 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
fe8718a4 657 section_size_type);
92e059d8
ILT		 658
659 private:
660 // Do a TLS relocation.
ead1e424 661 inline void
07f397ab 662 relocate_tls(const Relocate_info<32, false>*, Target_i386* target,
2e702c99 663 size_t relnum, const elfcpp::Rel<32, false>&,
c06b7b0b 664 unsigned int r_type, const Sized_symbol<32>*,
b8e6aad9 665 const Symbol_value<32>*,
fe8718a4
ILT		 666 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
667 section_size_type);
92e059d8 668
07f397ab
ILT		 669 // Do a TLS General-Dynamic to Initial-Exec transition.
670 inline void
671 tls_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,
07f397ab
ILT		 672 const elfcpp::Rel<32, false>&, unsigned int r_type,
673 elfcpp::Elf_types<32>::Elf_Addr value,
674 unsigned char* view,
fe8718a4 675 section_size_type view_size);
07f397ab 676
56622147
ILT		 677 // Do a TLS General-Dynamic to Local-Exec transition.
678 inline void
679 tls_gd_to_le(const Relocate_info<32, false>*, size_t relnum,
92e059d8
ILT		 680 Output_segment* tls_segment,
681 const elfcpp::Rel<32, false>&, unsigned int r_type,
682 elfcpp::Elf_types<32>::Elf_Addr value,
683 unsigned char* view,
fe8718a4 684 section_size_type view_size);
92e059d8 685
c2b45e22
CC		 686 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Initial-Exec
687 // transition.
688 inline void
689 tls_desc_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,
c2b45e22
CC		 690 const elfcpp::Rel<32, false>&, unsigned int r_type,
691 elfcpp::Elf_types<32>::Elf_Addr value,
692 unsigned char* view,
693 section_size_type view_size);
694
695 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Local-Exec
696 // transition.
697 inline void
698 tls_desc_gd_to_le(const Relocate_info<32, false>*, size_t relnum,
699 Output_segment* tls_segment,
700 const elfcpp::Rel<32, false>&, unsigned int r_type,
701 elfcpp::Elf_types<32>::Elf_Addr value,
702 unsigned char* view,
703 section_size_type view_size);
704
56622147 705 // Do a TLS Local-Dynamic to Local-Exec transition.
ead1e424 706 inline void
56622147 707 tls_ld_to_le(const Relocate_info<32, false>*, size_t relnum,
ead1e424
ILT		 708 Output_segment* tls_segment,
709 const elfcpp::Rel<32, false>&, unsigned int r_type,
710 elfcpp::Elf_types<32>::Elf_Addr value,
711 unsigned char* view,
fe8718a4 712 section_size_type view_size);
ead1e424 713
56622147
ILT		 714 // Do a TLS Initial-Exec to Local-Exec transition.
715 static inline void
716 tls_ie_to_le(const Relocate_info<32, false>*, size_t relnum,
46cf9fa2
ILT		 717 Output_segment* tls_segment,
718 const elfcpp::Rel<32, false>&, unsigned int r_type,
719 elfcpp::Elf_types<32>::Elf_Addr value,
720 unsigned char* view,
fe8718a4 721 section_size_type view_size);
46cf9fa2 722
46cf9fa2
ILT		 723 // We need to keep track of which type of local dynamic relocation
724 // we have seen, so that we can optimize R_386_TLS_LDO_32 correctly.
725 enum Local_dynamic_type
726 {
727 LOCAL_DYNAMIC_NONE,
728 LOCAL_DYNAMIC_SUN,
729 LOCAL_DYNAMIC_GNU
730 };
731
ead1e424
ILT		 732 // This is set if we should skip the next reloc, which should be a
733 // PLT32 reloc against ___tls_get_addr.
734 bool skip_call_tls_get_addr_;
46cf9fa2
ILT		 735 // The type of local dynamic relocation we have seen in the section
736 // being relocated, if any.
737 Local_dynamic_type local_dynamic_type_;
92e059d8
ILT		 738 };
739
4d625b70
CC		 740 // A class for inquiring about properties of a relocation,
741 // used while scanning relocs during a relocatable link and
742 // garbage collection.
743 class Classify_reloc :
744 public gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>
6a74a719
ILT		 745 {
746 public:
41549dfb 747 typedef Reloc_types<elfcpp::SHT_REL, 32, false>::Reloc Reltype;
8a8880cb
CC		 748
749 // Return the explicit addend of the relocation (return 0 for SHT_REL).
41549dfb 750 static elfcpp::Elf_types<32>::Elf_Swxword
8a8880cb
CC		 751 get_r_addend(const Reltype*)
752 { return 0; }
753
4d625b70
CC		 754 // Return the size of the addend of the relocation (only used for SHT_REL).
755 static unsigned int
6a74a719
ILT		 756 get_size_for_reloc(unsigned int, Relobj*);
757 };
758
92e059d8
ILT		 759 // Adjust TLS relocation type based on the options and whether this
760 // is a local symbol.
af6359d5 761 static tls::Tls_optimization
7e1edb90 762 optimize_tls_reloc(bool is_final, int r_type);
92e059d8 763
c4fc4724
IT		 764 // Check if relocation against this symbol is a candidate for
765 // conversion from
766 // mov foo@GOT(%reg), %reg
767 // to
768 // lea foo@GOTOFF(%reg), %reg.
769 static bool
770 can_convert_mov_to_lea(const Symbol* gsym)
771 {
772 gold_assert(gsym != NULL);
773 return (gsym->type() != elfcpp::STT_GNU_IFUNC
774 && !gsym->is_undefined ()
775 && !gsym->is_from_dynobj()
776 && !gsym->is_preemptible()
777 && (!parameters->options().shared()
778 || (gsym->visibility() != elfcpp::STV_DEFAULT
779 && gsym->visibility() != elfcpp::STV_PROTECTED)
780 || parameters->options().Bsymbolic())
781 && strcmp(gsym->name(), "_DYNAMIC") != 0);
782 }
783
ead1e424 784 // Get the GOT section, creating it if necessary.
dbe717ef 785 Output_data_got<32, false>*
7e1edb90 786 got_section(Symbol_table*, Layout*);
a3ad94ed 787
96f2030e 788 // Get the GOT PLT section.
57b2284c 789 Output_data_got_plt_i386*
96f2030e
ILT		 790 got_plt_section() const
791 {
792 gold_assert(this->got_plt_ != NULL);
793 return this->got_plt_;
794 }
795
a8df5856
ILT		 796 // Get the GOT section for TLSDESC entries.
797 Output_data_got<32, false>*
798 got_tlsdesc_section() const
799 {
800 gold_assert(this->got_tlsdesc_ != NULL);
801 return this->got_tlsdesc_;
802 }
803
7223e9ca
ILT		 804 // Create the PLT section.
805 void
806 make_plt_section(Symbol_table* symtab, Layout* layout);
807
a3ad94ed
ILT		 808 // Create a PLT entry for a global symbol.
809 void
7e1edb90 810 make_plt_entry(Symbol_table*, Layout*, Symbol*);
a3ad94ed 811
7223e9ca
ILT		 812 // Create a PLT entry for a local STT_GNU_IFUNC symbol.
813 void
814 make_local_ifunc_plt_entry(Symbol_table*, Layout*,
6fa2a40b 815 Sized_relobj_file<32, false>* relobj,
7223e9ca
ILT		 816 unsigned int local_sym_index);
817
9fa33bee 818 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC		 819 void
820 define_tls_base_symbol(Symbol_table*, Layout*);
821
94c4710f
ILT		 822 // Create a GOT entry for the TLS module index.
823 unsigned int
824 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 825 Sized_relobj_file<32, false>* object);
94c4710f 826
a3ad94ed 827 // Get the PLT section.
e291e7b9 828 Output_data_plt_i386*
a3ad94ed
ILT		 829 plt_section() const
830 {
831 gold_assert(this->plt_ != NULL);
832 return this->plt_;
833 }
834
5a6f7e2d
ILT		 835 // Get the dynamic reloc section, creating it if necessary.
836 Reloc_section*
837 rel_dyn_section(Layout*);
838
e291e7b9
ILT		 839 // Get the section to use for TLS_DESC relocations.
840 Reloc_section*
841 rel_tls_desc_section(Layout*) const;
842
67181c72
ILT		 843 // Get the section to use for IRELATIVE relocations.
844 Reloc_section*
845 rel_irelative_section(Layout*);
846
12c0daef 847 // Add a potential copy relocation.
a3ad94ed 848 void
ef9beddf 849 copy_reloc(Symbol_table* symtab, Layout* layout,
2e702c99 850 Sized_relobj_file<32, false>* object,
12c0daef
ILT		 851 unsigned int shndx, Output_section* output_section,
852 Symbol* sym, const elfcpp::Rel<32, false>& reloc)
853 {
859d7987 854 unsigned int r_type = elfcpp::elf_r_type<32>(reloc.get_r_info());
12c0daef
ILT		 855 this->copy_relocs_.copy_reloc(symtab, layout,
856 symtab->get_sized_symbol<32>(sym),
859d7987
CC		 857 object, shndx, output_section,
858 r_type, reloc.get_r_offset(), 0,
12c0daef
ILT		 859 this->rel_dyn_section(layout));
860 }
ead1e424 861
92e059d8
ILT		 862 // Information about this specific target which we pass to the
863 // general Target structure.
75f65a3e 864 static const Target::Target_info i386_info;
ead1e424 865
0a65a3a7 866 // The types of GOT entries needed for this platform.
0e70b911
CC		 867 // These values are exposed to the ABI in an incremental link.
868 // Do not renumber existing values without changing the version
869 // number of the .gnu_incremental_inputs section.
0a65a3a7
CC		 870 enum Got_type
871 {
872 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
c2b45e22
CC		 873 GOT_TYPE_TLS_NOFFSET = 1, // GOT entry for negative TLS offset
874 GOT_TYPE_TLS_OFFSET = 2, // GOT entry for positive TLS offset
875 GOT_TYPE_TLS_PAIR = 3, // GOT entry for TLS module/offset pair
876 GOT_TYPE_TLS_DESC = 4 // GOT entry for TLS_DESC pair
0a65a3a7
CC		 877 };
878
ead1e424 879 // The GOT section.
dbe717ef 880 Output_data_got<32, false>* got_;
a3ad94ed
ILT		 881 // The PLT section.
882 Output_data_plt_i386* plt_;
883 // The GOT PLT section.
57b2284c 884 Output_data_got_plt_i386* got_plt_;
67181c72
ILT		 885 // The GOT section for IRELATIVE relocations.
886 Output_data_space* got_irelative_;
a8df5856
ILT		 887 // The GOT section for TLSDESC relocations.
888 Output_data_got<32, false>* got_tlsdesc_;
e785ec03
ILT		 889 // The _GLOBAL_OFFSET_TABLE_ symbol.
890 Symbol* global_offset_table_;
5a6f7e2d
ILT		 891 // The dynamic reloc section.
892 Reloc_section* rel_dyn_;
67181c72
ILT		 893 // The section to use for IRELATIVE relocs.
894 Reloc_section* rel_irelative_;
5a6f7e2d 895 // Relocs saved to avoid a COPY reloc.
12c0daef 896 Copy_relocs<elfcpp::SHT_REL, 32, false> copy_relocs_;
c2b45e22 897 // Offset of the GOT entry for the TLS module index.
94c4710f 898 unsigned int got_mod_index_offset_;
edfbb029
CC		 899 // True if the _TLS_MODULE_BASE_ symbol has been defined.
900 bool tls_base_symbol_defined_;
75f65a3e
ILT		 901};
902
903const Target::Target_info Target_i386::i386_info =
904{
61ba1cf9
ILT		 905 32, // size
906 false, // is_big_endian
907 elfcpp::EM_386, // machine_code
908 false, // has_make_symbol
dbe717ef 909 false, // has_resolve
c51e6221 910 true, // has_code_fill
35cdfc9a 911 true, // is_default_stack_executable
b3ce541e 912 true, // can_icf_inline_merge_sections
0864d551 913 '\0', // wrap_char
dbe717ef 914 "/usr/lib/libc.so.1", // dynamic_linker
0c5e9c22 915 0x08048000, // default_text_segment_address
cd72c291 916 0x1000, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08 917 0x1000, // common_pagesize (overridable by -z common-page-size)
2e702c99
RM		 918 false, // isolate_execinstr
919 0, // rosegment_gap
8a5e3e08
ILT		 920 elfcpp::SHN_UNDEF, // small_common_shndx
921 elfcpp::SHN_UNDEF, // large_common_shndx
922 0, // small_common_section_flags
05a352e6
DK		 923 0, // large_common_section_flags
924 NULL, // attributes_section
a67858e0 925 NULL, // attributes_vendor
8d9743bd
MK		 926 "_start", // entry_symbol_name
927 32, // hash_entry_size
14bfc3f5
ILT		 928};
929
ead1e424
ILT		 930// Get the GOT section, creating it if necessary.
931
dbe717ef 932Output_data_got<32, false>*
7e1edb90 933Target_i386::got_section(Symbol_table* symtab, Layout* layout)
ead1e424
ILT		 934{
935 if (this->got_ == NULL)
936 {
7e1edb90 937 gold_assert(symtab != NULL && layout != NULL);
a3ad94ed 938
7e1edb90 939 this->got_ = new Output_data_got<32, false>();
ead1e424 940
9446efde
ILT		 941 // When using -z now, we can treat .got.plt as a relro section.
942 // Without -z now, it is modified after program startup by lazy
943 // PLT relocations.
944 bool is_got_plt_relro = parameters->options().now();
945 Output_section_order got_order = (is_got_plt_relro
946 ? ORDER_RELRO
947 : ORDER_RELRO_LAST);
948 Output_section_order got_plt_order = (is_got_plt_relro
949 ? ORDER_RELRO
950 : ORDER_NON_RELRO_FIRST);
951
82742395
ILT		 952 layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
953 (elfcpp::SHF_ALLOC
954 | elfcpp::SHF_WRITE),
9446efde 955 this->got_, got_order, true);
ead1e424 956
57b2284c 957 this->got_plt_ = new Output_data_got_plt_i386(layout);
82742395
ILT		 958 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
959 (elfcpp::SHF_ALLOC
960 | elfcpp::SHF_WRITE),
9446efde
ILT		 961 this->got_plt_, got_plt_order,
962 is_got_plt_relro);
a3ad94ed 963
ead1e424 964 // The first three entries are reserved.
27bc2bce 965 this->got_plt_->set_current_data_size(3 * 4);
ead1e424 966
9446efde
ILT		 967 if (!is_got_plt_relro)
968 {
969 // Those bytes can go into the relro segment.
970 layout->increase_relro(3 * 4);
971 }
1a2dff53 972
a3ad94ed 973 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
e785ec03
ILT		 974 this->global_offset_table_ =
975 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
976 Symbol_table::PREDEFINED,
977 this->got_plt_,
978 0, 0, elfcpp::STT_OBJECT,
979 elfcpp::STB_LOCAL,
980 elfcpp::STV_HIDDEN, 0,
981 false, false);
a8df5856 982
67181c72
ILT		 983 // If there are any IRELATIVE relocations, they get GOT entries
984 // in .got.plt after the jump slot relocations.
985 this->got_irelative_ = new Output_data_space(4, "** GOT IRELATIVE PLT");
986 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
987 (elfcpp::SHF_ALLOC
988 | elfcpp::SHF_WRITE),
989 this->got_irelative_,
9446efde 990 got_plt_order, is_got_plt_relro);
67181c72 991
a8df5856
ILT		 992 // If there are any TLSDESC relocations, they get GOT entries in
993 // .got.plt after the jump slot entries.
994 this->got_tlsdesc_ = new Output_data_got<32, false>();
995 layout->add_output_section_data(".got.plt", elfcpp::SHT_PROGBITS,
996 (elfcpp::SHF_ALLOC
997 | elfcpp::SHF_WRITE),
22f0da72 998 this->got_tlsdesc_,
9446efde 999 got_plt_order, is_got_plt_relro);
ead1e424 1000 }
a3ad94ed 1001
ead1e424
ILT		 1002 return this->got_;
1003}
1004
5a6f7e2d
ILT		 1005// Get the dynamic reloc section, creating it if necessary.
1006
1007Target_i386::Reloc_section*
1008Target_i386::rel_dyn_section(Layout* layout)
1009{
1010 if (this->rel_dyn_ == NULL)
1011 {
1012 gold_assert(layout != NULL);
d98bc257 1013 this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
5a6f7e2d 1014 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
22f0da72
ILT		 1015 elfcpp::SHF_ALLOC, this->rel_dyn_,
1016 ORDER_DYNAMIC_RELOCS, false);
5a6f7e2d
ILT		 1017 }
1018 return this->rel_dyn_;
1019}
1020
67181c72
ILT		 1021// Get the section to use for IRELATIVE relocs, creating it if
1022// necessary. These go in .rel.dyn, but only after all other dynamic
1023// relocations. They need to follow the other dynamic relocations so
1024// that they can refer to global variables initialized by those
1025// relocs.
1026
1027Target_i386::Reloc_section*
1028Target_i386::rel_irelative_section(Layout* layout)
1029{
1030 if (this->rel_irelative_ == NULL)
1031 {
1032 // Make sure we have already create the dynamic reloc section.
1033 this->rel_dyn_section(layout);
1034 this->rel_irelative_ = new Reloc_section(false);
1035 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
1036 elfcpp::SHF_ALLOC, this->rel_irelative_,
1037 ORDER_DYNAMIC_RELOCS, false);
1038 gold_assert(this->rel_dyn_->output_section()
1039 == this->rel_irelative_->output_section());
1040 }
1041 return this->rel_irelative_;
1042}
1043
57b2284c
CC		 1044// Write the first three reserved words of the .got.plt section.
1045// The remainder of the section is written while writing the PLT
1046// in Output_data_plt_i386::do_write.
1047
1048void
1049Output_data_got_plt_i386::do_write(Output_file* of)
1050{
1051 // The first entry in the GOT is the address of the .dynamic section
1052 // aka the PT_DYNAMIC segment. The next two entries are reserved.
1053 // We saved space for them when we created the section in
1054 // Target_i386::got_section.
1055 const off_t got_file_offset = this->offset();
1056 gold_assert(this->data_size() >= 12);
1057 unsigned char* const got_view = of->get_output_view(got_file_offset, 12);
1058 Output_section* dynamic = this->layout_->dynamic_section();
1059 uint32_t dynamic_addr = dynamic == NULL ? 0 : dynamic->address();
1060 elfcpp::Swap<32, false>::writeval(got_view, dynamic_addr);
1061 memset(got_view + 4, 0, 8);
1062 of->write_output_view(got_file_offset, 12, got_view);
1063}
1064
a3ad94ed
ILT		 1065// Create the PLT section. The ordinary .got section is an argument,
1066// since we need to refer to the start. We also create our own .got
1067// section just for PLT entries.
1068
67181c72 1069Output_data_plt_i386::Output_data_plt_i386(Layout* layout,
2e702c99 1070 uint64_t addralign,
57b2284c 1071 Output_data_got_plt_i386* got_plt,
67181c72 1072 Output_data_space* got_irelative)
2e702c99 1073 : Output_section_data(addralign),
57b2284c
CC		 1074 tls_desc_rel_(NULL), irelative_rel_(NULL), got_plt_(got_plt),
1075 got_irelative_(got_irelative), count_(0), irelative_count_(0),
1076 global_ifuncs_(), local_ifuncs_()
a3ad94ed 1077{
d98bc257 1078 this->rel_ = new Reloc_section(false);
a3ad94ed 1079 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
22f0da72
ILT		 1080 elfcpp::SHF_ALLOC, this->rel_,
1081 ORDER_DYNAMIC_PLT_RELOCS, false);
a3ad94ed
ILT		 1082}
1083
16649710
ILT		 1084void
1085Output_data_plt_i386::do_adjust_output_section(Output_section* os)
1086{
1087 // UnixWare sets the entsize of .plt to 4, and so does the old GNU
1088 // linker, and so do we.
1089 os->set_entsize(4);
1090}
1091
a3ad94ed
ILT		 1092// Add an entry to the PLT.
1093
1094void
67181c72
ILT		 1095Output_data_plt_i386::add_entry(Symbol_table* symtab, Layout* layout,
1096 Symbol* gsym)
a3ad94ed
ILT		 1097{
1098 gold_assert(!gsym->has_plt_offset());
1099
a3ad94ed 1100 // Every PLT entry needs a reloc.
7223e9ca
ILT		 1101 if (gsym->type() == elfcpp::STT_GNU_IFUNC
1102 && gsym->can_use_relative_reloc(false))
1103 {
2e702c99 1104 gsym->set_plt_offset(this->irelative_count_ * this->get_plt_entry_size());
67181c72
ILT		 1105 ++this->irelative_count_;
1106 section_offset_type got_offset =
1107 this->got_irelative_->current_data_size();
1108 this->got_irelative_->set_current_data_size(got_offset + 4);
1109 Reloc_section* rel = this->rel_irelative(symtab, layout);
1110 rel->add_symbolless_global_addend(gsym, elfcpp::R_386_IRELATIVE,
1111 this->got_irelative_, got_offset);
7223e9ca
ILT		 1112 struct Global_ifunc gi;
1113 gi.sym = gsym;
1114 gi.got_offset = got_offset;
1115 this->global_ifuncs_.push_back(gi);
1116 }
1117 else
1118 {
67181c72
ILT		 1119 // When setting the PLT offset we skip the initial reserved PLT
1120 // entry.
2e702c99 1121 gsym->set_plt_offset((this->count_ + 1) * this->get_plt_entry_size());
67181c72
ILT		 1122
1123 ++this->count_;
1124
1125 section_offset_type got_offset = this->got_plt_->current_data_size();
1126
1127 // Every PLT entry needs a GOT entry which points back to the
1128 // PLT entry (this will be changed by the dynamic linker,
1129 // normally lazily when the function is called).
1130 this->got_plt_->set_current_data_size(got_offset + 4);
1131
7223e9ca
ILT		 1132 gsym->set_needs_dynsym_entry();
1133 this->rel_->add_global(gsym, elfcpp::R_386_JUMP_SLOT, this->got_plt_,
1134 got_offset);
1135 }
a3ad94ed
ILT		 1136
1137 // Note that we don't need to save the symbol. The contents of the
1138 // PLT are independent of which symbols are used. The symbols only
1139 // appear in the relocations.
1140}
1141
7223e9ca
ILT		 1142// Add an entry to the PLT for a local STT_GNU_IFUNC symbol. Return
1143// the PLT offset.
1144
1145unsigned int
6fa2a40b 1146Output_data_plt_i386::add_local_ifunc_entry(
67181c72
ILT		 1147 Symbol_table* symtab,
1148 Layout* layout,
6fa2a40b
CC		 1149 Sized_relobj_file<32, false>* relobj,
1150 unsigned int local_sym_index)
7223e9ca 1151{
2e702c99 1152 unsigned int plt_offset = this->irelative_count_ * this->get_plt_entry_size();
67181c72 1153 ++this->irelative_count_;
7223e9ca 1154
67181c72 1155 section_offset_type got_offset = this->got_irelative_->current_data_size();
7223e9ca
ILT		 1156
1157 // Every PLT entry needs a GOT entry which points back to the PLT
1158 // entry.
67181c72 1159 this->got_irelative_->set_current_data_size(got_offset + 4);
7223e9ca
ILT		 1160
1161 // Every PLT entry needs a reloc.
67181c72
ILT		 1162 Reloc_section* rel = this->rel_irelative(symtab, layout);
1163 rel->add_symbolless_local_addend(relobj, local_sym_index,
1164 elfcpp::R_386_IRELATIVE,
1165 this->got_irelative_, got_offset);
7223e9ca
ILT		 1166
1167 struct Local_ifunc li;
1168 li.object = relobj;
1169 li.local_sym_index = local_sym_index;
1170 li.got_offset = got_offset;
1171 this->local_ifuncs_.push_back(li);
1172
1173 return plt_offset;
1174}
1175
e291e7b9
ILT		 1176// Return where the TLS_DESC relocations should go, creating it if
1177// necessary. These follow the JUMP_SLOT relocations.
1178
1179Output_data_plt_i386::Reloc_section*
1180Output_data_plt_i386::rel_tls_desc(Layout* layout)
1181{
1182 if (this->tls_desc_rel_ == NULL)
1183 {
1184 this->tls_desc_rel_ = new Reloc_section(false);
1185 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
1186 elfcpp::SHF_ALLOC, this->tls_desc_rel_,
22f0da72 1187 ORDER_DYNAMIC_PLT_RELOCS, false);
67181c72
ILT		 1188 gold_assert(this->tls_desc_rel_->output_section()
1189 == this->rel_->output_section());
e291e7b9
ILT		 1190 }
1191 return this->tls_desc_rel_;
1192}
1193
67181c72
ILT		 1194// Return where the IRELATIVE relocations should go in the PLT. These
1195// follow the JUMP_SLOT and TLS_DESC relocations.
1196
1197Output_data_plt_i386::Reloc_section*
1198Output_data_plt_i386::rel_irelative(Symbol_table* symtab, Layout* layout)
1199{
1200 if (this->irelative_rel_ == NULL)
1201 {
1202 // Make sure we have a place for the TLS_DESC relocations, in
1203 // case we see any later on.
1204 this->rel_tls_desc(layout);
1205 this->irelative_rel_ = new Reloc_section(false);
1206 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
1207 elfcpp::SHF_ALLOC, this->irelative_rel_,
1208 ORDER_DYNAMIC_PLT_RELOCS, false);
1209 gold_assert(this->irelative_rel_->output_section()
1210 == this->rel_->output_section());
1211
1212 if (parameters->doing_static_link())
1213 {
1214 // A statically linked executable will only have a .rel.plt
1215 // section to hold R_386_IRELATIVE relocs for STT_GNU_IFUNC
1216 // symbols. The library will use these symbols to locate
1217 // the IRELATIVE relocs at program startup time.
1218 symtab->define_in_output_data("__rel_iplt_start", NULL,
1219 Symbol_table::PREDEFINED,
1220 this->irelative_rel_, 0, 0,
1221 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1222 elfcpp::STV_HIDDEN, 0, false, true);
1223 symtab->define_in_output_data("__rel_iplt_end", NULL,
1224 Symbol_table::PREDEFINED,
1225 this->irelative_rel_, 0, 0,
1226 elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL,
1227 elfcpp::STV_HIDDEN, 0, true, true);
1228 }
1229 }
1230 return this->irelative_rel_;
1231}
1232
1233// Return the PLT address to use for a global symbol.
1234
1235uint64_t
1236Output_data_plt_i386::address_for_global(const Symbol* gsym)
1237{
1238 uint64_t offset = 0;
1239 if (gsym->type() == elfcpp::STT_GNU_IFUNC
1240 && gsym->can_use_relative_reloc(false))
2e702c99 1241 offset = (this->count_ + 1) * this->get_plt_entry_size();
19fec8c1 1242 return this->address() + offset + gsym->plt_offset();
67181c72
ILT		 1243}
1244
1245// Return the PLT address to use for a local symbol. These are always
1246// IRELATIVE relocs.
1247
1248uint64_t
19fec8c1
AM		 1249Output_data_plt_i386::address_for_local(const Relobj* object,
1250 unsigned int r_sym)
67181c72 1251{
19fec8c1
AM		 1252 return (this->address()
1253 + (this->count_ + 1) * this->get_plt_entry_size()
1254 + object->local_plt_offset(r_sym));
67181c72
ILT		 1255}
1256
a3ad94ed
ILT		 1257// The first entry in the PLT for an executable.
1258
2e702c99 1259const unsigned char Output_data_plt_i386_exec::first_plt_entry[plt_entry_size] =
a3ad94ed
ILT		 1260{
1261 0xff, 0x35, // pushl contents of memory address
1262 0, 0, 0, 0, // replaced with address of .got + 4
1263 0xff, 0x25, // jmp indirect
1264 0, 0, 0, 0, // replaced with address of .got + 8
1265 0, 0, 0, 0 // unused
1266};
1267
2e702c99
RM		 1268void
1269Output_data_plt_i386_exec::do_fill_first_plt_entry(
1270 unsigned char* pov,
1271 elfcpp::Elf_types<32>::Elf_Addr got_address)
1272{
1273 memcpy(pov, first_plt_entry, plt_entry_size);
1274 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
1275 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
1276}
1277
a3ad94ed
ILT		 1278// The first entry in the PLT for a shared object.
1279
2e702c99 1280const unsigned char Output_data_plt_i386_dyn::first_plt_entry[plt_entry_size] =
a3ad94ed
ILT		 1281{
1282 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx)
1283 0xff, 0xa3, 8, 0, 0, 0, // jmp *8(%ebx)
1284 0, 0, 0, 0 // unused
1285};
1286
2e702c99
RM		 1287void
1288Output_data_plt_i386_dyn::do_fill_first_plt_entry(
1289 unsigned char* pov,
1290 elfcpp::Elf_types<32>::Elf_Addr)
1291{
1292 memcpy(pov, first_plt_entry, plt_entry_size);
1293}
1294
a3ad94ed
ILT		 1295// Subsequent entries in the PLT for an executable.
1296
2e702c99 1297const unsigned char Output_data_plt_i386_exec::plt_entry[plt_entry_size] =
a3ad94ed
ILT		 1298{
1299 0xff, 0x25, // jmp indirect
1300 0, 0, 0, 0, // replaced with address of symbol in .got
1301 0x68, // pushl immediate
1302 0, 0, 0, 0, // replaced with offset into relocation table
1303 0xe9, // jmp relative
1304 0, 0, 0, 0 // replaced with offset to start of .plt
1305};
1306
2e702c99
RM		 1307unsigned int
1308Output_data_plt_i386_exec::do_fill_plt_entry(
1309 unsigned char* pov,
1310 elfcpp::Elf_types<32>::Elf_Addr got_address,
1311 unsigned int got_offset,
1312 unsigned int plt_offset,
1313 unsigned int plt_rel_offset)
1314{
1315 memcpy(pov, plt_entry, plt_entry_size);
1316 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
1317 got_address + got_offset);
1318 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset);
1319 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4));
1320 return 6;
1321}
1322
a3ad94ed
ILT		 1323// Subsequent entries in the PLT for a shared object.
1324
2e702c99 1325const unsigned char Output_data_plt_i386_dyn::plt_entry[plt_entry_size] =
a3ad94ed
ILT		 1326{
1327 0xff, 0xa3, // jmp *offset(%ebx)
1328 0, 0, 0, 0, // replaced with offset of symbol in .got
1329 0x68, // pushl immediate
1330 0, 0, 0, 0, // replaced with offset into relocation table
1331 0xe9, // jmp relative
1332 0, 0, 0, 0 // replaced with offset to start of .plt
1333};
1334
2e702c99
RM		 1335unsigned int
1336Output_data_plt_i386_dyn::do_fill_plt_entry(unsigned char* pov,
1337 elfcpp::Elf_types<32>::Elf_Addr,
1338 unsigned int got_offset,
1339 unsigned int plt_offset,
1340 unsigned int plt_rel_offset)
1341{
1342 memcpy(pov, plt_entry, plt_entry_size);
1343 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
1344 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset);
1345 elfcpp::Swap<32, false>::writeval(pov + 12, - (plt_offset + 12 + 4));
1346 return 6;
1347}
1348
07a60597
ILT		 1349// The .eh_frame unwind information for the PLT.
1350
1351const unsigned char
1352Output_data_plt_i386::plt_eh_frame_cie[plt_eh_frame_cie_size] =
1353{
1354 1, // CIE version.
1355 'z', // Augmentation: augmentation size included.
1356 'R', // Augmentation: FDE encoding included.
1357 '\0', // End of augmentation string.
1358 1, // Code alignment factor.
1359 0x7c, // Data alignment factor.
1360 8, // Return address column.
1361 1, // Augmentation size.
1362 (elfcpp::DW_EH_PE_pcrel // FDE encoding.
1363 | elfcpp::DW_EH_PE_sdata4),
1364 elfcpp::DW_CFA_def_cfa, 4, 4, // DW_CFA_def_cfa: r4 (esp) ofs 4.
1365 elfcpp::DW_CFA_offset + 8, 1, // DW_CFA_offset: r8 (eip) at cfa-4.
1366 elfcpp::DW_CFA_nop, // Align to 16 bytes.
1367 elfcpp::DW_CFA_nop
1368};
1369
1370const unsigned char
2e702c99 1371Output_data_plt_i386_standard::plt_eh_frame_fde[plt_eh_frame_fde_size] =
07a60597
ILT		 1372{
1373 0, 0, 0, 0, // Replaced with offset to .plt.
1374 0, 0, 0, 0, // Replaced with size of .plt.
1375 0, // Augmentation size.
1376 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8.
1377 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
1378 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12.
1379 elfcpp::DW_CFA_advance_loc + 10, // Advance 10 to __PLT__ + 16.
1380 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
1381 11, // Block length.
1382 elfcpp::DW_OP_breg4, 4, // Push %esp + 4.
1383 elfcpp::DW_OP_breg8, 0, // Push %eip.
1384 elfcpp::DW_OP_lit15, // Push 0xf.
1385 elfcpp::DW_OP_and, // & (%eip & 0xf).
1386 elfcpp::DW_OP_lit11, // Push 0xb.
1387 elfcpp::DW_OP_ge, // >= ((%eip & 0xf) >= 0xb)
1388 elfcpp::DW_OP_lit2, // Push 2.
1389 elfcpp::DW_OP_shl, // << (((%eip & 0xf) >= 0xb) << 2)
491f21ca 1390 elfcpp::DW_OP_plus, // + ((((%eip&0xf)>=0xb)<<2)+%esp+4
07a60597
ILT		 1391 elfcpp::DW_CFA_nop, // Align to 32 bytes.
1392 elfcpp::DW_CFA_nop,
1393 elfcpp::DW_CFA_nop,
1394 elfcpp::DW_CFA_nop
1395};
1396
a3ad94ed
ILT		 1397// Write out the PLT. This uses the hand-coded instructions above,
1398// and adjusts them as needed. This is all specified by the i386 ELF
1399// Processor Supplement.
1400
1401void
1402Output_data_plt_i386::do_write(Output_file* of)
1403{
2ea97941 1404 const off_t offset = this->offset();
fe8718a4
ILT		 1405 const section_size_type oview_size =
1406 convert_to_section_size_type(this->data_size());
2ea97941 1407 unsigned char* const oview = of->get_output_view(offset, oview_size);
a3ad94ed
ILT		 1408
1409 const off_t got_file_offset = this->got_plt_->offset();
67181c72
ILT		 1410 gold_assert(parameters->incremental_update()
1411 || (got_file_offset + this->got_plt_->data_size()
1412 == this->got_irelative_->offset()));
fe8718a4 1413 const section_size_type got_size =
67181c72
ILT		 1414 convert_to_section_size_type(this->got_plt_->data_size()
1415 + this->got_irelative_->data_size());
57b2284c 1416
a3ad94ed
ILT		 1417 unsigned char* const got_view = of->get_output_view(got_file_offset,
1418 got_size);
1419
1420 unsigned char* pov = oview;
1421
1422 elfcpp::Elf_types<32>::Elf_Addr plt_address = this->address();
1423 elfcpp::Elf_types<32>::Elf_Addr got_address = this->got_plt_->address();
1424
2e702c99
RM		 1425 this->fill_first_plt_entry(pov, got_address);
1426 pov += this->get_plt_entry_size();
a3ad94ed 1427
57b2284c
CC		 1428 // The first three entries in the GOT are reserved, and are written
1429 // by Output_data_got_plt_i386::do_write.
1430 unsigned char* got_pov = got_view + 12;
a3ad94ed
ILT		 1431
1432 const int rel_size = elfcpp::Elf_sizes<32>::rel_size;
1433
2e702c99 1434 unsigned int plt_offset = this->get_plt_entry_size();
a3ad94ed
ILT		 1435 unsigned int plt_rel_offset = 0;
1436 unsigned int got_offset = 12;
67181c72 1437 const unsigned int count = this->count_ + this->irelative_count_;
a3ad94ed
ILT		 1438 for (unsigned int i = 0;
1439 i < count;
1440 ++i,
2e702c99 1441 pov += this->get_plt_entry_size(),
a3ad94ed 1442 got_pov += 4,
2e702c99 1443 plt_offset += this->get_plt_entry_size(),
a3ad94ed
ILT		 1444 plt_rel_offset += rel_size,
1445 got_offset += 4)
1446 {
1447 // Set and adjust the PLT entry itself.
2e702c99
RM		 1448 unsigned int lazy_offset = this->fill_plt_entry(pov,
1449 got_address,
1450 got_offset,
1451 plt_offset,
1452 plt_rel_offset);
a3ad94ed
ILT		 1453
1454 // Set the entry in the GOT.
2e702c99
RM		 1455 elfcpp::Swap<32, false>::writeval(got_pov,
1456 plt_address + plt_offset + lazy_offset);
a3ad94ed
ILT		 1457 }
1458
7223e9ca
ILT		 1459 // If any STT_GNU_IFUNC symbols have PLT entries, we need to change
1460 // the GOT to point to the actual symbol value, rather than point to
1461 // the PLT entry. That will let the dynamic linker call the right
1462 // function when resolving IRELATIVE relocations.
67181c72 1463 unsigned char* got_irelative_view = got_view + this->got_plt_->data_size();
7223e9ca
ILT		 1464 for (std::vector<Global_ifunc>::const_iterator p =
1465 this->global_ifuncs_.begin();
1466 p != this->global_ifuncs_.end();
1467 ++p)
1468 {
1469 const Sized_symbol<32>* ssym =
1470 static_cast<const Sized_symbol<32>*>(p->sym);
67181c72 1471 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset,
7223e9ca
ILT		 1472 ssym->value());
1473 }
1474
1475 for (std::vector<Local_ifunc>::const_iterator p =
1476 this->local_ifuncs_.begin();
1477 p != this->local_ifuncs_.end();
1478 ++p)
1479 {
1480 const Symbol_value<32>* psymval =
1481 p->object->local_symbol(p->local_sym_index);
67181c72 1482 elfcpp::Swap<32, false>::writeval(got_irelative_view + p->got_offset,
7223e9ca
ILT		 1483 psymval->value(p->object, 0));
1484 }
1485
fe8718a4
ILT		 1486 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
1487 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
a3ad94ed 1488
2ea97941 1489 of->write_output_view(offset, oview_size, oview);
a3ad94ed
ILT		 1490 of->write_output_view(got_file_offset, got_size, got_view);
1491}
1492
7223e9ca 1493// Create the PLT section.
a3ad94ed
ILT		 1494
1495void
7223e9ca 1496Target_i386::make_plt_section(Symbol_table* symtab, Layout* layout)
a3ad94ed 1497{
a3ad94ed
ILT		 1498 if (this->plt_ == NULL)
1499 {
1500 // Create the GOT sections first.
7e1edb90 1501 this->got_section(symtab, layout);
a3ad94ed 1502
2e702c99
RM		 1503 const bool dyn = parameters->options().output_is_position_independent();
1504 this->plt_ = this->make_data_plt(layout,
1505 this->got_plt_,
1506 this->got_irelative_,
1507 dyn);
1508
1509 // Add unwind information if requested.
1510 if (parameters->options().ld_generated_unwind_info())
1511 this->plt_->add_eh_frame(layout);
1512
16649710
ILT		 1513 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
1514 (elfcpp::SHF_ALLOC
1515 | elfcpp::SHF_EXECINSTR),
22f0da72 1516 this->plt_, ORDER_PLT, false);
7223e9ca
ILT		 1517
1518 // Make the sh_info field of .rel.plt point to .plt.
1519 Output_section* rel_plt_os = this->plt_->rel_plt()->output_section();
1520 rel_plt_os->set_info_section(this->plt_->output_section());
a3ad94ed 1521 }
7223e9ca 1522}
a3ad94ed 1523
7223e9ca
ILT		 1524// Create a PLT entry for a global symbol.
1525
1526void
1527Target_i386::make_plt_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym)
1528{
1529 if (gsym->has_plt_offset())
1530 return;
1531 if (this->plt_ == NULL)
1532 this->make_plt_section(symtab, layout);
67181c72 1533 this->plt_->add_entry(symtab, layout, gsym);
a3ad94ed
ILT		 1534}
1535
7223e9ca
ILT		 1536// Make a PLT entry for a local STT_GNU_IFUNC symbol.
1537
1538void
1539Target_i386::make_local_ifunc_plt_entry(Symbol_table* symtab, Layout* layout,
6fa2a40b 1540 Sized_relobj_file<32, false>* relobj,
7223e9ca
ILT		 1541 unsigned int local_sym_index)
1542{
1543 if (relobj->local_has_plt_offset(local_sym_index))
1544 return;
1545 if (this->plt_ == NULL)
1546 this->make_plt_section(symtab, layout);
67181c72
ILT		 1547 unsigned int plt_offset = this->plt_->add_local_ifunc_entry(symtab, layout,
1548 relobj,
7223e9ca
ILT		 1549 local_sym_index);
1550 relobj->set_local_plt_offset(local_sym_index, plt_offset);
1551}
1552
0e70b911
CC		 1553// Return the number of entries in the PLT.
1554
1555unsigned int
1556Target_i386::plt_entry_count() const
1557{
1558 if (this->plt_ == NULL)
1559 return 0;
1560 return this->plt_->entry_count();
1561}
1562
1563// Return the offset of the first non-reserved PLT entry.
1564
1565unsigned int
1566Target_i386::first_plt_entry_offset() const
1567{
2e702c99 1568 return this->plt_->first_plt_entry_offset();
0e70b911
CC		 1569}
1570
1571// Return the size of each PLT entry.
1572
1573unsigned int
1574Target_i386::plt_entry_size() const
1575{
2e702c99 1576 return this->plt_->get_plt_entry_size();
0e70b911
CC		 1577}
1578
e291e7b9
ILT		 1579// Get the section to use for TLS_DESC relocations.
1580
1581Target_i386::Reloc_section*
1582Target_i386::rel_tls_desc_section(Layout* layout) const
1583{
1584 return this->plt_section()->rel_tls_desc(layout);
1585}
1586
9fa33bee 1587// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC		 1588
1589void
1590Target_i386::define_tls_base_symbol(Symbol_table* symtab, Layout* layout)
1591{
1592 if (this->tls_base_symbol_defined_)
1593 return;
1594
1595 Output_segment* tls_segment = layout->tls_segment();
1596 if (tls_segment != NULL)
1597 {
183fd0e3 1598 bool is_exec = parameters->options().output_is_executable();
edfbb029 1599 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
99fff23b 1600 Symbol_table::PREDEFINED,
edfbb029
CC		 1601 tls_segment, 0, 0,
1602 elfcpp::STT_TLS,
1603 elfcpp::STB_LOCAL,
1604 elfcpp::STV_HIDDEN, 0,
183fd0e3
AO		 1605 (is_exec
1606 ? Symbol::SEGMENT_END
1607 : Symbol::SEGMENT_START),
1608 true);
edfbb029
CC		 1609 }
1610 this->tls_base_symbol_defined_ = true;
1611}
1612
94c4710f
ILT		 1613// Create a GOT entry for the TLS module index.
1614
1615unsigned int
1616Target_i386::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
2e702c99 1617 Sized_relobj_file<32, false>* object)
94c4710f
ILT		 1618{
1619 if (this->got_mod_index_offset_ == -1U)
1620 {
1621 gold_assert(symtab != NULL && layout != NULL && object != NULL);
1622 Reloc_section* rel_dyn = this->rel_dyn_section(layout);
1623 Output_data_got<32, false>* got = this->got_section(symtab, layout);
1624 unsigned int got_offset = got->add_constant(0);
1625 rel_dyn->add_local(object, 0, elfcpp::R_386_TLS_DTPMOD32, got,
2e702c99 1626 got_offset);
009a67a2 1627 got->add_constant(0);
94c4710f
ILT		 1628 this->got_mod_index_offset_ = got_offset;
1629 }
1630 return this->got_mod_index_offset_;
1631}
1632
92e059d8 1633// Optimize the TLS relocation type based on what we know about the
a3ad94ed
ILT		 1634// symbol. IS_FINAL is true if the final address of this symbol is
1635// known at link time.
92e059d8 1636
af6359d5 1637tls::Tls_optimization
7e1edb90 1638Target_i386::optimize_tls_reloc(bool is_final, int r_type)
92e059d8
ILT		 1639{
1640 // If we are generating a shared library, then we can't do anything
1641 // in the linker.
8851ecca 1642 if (parameters->options().shared())
af6359d5 1643 return tls::TLSOPT_NONE;
92e059d8
ILT		 1644
1645 switch (r_type)
1646 {
1647 case elfcpp::R_386_TLS_GD:
1648 case elfcpp::R_386_TLS_GOTDESC:
1649 case elfcpp::R_386_TLS_DESC_CALL:
e041f13d 1650 // These are General-Dynamic which permits fully general TLS
92e059d8
ILT		 1651 // access. Since we know that we are generating an executable,
1652 // we can convert this to Initial-Exec. If we also know that
1653 // this is a local symbol, we can further switch to Local-Exec.
a3ad94ed 1654 if (is_final)
af6359d5
ILT		 1655 return tls::TLSOPT_TO_LE;
1656 return tls::TLSOPT_TO_IE;
92e059d8
ILT		 1657
1658 case elfcpp::R_386_TLS_LDM:
1659 // This is Local-Dynamic, which refers to a local symbol in the
1660 // dynamic TLS block. Since we know that we generating an
1661 // executable, we can switch to Local-Exec.
af6359d5 1662 return tls::TLSOPT_TO_LE;
92e059d8
ILT		 1663
1664 case elfcpp::R_386_TLS_LDO_32:
af6359d5
ILT		 1665 // Another type of Local-Dynamic relocation.
1666 return tls::TLSOPT_TO_LE;
92e059d8
ILT		 1667
1668 case elfcpp::R_386_TLS_IE:
1669 case elfcpp::R_386_TLS_GOTIE:
1670 case elfcpp::R_386_TLS_IE_32:
1671 // These are Initial-Exec relocs which get the thread offset
1672 // from the GOT. If we know that we are linking against the
1673 // local symbol, we can switch to Local-Exec, which links the
1674 // thread offset into the instruction.
a3ad94ed 1675 if (is_final)
af6359d5
ILT		 1676 return tls::TLSOPT_TO_LE;
1677 return tls::TLSOPT_NONE;
8462ae85 1678
92e059d8
ILT		 1679 case elfcpp::R_386_TLS_LE:
1680 case elfcpp::R_386_TLS_LE_32:
1681 // When we already have Local-Exec, there is nothing further we
1682 // can do.
af6359d5 1683 return tls::TLSOPT_NONE;
92e059d8
ILT		 1684
1685 default:
a3ad94ed 1686 gold_unreachable();
92e059d8
ILT		 1687 }
1688}
1689
95a2c8d6 1690// Get the Reference_flags for a particular relocation.
af6359d5 1691
95a2c8d6
RS		 1692int
1693Target_i386::Scan::get_reference_flags(unsigned int r_type)
7223e9ca
ILT		 1694{
1695 switch (r_type)
1696 {
1697 case elfcpp::R_386_NONE:
1698 case elfcpp::R_386_GNU_VTINHERIT:
1699 case elfcpp::R_386_GNU_VTENTRY:
95a2c8d6
RS		 1700 case elfcpp::R_386_GOTPC:
1701 // No symbol reference.
1702 return 0;
7223e9ca
ILT		 1703
1704 case elfcpp::R_386_32:
1705 case elfcpp::R_386_16:
1706 case elfcpp::R_386_8:
95a2c8d6
RS		 1707 return Symbol::ABSOLUTE_REF;
1708
7223e9ca
ILT		 1709 case elfcpp::R_386_PC32:
1710 case elfcpp::R_386_PC16:
1711 case elfcpp::R_386_PC8:
7223e9ca 1712 case elfcpp::R_386_GOTOFF:
95a2c8d6
RS		 1713 return Symbol::RELATIVE_REF;
1714
1715 case elfcpp::R_386_PLT32:
1716 return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
1717
7223e9ca 1718 case elfcpp::R_386_GOT32:
493d4b48 1719 case elfcpp::R_386_GOT32X:
95a2c8d6
RS		 1720 // Absolute in GOT.
1721 return Symbol::ABSOLUTE_REF;
1722
1723 case elfcpp::R_386_TLS_GD: // Global-dynamic
1724 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1725 case elfcpp::R_386_TLS_DESC_CALL:
1726 case elfcpp::R_386_TLS_LDM: // Local-dynamic
1727 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
1728 case elfcpp::R_386_TLS_IE: // Initial-exec
1729 case elfcpp::R_386_TLS_IE_32:
1730 case elfcpp::R_386_TLS_GOTIE:
1731 case elfcpp::R_386_TLS_LE: // Local-exec
1732 case elfcpp::R_386_TLS_LE_32:
1733 return Symbol::TLS_REF;
7223e9ca
ILT		 1734
1735 case elfcpp::R_386_COPY:
1736 case elfcpp::R_386_GLOB_DAT:
1737 case elfcpp::R_386_JUMP_SLOT:
1738 case elfcpp::R_386_RELATIVE:
1739 case elfcpp::R_386_IRELATIVE:
1740 case elfcpp::R_386_TLS_TPOFF:
1741 case elfcpp::R_386_TLS_DTPMOD32:
1742 case elfcpp::R_386_TLS_DTPOFF32:
1743 case elfcpp::R_386_TLS_TPOFF32:
1744 case elfcpp::R_386_TLS_DESC:
7223e9ca
ILT		 1745 case elfcpp::R_386_32PLT:
1746 case elfcpp::R_386_TLS_GD_32:
1747 case elfcpp::R_386_TLS_GD_PUSH:
1748 case elfcpp::R_386_TLS_GD_CALL:
1749 case elfcpp::R_386_TLS_GD_POP:
1750 case elfcpp::R_386_TLS_LDM_32:
1751 case elfcpp::R_386_TLS_LDM_PUSH:
1752 case elfcpp::R_386_TLS_LDM_CALL:
1753 case elfcpp::R_386_TLS_LDM_POP:
1754 case elfcpp::R_386_USED_BY_INTEL_200:
1755 default:
95a2c8d6
RS		 1756 // Not expected. We will give an error later.
1757 return 0;
7223e9ca
ILT		 1758 }
1759}
1760
95a2c8d6
RS		 1761// Report an unsupported relocation against a local symbol.
1762
1763void
6fa2a40b 1764Target_i386::Scan::unsupported_reloc_local(Sized_relobj_file<32, false>* object,
95a2c8d6
RS		 1765 unsigned int r_type)
1766{
1767 gold_error(_("%s: unsupported reloc %u against local symbol"),
1768 object->name().c_str(), r_type);
1769}
1770
1771// Return whether we need to make a PLT entry for a relocation of a
1772// given type against a STT_GNU_IFUNC symbol.
1773
1774bool
6fa2a40b
CC		 1775Target_i386::Scan::reloc_needs_plt_for_ifunc(
1776 Sized_relobj_file<32, false>* object,
1777 unsigned int r_type)
95a2c8d6
RS		 1778{
1779 int flags = Scan::get_reference_flags(r_type);
1780 if (flags & Symbol::TLS_REF)
1781 gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
2e702c99 1782 object->name().c_str(), r_type);
95a2c8d6
RS		 1783 return flags != 0;
1784}
1785
92e059d8
ILT		 1786// Scan a relocation for a local symbol.
1787
1788inline void
ad0f2072 1789Target_i386::Scan::local(Symbol_table* symtab,
bfdfa4cd
AM		 1790 Layout* layout,
1791 Target_i386* target,
1792 Sized_relobj_file<32, false>* object,
1793 unsigned int data_shndx,
1794 Output_section* output_section,
1795 const elfcpp::Rel<32, false>& reloc,
1796 unsigned int r_type,
1797 const elfcpp::Sym<32, false>& lsym,
1798 bool is_discarded)
92e059d8 1799{
bfdfa4cd
AM		 1800 if (is_discarded)
1801 return;
1802
7223e9ca
ILT		 1803 // A local STT_GNU_IFUNC symbol may require a PLT entry.
1804 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC
1805 && this->reloc_needs_plt_for_ifunc(object, r_type))
1806 {
1807 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1808 target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
1809 }
1810
92e059d8
ILT		 1811 switch (r_type)
1812 {
1813 case elfcpp::R_386_NONE:
1814 case elfcpp::R_386_GNU_VTINHERIT:
1815 case elfcpp::R_386_GNU_VTENTRY:
1816 break;
1817
1818 case elfcpp::R_386_32:
436ca963
ILT		 1819 // If building a shared library (or a position-independent
1820 // executable), we need to create a dynamic relocation for
1821 // this location. The relocation applied at link time will
1822 // apply the link-time value, so we flag the location with
1823 // an R_386_RELATIVE relocation so the dynamic loader can
1824 // relocate it easily.
8851ecca 1825 if (parameters->options().output_is_position_independent())
2e702c99
RM		 1826 {
1827 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1828 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
7223e9ca
ILT		 1829 rel_dyn->add_local_relative(object, r_sym, elfcpp::R_386_RELATIVE,
1830 output_section, data_shndx,
1831 reloc.get_r_offset());
2e702c99 1832 }
d61c6bd4
ILT		 1833 break;
1834
1835 case elfcpp::R_386_16:
1836 case elfcpp::R_386_8:
1837 // If building a shared library (or a position-independent
1838 // executable), we need to create a dynamic relocation for
1839 // this location. Because the addend needs to remain in the
1840 // data section, we need to be careful not to apply this
1841 // relocation statically.
8851ecca 1842 if (parameters->options().output_is_position_independent())
2e702c99
RM		 1843 {
1844 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
d491d34e 1845 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2e702c99 1846 if (lsym.get_st_type() != elfcpp::STT_SECTION)
d491d34e
ILT		 1847 rel_dyn->add_local(object, r_sym, r_type, output_section,
1848 data_shndx, reloc.get_r_offset());
2e702c99
RM		 1849 else
1850 {
1851 gold_assert(lsym.get_st_value() == 0);
d491d34e
ILT		 1852 unsigned int shndx = lsym.get_st_shndx();
1853 bool is_ordinary;
1854 shndx = object->adjust_sym_shndx(r_sym, shndx,
1855 &is_ordinary);
1856 if (!is_ordinary)
1857 object->error(_("section symbol %u has bad shndx %u"),
1858 r_sym, shndx);
1859 else
1860 rel_dyn->add_local_section(object, shndx,
1861 r_type, output_section,
1862 data_shndx, reloc.get_r_offset());
2e702c99
RM		 1863 }
1864 }
92e059d8
ILT		 1865 break;
1866
1867 case elfcpp::R_386_PC32:
1868 case elfcpp::R_386_PC16:
1869 case elfcpp::R_386_PC8:
1870 break;
1871
df2efe71
ILT		 1872 case elfcpp::R_386_PLT32:
1873 // Since we know this is a local symbol, we can handle this as a
1874 // PC32 reloc.
1875 break;
1876
ead1e424
ILT		 1877 case elfcpp::R_386_GOTOFF:
1878 case elfcpp::R_386_GOTPC:
1879 // We need a GOT section.
7e1edb90 1880 target->got_section(symtab, layout);
ead1e424
ILT		 1881 break;
1882
1b64748b 1883 case elfcpp::R_386_GOT32:
493d4b48 1884 case elfcpp::R_386_GOT32X:
1b64748b 1885 {
c4fc4724 1886 // We need GOT section.
2e702c99 1887 Output_data_got<32, false>* got = target->got_section(symtab, layout);
c4fc4724
IT		 1888
1889 // If the relocation symbol isn't IFUNC,
1890 // and is local, then we will convert
1891 // mov foo@GOT(%reg), %reg
1892 // to
1893 // lea foo@GOTOFF(%reg), %reg
1894 // in Relocate::relocate.
1895 if (reloc.get_r_offset() >= 2
1896 && lsym.get_st_type() != elfcpp::STT_GNU_IFUNC)
1897 {
1898 section_size_type stype;
1899 const unsigned char* view = object->section_contents(data_shndx,
1900 &stype, true);
1901 if (view[reloc.get_r_offset() - 2] == 0x8b)
1902 break;
1903 }
1904
1905 // Otherwise, the symbol requires a GOT entry.
2e702c99 1906 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
7223e9ca
ILT		 1907
1908 // For a STT_GNU_IFUNC symbol we want the PLT offset. That
1909 // lets function pointers compare correctly with shared
1910 // libraries. Otherwise we would need an IRELATIVE reloc.
1911 bool is_new;
1912 if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1913 is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
1914 else
1915 is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
2e702c99
RM		 1916 if (is_new)
1917 {
1918 // If we are generating a shared object, we need to add a
1919 // dynamic RELATIVE relocation for this symbol's GOT entry.
1920 if (parameters->options().output_is_position_independent())
1921 {
1922 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
7223e9ca
ILT		 1923 unsigned int got_offset =
1924 object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1925 rel_dyn->add_local_relative(object, r_sym,
1926 elfcpp::R_386_RELATIVE,
1927 got, got_offset);
2e702c99
RM		 1928 }
1929 }
1b64748b
ILT		 1930 }
1931 break;
1932
af6359d5
ILT		 1933 // These are relocations which should only be seen by the
1934 // dynamic linker, and should never be seen here.
92e059d8
ILT		 1935 case elfcpp::R_386_COPY:
1936 case elfcpp::R_386_GLOB_DAT:
1937 case elfcpp::R_386_JUMP_SLOT:
1938 case elfcpp::R_386_RELATIVE:
7223e9ca 1939 case elfcpp::R_386_IRELATIVE:
92e059d8
ILT		 1940 case elfcpp::R_386_TLS_TPOFF:
1941 case elfcpp::R_386_TLS_DTPMOD32:
1942 case elfcpp::R_386_TLS_DTPOFF32:
1943 case elfcpp::R_386_TLS_TPOFF32:
1944 case elfcpp::R_386_TLS_DESC:
a0c4fb0a 1945 gold_error(_("%s: unexpected reloc %u in object file"),
75f2446e 1946 object->name().c_str(), r_type);
92e059d8
ILT		 1947 break;
1948
af6359d5 1949 // These are initial TLS relocs, which are expected when
d61c17ea 1950 // linking.
56622147
ILT		 1951 case elfcpp::R_386_TLS_GD: // Global-dynamic
1952 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1953 case elfcpp::R_386_TLS_DESC_CALL:
1954 case elfcpp::R_386_TLS_LDM: // Local-dynamic
1955 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
1956 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 1957 case elfcpp::R_386_TLS_IE_32:
56622147
ILT		 1958 case elfcpp::R_386_TLS_GOTIE:
1959 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 1960 case elfcpp::R_386_TLS_LE_32:
7e1edb90 1961 {
8851ecca 1962 bool output_is_shared = parameters->options().shared();
af6359d5 1963 const tls::Tls_optimization optimized_type
2e702c99 1964 = Target_i386::optimize_tls_reloc(!output_is_shared, r_type);
7e1edb90
ILT		 1965 switch (r_type)
1966 {
56622147 1967 case elfcpp::R_386_TLS_GD: // Global-dynamic
07f397ab
ILT		 1968 if (optimized_type == tls::TLSOPT_NONE)
1969 {
2e702c99
RM		 1970 // Create a pair of GOT entries for the module index and
1971 // dtv-relative offset.
1972 Output_data_got<32, false>* got
1973 = target->got_section(symtab, layout);
1974 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
d491d34e
ILT		 1975 unsigned int shndx = lsym.get_st_shndx();
1976 bool is_ordinary;
1977 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1978 if (!is_ordinary)
1979 object->error(_("local symbol %u has bad shndx %u"),
1980 r_sym, shndx);
2e702c99 1981 else
d491d34e
ILT		 1982 got->add_local_pair_with_rel(object, r_sym, shndx,
1983 GOT_TYPE_TLS_PAIR,
1984 target->rel_dyn_section(layout),
bd73a62d 1985 elfcpp::R_386_TLS_DTPMOD32);
07f397ab
ILT		 1986 }
1987 else if (optimized_type != tls::TLSOPT_TO_LE)
1988 unsupported_reloc_local(object, r_type);
1989 break;
1990
56622147 1991 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva)
edfbb029 1992 target->define_tls_base_symbol(symtab, layout);
2e702c99
RM		 1993 if (optimized_type == tls::TLSOPT_NONE)
1994 {
1995 // Create a double GOT entry with an R_386_TLS_DESC
1996 // reloc. The R_386_TLS_DESC reloc is resolved
1997 // lazily, so the GOT entry needs to be in an area in
1998 // .got.plt, not .got. Call got_section to make sure
1999 // the section has been created.
a8df5856 2000 target->got_section(symtab, layout);
2e702c99
RM		 2001 Output_data_got<32, false>* got = target->got_tlsdesc_section();
2002 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
e291e7b9
ILT		 2003 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
2004 {
2005 unsigned int got_offset = got->add_constant(0);
2006 // The local symbol value is stored in the second
2007 // GOT entry.
2008 got->add_local(object, r_sym, GOT_TYPE_TLS_DESC);
2009 // That set the GOT offset of the local symbol to
2010 // point to the second entry, but we want it to
2011 // point to the first.
2012 object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
2013 got_offset);
2014 Reloc_section* rt = target->rel_tls_desc_section(layout);
2015 rt->add_absolute(elfcpp::R_386_TLS_DESC, got, got_offset);
2016 }
2e702c99
RM		 2017 }
2018 else if (optimized_type != tls::TLSOPT_TO_LE)
2019 unsupported_reloc_local(object, r_type);
af6359d5
ILT		 2020 break;
2021
c2b45e22
CC		 2022 case elfcpp::R_386_TLS_DESC_CALL:
2023 break;
2024
56622147 2025 case elfcpp::R_386_TLS_LDM: // Local-dynamic
07f397ab
ILT		 2026 if (optimized_type == tls::TLSOPT_NONE)
2027 {
2e702c99
RM		 2028 // Create a GOT entry for the module index.
2029 target->got_mod_index_entry(symtab, layout, object);
07f397ab
ILT		 2030 }
2031 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5
ILT		 2032 unsupported_reloc_local(object, r_type);
2033 break;
2034
56622147 2035 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
46cf9fa2
ILT		 2036 break;
2037
56622147
ILT		 2038 case elfcpp::R_386_TLS_IE: // Initial-exec
2039 case elfcpp::R_386_TLS_IE_32:
2040 case elfcpp::R_386_TLS_GOTIE:
535890bb 2041 layout->set_has_static_tls();
07f397ab
ILT		 2042 if (optimized_type == tls::TLSOPT_NONE)
2043 {
2e702c99
RM		 2044 // For the R_386_TLS_IE relocation, we need to create a
2045 // dynamic relocation when building a shared library.
2046 if (r_type == elfcpp::R_386_TLS_IE
2047 && parameters->options().shared())
2048 {
2049 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2050 unsigned int r_sym
2051 = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2052 rel_dyn->add_local_relative(object, r_sym,
2053 elfcpp::R_386_RELATIVE,
2054 output_section, data_shndx,
2055 reloc.get_r_offset());
2056 }
2057 // Create a GOT entry for the tp-relative offset.
2058 Output_data_got<32, false>* got
2059 = target->got_section(symtab, layout);
2060 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2061 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
2062 ? elfcpp::R_386_TLS_TPOFF32
2063 : elfcpp::R_386_TLS_TPOFF);
2064 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2065 ? GOT_TYPE_TLS_OFFSET
2066 : GOT_TYPE_TLS_NOFFSET);
2067 got->add_local_with_rel(object, r_sym, got_type,
2068 target->rel_dyn_section(layout),
2069 dyn_r_type);
07f397ab
ILT		 2070 }
2071 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5 2072 unsupported_reloc_local(object, r_type);
7e1edb90 2073 break;
af6359d5 2074
56622147
ILT		 2075 case elfcpp::R_386_TLS_LE: // Local-exec
2076 case elfcpp::R_386_TLS_LE_32:
535890bb 2077 layout->set_has_static_tls();
07f397ab 2078 if (output_is_shared)
7bf1f802 2079 {
2e702c99
RM		 2080 // We need to create a dynamic relocation.
2081 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
2082 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2083 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
2084 ? elfcpp::R_386_TLS_TPOFF32
2085 : elfcpp::R_386_TLS_TPOFF);
2086 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2087 rel_dyn->add_local(object, r_sym, dyn_r_type, output_section,
2088 data_shndx, reloc.get_r_offset());
7bf1f802 2089 }
56622147
ILT		 2090 break;
2091
af6359d5
ILT		 2092 default:
2093 gold_unreachable();
7e1edb90
ILT		 2094 }
2095 }
92e059d8
ILT		 2096 break;
2097
92e059d8
ILT		 2098 case elfcpp::R_386_32PLT:
2099 case elfcpp::R_386_TLS_GD_32:
2100 case elfcpp::R_386_TLS_GD_PUSH:
2101 case elfcpp::R_386_TLS_GD_CALL:
2102 case elfcpp::R_386_TLS_GD_POP:
2103 case elfcpp::R_386_TLS_LDM_32:
2104 case elfcpp::R_386_TLS_LDM_PUSH:
2105 case elfcpp::R_386_TLS_LDM_CALL:
2106 case elfcpp::R_386_TLS_LDM_POP:
2107 case elfcpp::R_386_USED_BY_INTEL_200:
2108 default:
af6359d5 2109 unsupported_reloc_local(object, r_type);
92e059d8
ILT		 2110 break;
2111 }
2112}
2113
af6359d5
ILT		 2114// Report an unsupported relocation against a global symbol.
2115
2116void
6fa2a40b
CC		 2117Target_i386::Scan::unsupported_reloc_global(
2118 Sized_relobj_file<32, false>* object,
2119 unsigned int r_type,
2120 Symbol* gsym)
af6359d5 2121{
75f2446e 2122 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12 2123 object->name().c_str(), r_type, gsym->demangled_name().c_str());
af6359d5
ILT		 2124}
2125
0897ed3b
ST		 2126inline bool
2127Target_i386::Scan::possible_function_pointer_reloc(unsigned int r_type)
2128{
2129 switch (r_type)
2130 {
2131 case elfcpp::R_386_32:
2132 case elfcpp::R_386_16:
2133 case elfcpp::R_386_8:
2134 case elfcpp::R_386_GOTOFF:
2135 case elfcpp::R_386_GOT32:
493d4b48 2136 case elfcpp::R_386_GOT32X:
0897ed3b 2137 {
2e702c99 2138 return true;
0897ed3b
ST		 2139 }
2140 default:
2141 return false;
2142 }
2143 return false;
2144}
2145
2146inline bool
2147Target_i386::Scan::local_reloc_may_be_function_pointer(
2148 Symbol_table* ,
2149 Layout* ,
2150 Target_i386* ,
6fa2a40b 2151 Sized_relobj_file<32, false>* ,
0897ed3b
ST		 2152 unsigned int ,
2153 Output_section* ,
2154 const elfcpp::Rel<32, false>& ,
2155 unsigned int r_type,
2156 const elfcpp::Sym<32, false>&)
2157{
2158 return possible_function_pointer_reloc(r_type);
2159}
2160
2161inline bool
2162Target_i386::Scan::global_reloc_may_be_function_pointer(
2163 Symbol_table* ,
2164 Layout* ,
2165 Target_i386* ,
6fa2a40b 2166 Sized_relobj_file<32, false>* ,
0897ed3b
ST		 2167 unsigned int ,
2168 Output_section* ,
2169 const elfcpp::Rel<32, false>& ,
2170 unsigned int r_type,
2171 Symbol*)
2172{
2173 return possible_function_pointer_reloc(r_type);
2174}
2175
92e059d8
ILT		 2176// Scan a relocation for a global symbol.
2177
2178inline void
ad0f2072 2179Target_i386::Scan::global(Symbol_table* symtab,
2e702c99
RM		 2180 Layout* layout,
2181 Target_i386* target,
2182 Sized_relobj_file<32, false>* object,
2183 unsigned int data_shndx,
2184 Output_section* output_section,
2185 const elfcpp::Rel<32, false>& reloc,
2186 unsigned int r_type,
2187 Symbol* gsym)
92e059d8 2188{
7223e9ca
ILT		 2189 // A STT_GNU_IFUNC symbol may require a PLT entry.
2190 if (gsym->type() == elfcpp::STT_GNU_IFUNC
2191 && this->reloc_needs_plt_for_ifunc(object, r_type))
2192 target->make_plt_entry(symtab, layout, gsym);
2193
92e059d8
ILT		 2194 switch (r_type)
2195 {
2196 case elfcpp::R_386_NONE:
2197 case elfcpp::R_386_GNU_VTINHERIT:
8462ae85 2198 case elfcpp::R_386_GNU_VTENTRY:
92e059d8
ILT		 2199 break;
2200
2201 case elfcpp::R_386_32:
92e059d8 2202 case elfcpp::R_386_16:
92e059d8 2203 case elfcpp::R_386_8:
96f2030e 2204 {
2e702c99
RM		 2205 // Make a PLT entry if necessary.
2206 if (gsym->needs_plt_entry())
2207 {
2208 target->make_plt_entry(symtab, layout, gsym);
2209 // Since this is not a PC-relative relocation, we may be
2210 // taking the address of a function. In that case we need to
2211 // set the entry in the dynamic symbol table to the address of
2212 // the PLT entry.
2213 if (gsym->is_from_dynobj() && !parameters->options().shared())
2214 gsym->set_needs_dynsym_value();
2215 }
2216 // Make a dynamic relocation if necessary.
2217 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2218 {
a82bef93
ST		 2219 if (!parameters->options().output_is_position_independent()
2220 && gsym->may_need_copy_reloc())
2e702c99
RM		 2221 {
2222 target->copy_reloc(symtab, layout, object,
2223 data_shndx, output_section, gsym, reloc);
2224 }
7223e9ca
ILT		 2225 else if (r_type == elfcpp::R_386_32
2226 && gsym->type() == elfcpp::STT_GNU_IFUNC
2227 && gsym->can_use_relative_reloc(false)
2228 && !gsym->is_from_dynobj()
2229 && !gsym->is_undefined()
2230 && !gsym->is_preemptible())
2231 {
2232 // Use an IRELATIVE reloc for a locally defined
2233 // STT_GNU_IFUNC symbol. This makes a function
2234 // address in a PIE executable match the address in a
2235 // shared library that it links against.
67181c72 2236 Reloc_section* rel_dyn = target->rel_irelative_section(layout);
7223e9ca
ILT		 2237 rel_dyn->add_symbolless_global_addend(gsym,
2238 elfcpp::R_386_IRELATIVE,
2239 output_section,
2240 object, data_shndx,
2241 reloc.get_r_offset());
2242 }
2e702c99
RM		 2243 else if (r_type == elfcpp::R_386_32
2244 && gsym->can_use_relative_reloc(false))
2245 {
2246 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
7223e9ca
ILT		 2247 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2248 output_section, object,
2249 data_shndx, reloc.get_r_offset());
2e702c99
RM		 2250 }
2251 else
2252 {
2253 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2254 rel_dyn->add_global(gsym, r_type, output_section, object,
2255 data_shndx, reloc.get_r_offset());
2256 }
2257 }
d61c6bd4
ILT		 2258 }
2259 break;
2260
2261 case elfcpp::R_386_PC32:
2262 case elfcpp::R_386_PC16:
2263 case elfcpp::R_386_PC8:
2264 {
2e702c99
RM		 2265 // Make a PLT entry if necessary.
2266 if (gsym->needs_plt_entry())
2267 {
2268 // These relocations are used for function calls only in
2269 // non-PIC code. For a 32-bit relocation in a shared library,
2270 // we'll need a text relocation anyway, so we can skip the
2271 // PLT entry and let the dynamic linker bind the call directly
2272 // to the target. For smaller relocations, we should use a
2273 // PLT entry to ensure that the call can reach.
2274 if (!parameters->options().shared()
2275 || r_type != elfcpp::R_386_PC32)
2276 target->make_plt_entry(symtab, layout, gsym);
2277 }
2278 // Make a dynamic relocation if necessary.
2279 if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2280 {
a82bef93
ST		 2281 if (parameters->options().output_is_executable()
2282 && gsym->may_need_copy_reloc())
2e702c99
RM		 2283 {
2284 target->copy_reloc(symtab, layout, object,
2285 data_shndx, output_section, gsym, reloc);
2286 }
2287 else
2288 {
2289 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2290 rel_dyn->add_global(gsym, r_type, output_section, object,
2291 data_shndx, reloc.get_r_offset());
2292 }
2293 }
96f2030e 2294 }
92e059d8
ILT		 2295 break;
2296
ead1e424 2297 case elfcpp::R_386_GOT32:
493d4b48 2298 case elfcpp::R_386_GOT32X:
8462ae85 2299 {
c4fc4724 2300 // The symbol requires a GOT section.
2e702c99 2301 Output_data_got<32, false>* got = target->got_section(symtab, layout);
c4fc4724
IT		 2302
2303 // If we convert this from
2304 // mov foo@GOT(%reg), %reg
2305 // to
2306 // lea foo@GOTOFF(%reg), %reg
2307 // in Relocate::relocate, then there is nothing to do here.
2308 if (reloc.get_r_offset() >= 2
2309 && Target_i386::can_convert_mov_to_lea(gsym))
2310 {
2311 section_size_type stype;
2312 const unsigned char* view = object->section_contents(data_shndx,
2313 &stype, true);
2314 if (view[reloc.get_r_offset() - 2] == 0x8b)
2315 break;
2316 }
2317
2e702c99 2318 if (gsym->final_value_is_known())
7223e9ca
ILT		 2319 {
2320 // For a STT_GNU_IFUNC symbol we want the PLT address.
2321 if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2322 got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2323 else
2324 got->add_global(gsym, GOT_TYPE_STANDARD);
2325 }
2e702c99
RM		 2326 else
2327 {
2328 // If this symbol is not fully resolved, we need to add a
2329 // GOT entry with a dynamic relocation.
2330 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
07aa62f2
ILT		 2331
2332 // Use a GLOB_DAT rather than a RELATIVE reloc if:
2333 //
2334 // 1) The symbol may be defined in some other module.
2335 //
2336 // 2) We are building a shared library and this is a
2337 // protected symbol; using GLOB_DAT means that the dynamic
2338 // linker can use the address of the PLT in the main
2339 // executable when appropriate so that function address
2340 // comparisons work.
2341 //
2342 // 3) This is a STT_GNU_IFUNC symbol in position dependent
2343 // code, again so that function address comparisons work.
2e702c99
RM		 2344 if (gsym->is_from_dynobj()
2345 || gsym->is_undefined()
2346 || gsym->is_preemptible()
07aa62f2
ILT		 2347 || (gsym->visibility() == elfcpp::STV_PROTECTED
2348 && parameters->options().shared())
7223e9ca
ILT		 2349 || (gsym->type() == elfcpp::STT_GNU_IFUNC
2350 && parameters->options().output_is_position_independent()))
2e702c99
RM		 2351 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD,
2352 rel_dyn, elfcpp::R_386_GLOB_DAT);
2353 else
2354 {
7223e9ca
ILT		 2355 // For a STT_GNU_IFUNC symbol we want to write the PLT
2356 // offset into the GOT, so that function pointer
2357 // comparisons work correctly.
2358 bool is_new;
2359 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2360 is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2361 else
2362 {
2363 is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2364 // Tell the dynamic linker to use the PLT address
2365 // when resolving relocations.
2366 if (gsym->is_from_dynobj()
2367 && !parameters->options().shared())
2368 gsym->set_needs_dynsym_value();
2369 }
2e702c99 2370 if (is_new)
7223e9ca
ILT		 2371 {
2372 unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2373 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2374 got, got_off);
2375 }
2e702c99
RM		 2376 }
2377 }
8462ae85 2378 }
ead1e424
ILT		 2379 break;
2380
2381 case elfcpp::R_386_PLT32:
a3ad94ed
ILT		 2382 // If the symbol is fully resolved, this is just a PC32 reloc.
2383 // Otherwise we need a PLT entry.
7e1edb90 2384 if (gsym->final_value_is_known())
ead1e424 2385 break;
436ca963
ILT		 2386 // If building a shared library, we can also skip the PLT entry
2387 // if the symbol is defined in the output file and is protected
2388 // or hidden.
2389 if (gsym->is_defined()
2e702c99
RM		 2390 && !gsym->is_from_dynobj()
2391 && !gsym->is_preemptible())
436ca963 2392 break;
7e1edb90 2393 target->make_plt_entry(symtab, layout, gsym);
ead1e424
ILT		 2394 break;
2395
2396 case elfcpp::R_386_GOTOFF:
ed700649
CC		 2397 // A GOT-relative reference must resolve locally.
2398 if (!gsym->is_defined())
2399 gold_error(_("%s: relocation R_386_GOTOFF against undefined symbol %s"
2400 " cannot be used when making a shared object"),
2401 object->name().c_str(), gsym->name());
2402 else if (gsym->is_from_dynobj())
2403 gold_error(_("%s: relocation R_386_GOTOFF against external symbol %s"
2404 " cannot be used when making a shared object"),
2405 object->name().c_str(), gsym->name());
2406 else if (gsym->is_preemptible())
2407 gold_error(_("%s: relocation R_386_GOTOFF against preemptible symbol %s"
2408 " cannot be used when making a shared object"),
2409 object->name().c_str(), gsym->name());
2410 // We need a GOT section.
2411 target->got_section(symtab, layout);
2412 break;
2413
ead1e424
ILT		 2414 case elfcpp::R_386_GOTPC:
2415 // We need a GOT section.
7e1edb90 2416 target->got_section(symtab, layout);
ead1e424
ILT		 2417 break;
2418
af6359d5
ILT		 2419 // These are relocations which should only be seen by the
2420 // dynamic linker, and should never be seen here.
92e059d8
ILT		 2421 case elfcpp::R_386_COPY:
2422 case elfcpp::R_386_GLOB_DAT:
2423 case elfcpp::R_386_JUMP_SLOT:
2424 case elfcpp::R_386_RELATIVE:
7223e9ca 2425 case elfcpp::R_386_IRELATIVE:
92e059d8
ILT		 2426 case elfcpp::R_386_TLS_TPOFF:
2427 case elfcpp::R_386_TLS_DTPMOD32:
2428 case elfcpp::R_386_TLS_DTPOFF32:
2429 case elfcpp::R_386_TLS_TPOFF32:
2430 case elfcpp::R_386_TLS_DESC:
75f2446e
ILT		 2431 gold_error(_("%s: unexpected reloc %u in object file"),
2432 object->name().c_str(), r_type);
92e059d8
ILT		 2433 break;
2434
d61c17ea
ILT		 2435 // These are initial tls relocs, which are expected when
2436 // linking.
56622147
ILT		 2437 case elfcpp::R_386_TLS_GD: // Global-dynamic
2438 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
2439 case elfcpp::R_386_TLS_DESC_CALL:
2440 case elfcpp::R_386_TLS_LDM: // Local-dynamic
2441 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
2442 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 2443 case elfcpp::R_386_TLS_IE_32:
56622147
ILT		 2444 case elfcpp::R_386_TLS_GOTIE:
2445 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 2446 case elfcpp::R_386_TLS_LE_32:
a3ad94ed 2447 {
7e1edb90 2448 const bool is_final = gsym->final_value_is_known();
af6359d5 2449 const tls::Tls_optimization optimized_type
2e702c99 2450 = Target_i386::optimize_tls_reloc(is_final, r_type);
a3ad94ed
ILT		 2451 switch (r_type)
2452 {
56622147 2453 case elfcpp::R_386_TLS_GD: // Global-dynamic
07f397ab
ILT		 2454 if (optimized_type == tls::TLSOPT_NONE)
2455 {
2e702c99
RM		 2456 // Create a pair of GOT entries for the module index and
2457 // dtv-relative offset.
2458 Output_data_got<32, false>* got
2459 = target->got_section(symtab, layout);
2460 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
2461 target->rel_dyn_section(layout),
2462 elfcpp::R_386_TLS_DTPMOD32,
2463 elfcpp::R_386_TLS_DTPOFF32);
07f397ab
ILT		 2464 }
2465 else if (optimized_type == tls::TLSOPT_TO_IE)
2466 {
2e702c99
RM		 2467 // Create a GOT entry for the tp-relative offset.
2468 Output_data_got<32, false>* got
2469 = target->got_section(symtab, layout);
2470 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
2471 target->rel_dyn_section(layout),
2472 elfcpp::R_386_TLS_TPOFF);
07f397ab
ILT		 2473 }
2474 else if (optimized_type != tls::TLSOPT_TO_LE)
2475 unsupported_reloc_global(object, r_type, gsym);
2476 break;
2477
56622147 2478 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (~oliva url)
edfbb029 2479 target->define_tls_base_symbol(symtab, layout);
2e702c99
RM		 2480 if (optimized_type == tls::TLSOPT_NONE)
2481 {
2482 // Create a double GOT entry with an R_386_TLS_DESC
2483 // reloc. The R_386_TLS_DESC reloc is resolved
2484 // lazily, so the GOT entry needs to be in an area in
2485 // .got.plt, not .got. Call got_section to make sure
2486 // the section has been created.
a8df5856 2487 target->got_section(symtab, layout);
2e702c99 2488 Output_data_got<32, false>* got = target->got_tlsdesc_section();
e291e7b9 2489 Reloc_section* rt = target->rel_tls_desc_section(layout);
2e702c99
RM		 2490 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt,
2491 elfcpp::R_386_TLS_DESC, 0);
2492 }
2493 else if (optimized_type == tls::TLSOPT_TO_IE)
2494 {
2495 // Create a GOT entry for the tp-relative offset.
2496 Output_data_got<32, false>* got
2497 = target->got_section(symtab, layout);
2498 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
2499 target->rel_dyn_section(layout),
2500 elfcpp::R_386_TLS_TPOFF);
2501 }
2502 else if (optimized_type != tls::TLSOPT_TO_LE)
2503 unsupported_reloc_global(object, r_type, gsym);
c2b45e22
CC		 2504 break;
2505
2506 case elfcpp::R_386_TLS_DESC_CALL:
af6359d5
ILT		 2507 break;
2508
56622147 2509 case elfcpp::R_386_TLS_LDM: // Local-dynamic
07f397ab
ILT		 2510 if (optimized_type == tls::TLSOPT_NONE)
2511 {
2e702c99
RM		 2512 // Create a GOT entry for the module index.
2513 target->got_mod_index_entry(symtab, layout, object);
07f397ab
ILT		 2514 }
2515 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5
ILT		 2516 unsupported_reloc_global(object, r_type, gsym);
2517 break;
2518
56622147 2519 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
46cf9fa2
ILT		 2520 break;
2521
56622147
ILT		 2522 case elfcpp::R_386_TLS_IE: // Initial-exec
2523 case elfcpp::R_386_TLS_IE_32:
2524 case elfcpp::R_386_TLS_GOTIE:
535890bb 2525 layout->set_has_static_tls();
07f397ab
ILT		 2526 if (optimized_type == tls::TLSOPT_NONE)
2527 {
2e702c99
RM		 2528 // For the R_386_TLS_IE relocation, we need to create a
2529 // dynamic relocation when building a shared library.
2530 if (r_type == elfcpp::R_386_TLS_IE
2531 && parameters->options().shared())
2532 {
2533 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2534 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2535 output_section, object,
2536 data_shndx,
2537 reloc.get_r_offset());
2538 }
2539 // Create a GOT entry for the tp-relative offset.
2540 Output_data_got<32, false>* got
2541 = target->got_section(symtab, layout);
2542 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
2543 ? elfcpp::R_386_TLS_TPOFF32
2544 : elfcpp::R_386_TLS_TPOFF);
2545 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2546 ? GOT_TYPE_TLS_OFFSET
2547 : GOT_TYPE_TLS_NOFFSET);
2548 got->add_global_with_rel(gsym, got_type,
2549 target->rel_dyn_section(layout),
2550 dyn_r_type);
07f397ab
ILT		 2551 }
2552 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5 2553 unsupported_reloc_global(object, r_type, gsym);
a3ad94ed 2554 break;
af6359d5 2555
56622147
ILT		 2556 case elfcpp::R_386_TLS_LE: // Local-exec
2557 case elfcpp::R_386_TLS_LE_32:
535890bb 2558 layout->set_has_static_tls();
8851ecca 2559 if (parameters->options().shared())
7bf1f802 2560 {
2e702c99
RM		 2561 // We need to create a dynamic relocation.
2562 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
2563 ? elfcpp::R_386_TLS_TPOFF32
2564 : elfcpp::R_386_TLS_TPOFF);
2565 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2566 rel_dyn->add_global(gsym, dyn_r_type, output_section, object,
2567 data_shndx, reloc.get_r_offset());
7bf1f802 2568 }
56622147
ILT		 2569 break;
2570
af6359d5
ILT		 2571 default:
2572 gold_unreachable();
a3ad94ed
ILT		 2573 }
2574 }
92e059d8
ILT		 2575 break;
2576
92e059d8
ILT		 2577 case elfcpp::R_386_32PLT:
2578 case elfcpp::R_386_TLS_GD_32:
2579 case elfcpp::R_386_TLS_GD_PUSH:
2580 case elfcpp::R_386_TLS_GD_CALL:
2581 case elfcpp::R_386_TLS_GD_POP:
2582 case elfcpp::R_386_TLS_LDM_32:
2583 case elfcpp::R_386_TLS_LDM_PUSH:
2584 case elfcpp::R_386_TLS_LDM_CALL:
2585 case elfcpp::R_386_TLS_LDM_POP:
2586 case elfcpp::R_386_USED_BY_INTEL_200:
2587 default:
af6359d5 2588 unsupported_reloc_global(object, r_type, gsym);
92e059d8
ILT		 2589 break;
2590 }
2591}
2592
6d03d481
ST		 2593// Process relocations for gc.
2594
2595void
ad0f2072 2596Target_i386::gc_process_relocs(Symbol_table* symtab,
2e702c99
RM		 2597 Layout* layout,
2598 Sized_relobj_file<32, false>* object,
2599 unsigned int data_shndx,
2600 unsigned int,
2601 const unsigned char* prelocs,
2602 size_t reloc_count,
2603 Output_section* output_section,
2604 bool needs_special_offset_handling,
2605 size_t local_symbol_count,
2606 const unsigned char* plocal_symbols)
6d03d481 2607{
4d625b70 2608 gold::gc_process_relocs<32, false, Target_i386, Scan, Classify_reloc>(
6d03d481
ST		 2609 symtab,
2610 layout,
2611 this,
2612 object,
2613 data_shndx,
2614 prelocs,
2615 reloc_count,
2616 output_section,
2617 needs_special_offset_handling,
2618 local_symbol_count,
2619 plocal_symbols);
2620}
2621
92e059d8
ILT		 2622// Scan relocations for a section.
2623
2624void
ad0f2072 2625Target_i386::scan_relocs(Symbol_table* symtab,
2e702c99
RM		 2626 Layout* layout,
2627 Sized_relobj_file<32, false>* object,
2628 unsigned int data_shndx,
2629 unsigned int sh_type,
2630 const unsigned char* prelocs,
2631 size_t reloc_count,
2632 Output_section* output_section,
2633 bool needs_special_offset_handling,
2634 size_t local_symbol_count,
2635 const unsigned char* plocal_symbols)
92e059d8
ILT		 2636{
2637 if (sh_type == elfcpp::SHT_RELA)
2638 {
75f2446e
ILT		 2639 gold_error(_("%s: unsupported RELA reloc section"),
2640 object->name().c_str());
2641 return;
92e059d8
ILT		 2642 }
2643
4d625b70 2644 gold::scan_relocs<32, false, Target_i386, Scan, Classify_reloc>(
92e059d8 2645 symtab,
ead1e424
ILT		 2646 layout,
2647 this,
92e059d8 2648 object,
a3ad94ed 2649 data_shndx,
92e059d8
ILT		 2650 prelocs,
2651 reloc_count,
730cdc88
ILT		 2652 output_section,
2653 needs_special_offset_handling,
92e059d8 2654 local_symbol_count,
730cdc88 2655 plocal_symbols);
92e059d8
ILT		 2656}
2657
16649710 2658// Finalize the sections.
5a6f7e2d
ILT		 2659
2660void
f59f41f3
DK		 2661Target_i386::do_finalize_sections(
2662 Layout* layout,
2663 const Input_objects*,
e785ec03 2664 Symbol_table* symtab)
5a6f7e2d 2665{
ea715a34
ILT		 2666 const Reloc_section* rel_plt = (this->plt_ == NULL
2667 ? NULL
2668 : this->plt_->rel_plt());
2669 layout->add_target_dynamic_tags(true, this->got_plt_, rel_plt,
612a8d3d 2670 this->rel_dyn_, true, false);
16649710
ILT		 2671
2672 // Emit any relocs we saved in an attempt to avoid generating COPY
2673 // relocs.
12c0daef
ILT		 2674 if (this->copy_relocs_.any_saved_relocs())
2675 this->copy_relocs_.emit(this->rel_dyn_section(layout));
e785ec03
ILT		 2676
2677 // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
2678 // the .got.plt section.
2679 Symbol* sym = this->global_offset_table_;
2680 if (sym != NULL)
2681 {
2682 uint32_t data_size = this->got_plt_->current_data_size();
2683 symtab->get_sized_symbol<32>(sym)->set_symsize(data_size);
2684 }
28a13fec 2685
67181c72
ILT		 2686 if (parameters->doing_static_link()
2687 && (this->plt_ == NULL || !this->plt_->has_irelative_section()))
28a13fec
ILT		 2688 {
2689 // If linking statically, make sure that the __rel_iplt symbols
2690 // were defined if necessary, even if we didn't create a PLT.
2691 static const Define_symbol_in_segment syms[] =
2692 {
2693 {
2694 "__rel_iplt_start", // name
2695 elfcpp::PT_LOAD, // segment_type
2696 elfcpp::PF_W, // segment_flags_set
2697 elfcpp::PF(0), // segment_flags_clear
2698 0, // value
2699 0, // size
2700 elfcpp::STT_NOTYPE, // type
2701 elfcpp::STB_GLOBAL, // binding
2702 elfcpp::STV_HIDDEN, // visibility
2703 0, // nonvis
2704 Symbol::SEGMENT_START, // offset_from_base
2705 true // only_if_ref
2706 },
2707 {
2708 "__rel_iplt_end", // name
2709 elfcpp::PT_LOAD, // segment_type
2710 elfcpp::PF_W, // segment_flags_set
2711 elfcpp::PF(0), // segment_flags_clear
2712 0, // value
2713 0, // size
2714 elfcpp::STT_NOTYPE, // type
2715 elfcpp::STB_GLOBAL, // binding
2716 elfcpp::STV_HIDDEN, // visibility
2717 0, // nonvis
2718 Symbol::SEGMENT_START, // offset_from_base
2719 true // only_if_ref
2720 }
2721 };
2722
2723 symtab->define_symbols(layout, 2, syms,
2724 layout->script_options()->saw_sections_clause());
2725 }
5a6f7e2d
ILT		 2726}
2727
86849f1f
ILT		 2728// Return whether a direct absolute static relocation needs to be applied.
2729// In cases where Scan::local() or Scan::global() has created
2730// a dynamic relocation other than R_386_RELATIVE, the addend
2731// of the relocation is carried in the data, and we must not
2732// apply the static relocation.
2733
2734inline bool
2735Target_i386::Relocate::should_apply_static_reloc(const Sized_symbol<32>* gsym,
2e702c99
RM		 2736 unsigned int r_type,
2737 bool is_32bit,
031cdbed 2738 Output_section* output_section)
86849f1f 2739{
031cdbed
ILT		 2740 // If the output section is not allocated, then we didn't call
2741 // scan_relocs, we didn't create a dynamic reloc, and we must apply
2742 // the reloc here.
2743 if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0)
2744 return true;
2745
95a2c8d6
RS		 2746 int ref_flags = Scan::get_reference_flags(r_type);
2747
d61c6bd4
ILT		 2748 // For local symbols, we will have created a non-RELATIVE dynamic
2749 // relocation only if (a) the output is position independent,
2750 // (b) the relocation is absolute (not pc- or segment-relative), and
2751 // (c) the relocation is not 32 bits wide.
86849f1f 2752 if (gsym == NULL)
8851ecca 2753 return !(parameters->options().output_is_position_independent()
2e702c99
RM		 2754 && (ref_flags & Symbol::ABSOLUTE_REF)
2755 && !is_32bit);
86849f1f 2756
0700cf32
ILT		 2757 // For global symbols, we use the same helper routines used in the
2758 // scan pass. If we did not create a dynamic relocation, or if we
2759 // created a RELATIVE dynamic relocation, we should apply the static
2760 // relocation.
2761 bool has_dyn = gsym->needs_dynamic_reloc(ref_flags);
2762 bool is_rel = (ref_flags & Symbol::ABSOLUTE_REF)
2e702c99
RM		 2763 && gsym->can_use_relative_reloc(ref_flags
2764 & Symbol::FUNCTION_CALL);
0700cf32 2765 return !has_dyn || is_rel;
86849f1f
ILT		 2766}
2767
61ba1cf9
ILT		 2768// Perform a relocation.
2769
ead1e424 2770inline bool
92e059d8 2771Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
91a65d2f
AM		 2772 unsigned int,
2773 Target_i386* target,
2774 Output_section* output_section,
2775 size_t relnum,
2776 const unsigned char* preloc,
2777 const Sized_symbol<32>* gsym,
2778 const Symbol_value<32>* psymval,
2779 unsigned char* view,
2780 elfcpp::Elf_types<32>::Elf_Addr address,
2781 section_size_type view_size)
61ba1cf9 2782{
91a65d2f
AM		 2783 const elfcpp::Rel<32, false> rel(preloc);
2784 unsigned int r_type = elfcpp::elf_r_type<32>(rel.get_r_info());
2785
ead1e424
ILT		 2786 if (this->skip_call_tls_get_addr_)
2787 {
5efc7cd2 2788 if ((r_type != elfcpp::R_386_PLT32
2e702c99 2789 && r_type != elfcpp::R_386_PC32)
ead1e424
ILT		 2790 || gsym == NULL
2791 || strcmp(gsym->name(), "___tls_get_addr") != 0)
75f2446e
ILT		 2792 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2793 _("missing expected TLS relocation"));
2794 else
ead1e424 2795 {
75f2446e
ILT		 2796 this->skip_call_tls_get_addr_ = false;
2797 return false;
ead1e424 2798 }
ead1e424
ILT		 2799 }
2800
0e804863
ILT		 2801 if (view == NULL)
2802 return true;
2803
6fa2a40b 2804 const Sized_relobj_file<32, false>* object = relinfo->object;
7223e9ca 2805
a3ad94ed 2806 // Pick the value to use for symbols defined in shared objects.
b8e6aad9 2807 Symbol_value<32> symval;
436ca963 2808 if (gsym != NULL
7223e9ca
ILT		 2809 && gsym->type() == elfcpp::STT_GNU_IFUNC
2810 && r_type == elfcpp::R_386_32
95a2c8d6 2811 && gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))
7223e9ca
ILT		 2812 && gsym->can_use_relative_reloc(false)
2813 && !gsym->is_from_dynobj()
2814 && !gsym->is_undefined()
2815 && !gsym->is_preemptible())
2816 {
2817 // In this case we are generating a R_386_IRELATIVE reloc. We
2818 // want to use the real value of the symbol, not the PLT offset.
2819 }
2820 else if (gsym != NULL
95a2c8d6 2821 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
a3ad94ed 2822 {
19fec8c1 2823 symval.set_output_value(target->plt_address_for_global(gsym));
b8e6aad9 2824 psymval = &symval;
a3ad94ed 2825 }
7223e9ca
ILT		 2826 else if (gsym == NULL && psymval->is_ifunc_symbol())
2827 {
2828 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2829 if (object->local_has_plt_offset(r_sym))
2830 {
19fec8c1 2831 symval.set_output_value(target->plt_address_for_local(object, r_sym));
7223e9ca
ILT		 2832 psymval = &symval;
2833 }
2834 }
b8e6aad9 2835
3043c1ab
L		 2836 bool baseless;
2837
61ba1cf9
ILT		 2838 switch (r_type)
2839 {
2840 case elfcpp::R_386_NONE:
92e059d8
ILT		 2841 case elfcpp::R_386_GNU_VTINHERIT:
2842 case elfcpp::R_386_GNU_VTENTRY:
61ba1cf9
ILT		 2843 break;
2844
2845 case elfcpp::R_386_32:
95a2c8d6 2846 if (should_apply_static_reloc(gsym, r_type, true, output_section))
2e702c99 2847 Relocate_functions<32, false>::rel32(view, object, psymval);
61ba1cf9
ILT		 2848 break;
2849
2850 case elfcpp::R_386_PC32:
95a2c8d6 2851 if (should_apply_static_reloc(gsym, r_type, true, output_section))
2e702c99 2852 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
92e059d8
ILT		 2853 break;
2854
2855 case elfcpp::R_386_16:
95a2c8d6 2856 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2857 Relocate_functions<32, false>::rel16(view, object, psymval);
92e059d8
ILT		 2858 break;
2859
2860 case elfcpp::R_386_PC16:
95a2c8d6 2861 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2862 Relocate_functions<32, false>::pcrel16(view, object, psymval, address);
61ba1cf9
ILT		 2863 break;
2864
92e059d8 2865 case elfcpp::R_386_8:
95a2c8d6 2866 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2867 Relocate_functions<32, false>::rel8(view, object, psymval);
92e059d8
ILT		 2868 break;
2869
2870 case elfcpp::R_386_PC8:
95a2c8d6 2871 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2872 Relocate_functions<32, false>::pcrel8(view, object, psymval, address);
92e059d8
ILT		 2873 break;
2874
ead1e424 2875 case elfcpp::R_386_PLT32:
df2efe71
ILT		 2876 gold_assert(gsym == NULL
2877 || gsym->has_plt_offset()
99f8faca
ILT		 2878 || gsym->final_value_is_known()
2879 || (gsym->is_defined()
2880 && !gsym->is_from_dynobj()
2881 && !gsym->is_preemptible()));
b8e6aad9 2882 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
ead1e424
ILT		 2883 break;
2884
2885 case elfcpp::R_386_GOT32:
493d4b48 2886 case elfcpp::R_386_GOT32X:
3043c1ab
L		 2887 baseless = (view[-1] & 0xc7) == 0x5;
2888 // R_386_GOT32 and R_386_GOT32X don't work without base register
2889 // when generating a position-independent output file.
2890 if (baseless
2891 && parameters->options().output_is_position_independent())
2892 {
2893 if(gsym)
2894 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2895 _("unexpected reloc %u against global symbol %s without base register in object file when generating a position-independent output file"),
2896 r_type, gsym->demangled_name().c_str());
2897 else
2898 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2899 _("unexpected reloc %u against local symbol without base register in object file when generating a position-independent output file"),
2900 r_type);
2901 }
2902
c4fc4724
IT		 2903 // Convert
2904 // mov foo@GOT(%reg), %reg
2905 // to
2906 // lea foo@GOTOFF(%reg), %reg
2907 // if possible.
2908 if (rel.get_r_offset() >= 2
2909 && view[-2] == 0x8b
2910 && ((gsym == NULL && !psymval->is_ifunc_symbol())
2911 || (gsym != NULL
2912 && Target_i386::can_convert_mov_to_lea(gsym))))
2913 {
2914 view[-2] = 0x8d;
2915 elfcpp::Elf_types<32>::Elf_Addr value;
3043c1ab
L		 2916 value = psymval->value(object, 0);
2917 // Don't subtract the .got.plt section address for baseless
2918 // addressing.
2919 if (!baseless)
2920 value -= target->got_plt_section()->address();
c4fc4724
IT		 2921 Relocate_functions<32, false>::rel32(view, value);
2922 }
2923 else
2924 {
2925 // The GOT pointer points to the end of the GOT section.
2926 // We need to subtract the size of the GOT section to get
2927 // the actual offset to use in the relocation.
2928 unsigned int got_offset = 0;
2929 if (gsym != NULL)
2930 {
2931 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2932 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD)
2933 - target->got_size());
2934 }
2935 else
2936 {
2937 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2938 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2939 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
2940 - target->got_size());
2941 }
3043c1ab
L		 2942 // Add the .got.plt section address for baseless addressing.
2943 if (baseless)
2944 got_offset += target->got_plt_section()->address();
c4fc4724
IT		 2945 Relocate_functions<32, false>::rel32(view, got_offset);
2946 }
ead1e424
ILT		 2947 break;
2948
2949 case elfcpp::R_386_GOTOFF:
b8e6aad9
ILT		 2950 {
2951 elfcpp::Elf_types<32>::Elf_Addr value;
2952 value = (psymval->value(object, 0)
96f2030e 2953 - target->got_plt_section()->address());
b8e6aad9
ILT		 2954 Relocate_functions<32, false>::rel32(view, value);
2955 }
ead1e424
ILT		 2956 break;
2957
2958 case elfcpp::R_386_GOTPC:
b8e6aad9
ILT		 2959 {
2960 elfcpp::Elf_types<32>::Elf_Addr value;
96f2030e 2961 value = target->got_plt_section()->address();
b8e6aad9
ILT		 2962 Relocate_functions<32, false>::pcrel32(view, value, address);
2963 }
ead1e424
ILT		 2964 break;
2965
92e059d8
ILT		 2966 case elfcpp::R_386_COPY:
2967 case elfcpp::R_386_GLOB_DAT:
2968 case elfcpp::R_386_JUMP_SLOT:
2969 case elfcpp::R_386_RELATIVE:
7223e9ca 2970 case elfcpp::R_386_IRELATIVE:
d61c17ea
ILT		 2971 // These are outstanding tls relocs, which are unexpected when
2972 // linking.
92e059d8
ILT		 2973 case elfcpp::R_386_TLS_TPOFF:
2974 case elfcpp::R_386_TLS_DTPMOD32:
2975 case elfcpp::R_386_TLS_DTPOFF32:
2976 case elfcpp::R_386_TLS_TPOFF32:
2977 case elfcpp::R_386_TLS_DESC:
75f2446e
ILT		 2978 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2979 _("unexpected reloc %u in object file"),
2980 r_type);
92e059d8
ILT		 2981 break;
2982
d61c17ea
ILT		 2983 // These are initial tls relocs, which are expected when
2984 // linking.
56622147
ILT		 2985 case elfcpp::R_386_TLS_GD: // Global-dynamic
2986 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
2987 case elfcpp::R_386_TLS_DESC_CALL:
2988 case elfcpp::R_386_TLS_LDM: // Local-dynamic
2989 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
2990 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 2991 case elfcpp::R_386_TLS_IE_32:
56622147
ILT		 2992 case elfcpp::R_386_TLS_GOTIE:
2993 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 2994 case elfcpp::R_386_TLS_LE_32:
07f397ab 2995 this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval,
2e702c99 2996 view, address, view_size);
92e059d8
ILT		 2997 break;
2998
92e059d8
ILT		 2999 case elfcpp::R_386_32PLT:
3000 case elfcpp::R_386_TLS_GD_32:
3001 case elfcpp::R_386_TLS_GD_PUSH:
3002 case elfcpp::R_386_TLS_GD_CALL:
3003 case elfcpp::R_386_TLS_GD_POP:
3004 case elfcpp::R_386_TLS_LDM_32:
3005 case elfcpp::R_386_TLS_LDM_PUSH:
3006 case elfcpp::R_386_TLS_LDM_CALL:
3007 case elfcpp::R_386_TLS_LDM_POP:
3008 case elfcpp::R_386_USED_BY_INTEL_200:
61ba1cf9 3009 default:
75f2446e
ILT		 3010 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3011 _("unsupported reloc %u"),
3012 r_type);
92e059d8
ILT		 3013 break;
3014 }
ead1e424
ILT		 3015
3016 return true;
92e059d8
ILT		 3017}
3018
3019// Perform a TLS relocation.
3020
3021inline void
3022Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
2e702c99 3023 Target_i386* target,
92e059d8
ILT		 3024 size_t relnum,
3025 const elfcpp::Rel<32, false>& rel,
3026 unsigned int r_type,
c06b7b0b 3027 const Sized_symbol<32>* gsym,
b8e6aad9 3028 const Symbol_value<32>* psymval,
92e059d8
ILT		 3029 unsigned char* view,
3030 elfcpp::Elf_types<32>::Elf_Addr,
fe8718a4 3031 section_size_type view_size)
92e059d8
ILT		 3032{
3033 Output_segment* tls_segment = relinfo->layout->tls_segment();
92e059d8 3034
6fa2a40b 3035 const Sized_relobj_file<32, false>* object = relinfo->object;
07f397ab
ILT		 3036
3037 elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0);
b8e6aad9 3038
b3705d2a
ILT		 3039 const bool is_final = (gsym == NULL
3040 ? !parameters->options().shared()
3041 : gsym->final_value_is_known());
af6359d5
ILT		 3042 const tls::Tls_optimization optimized_type
3043 = Target_i386::optimize_tls_reloc(is_final, r_type);
92e059d8
ILT		 3044 switch (r_type)
3045 {
56622147 3046 case elfcpp::R_386_TLS_GD: // Global-dynamic
af6359d5 3047 if (optimized_type == tls::TLSOPT_TO_LE)
92e059d8 3048 {
62855347
ILT		 3049 if (tls_segment == NULL)
3050 {
191f1a2d
ILT		 3051 gold_assert(parameters->errors()->error_count() > 0
3052 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3053 return;
3054 }
56622147
ILT		 3055 this->tls_gd_to_le(relinfo, relnum, tls_segment,
3056 rel, r_type, value, view,
3057 view_size);
92e059d8
ILT		 3058 break;
3059 }
07f397ab 3060 else
2e702c99
RM		 3061 {
3062 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3063 ? GOT_TYPE_TLS_NOFFSET
3064 : GOT_TYPE_TLS_PAIR);
3065 unsigned int got_offset;
3066 if (gsym != NULL)
3067 {
3068 gold_assert(gsym->has_got_offset(got_type));
3069 got_offset = gsym->got_offset(got_type) - target->got_size();
3070 }
3071 else
3072 {
3073 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3074 gold_assert(object->local_has_got_offset(r_sym, got_type));
3075 got_offset = (object->local_got_offset(r_sym, got_type)
07f397ab 3076 - target->got_size());
2e702c99
RM		 3077 }
3078 if (optimized_type == tls::TLSOPT_TO_IE)
07f397ab 3079 {
d21f123b 3080 this->tls_gd_to_ie(relinfo, relnum, rel, r_type,
2e702c99
RM		 3081 got_offset, view, view_size);
3082 break;
3083 }
3084 else if (optimized_type == tls::TLSOPT_NONE)
3085 {
3086 // Relocate the field with the offset of the pair of GOT
3087 // entries.
3088 Relocate_functions<32, false>::rel32(view, got_offset);
3089 break;
07f397ab 3090 }
2e702c99 3091 }
75f2446e
ILT		 3092 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3093 _("unsupported reloc %u"),
3094 r_type);
92e059d8
ILT		 3095 break;
3096
56622147
ILT		 3097 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
3098 case elfcpp::R_386_TLS_DESC_CALL:
497897f9 3099 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
c2b45e22 3100 if (optimized_type == tls::TLSOPT_TO_LE)
2e702c99 3101 {
62855347
ILT		 3102 if (tls_segment == NULL)
3103 {
191f1a2d
ILT		 3104 gold_assert(parameters->errors()->error_count() > 0
3105 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3106 return;
3107 }
c2b45e22 3108 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
2e702c99
RM		 3109 rel, r_type, value, view,
3110 view_size);
c2b45e22 3111 break;
2e702c99 3112 }
c2b45e22 3113 else
2e702c99
RM		 3114 {
3115 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3116 ? GOT_TYPE_TLS_NOFFSET
3117 : GOT_TYPE_TLS_DESC);
3118 unsigned int got_offset = 0;
a8df5856
ILT		 3119 if (r_type == elfcpp::R_386_TLS_GOTDESC
3120 && optimized_type == tls::TLSOPT_NONE)
3121 {
3122 // We created GOT entries in the .got.tlsdesc portion of
3123 // the .got.plt section, but the offset stored in the
3124 // symbol is the offset within .got.tlsdesc.
3125 got_offset = (target->got_size()
3126 + target->got_plt_section()->data_size());
3127 }
2e702c99
RM		 3128 if (gsym != NULL)
3129 {
3130 gold_assert(gsym->has_got_offset(got_type));
3131 got_offset += gsym->got_offset(got_type) - target->got_size();
3132 }
3133 else
3134 {
3135 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3136 gold_assert(object->local_has_got_offset(r_sym, got_type));
3137 got_offset += (object->local_got_offset(r_sym, got_type)
a8df5856 3138 - target->got_size());
2e702c99
RM		 3139 }
3140 if (optimized_type == tls::TLSOPT_TO_IE)
c2b45e22 3141 {
d21f123b 3142 this->tls_desc_gd_to_ie(relinfo, relnum, rel, r_type,
2e702c99
RM		 3143 got_offset, view, view_size);
3144 break;
3145 }
3146 else if (optimized_type == tls::TLSOPT_NONE)
3147 {
3148 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3149 {
3150 // Relocate the field with the offset of the pair of GOT
3151 // entries.
3152 Relocate_functions<32, false>::rel32(view, got_offset);
3153 }
3154 break;
c2b45e22 3155 }
2e702c99 3156 }
75f2446e
ILT		 3157 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3158 _("unsupported reloc %u"),
3159 r_type);
ead1e424
ILT		 3160 break;
3161
56622147 3162 case elfcpp::R_386_TLS_LDM: // Local-dynamic
46cf9fa2
ILT		 3163 if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN)
3164 {
75f2446e
ILT		 3165 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3166 _("both SUN and GNU model "
3167 "TLS relocations"));
3168 break;
46cf9fa2
ILT		 3169 }
3170 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
af6359d5 3171 if (optimized_type == tls::TLSOPT_TO_LE)
46cf9fa2 3172 {
62855347
ILT		 3173 if (tls_segment == NULL)
3174 {
191f1a2d
ILT		 3175 gold_assert(parameters->errors()->error_count() > 0
3176 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3177 return;
3178 }
46cf9fa2
ILT		 3179 this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type,
3180 value, view, view_size);
3181 break;
3182 }
07f397ab 3183 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3184 {
3185 // Relocate the field with the offset of the GOT entry for
3186 // the module index.
3187 unsigned int got_offset;
3188 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
94c4710f 3189 - target->got_size());
2e702c99
RM		 3190 Relocate_functions<32, false>::rel32(view, got_offset);
3191 break;
3192 }
75f2446e
ILT		 3193 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3194 _("unsupported reloc %u"),
3195 r_type);
46cf9fa2
ILT		 3196 break;
3197
56622147 3198 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
d6f22b98 3199 if (optimized_type == tls::TLSOPT_TO_LE)
e8a9fcda 3200 {
82bb573a
ILT		 3201 // This reloc can appear in debugging sections, in which
3202 // case we must not convert to local-exec. We decide what
3203 // to do based on whether the section is marked as
3204 // containing executable code. That is what the GNU linker
3205 // does as well.
3206 elfcpp::Shdr<32, false> shdr(relinfo->data_shdr);
3207 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
d6f22b98 3208 {
62855347
ILT		 3209 if (tls_segment == NULL)
3210 {
191f1a2d
ILT		 3211 gold_assert(parameters->errors()->error_count() > 0
3212 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3213 return;
3214 }
d6f22b98
ILT		 3215 value -= tls_segment->memsz();
3216 }
e8a9fcda 3217 }
46cf9fa2
ILT		 3218 Relocate_functions<32, false>::rel32(view, value);
3219 break;
3220
56622147
ILT		 3221 case elfcpp::R_386_TLS_IE: // Initial-exec
3222 case elfcpp::R_386_TLS_GOTIE:
3223 case elfcpp::R_386_TLS_IE_32:
3224 if (optimized_type == tls::TLSOPT_TO_LE)
3225 {
62855347
ILT		 3226 if (tls_segment == NULL)
3227 {
191f1a2d
ILT		 3228 gold_assert(parameters->errors()->error_count() > 0
3229 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3230 return;
3231 }
56622147
ILT		 3232 Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3233 rel, r_type, value, view,
3234 view_size);
3235 break;
3236 }
07f397ab 3237 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3238 {
3239 // Relocate the field with the offset of the GOT entry for
3240 // the tp-relative offset of the symbol.
c2b45e22 3241 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2e702c99
RM		 3242 ? GOT_TYPE_TLS_OFFSET
3243 : GOT_TYPE_TLS_NOFFSET);
3244 unsigned int got_offset;
3245 if (gsym != NULL)
3246 {
3247 gold_assert(gsym->has_got_offset(got_type));
3248 got_offset = gsym->got_offset(got_type);
3249 }
3250 else
3251 {
3252 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3253 gold_assert(object->local_has_got_offset(r_sym, got_type));
3254 got_offset = object->local_got_offset(r_sym, got_type);
3255 }
3256 // For the R_386_TLS_IE relocation, we need to apply the
3257 // absolute address of the GOT entry.
3258 if (r_type == elfcpp::R_386_TLS_IE)
3259 got_offset += target->got_plt_section()->address();
3260 // All GOT offsets are relative to the end of the GOT.
3261 got_offset -= target->got_size();
3262 Relocate_functions<32, false>::rel32(view, got_offset);
3263 break;
3264 }
75f2446e
ILT		 3265 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3266 _("unsupported reloc %u"),
3267 r_type);
92e059d8 3268 break;
92e059d8 3269
56622147 3270 case elfcpp::R_386_TLS_LE: // Local-exec
7bf1f802
ILT		 3271 // If we're creating a shared library, a dynamic relocation will
3272 // have been created for this location, so do not apply it now.
8851ecca 3273 if (!parameters->options().shared())
2e702c99 3274 {
62855347
ILT		 3275 if (tls_segment == NULL)
3276 {
191f1a2d
ILT		 3277 gold_assert(parameters->errors()->error_count() > 0
3278 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3279 return;
3280 }
2e702c99
RM		 3281 value -= tls_segment->memsz();
3282 Relocate_functions<32, false>::rel32(view, value);
3283 }
56622147 3284 break;
92e059d8 3285
56622147 3286 case elfcpp::R_386_TLS_LE_32:
7bf1f802
ILT		 3287 // If we're creating a shared library, a dynamic relocation will
3288 // have been created for this location, so do not apply it now.
8851ecca 3289 if (!parameters->options().shared())
2e702c99 3290 {
62855347
ILT		 3291 if (tls_segment == NULL)
3292 {
191f1a2d
ILT		 3293 gold_assert(parameters->errors()->error_count() > 0
3294 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3295 return;
3296 }
2e702c99
RM		 3297 value = tls_segment->memsz() - value;
3298 Relocate_functions<32, false>::rel32(view, value);
3299 }
56622147 3300 break;
92e059d8 3301 }
92e059d8
ILT		 3302}
3303
e041f13d 3304// Do a relocation in which we convert a TLS General-Dynamic to a
ead1e424
ILT		 3305// Local-Exec.
3306
3307inline void
3308Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo,
3309 size_t relnum,
3310 Output_segment* tls_segment,
3311 const elfcpp::Rel<32, false>& rel,
3312 unsigned int,
3313 elfcpp::Elf_types<32>::Elf_Addr value,
3314 unsigned char* view,
fe8718a4 3315 section_size_type view_size)
ead1e424
ILT		 3316{
3317 // leal foo(,%reg,1),%eax; call ___tls_get_addr
46cf9fa2 3318 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
ead1e424
ILT		 3319 // leal foo(%reg),%eax; call ___tls_get_addr
3320 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3321
af6359d5
ILT		 3322 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3323 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
ead1e424
ILT		 3324
3325 unsigned char op1 = view[-1];
3326 unsigned char op2 = view[-2];
3327
af6359d5 3328 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3329 op2 == 0x8d || op2 == 0x04);
af6359d5 3330 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
ead1e424
ILT		 3331
3332 int roff = 5;
3333
3334 if (op2 == 0x04)
3335 {
af6359d5
ILT		 3336 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3337 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3338 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3339 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
ead1e424
ILT		 3340 memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3341 }
3342 else
3343 {
af6359d5 3344 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3345 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
fe8718a4 3346 if (rel.get_r_offset() + 9 < view_size
2e702c99 3347 && view[9] == 0x90)
ead1e424
ILT		 3348 {
3349 // There is a trailing nop. Use the size byte subl.
3350 memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3351 roff = 6;
3352 }
3353 else
3354 {
3355 // Use the five byte subl.
3356 memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
3357 }
3358 }
3359
7bf1f802 3360 value = tls_segment->memsz() - value;
ead1e424
ILT		 3361 Relocate_functions<32, false>::rel32(view + roff, value);
3362
3363 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3364 // We can skip it.
3365 this->skip_call_tls_get_addr_ = true;
3366}
3367
7bf1f802 3368// Do a relocation in which we convert a TLS General-Dynamic to an
07f397ab
ILT		 3369// Initial-Exec.
3370
3371inline void
3372Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo,
3373 size_t relnum,
07f397ab
ILT		 3374 const elfcpp::Rel<32, false>& rel,
3375 unsigned int,
3376 elfcpp::Elf_types<32>::Elf_Addr value,
3377 unsigned char* view,
fe8718a4 3378 section_size_type view_size)
07f397ab
ILT		 3379{
3380 // leal foo(,%ebx,1),%eax; call ___tls_get_addr
3381 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
152f7024
CC		 3382 // leal foo(%ebx),%eax; call ___tls_get_addr; nop
3383 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
07f397ab
ILT		 3384
3385 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3386 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3387
3388 unsigned char op1 = view[-1];
3389 unsigned char op2 = view[-2];
3390
3391 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3392 op2 == 0x8d || op2 == 0x04);
07f397ab
ILT		 3393 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
3394
152f7024 3395 int roff;
07f397ab
ILT		 3396
3397 if (op2 == 0x04)
3398 {
3399 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3400 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3401 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3402 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
152f7024 3403 roff = 5;
07f397ab
ILT		 3404 }
3405 else
3406 {
152f7024 3407 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 10);
07f397ab 3408 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3409 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
152f7024
CC		 3410 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[9] == 0x90);
3411 roff = 6;
07f397ab
ILT		 3412 }
3413
152f7024 3414 memcpy(view + roff - 8, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12);
07f397ab
ILT		 3415 Relocate_functions<32, false>::rel32(view + roff, value);
3416
3417 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3418 // We can skip it.
3419 this->skip_call_tls_get_addr_ = true;
3420}
3421
c2b45e22
CC		 3422// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3423// General-Dynamic to a Local-Exec.
3424
3425inline void
3426Target_i386::Relocate::tls_desc_gd_to_le(
3427 const Relocate_info<32, false>* relinfo,
3428 size_t relnum,
3429 Output_segment* tls_segment,
3430 const elfcpp::Rel<32, false>& rel,
3431 unsigned int r_type,
3432 elfcpp::Elf_types<32>::Elf_Addr value,
3433 unsigned char* view,
3434 section_size_type view_size)
3435{
3436 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3437 {
3438 // leal foo@TLSDESC(%ebx), %eax
3439 // ==> leal foo@NTPOFF, %eax
3440 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3441 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3442 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3443 view[-2] == 0x8d && view[-1] == 0x83);
c2b45e22
CC		 3444 view[-1] = 0x05;
3445 value -= tls_segment->memsz();
3446 Relocate_functions<32, false>::rel32(view, value);
3447 }
3448 else
3449 {
3450 // call *foo@TLSCALL(%eax)
3451 // ==> nop; nop
3452 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3453 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3454 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3455 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 3456 view[0] = 0x66;
3457 view[1] = 0x90;
3458 }
3459}
3460
3461// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3462// General-Dynamic to an Initial-Exec.
3463
3464inline void
3465Target_i386::Relocate::tls_desc_gd_to_ie(
3466 const Relocate_info<32, false>* relinfo,
3467 size_t relnum,
c2b45e22
CC		 3468 const elfcpp::Rel<32, false>& rel,
3469 unsigned int r_type,
3470 elfcpp::Elf_types<32>::Elf_Addr value,
3471 unsigned char* view,
3472 section_size_type view_size)
3473{
3474 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3475 {
3476 // leal foo@TLSDESC(%ebx), %eax
3477 // ==> movl foo@GOTNTPOFF(%ebx), %eax
3478 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3479 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3480 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3481 view[-2] == 0x8d && view[-1] == 0x83);
c2b45e22
CC		 3482 view[-2] = 0x8b;
3483 Relocate_functions<32, false>::rel32(view, value);
3484 }
3485 else
3486 {
3487 // call *foo@TLSCALL(%eax)
3488 // ==> nop; nop
3489 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3490 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3491 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3492 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 3493 view[0] = 0x66;
3494 view[1] = 0x90;
3495 }
3496}
3497
46cf9fa2
ILT		 3498// Do a relocation in which we convert a TLS Local-Dynamic to a
3499// Local-Exec.
3500
3501inline void
3502Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo,
3503 size_t relnum,
3504 Output_segment*,
3505 const elfcpp::Rel<32, false>& rel,
3506 unsigned int,
3507 elfcpp::Elf_types<32>::Elf_Addr,
3508 unsigned char* view,
fe8718a4 3509 section_size_type view_size)
46cf9fa2
ILT		 3510{
3511 // leal foo(%reg), %eax; call ___tls_get_addr
3512 // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi
3513
af6359d5
ILT		 3514 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3515 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
46cf9fa2
ILT		 3516
3517 // FIXME: Does this test really always pass?
af6359d5 3518 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3519 view[-2] == 0x8d && view[-1] == 0x83);
46cf9fa2 3520
af6359d5 3521 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
46cf9fa2
ILT		 3522
3523 memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11);
3524
3525 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3526 // We can skip it.
3527 this->skip_call_tls_get_addr_ = true;
3528}
3529
56622147
ILT		 3530// Do a relocation in which we convert a TLS Initial-Exec to a
3531// Local-Exec.
3532
3533inline void
3534Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo,
3535 size_t relnum,
3536 Output_segment* tls_segment,
3537 const elfcpp::Rel<32, false>& rel,
3538 unsigned int r_type,
3539 elfcpp::Elf_types<32>::Elf_Addr value,
3540 unsigned char* view,
fe8718a4 3541 section_size_type view_size)
56622147
ILT		 3542{
3543 // We have to actually change the instructions, which means that we
3544 // need to examine the opcodes to figure out which instruction we
3545 // are looking at.
3546 if (r_type == elfcpp::R_386_TLS_IE)
3547 {
3548 // movl %gs:XX,%eax ==> movl $YY,%eax
3549 // movl %gs:XX,%reg ==> movl $YY,%reg
3550 // addl %gs:XX,%reg ==> addl $YY,%reg
3551 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1);
3552 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3553
3554 unsigned char op1 = view[-1];
3555 if (op1 == 0xa1)
3556 {
3557 // movl XX,%eax ==> movl $YY,%eax
3558 view[-1] = 0xb8;
3559 }
3560 else
3561 {
3562 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3563
3564 unsigned char op2 = view[-2];
3565 if (op2 == 0x8b)
3566 {
3567 // movl XX,%reg ==> movl $YY,%reg
3568 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3569 (op1 & 0xc7) == 0x05);
56622147
ILT		 3570 view[-2] = 0xc7;
3571 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3572 }
3573 else if (op2 == 0x03)
3574 {
3575 // addl XX,%reg ==> addl $YY,%reg
3576 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3577 (op1 & 0xc7) == 0x05);
56622147
ILT		 3578 view[-2] = 0x81;
3579 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3580 }
3581 else
3582 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3583 }
3584 }
3585 else
3586 {
3587 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
3588 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
3589 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
3590 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3591 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3592
3593 unsigned char op1 = view[-1];
3594 unsigned char op2 = view[-2];
3595 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3596 (op1 & 0xc0) == 0x80 && (op1 & 7) != 4);
56622147
ILT		 3597 if (op2 == 0x8b)
3598 {
3599 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
3600 view[-2] = 0xc7;
3601 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3602 }
3603 else if (op2 == 0x2b)
3604 {
3605 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
3606 view[-2] = 0x81;
3607 view[-1] = 0xe8 | ((op1 >> 3) & 7);
3608 }
3609 else if (op2 == 0x03)
3610 {
3611 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
3612 view[-2] = 0x81;
3613 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3614 }
3615 else
3616 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3617 }
3618
7bf1f802 3619 value = tls_segment->memsz() - value;
56622147
ILT		 3620 if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE)
3621 value = - value;
3622
3623 Relocate_functions<32, false>::rel32(view, value);
3624}
3625
61ba1cf9
ILT		 3626// Relocate section data.
3627
3628void
92e059d8 3629Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
61ba1cf9
ILT		 3630 unsigned int sh_type,
3631 const unsigned char* prelocs,
3632 size_t reloc_count,
730cdc88
ILT		 3633 Output_section* output_section,
3634 bool needs_special_offset_handling,
61ba1cf9
ILT		 3635 unsigned char* view,
3636 elfcpp::Elf_types<32>::Elf_Addr address,
364c7fa5
ILT		 3637 section_size_type view_size,
3638 const Reloc_symbol_changes* reloc_symbol_changes)
61ba1cf9 3639{
a3ad94ed 3640 gold_assert(sh_type == elfcpp::SHT_REL);
61ba1cf9 3641
4d625b70
CC		 3642 gold::relocate_section<32, false, Target_i386, Relocate,
3643 gold::Default_comdat_behavior, Classify_reloc>(
92e059d8 3644 relinfo,
ead1e424 3645 this,
61ba1cf9
ILT		 3646 prelocs,
3647 reloc_count,
730cdc88
ILT		 3648 output_section,
3649 needs_special_offset_handling,
61ba1cf9
ILT		 3650 view,
3651 address,
364c7fa5
ILT		 3652 view_size,
3653 reloc_symbol_changes);
61ba1cf9
ILT		 3654}
3655
6a74a719
ILT		 3656// Return the size of a relocation while scanning during a relocatable
3657// link.
3658
3659unsigned int
4d625b70 3660Target_i386::Classify_reloc::get_size_for_reloc(
6a74a719
ILT		 3661 unsigned int r_type,
3662 Relobj* object)
3663{
3664 switch (r_type)
3665 {
3666 case elfcpp::R_386_NONE:
3667 case elfcpp::R_386_GNU_VTINHERIT:
3668 case elfcpp::R_386_GNU_VTENTRY:
3669 case elfcpp::R_386_TLS_GD: // Global-dynamic
3670 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
3671 case elfcpp::R_386_TLS_DESC_CALL:
3672 case elfcpp::R_386_TLS_LDM: // Local-dynamic
3673 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
3674 case elfcpp::R_386_TLS_IE: // Initial-exec
3675 case elfcpp::R_386_TLS_IE_32:
3676 case elfcpp::R_386_TLS_GOTIE:
3677 case elfcpp::R_386_TLS_LE: // Local-exec
3678 case elfcpp::R_386_TLS_LE_32:
3679 return 0;
3680
3681 case elfcpp::R_386_32:
3682 case elfcpp::R_386_PC32:
3683 case elfcpp::R_386_GOT32:
493d4b48 3684 case elfcpp::R_386_GOT32X:
6a74a719
ILT		 3685 case elfcpp::R_386_PLT32:
3686 case elfcpp::R_386_GOTOFF:
3687 case elfcpp::R_386_GOTPC:
3688 return 4;
3689
3690 case elfcpp::R_386_16:
3691 case elfcpp::R_386_PC16:
3692 return 2;
3693
3694 case elfcpp::R_386_8:
3695 case elfcpp::R_386_PC8:
3696 return 1;
3697
3698 // These are relocations which should only be seen by the
3699 // dynamic linker, and should never be seen here.
3700 case elfcpp::R_386_COPY:
3701 case elfcpp::R_386_GLOB_DAT:
3702 case elfcpp::R_386_JUMP_SLOT:
3703 case elfcpp::R_386_RELATIVE:
7223e9ca 3704 case elfcpp::R_386_IRELATIVE:
6a74a719
ILT		 3705 case elfcpp::R_386_TLS_TPOFF:
3706 case elfcpp::R_386_TLS_DTPMOD32:
3707 case elfcpp::R_386_TLS_DTPOFF32:
3708 case elfcpp::R_386_TLS_TPOFF32:
3709 case elfcpp::R_386_TLS_DESC:
3710 object->error(_("unexpected reloc %u in object file"), r_type);
3711 return 0;
3712
3713 case elfcpp::R_386_32PLT:
3714 case elfcpp::R_386_TLS_GD_32:
3715 case elfcpp::R_386_TLS_GD_PUSH:
3716 case elfcpp::R_386_TLS_GD_CALL:
3717 case elfcpp::R_386_TLS_GD_POP:
3718 case elfcpp::R_386_TLS_LDM_32:
3719 case elfcpp::R_386_TLS_LDM_PUSH:
3720 case elfcpp::R_386_TLS_LDM_CALL:
3721 case elfcpp::R_386_TLS_LDM_POP:
3722 case elfcpp::R_386_USED_BY_INTEL_200:
3723 default:
3724 object->error(_("unsupported reloc %u in object file"), r_type);
3725 return 0;
3726 }
3727}
3728
3729// Scan the relocs during a relocatable link.
3730
3731void
ad0f2072 3732Target_i386::scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 3733 Layout* layout,
6fa2a40b 3734 Sized_relobj_file<32, false>* object,
6a74a719
ILT		 3735 unsigned int data_shndx,
3736 unsigned int sh_type,
3737 const unsigned char* prelocs,
3738 size_t reloc_count,
3739 Output_section* output_section,
3740 bool needs_special_offset_handling,
3741 size_t local_symbol_count,
3742 const unsigned char* plocal_symbols,
3743 Relocatable_relocs* rr)
3744{
4d625b70
CC		 3745 typedef gold::Default_scan_relocatable_relocs<Classify_reloc>
3746 Scan_relocatable_relocs;
6a74a719 3747
4d625b70 3748 gold_assert(sh_type == elfcpp::SHT_REL);
6a74a719 3749
4d625b70 3750 gold::scan_relocatable_relocs<32, false, Scan_relocatable_relocs>(
6a74a719
ILT		 3751 symtab,
3752 layout,
3753 object,
3754 data_shndx,
3755 prelocs,
3756 reloc_count,
3757 output_section,
3758 needs_special_offset_handling,
3759 local_symbol_count,
3760 plocal_symbols,
3761 rr);
3762}
3763
4d625b70
CC		 3764// Scan the relocs for --emit-relocs.
3765
3766void
3767Target_i386::emit_relocs_scan(Symbol_table* symtab,
3768 Layout* layout,
3769 Sized_relobj_file<32, false>* object,
3770 unsigned int data_shndx,
3771 unsigned int sh_type,
3772 const unsigned char* prelocs,
3773 size_t reloc_count,
3774 Output_section* output_section,
3775 bool needs_special_offset_handling,
3776 size_t local_symbol_count,
3777 const unsigned char* plocal_syms,
3778 Relocatable_relocs* rr)
3779{
3780 typedef gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>
3781 Classify_reloc;
3782 typedef gold::Default_emit_relocs_strategy<Classify_reloc>
3783 Emit_relocs_strategy;
3784
3785 gold_assert(sh_type == elfcpp::SHT_REL);
3786
3787 gold::scan_relocatable_relocs<32, false, Emit_relocs_strategy>(
3788 symtab,
3789 layout,
3790 object,
3791 data_shndx,
3792 prelocs,
3793 reloc_count,
3794 output_section,
3795 needs_special_offset_handling,
3796 local_symbol_count,
3797 plocal_syms,
3798 rr);
3799}
3800
7404fe1b 3801// Emit relocations for a section.
6a74a719
ILT		 3802
3803void
7404fe1b 3804Target_i386::relocate_relocs(
6a74a719
ILT		 3805 const Relocate_info<32, false>* relinfo,
3806 unsigned int sh_type,
3807 const unsigned char* prelocs,
3808 size_t reloc_count,
3809 Output_section* output_section,
cc928013 3810 elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,
6a74a719
ILT		 3811 unsigned char* view,
3812 elfcpp::Elf_types<32>::Elf_Addr view_address,
3813 section_size_type view_size,
3814 unsigned char* reloc_view,
3815 section_size_type reloc_view_size)
3816{
3817 gold_assert(sh_type == elfcpp::SHT_REL);
3818
4d625b70 3819 gold::relocate_relocs<32, false, Classify_reloc>(
6a74a719
ILT		 3820 relinfo,
3821 prelocs,
3822 reloc_count,
3823 output_section,
3824 offset_in_output_section,
6a74a719
ILT		 3825 view,
3826 view_address,
3827 view_size,
3828 reloc_view,
3829 reloc_view_size);
3830}
3831
ab5c9e90
ILT		 3832// Return the value to use for a dynamic which requires special
3833// treatment. This is how we support equality comparisons of function
3834// pointers across shared library boundaries, as described in the
3835// processor specific ABI supplement.
3836
3837uint64_t
3838Target_i386::do_dynsym_value(const Symbol* gsym) const
3839{
3840 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
19fec8c1 3841 return this->plt_address_for_global(gsym);
ab5c9e90
ILT		 3842}
3843
c51e6221
ILT		 3844// Return a string used to fill a code section with nops to take up
3845// the specified length.
3846
3847std::string
8851ecca 3848Target_i386::do_code_fill(section_size_type length) const
c51e6221
ILT		 3849{
3850 if (length >= 16)
3851 {
3852 // Build a jmp instruction to skip over the bytes.
3853 unsigned char jmp[5];
3854 jmp[0] = 0xe9;
3855 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
3856 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
2e702c99 3857 + std::string(length - 5, static_cast<char>(0x90)));
c51e6221
ILT		 3858 }
3859
3860 // Nop sequences of various lengths.
76677ad0
CC		 3861 const char nop1[1] = { '\x90' }; // nop
3862 const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax
3863 const char nop3[3] = { '\x8d', '\x76', '\x00' }; // leal 0(%esi),%esi
3864 const char nop4[4] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi
3865 '\x00'};
3866 const char nop5[5] = { '\x90', '\x8d', '\x74', // nop
2e702c99 3867 '\x26', '\x00' }; // leal 0(%esi,1),%esi
76677ad0 3868 const char nop6[6] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3869 '\x00', '\x00', '\x00' };
76677ad0 3870 const char nop7[7] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi
2e702c99 3871 '\x00', '\x00', '\x00',
76677ad0
CC		 3872 '\x00' };
3873 const char nop8[8] = { '\x90', '\x8d', '\xb4', // nop
2e702c99 3874 '\x26', '\x00', '\x00', // leal 0L(%esi,1),%esi
76677ad0
CC		 3875 '\x00', '\x00' };
3876 const char nop9[9] = { '\x89', '\xf6', '\x8d', // movl %esi,%esi
2e702c99 3877 '\xbc', '\x27', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3878 '\x00', '\x00', '\x00' };
3879 const char nop10[10] = { '\x8d', '\x76', '\x00', // leal 0(%esi),%esi
2e702c99 3880 '\x8d', '\xbc', '\x27', // leal 0L(%edi,1),%edi
76677ad0
CC		 3881 '\x00', '\x00', '\x00',
3882 '\x00' };
3883 const char nop11[11] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi
2e702c99 3884 '\x00', '\x8d', '\xbc', // leal 0L(%edi,1),%edi
76677ad0
CC		 3885 '\x27', '\x00', '\x00',
3886 '\x00', '\x00' };
3887 const char nop12[12] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3888 '\x00', '\x00', '\x00', // leal 0L(%edi),%edi
76677ad0
CC		 3889 '\x8d', '\xbf', '\x00',
3890 '\x00', '\x00', '\x00' };
3891 const char nop13[13] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3892 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3893 '\x8d', '\xbc', '\x27',
3894 '\x00', '\x00', '\x00',
2e702c99 3895 '\x00' };
76677ad0 3896 const char nop14[14] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi
2e702c99 3897 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3898 '\x00', '\x8d', '\xbc',
3899 '\x27', '\x00', '\x00',
2e702c99 3900 '\x00', '\x00' };
76677ad0 3901 const char nop15[15] = { '\xeb', '\x0d', '\x90', // jmp .+15
2e702c99 3902 '\x90', '\x90', '\x90', // nop,nop,nop,...
76677ad0
CC		 3903 '\x90', '\x90', '\x90',
3904 '\x90', '\x90', '\x90',
2e702c99 3905 '\x90', '\x90', '\x90' };
c51e6221
ILT		 3906
3907 const char* nops[16] = {
3908 NULL,
3909 nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3910 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3911 };
3912
3913 return std::string(nops[length], length);
3914}
3915
02d7cd44
ILT		 3916// Return the value to use for the base of a DW_EH_PE_datarel offset
3917// in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
3918// assembler can not write out the difference between two labels in
3919// different sections, so instead of using a pc-relative value they
3920// use an offset from the GOT.
3921
3922uint64_t
3923Target_i386::do_ehframe_datarel_base() const
3924{
3925 gold_assert(this->global_offset_table_ != NULL);
3926 Symbol* sym = this->global_offset_table_;
3927 Sized_symbol<32>* ssym = static_cast<Sized_symbol<32>*>(sym);
3928 return ssym->value();
3929}
3930
b6848d3c
ILT		 3931// Return whether SYM should be treated as a call to a non-split
3932// function. We don't want that to be true of a call to a
3933// get_pc_thunk function.
3934
3935bool
4d625b70 3936Target_i386::do_is_call_to_non_split(const Symbol* sym,
bd8d853f
MK		 3937 const unsigned char*,
3938 const unsigned char*,
3939 section_size_type) const
b6848d3c
ILT		 3940{
3941 return (sym->type() == elfcpp::STT_FUNC
b6848d3c
ILT		 3942 && !is_prefix_of("__i686.get_pc_thunk.", sym->name()));
3943}
3944
364c7fa5 3945// FNOFFSET in section SHNDX in OBJECT is the start of a function
9b547ce6 3946// compiled with -fsplit-stack. The function calls non-split-stack
364c7fa5
ILT		 3947// code. We have to change the function so that it always ensures
3948// that it has enough stack space to run some random function.
3949
3950void
3951Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx,
2e702c99
RM		 3952 section_offset_type fnoffset,
3953 section_size_type fnsize,
6e0813d3
CC		 3954 const unsigned char*,
3955 size_t,
2e702c99
RM		 3956 unsigned char* view,
3957 section_size_type view_size,
3958 std::string* from,
3959 std::string* to) const
364c7fa5
ILT		 3960{
3961 // The function starts with a comparison of the stack pointer and a
3962 // field in the TCB. This is followed by a jump.
3963
3964 // cmp %gs:NN,%esp
3965 if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3)
3966 && fnsize > 7)
3967 {
3968 // We will call __morestack if the carry flag is set after this
3969 // comparison. We turn the comparison into an stc instruction
3970 // and some nops.
3971 view[fnoffset] = '\xf9';
3972 this->set_view_to_nop(view, view_size, fnoffset + 1, 6);
3973 }
3974 // lea NN(%esp),%ecx
1782c879
ILT		 3975 // lea NN(%esp),%edx
3976 else if ((this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3)
3977 || this->match_view(view, view_size, fnoffset, "\x8d\x94\x24", 3))
364c7fa5
ILT		 3978 && fnsize > 7)
3979 {
3980 // This is loading an offset from the stack pointer for a
3981 // comparison. The offset is negative, so we decrease the
3982 // offset by the amount of space we need for the stack. This
3983 // means we will avoid calling __morestack if there happens to
3984 // be plenty of space on the stack already.
3985 unsigned char* pval = view + fnoffset + 3;
3986 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
3987 val -= parameters->options().split_stack_adjust_size();
3988 elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
3989 }
3990 else
3991 {
3992 if (!object->has_no_split_stack())
3993 object->error(_("failed to match split-stack sequence at "
3994 "section %u offset %0zx"),
ac33a407 3995 shndx, static_cast<size_t>(fnoffset));
364c7fa5
ILT		 3996 return;
3997 }
3998
3999 // We have to change the function so that it calls
4000 // __morestack_non_split instead of __morestack. The former will
4001 // allocate additional stack space.
4002 *from = "__morestack";
4003 *to = "__morestack_non_split";
4004}
4005
2e702c99
RM		 4006// The selector for i386 object files. Note this is never instantiated
4007// directly. It's only used in Target_selector_i386_nacl, below.
14bfc3f5 4008
36959681 4009class Target_selector_i386 : public Target_selector_freebsd
14bfc3f5
ILT		 4010{
4011public:
4012 Target_selector_i386()
36959681 4013 : Target_selector_freebsd(elfcpp::EM_386, 32, false,
03ef7571
ILT		 4014 "elf32-i386", "elf32-i386-freebsd",
4015 "elf_i386")
14bfc3f5
ILT		 4016 { }
4017
4018 Target*
e96caa79
ILT		 4019 do_instantiate_target()
4020 { return new Target_i386(); }
14bfc3f5
ILT		 4021};
4022
2e702c99
RM		 4023// NaCl variant. It uses different PLT contents.
4024
4025class Output_data_plt_i386_nacl : public Output_data_plt_i386
4026{
4027 public:
4028 Output_data_plt_i386_nacl(Layout* layout,
57b2284c 4029 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4030 Output_data_space* got_irelative)
4031 : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)
4032 { }
4033
4034 protected:
4035 virtual unsigned int
4036 do_get_plt_entry_size() const
4037 { return plt_entry_size; }
4038
4039 virtual void
4040 do_add_eh_frame(Layout* layout)
4041 {
4042 layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,
4043 plt_eh_frame_fde, plt_eh_frame_fde_size);
4044 }
4045
4046 // The size of an entry in the PLT.
4047 static const int plt_entry_size = 64;
4048
4049 // The .eh_frame unwind information for the PLT.
4050 static const int plt_eh_frame_fde_size = 32;
4051 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4052};
4053
4054class Output_data_plt_i386_nacl_exec : public Output_data_plt_i386_nacl
4055{
4056public:
4057 Output_data_plt_i386_nacl_exec(Layout* layout,
57b2284c 4058 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4059 Output_data_space* got_irelative)
4060 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4061 { }
4062
4063 protected:
4064 virtual void
4065 do_fill_first_plt_entry(unsigned char* pov,
4066 elfcpp::Elf_types<32>::Elf_Addr got_address);
4067
4068 virtual unsigned int
4069 do_fill_plt_entry(unsigned char* pov,
4070 elfcpp::Elf_types<32>::Elf_Addr got_address,
4071 unsigned int got_offset,
4072 unsigned int plt_offset,
4073 unsigned int plt_rel_offset);
4074
4075 private:
4076 // The first entry in the PLT for an executable.
4077 static const unsigned char first_plt_entry[plt_entry_size];
4078
4079 // Other entries in the PLT for an executable.
4080 static const unsigned char plt_entry[plt_entry_size];
4081};
4082
4083class Output_data_plt_i386_nacl_dyn : public Output_data_plt_i386_nacl
4084{
4085 public:
4086 Output_data_plt_i386_nacl_dyn(Layout* layout,
57b2284c 4087 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4088 Output_data_space* got_irelative)
4089 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4090 { }
4091
4092 protected:
4093 virtual void
4094 do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);
4095
4096 virtual unsigned int
4097 do_fill_plt_entry(unsigned char* pov,
4098 elfcpp::Elf_types<32>::Elf_Addr,
4099 unsigned int got_offset,
4100 unsigned int plt_offset,
4101 unsigned int plt_rel_offset);
4102
4103 private:
4104 // The first entry in the PLT for a shared object.
4105 static const unsigned char first_plt_entry[plt_entry_size];
4106
4107 // Other entries in the PLT for a shared object.
4108 static const unsigned char plt_entry[plt_entry_size];
4109};
4110
4111class Target_i386_nacl : public Target_i386
4112{
4113 public:
4114 Target_i386_nacl()
4115 : Target_i386(&i386_nacl_info)
4116 { }
4117
4118 protected:
4119 virtual Output_data_plt_i386*
4120 do_make_data_plt(Layout* layout,
57b2284c 4121 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4122 Output_data_space* got_irelative,
4123 bool dyn)
4124 {
4125 if (dyn)
4126 return new Output_data_plt_i386_nacl_dyn(layout, got_plt, got_irelative);
4127 else
4128 return new Output_data_plt_i386_nacl_exec(layout, got_plt, got_irelative);
4129 }
4130
93f8221c
RM		 4131 virtual std::string
4132 do_code_fill(section_size_type length) const;
4133
2e702c99
RM		 4134 private:
4135 static const Target::Target_info i386_nacl_info;
4136};
4137
4138const Target::Target_info Target_i386_nacl::i386_nacl_info =
4139{
4140 32, // size
4141 false, // is_big_endian
4142 elfcpp::EM_386, // machine_code
4143 false, // has_make_symbol
4144 false, // has_resolve
4145 true, // has_code_fill
4146 true, // is_default_stack_executable
4147 true, // can_icf_inline_merge_sections
4148 '\0', // wrap_char
4149 "/lib/ld-nacl-x86-32.so.1", // dynamic_linker
4150 0x20000, // default_text_segment_address
4151 0x10000, // abi_pagesize (overridable by -z max-page-size)
4152 0x10000, // common_pagesize (overridable by -z common-page-size)
4153 true, // isolate_execinstr
4154 0x10000000, // rosegment_gap
4155 elfcpp::SHN_UNDEF, // small_common_shndx
4156 elfcpp::SHN_UNDEF, // large_common_shndx
4157 0, // small_common_section_flags
4158 0, // large_common_section_flags
4159 NULL, // attributes_section
a67858e0 4160 NULL, // attributes_vendor
8d9743bd
MK		 4161 "_start", // entry_symbol_name
4162 32, // hash_entry_size
2e702c99
RM		 4163};
4164
4165#define NACLMASK 0xe0 // 32-byte alignment mask
4166
4167const unsigned char
4168Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] =
4169{
4170 0xff, 0x35, // pushl contents of memory address
4171 0, 0, 0, 0, // replaced with address of .got + 4
4172 0x8b, 0x0d, // movl contents of address, %ecx
4173 0, 0, 0, 0, // replaced with address of .got + 8
4174 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4175 0xff, 0xe1, // jmp *%ecx
4176 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4177 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4178 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4179 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4180 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4181 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4182 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4183 0x90, 0x90, 0x90, 0x90, 0x90
4184};
4185
4186void
4187Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry(
4188 unsigned char* pov,
4189 elfcpp::Elf_types<32>::Elf_Addr got_address)
4190{
4191 memcpy(pov, first_plt_entry, plt_entry_size);
4192 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
4193 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
4194}
4195
4196// The first entry in the PLT for a shared object.
4197
4198const unsigned char
4199Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] =
4200{
4201 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx)
4202 0x8b, 0x4b, 0x08, // mov 0x8(%ebx), %ecx
4203 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4204 0xff, 0xe1, // jmp *%ecx
4205 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4206 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4207 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4208 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4209 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4210 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4211 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4212 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4213 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4214 0x90, 0x90, 0x90, 0x90, 0x90 // nops
4215};
4216
4217void
4218Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry(
4219 unsigned char* pov,
4220 elfcpp::Elf_types<32>::Elf_Addr)
4221{
4222 memcpy(pov, first_plt_entry, plt_entry_size);
4223}
4224
4225// Subsequent entries in the PLT for an executable.
4226
4227const unsigned char
4228Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] =
4229{
4230 0x8b, 0x0d, // movl contents of address, %ecx */
4231 0, 0, 0, 0, // replaced with address of symbol in .got
4232 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4233 0xff, 0xe1, // jmp *%ecx
4234
4235 // Pad to the next 32-byte boundary with nop instructions.
4236 0x90,
4237 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4238 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4239
4240 // Lazy GOT entries point here (32-byte aligned).
4241 0x68, // pushl immediate
4242 0, 0, 0, 0, // replaced with offset into relocation table
4243 0xe9, // jmp relative
4244 0, 0, 0, 0, // replaced with offset to start of .plt
4245
4246 // Pad to the next 32-byte boundary with nop instructions.
4247 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4248 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4249 0x90, 0x90
4250};
4251
4252unsigned int
4253Output_data_plt_i386_nacl_exec::do_fill_plt_entry(
4254 unsigned char* pov,
4255 elfcpp::Elf_types<32>::Elf_Addr got_address,
4256 unsigned int got_offset,
4257 unsigned int plt_offset,
4258 unsigned int plt_rel_offset)
4259{
4260 memcpy(pov, plt_entry, plt_entry_size);
4261 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4262 got_address + got_offset);
4263 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4264 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4265 return 32;
4266}
4267
4268// Subsequent entries in the PLT for a shared object.
4269
4270const unsigned char
4271Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] =
4272{
4273 0x8b, 0x8b, // movl offset(%ebx), %ecx
4274 0, 0, 0, 0, // replaced with offset of symbol in .got
4275 0x83, 0xe1, 0xe0, // andl $NACLMASK, %ecx
4276 0xff, 0xe1, // jmp *%ecx
4277
4278 // Pad to the next 32-byte boundary with nop instructions.
4279 0x90,
4280 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4281 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4282
4283 // Lazy GOT entries point here (32-byte aligned).
4284 0x68, // pushl immediate
4285 0, 0, 0, 0, // replaced with offset into relocation table.
4286 0xe9, // jmp relative
4287 0, 0, 0, 0, // replaced with offset to start of .plt.
4288
4289 // Pad to the next 32-byte boundary with nop instructions.
4290 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4291 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4292 0x90, 0x90
4293};
4294
4295unsigned int
4296Output_data_plt_i386_nacl_dyn::do_fill_plt_entry(
4297 unsigned char* pov,
4298 elfcpp::Elf_types<32>::Elf_Addr,
4299 unsigned int got_offset,
4300 unsigned int plt_offset,
4301 unsigned int plt_rel_offset)
4302{
4303 memcpy(pov, plt_entry, plt_entry_size);
4304 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
4305 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4306 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4307 return 32;
4308}
4309
4310const unsigned char
4311Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] =
4312{
4313 0, 0, 0, 0, // Replaced with offset to .plt.
4314 0, 0, 0, 0, // Replaced with size of .plt.
4315 0, // Augmentation size.
4316 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8.
4317 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
4318 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12.
4319 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64.
4320 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
4321 13, // Block length.
4322 elfcpp::DW_OP_breg4, 4, // Push %esp + 4.
4323 elfcpp::DW_OP_breg8, 0, // Push %eip.
4324 elfcpp::DW_OP_const1u, 63, // Push 0x3f.
4325 elfcpp::DW_OP_and, // & (%eip & 0x3f).
4326 elfcpp::DW_OP_const1u, 37, // Push 0x25.
4327 elfcpp::DW_OP_ge, // >= ((%eip & 0x3f) >= 0x25)
4328 elfcpp::DW_OP_lit2, // Push 2.
4329 elfcpp::DW_OP_shl, // << (((%eip & 0x3f) >= 0x25) << 2)
4330 elfcpp::DW_OP_plus, // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4
4331 elfcpp::DW_CFA_nop, // Align to 32 bytes.
4332 elfcpp::DW_CFA_nop
4333};
4334
93f8221c
RM		 4335// Return a string used to fill a code section with nops.
4336// For NaCl, long NOPs are only valid if they do not cross
4337// bundle alignment boundaries, so keep it simple with one-byte NOPs.
4338std::string
4339Target_i386_nacl::do_code_fill(section_size_type length) const
4340{
4341 return std::string(length, static_cast<char>(0x90));
4342}
4343
2e702c99
RM		 4344// The selector for i386-nacl object files.
4345
4346class Target_selector_i386_nacl
4347 : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl>
4348{
4349 public:
4350 Target_selector_i386_nacl()
4351 : Target_selector_nacl<Target_selector_i386,
4352 Target_i386_nacl>("x86-32",
4353 "elf32-i386-nacl",
4354 "elf_i386_nacl")
4355 { }
4356};
4357
4358Target_selector_i386_nacl target_selector_i386;
14bfc3f5 4359
01f573ad
L		 4360// IAMCU variant. It uses EM_IAMCU, not EM_386.
4361
4362class Target_iamcu : public Target_i386
4363{
4364 public:
4365 Target_iamcu()
4366 : Target_i386(&iamcu_info)
4367 { }
4368
4369 private:
4370 // Information about this specific target which we pass to the
4371 // general Target structure.
4372 static const Target::Target_info iamcu_info;
4373};
4374
4375const Target::Target_info Target_iamcu::iamcu_info =
4376{
4377 32, // size
4378 false, // is_big_endian
4379 elfcpp::EM_IAMCU, // machine_code
4380 false, // has_make_symbol
4381 false, // has_resolve
4382 true, // has_code_fill
4383 true, // is_default_stack_executable
4384 true, // can_icf_inline_merge_sections
4385 '\0', // wrap_char
4386 "/usr/lib/libc.so.1", // dynamic_linker
4387 0x08048000, // default_text_segment_address
4388 0x1000, // abi_pagesize (overridable by -z max-page-size)
4389 0x1000, // common_pagesize (overridable by -z common-page-size)
4390 false, // isolate_execinstr
4391 0, // rosegment_gap
4392 elfcpp::SHN_UNDEF, // small_common_shndx
4393 elfcpp::SHN_UNDEF, // large_common_shndx
4394 0, // small_common_section_flags
4395 0, // large_common_section_flags
4396 NULL, // attributes_section
4397 NULL, // attributes_vendor
8d9743bd
MK		 4398 "_start", // entry_symbol_name
4399 32, // hash_entry_size
01f573ad
L		 4400};
4401
4402class Target_selector_iamcu : public Target_selector
4403{
4404public:
4405 Target_selector_iamcu()
4406 : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu",
4407 "elf_iamcu")
4408 { }
4409
4410 Target*
4411 do_instantiate_target()
4412 { return new Target_iamcu(); }
4413};
4414
4415Target_selector_iamcu target_selector_iamcu;
4416
14bfc3f5 4417} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 0.685841 seconds and 4 git commands to generate.