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