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