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