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