projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gold: Support x86-64 TLS code sequences without PLT
[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
2e702c99 2793 && r_type != elfcpp::R_386_PC32)
ead1e424
ILT		 2794 || gsym == NULL
2795 || strcmp(gsym->name(), "___tls_get_addr") != 0)
75f2446e
ILT		 2796 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2797 _("missing expected TLS relocation"));
2798 else
ead1e424 2799 {
75f2446e
ILT		 2800 this->skip_call_tls_get_addr_ = false;
2801 return false;
ead1e424 2802 }
ead1e424
ILT		 2803 }
2804
0e804863
ILT		 2805 if (view == NULL)
2806 return true;
2807
6fa2a40b 2808 const Sized_relobj_file<32, false>* object = relinfo->object;
7223e9ca 2809
a3ad94ed 2810 // Pick the value to use for symbols defined in shared objects.
b8e6aad9 2811 Symbol_value<32> symval;
436ca963 2812 if (gsym != NULL
7223e9ca
ILT		 2813 && gsym->type() == elfcpp::STT_GNU_IFUNC
2814 && r_type == elfcpp::R_386_32
95a2c8d6 2815 && gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))
7223e9ca
ILT		 2816 && gsym->can_use_relative_reloc(false)
2817 && !gsym->is_from_dynobj()
2818 && !gsym->is_undefined()
2819 && !gsym->is_preemptible())
2820 {
2821 // In this case we are generating a R_386_IRELATIVE reloc. We
2822 // want to use the real value of the symbol, not the PLT offset.
2823 }
2824 else if (gsym != NULL
95a2c8d6 2825 && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
a3ad94ed 2826 {
19fec8c1 2827 symval.set_output_value(target->plt_address_for_global(gsym));
b8e6aad9 2828 psymval = &symval;
a3ad94ed 2829 }
7223e9ca
ILT		 2830 else if (gsym == NULL && psymval->is_ifunc_symbol())
2831 {
2832 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2833 if (object->local_has_plt_offset(r_sym))
2834 {
19fec8c1 2835 symval.set_output_value(target->plt_address_for_local(object, r_sym));
7223e9ca
ILT		 2836 psymval = &symval;
2837 }
2838 }
b8e6aad9 2839
3043c1ab
L		 2840 bool baseless;
2841
61ba1cf9
ILT		 2842 switch (r_type)
2843 {
2844 case elfcpp::R_386_NONE:
92e059d8
ILT		 2845 case elfcpp::R_386_GNU_VTINHERIT:
2846 case elfcpp::R_386_GNU_VTENTRY:
61ba1cf9
ILT		 2847 break;
2848
2849 case elfcpp::R_386_32:
95a2c8d6 2850 if (should_apply_static_reloc(gsym, r_type, true, output_section))
2e702c99 2851 Relocate_functions<32, false>::rel32(view, object, psymval);
61ba1cf9
ILT		 2852 break;
2853
2854 case elfcpp::R_386_PC32:
95a2c8d6 2855 if (should_apply_static_reloc(gsym, r_type, true, output_section))
2e702c99 2856 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
92e059d8
ILT		 2857 break;
2858
2859 case elfcpp::R_386_16:
95a2c8d6 2860 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2861 Relocate_functions<32, false>::rel16(view, object, psymval);
92e059d8
ILT		 2862 break;
2863
2864 case elfcpp::R_386_PC16:
95a2c8d6 2865 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2866 Relocate_functions<32, false>::pcrel16(view, object, psymval, address);
61ba1cf9
ILT		 2867 break;
2868
92e059d8 2869 case elfcpp::R_386_8:
95a2c8d6 2870 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2871 Relocate_functions<32, false>::rel8(view, object, psymval);
92e059d8
ILT		 2872 break;
2873
2874 case elfcpp::R_386_PC8:
95a2c8d6 2875 if (should_apply_static_reloc(gsym, r_type, false, output_section))
2e702c99 2876 Relocate_functions<32, false>::pcrel8(view, object, psymval, address);
92e059d8
ILT		 2877 break;
2878
ead1e424 2879 case elfcpp::R_386_PLT32:
df2efe71
ILT		 2880 gold_assert(gsym == NULL
2881 || gsym->has_plt_offset()
99f8faca
ILT		 2882 || gsym->final_value_is_known()
2883 || (gsym->is_defined()
2884 && !gsym->is_from_dynobj()
2885 && !gsym->is_preemptible()));
b8e6aad9 2886 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
ead1e424
ILT		 2887 break;
2888
2889 case elfcpp::R_386_GOT32:
493d4b48 2890 case elfcpp::R_386_GOT32X:
3043c1ab
L		 2891 baseless = (view[-1] & 0xc7) == 0x5;
2892 // R_386_GOT32 and R_386_GOT32X don't work without base register
2893 // when generating a position-independent output file.
2894 if (baseless
2895 && parameters->options().output_is_position_independent())
2896 {
2897 if(gsym)
2898 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2899 _("unexpected reloc %u against global symbol %s without base register in object file when generating a position-independent output file"),
2900 r_type, gsym->demangled_name().c_str());
2901 else
2902 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2903 _("unexpected reloc %u against local symbol without base register in object file when generating a position-independent output file"),
2904 r_type);
2905 }
2906
c4fc4724
IT		 2907 // Convert
2908 // mov foo@GOT(%reg), %reg
2909 // to
2910 // lea foo@GOTOFF(%reg), %reg
2911 // if possible.
2912 if (rel.get_r_offset() >= 2
2913 && view[-2] == 0x8b
2914 && ((gsym == NULL && !psymval->is_ifunc_symbol())
2915 || (gsym != NULL
2916 && Target_i386::can_convert_mov_to_lea(gsym))))
2917 {
2918 view[-2] = 0x8d;
2919 elfcpp::Elf_types<32>::Elf_Addr value;
3043c1ab
L		 2920 value = psymval->value(object, 0);
2921 // Don't subtract the .got.plt section address for baseless
2922 // addressing.
2923 if (!baseless)
2924 value -= target->got_plt_section()->address();
c4fc4724
IT		 2925 Relocate_functions<32, false>::rel32(view, value);
2926 }
2927 else
2928 {
2929 // The GOT pointer points to the end of the GOT section.
2930 // We need to subtract the size of the GOT section to get
2931 // the actual offset to use in the relocation.
2932 unsigned int got_offset = 0;
2933 if (gsym != NULL)
2934 {
2935 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2936 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD)
2937 - target->got_size());
2938 }
2939 else
2940 {
2941 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2942 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2943 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
2944 - target->got_size());
2945 }
3043c1ab
L		 2946 // Add the .got.plt section address for baseless addressing.
2947 if (baseless)
2948 got_offset += target->got_plt_section()->address();
c4fc4724
IT		 2949 Relocate_functions<32, false>::rel32(view, got_offset);
2950 }
ead1e424
ILT		 2951 break;
2952
2953 case elfcpp::R_386_GOTOFF:
b8e6aad9
ILT		 2954 {
2955 elfcpp::Elf_types<32>::Elf_Addr value;
2956 value = (psymval->value(object, 0)
96f2030e 2957 - target->got_plt_section()->address());
b8e6aad9
ILT		 2958 Relocate_functions<32, false>::rel32(view, value);
2959 }
ead1e424
ILT		 2960 break;
2961
2962 case elfcpp::R_386_GOTPC:
b8e6aad9
ILT		 2963 {
2964 elfcpp::Elf_types<32>::Elf_Addr value;
96f2030e 2965 value = target->got_plt_section()->address();
b8e6aad9
ILT		 2966 Relocate_functions<32, false>::pcrel32(view, value, address);
2967 }
ead1e424
ILT		 2968 break;
2969
92e059d8
ILT		 2970 case elfcpp::R_386_COPY:
2971 case elfcpp::R_386_GLOB_DAT:
2972 case elfcpp::R_386_JUMP_SLOT:
2973 case elfcpp::R_386_RELATIVE:
7223e9ca 2974 case elfcpp::R_386_IRELATIVE:
d61c17ea
ILT		 2975 // These are outstanding tls relocs, which are unexpected when
2976 // linking.
92e059d8
ILT		 2977 case elfcpp::R_386_TLS_TPOFF:
2978 case elfcpp::R_386_TLS_DTPMOD32:
2979 case elfcpp::R_386_TLS_DTPOFF32:
2980 case elfcpp::R_386_TLS_TPOFF32:
2981 case elfcpp::R_386_TLS_DESC:
75f2446e
ILT		 2982 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2983 _("unexpected reloc %u in object file"),
2984 r_type);
92e059d8
ILT		 2985 break;
2986
d61c17ea
ILT		 2987 // These are initial tls relocs, which are expected when
2988 // linking.
56622147
ILT		 2989 case elfcpp::R_386_TLS_GD: // Global-dynamic
2990 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
2991 case elfcpp::R_386_TLS_DESC_CALL:
2992 case elfcpp::R_386_TLS_LDM: // Local-dynamic
2993 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
2994 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 2995 case elfcpp::R_386_TLS_IE_32:
56622147
ILT		 2996 case elfcpp::R_386_TLS_GOTIE:
2997 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 2998 case elfcpp::R_386_TLS_LE_32:
07f397ab 2999 this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval,
2e702c99 3000 view, address, view_size);
92e059d8
ILT		 3001 break;
3002
92e059d8
ILT		 3003 case elfcpp::R_386_32PLT:
3004 case elfcpp::R_386_TLS_GD_32:
3005 case elfcpp::R_386_TLS_GD_PUSH:
3006 case elfcpp::R_386_TLS_GD_CALL:
3007 case elfcpp::R_386_TLS_GD_POP:
3008 case elfcpp::R_386_TLS_LDM_32:
3009 case elfcpp::R_386_TLS_LDM_PUSH:
3010 case elfcpp::R_386_TLS_LDM_CALL:
3011 case elfcpp::R_386_TLS_LDM_POP:
3012 case elfcpp::R_386_USED_BY_INTEL_200:
61ba1cf9 3013 default:
75f2446e
ILT		 3014 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3015 _("unsupported reloc %u"),
3016 r_type);
92e059d8
ILT		 3017 break;
3018 }
ead1e424
ILT		 3019
3020 return true;
92e059d8
ILT		 3021}
3022
3023// Perform a TLS relocation.
3024
3025inline void
3026Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
2e702c99 3027 Target_i386* target,
92e059d8
ILT		 3028 size_t relnum,
3029 const elfcpp::Rel<32, false>& rel,
3030 unsigned int r_type,
c06b7b0b 3031 const Sized_symbol<32>* gsym,
b8e6aad9 3032 const Symbol_value<32>* psymval,
92e059d8
ILT		 3033 unsigned char* view,
3034 elfcpp::Elf_types<32>::Elf_Addr,
fe8718a4 3035 section_size_type view_size)
92e059d8
ILT		 3036{
3037 Output_segment* tls_segment = relinfo->layout->tls_segment();
92e059d8 3038
6fa2a40b 3039 const Sized_relobj_file<32, false>* object = relinfo->object;
07f397ab
ILT		 3040
3041 elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0);
b8e6aad9 3042
b3705d2a
ILT		 3043 const bool is_final = (gsym == NULL
3044 ? !parameters->options().shared()
3045 : gsym->final_value_is_known());
af6359d5
ILT		 3046 const tls::Tls_optimization optimized_type
3047 = Target_i386::optimize_tls_reloc(is_final, r_type);
92e059d8
ILT		 3048 switch (r_type)
3049 {
56622147 3050 case elfcpp::R_386_TLS_GD: // Global-dynamic
af6359d5 3051 if (optimized_type == tls::TLSOPT_TO_LE)
92e059d8 3052 {
62855347
ILT		 3053 if (tls_segment == NULL)
3054 {
191f1a2d
ILT		 3055 gold_assert(parameters->errors()->error_count() > 0
3056 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3057 return;
3058 }
56622147
ILT		 3059 this->tls_gd_to_le(relinfo, relnum, tls_segment,
3060 rel, r_type, value, view,
3061 view_size);
92e059d8
ILT		 3062 break;
3063 }
07f397ab 3064 else
2e702c99
RM		 3065 {
3066 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3067 ? GOT_TYPE_TLS_NOFFSET
3068 : GOT_TYPE_TLS_PAIR);
3069 unsigned int got_offset;
3070 if (gsym != NULL)
3071 {
3072 gold_assert(gsym->has_got_offset(got_type));
3073 got_offset = gsym->got_offset(got_type) - target->got_size();
3074 }
3075 else
3076 {
3077 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3078 gold_assert(object->local_has_got_offset(r_sym, got_type));
3079 got_offset = (object->local_got_offset(r_sym, got_type)
07f397ab 3080 - target->got_size());
2e702c99
RM		 3081 }
3082 if (optimized_type == tls::TLSOPT_TO_IE)
07f397ab 3083 {
d21f123b 3084 this->tls_gd_to_ie(relinfo, relnum, rel, r_type,
2e702c99
RM		 3085 got_offset, view, view_size);
3086 break;
3087 }
3088 else if (optimized_type == tls::TLSOPT_NONE)
3089 {
3090 // Relocate the field with the offset of the pair of GOT
3091 // entries.
3092 Relocate_functions<32, false>::rel32(view, got_offset);
3093 break;
07f397ab 3094 }
2e702c99 3095 }
75f2446e
ILT		 3096 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3097 _("unsupported reloc %u"),
3098 r_type);
92e059d8
ILT		 3099 break;
3100
56622147
ILT		 3101 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
3102 case elfcpp::R_386_TLS_DESC_CALL:
497897f9 3103 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
c2b45e22 3104 if (optimized_type == tls::TLSOPT_TO_LE)
2e702c99 3105 {
62855347
ILT		 3106 if (tls_segment == NULL)
3107 {
191f1a2d
ILT		 3108 gold_assert(parameters->errors()->error_count() > 0
3109 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3110 return;
3111 }
c2b45e22 3112 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
2e702c99
RM		 3113 rel, r_type, value, view,
3114 view_size);
c2b45e22 3115 break;
2e702c99 3116 }
c2b45e22 3117 else
2e702c99
RM		 3118 {
3119 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3120 ? GOT_TYPE_TLS_NOFFSET
3121 : GOT_TYPE_TLS_DESC);
3122 unsigned int got_offset = 0;
a8df5856
ILT		 3123 if (r_type == elfcpp::R_386_TLS_GOTDESC
3124 && optimized_type == tls::TLSOPT_NONE)
3125 {
3126 // We created GOT entries in the .got.tlsdesc portion of
3127 // the .got.plt section, but the offset stored in the
3128 // symbol is the offset within .got.tlsdesc.
3129 got_offset = (target->got_size()
3130 + target->got_plt_section()->data_size());
3131 }
2e702c99
RM		 3132 if (gsym != NULL)
3133 {
3134 gold_assert(gsym->has_got_offset(got_type));
3135 got_offset += gsym->got_offset(got_type) - target->got_size();
3136 }
3137 else
3138 {
3139 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3140 gold_assert(object->local_has_got_offset(r_sym, got_type));
3141 got_offset += (object->local_got_offset(r_sym, got_type)
a8df5856 3142 - target->got_size());
2e702c99
RM		 3143 }
3144 if (optimized_type == tls::TLSOPT_TO_IE)
c2b45e22 3145 {
d21f123b 3146 this->tls_desc_gd_to_ie(relinfo, relnum, rel, r_type,
2e702c99
RM		 3147 got_offset, view, view_size);
3148 break;
3149 }
3150 else if (optimized_type == tls::TLSOPT_NONE)
3151 {
3152 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3153 {
3154 // Relocate the field with the offset of the pair of GOT
3155 // entries.
3156 Relocate_functions<32, false>::rel32(view, got_offset);
3157 }
3158 break;
c2b45e22 3159 }
2e702c99 3160 }
75f2446e
ILT		 3161 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3162 _("unsupported reloc %u"),
3163 r_type);
ead1e424
ILT		 3164 break;
3165
56622147 3166 case elfcpp::R_386_TLS_LDM: // Local-dynamic
46cf9fa2
ILT		 3167 if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN)
3168 {
75f2446e
ILT		 3169 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3170 _("both SUN and GNU model "
3171 "TLS relocations"));
3172 break;
46cf9fa2
ILT		 3173 }
3174 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
af6359d5 3175 if (optimized_type == tls::TLSOPT_TO_LE)
46cf9fa2 3176 {
62855347
ILT		 3177 if (tls_segment == NULL)
3178 {
191f1a2d
ILT		 3179 gold_assert(parameters->errors()->error_count() > 0
3180 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3181 return;
3182 }
46cf9fa2
ILT		 3183 this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type,
3184 value, view, view_size);
3185 break;
3186 }
07f397ab 3187 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3188 {
3189 // Relocate the field with the offset of the GOT entry for
3190 // the module index.
3191 unsigned int got_offset;
3192 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
94c4710f 3193 - target->got_size());
2e702c99
RM		 3194 Relocate_functions<32, false>::rel32(view, got_offset);
3195 break;
3196 }
75f2446e
ILT		 3197 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3198 _("unsupported reloc %u"),
3199 r_type);
46cf9fa2
ILT		 3200 break;
3201
56622147 3202 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
d6f22b98 3203 if (optimized_type == tls::TLSOPT_TO_LE)
e8a9fcda 3204 {
82bb573a
ILT		 3205 // This reloc can appear in debugging sections, in which
3206 // case we must not convert to local-exec. We decide what
3207 // to do based on whether the section is marked as
3208 // containing executable code. That is what the GNU linker
3209 // does as well.
3210 elfcpp::Shdr<32, false> shdr(relinfo->data_shdr);
3211 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
d6f22b98 3212 {
62855347
ILT		 3213 if (tls_segment == NULL)
3214 {
191f1a2d
ILT		 3215 gold_assert(parameters->errors()->error_count() > 0
3216 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3217 return;
3218 }
d6f22b98
ILT		 3219 value -= tls_segment->memsz();
3220 }
e8a9fcda 3221 }
46cf9fa2
ILT		 3222 Relocate_functions<32, false>::rel32(view, value);
3223 break;
3224
56622147
ILT		 3225 case elfcpp::R_386_TLS_IE: // Initial-exec
3226 case elfcpp::R_386_TLS_GOTIE:
3227 case elfcpp::R_386_TLS_IE_32:
3228 if (optimized_type == tls::TLSOPT_TO_LE)
3229 {
62855347
ILT		 3230 if (tls_segment == NULL)
3231 {
191f1a2d
ILT		 3232 gold_assert(parameters->errors()->error_count() > 0
3233 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3234 return;
3235 }
56622147
ILT		 3236 Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3237 rel, r_type, value, view,
3238 view_size);
3239 break;
3240 }
07f397ab 3241 else if (optimized_type == tls::TLSOPT_NONE)
2e702c99
RM		 3242 {
3243 // Relocate the field with the offset of the GOT entry for
3244 // the tp-relative offset of the symbol.
c2b45e22 3245 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2e702c99
RM		 3246 ? GOT_TYPE_TLS_OFFSET
3247 : GOT_TYPE_TLS_NOFFSET);
3248 unsigned int got_offset;
3249 if (gsym != NULL)
3250 {
3251 gold_assert(gsym->has_got_offset(got_type));
3252 got_offset = gsym->got_offset(got_type);
3253 }
3254 else
3255 {
3256 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3257 gold_assert(object->local_has_got_offset(r_sym, got_type));
3258 got_offset = object->local_got_offset(r_sym, got_type);
3259 }
3260 // For the R_386_TLS_IE relocation, we need to apply the
3261 // absolute address of the GOT entry.
3262 if (r_type == elfcpp::R_386_TLS_IE)
3263 got_offset += target->got_plt_section()->address();
3264 // All GOT offsets are relative to the end of the GOT.
3265 got_offset -= target->got_size();
3266 Relocate_functions<32, false>::rel32(view, got_offset);
3267 break;
3268 }
75f2446e
ILT		 3269 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3270 _("unsupported reloc %u"),
3271 r_type);
92e059d8 3272 break;
92e059d8 3273
56622147 3274 case elfcpp::R_386_TLS_LE: // Local-exec
7bf1f802
ILT		 3275 // If we're creating a shared library, a dynamic relocation will
3276 // have been created for this location, so do not apply it now.
8851ecca 3277 if (!parameters->options().shared())
2e702c99 3278 {
62855347
ILT		 3279 if (tls_segment == NULL)
3280 {
191f1a2d
ILT		 3281 gold_assert(parameters->errors()->error_count() > 0
3282 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3283 return;
3284 }
2e702c99
RM		 3285 value -= tls_segment->memsz();
3286 Relocate_functions<32, false>::rel32(view, value);
3287 }
56622147 3288 break;
92e059d8 3289
56622147 3290 case elfcpp::R_386_TLS_LE_32:
7bf1f802
ILT		 3291 // If we're creating a shared library, a dynamic relocation will
3292 // have been created for this location, so do not apply it now.
8851ecca 3293 if (!parameters->options().shared())
2e702c99 3294 {
62855347
ILT		 3295 if (tls_segment == NULL)
3296 {
191f1a2d
ILT		 3297 gold_assert(parameters->errors()->error_count() > 0
3298 || issue_undefined_symbol_error(gsym));
62855347
ILT		 3299 return;
3300 }
2e702c99
RM		 3301 value = tls_segment->memsz() - value;
3302 Relocate_functions<32, false>::rel32(view, value);
3303 }
56622147 3304 break;
92e059d8 3305 }
92e059d8
ILT		 3306}
3307
e041f13d 3308// Do a relocation in which we convert a TLS General-Dynamic to a
ead1e424
ILT		 3309// Local-Exec.
3310
3311inline void
3312Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo,
3313 size_t relnum,
3314 Output_segment* tls_segment,
3315 const elfcpp::Rel<32, false>& rel,
3316 unsigned int,
3317 elfcpp::Elf_types<32>::Elf_Addr value,
3318 unsigned char* view,
fe8718a4 3319 section_size_type view_size)
ead1e424
ILT		 3320{
3321 // leal foo(,%reg,1),%eax; call ___tls_get_addr
46cf9fa2 3322 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
ead1e424
ILT		 3323 // leal foo(%reg),%eax; call ___tls_get_addr
3324 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3325
af6359d5
ILT		 3326 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3327 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
ead1e424
ILT		 3328
3329 unsigned char op1 = view[-1];
3330 unsigned char op2 = view[-2];
3331
af6359d5 3332 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3333 op2 == 0x8d || op2 == 0x04);
af6359d5 3334 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
ead1e424
ILT		 3335
3336 int roff = 5;
3337
3338 if (op2 == 0x04)
3339 {
af6359d5
ILT		 3340 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3341 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3342 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3343 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
ead1e424
ILT		 3344 memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3345 }
3346 else
3347 {
af6359d5 3348 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3349 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
fe8718a4 3350 if (rel.get_r_offset() + 9 < view_size
2e702c99 3351 && view[9] == 0x90)
ead1e424
ILT		 3352 {
3353 // There is a trailing nop. Use the size byte subl.
3354 memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3355 roff = 6;
3356 }
3357 else
3358 {
3359 // Use the five byte subl.
3360 memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
3361 }
3362 }
3363
7bf1f802 3364 value = tls_segment->memsz() - value;
ead1e424
ILT		 3365 Relocate_functions<32, false>::rel32(view + roff, value);
3366
3367 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3368 // We can skip it.
3369 this->skip_call_tls_get_addr_ = true;
3370}
3371
7bf1f802 3372// Do a relocation in which we convert a TLS General-Dynamic to an
07f397ab
ILT		 3373// Initial-Exec.
3374
3375inline void
3376Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo,
3377 size_t relnum,
07f397ab
ILT		 3378 const elfcpp::Rel<32, false>& rel,
3379 unsigned int,
3380 elfcpp::Elf_types<32>::Elf_Addr value,
3381 unsigned char* view,
fe8718a4 3382 section_size_type view_size)
07f397ab
ILT		 3383{
3384 // leal foo(,%ebx,1),%eax; call ___tls_get_addr
3385 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
152f7024
CC		 3386 // leal foo(%ebx),%eax; call ___tls_get_addr; nop
3387 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
07f397ab
ILT		 3388
3389 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3390 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3391
3392 unsigned char op1 = view[-1];
3393 unsigned char op2 = view[-2];
3394
3395 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3396 op2 == 0x8d || op2 == 0x04);
07f397ab
ILT		 3397 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
3398
152f7024 3399 int roff;
07f397ab
ILT		 3400
3401 if (op2 == 0x04)
3402 {
3403 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3404 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3405 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3406 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
152f7024 3407 roff = 5;
07f397ab
ILT		 3408 }
3409 else
3410 {
152f7024 3411 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 10);
07f397ab 3412 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3413 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
152f7024
CC		 3414 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[9] == 0x90);
3415 roff = 6;
07f397ab
ILT		 3416 }
3417
152f7024 3418 memcpy(view + roff - 8, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12);
07f397ab
ILT		 3419 Relocate_functions<32, false>::rel32(view + roff, value);
3420
3421 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3422 // We can skip it.
3423 this->skip_call_tls_get_addr_ = true;
3424}
3425
c2b45e22
CC		 3426// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3427// General-Dynamic to a Local-Exec.
3428
3429inline void
3430Target_i386::Relocate::tls_desc_gd_to_le(
3431 const Relocate_info<32, false>* relinfo,
3432 size_t relnum,
3433 Output_segment* tls_segment,
3434 const elfcpp::Rel<32, false>& rel,
3435 unsigned int r_type,
3436 elfcpp::Elf_types<32>::Elf_Addr value,
3437 unsigned char* view,
3438 section_size_type view_size)
3439{
3440 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3441 {
3442 // leal foo@TLSDESC(%ebx), %eax
3443 // ==> leal foo@NTPOFF, %eax
3444 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3445 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3446 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3447 view[-2] == 0x8d && view[-1] == 0x83);
c2b45e22
CC		 3448 view[-1] = 0x05;
3449 value -= tls_segment->memsz();
3450 Relocate_functions<32, false>::rel32(view, value);
3451 }
3452 else
3453 {
3454 // call *foo@TLSCALL(%eax)
3455 // ==> nop; nop
3456 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3457 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3458 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3459 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 3460 view[0] = 0x66;
3461 view[1] = 0x90;
3462 }
3463}
3464
3465// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3466// General-Dynamic to an Initial-Exec.
3467
3468inline void
3469Target_i386::Relocate::tls_desc_gd_to_ie(
3470 const Relocate_info<32, false>* relinfo,
3471 size_t relnum,
c2b45e22
CC		 3472 const elfcpp::Rel<32, false>& rel,
3473 unsigned int r_type,
3474 elfcpp::Elf_types<32>::Elf_Addr value,
3475 unsigned char* view,
3476 section_size_type view_size)
3477{
3478 if (r_type == elfcpp::R_386_TLS_GOTDESC)
3479 {
3480 // leal foo@TLSDESC(%ebx), %eax
3481 // ==> movl foo@GOTNTPOFF(%ebx), %eax
3482 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3483 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3484 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3485 view[-2] == 0x8d && view[-1] == 0x83);
c2b45e22
CC		 3486 view[-2] = 0x8b;
3487 Relocate_functions<32, false>::rel32(view, value);
3488 }
3489 else
3490 {
3491 // call *foo@TLSCALL(%eax)
3492 // ==> nop; nop
3493 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3494 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3495 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3496 view[0] == 0xff && view[1] == 0x10);
c2b45e22
CC		 3497 view[0] = 0x66;
3498 view[1] = 0x90;
3499 }
3500}
3501
46cf9fa2
ILT		 3502// Do a relocation in which we convert a TLS Local-Dynamic to a
3503// Local-Exec.
3504
3505inline void
3506Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo,
3507 size_t relnum,
3508 Output_segment*,
3509 const elfcpp::Rel<32, false>& rel,
3510 unsigned int,
3511 elfcpp::Elf_types<32>::Elf_Addr,
3512 unsigned char* view,
fe8718a4 3513 section_size_type view_size)
46cf9fa2
ILT		 3514{
3515 // leal foo(%reg), %eax; call ___tls_get_addr
3516 // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi
3517
af6359d5
ILT		 3518 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3519 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
46cf9fa2
ILT		 3520
3521 // FIXME: Does this test really always pass?
af6359d5 3522 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3523 view[-2] == 0x8d && view[-1] == 0x83);
46cf9fa2 3524
af6359d5 3525 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
46cf9fa2
ILT		 3526
3527 memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11);
3528
3529 // The next reloc should be a PLT32 reloc against __tls_get_addr.
3530 // We can skip it.
3531 this->skip_call_tls_get_addr_ = true;
3532}
3533
56622147
ILT		 3534// Do a relocation in which we convert a TLS Initial-Exec to a
3535// Local-Exec.
3536
3537inline void
3538Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo,
3539 size_t relnum,
3540 Output_segment* tls_segment,
3541 const elfcpp::Rel<32, false>& rel,
3542 unsigned int r_type,
3543 elfcpp::Elf_types<32>::Elf_Addr value,
3544 unsigned char* view,
fe8718a4 3545 section_size_type view_size)
56622147
ILT		 3546{
3547 // We have to actually change the instructions, which means that we
3548 // need to examine the opcodes to figure out which instruction we
3549 // are looking at.
3550 if (r_type == elfcpp::R_386_TLS_IE)
3551 {
3552 // movl %gs:XX,%eax ==> movl $YY,%eax
3553 // movl %gs:XX,%reg ==> movl $YY,%reg
3554 // addl %gs:XX,%reg ==> addl $YY,%reg
3555 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1);
3556 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3557
3558 unsigned char op1 = view[-1];
3559 if (op1 == 0xa1)
3560 {
3561 // movl XX,%eax ==> movl $YY,%eax
3562 view[-1] = 0xb8;
3563 }
3564 else
3565 {
3566 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3567
3568 unsigned char op2 = view[-2];
3569 if (op2 == 0x8b)
3570 {
3571 // movl XX,%reg ==> movl $YY,%reg
3572 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3573 (op1 & 0xc7) == 0x05);
56622147
ILT		 3574 view[-2] = 0xc7;
3575 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3576 }
3577 else if (op2 == 0x03)
3578 {
3579 // addl XX,%reg ==> addl $YY,%reg
3580 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3581 (op1 & 0xc7) == 0x05);
56622147
ILT		 3582 view[-2] = 0x81;
3583 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3584 }
3585 else
3586 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3587 }
3588 }
3589 else
3590 {
3591 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
3592 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
3593 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
3594 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3595 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3596
3597 unsigned char op1 = view[-1];
3598 unsigned char op2 = view[-2];
3599 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2e702c99 3600 (op1 & 0xc0) == 0x80 && (op1 & 7) != 4);
56622147
ILT		 3601 if (op2 == 0x8b)
3602 {
3603 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
3604 view[-2] = 0xc7;
3605 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3606 }
3607 else if (op2 == 0x2b)
3608 {
3609 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
3610 view[-2] = 0x81;
3611 view[-1] = 0xe8 | ((op1 >> 3) & 7);
3612 }
3613 else if (op2 == 0x03)
3614 {
3615 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
3616 view[-2] = 0x81;
3617 view[-1] = 0xc0 | ((op1 >> 3) & 7);
3618 }
3619 else
3620 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3621 }
3622
7bf1f802 3623 value = tls_segment->memsz() - value;
56622147
ILT		 3624 if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE)
3625 value = - value;
3626
3627 Relocate_functions<32, false>::rel32(view, value);
3628}
3629
61ba1cf9
ILT		 3630// Relocate section data.
3631
3632void
92e059d8 3633Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
61ba1cf9
ILT		 3634 unsigned int sh_type,
3635 const unsigned char* prelocs,
3636 size_t reloc_count,
730cdc88
ILT		 3637 Output_section* output_section,
3638 bool needs_special_offset_handling,
61ba1cf9
ILT		 3639 unsigned char* view,
3640 elfcpp::Elf_types<32>::Elf_Addr address,
364c7fa5
ILT		 3641 section_size_type view_size,
3642 const Reloc_symbol_changes* reloc_symbol_changes)
61ba1cf9 3643{
a3ad94ed 3644 gold_assert(sh_type == elfcpp::SHT_REL);
61ba1cf9 3645
4d625b70
CC		 3646 gold::relocate_section<32, false, Target_i386, Relocate,
3647 gold::Default_comdat_behavior, Classify_reloc>(
92e059d8 3648 relinfo,
ead1e424 3649 this,
61ba1cf9
ILT		 3650 prelocs,
3651 reloc_count,
730cdc88
ILT		 3652 output_section,
3653 needs_special_offset_handling,
61ba1cf9
ILT		 3654 view,
3655 address,
364c7fa5
ILT		 3656 view_size,
3657 reloc_symbol_changes);
61ba1cf9
ILT		 3658}
3659
6a74a719
ILT		 3660// Return the size of a relocation while scanning during a relocatable
3661// link.
3662
3663unsigned int
4d625b70 3664Target_i386::Classify_reloc::get_size_for_reloc(
6a74a719
ILT		 3665 unsigned int r_type,
3666 Relobj* object)
3667{
3668 switch (r_type)
3669 {
3670 case elfcpp::R_386_NONE:
3671 case elfcpp::R_386_GNU_VTINHERIT:
3672 case elfcpp::R_386_GNU_VTENTRY:
3673 case elfcpp::R_386_TLS_GD: // Global-dynamic
3674 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
3675 case elfcpp::R_386_TLS_DESC_CALL:
3676 case elfcpp::R_386_TLS_LDM: // Local-dynamic
3677 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
3678 case elfcpp::R_386_TLS_IE: // Initial-exec
3679 case elfcpp::R_386_TLS_IE_32:
3680 case elfcpp::R_386_TLS_GOTIE:
3681 case elfcpp::R_386_TLS_LE: // Local-exec
3682 case elfcpp::R_386_TLS_LE_32:
3683 return 0;
3684
3685 case elfcpp::R_386_32:
3686 case elfcpp::R_386_PC32:
3687 case elfcpp::R_386_GOT32:
493d4b48 3688 case elfcpp::R_386_GOT32X:
6a74a719
ILT		 3689 case elfcpp::R_386_PLT32:
3690 case elfcpp::R_386_GOTOFF:
3691 case elfcpp::R_386_GOTPC:
3692 return 4;
3693
3694 case elfcpp::R_386_16:
3695 case elfcpp::R_386_PC16:
3696 return 2;
3697
3698 case elfcpp::R_386_8:
3699 case elfcpp::R_386_PC8:
3700 return 1;
3701
3702 // These are relocations which should only be seen by the
3703 // dynamic linker, and should never be seen here.
3704 case elfcpp::R_386_COPY:
3705 case elfcpp::R_386_GLOB_DAT:
3706 case elfcpp::R_386_JUMP_SLOT:
3707 case elfcpp::R_386_RELATIVE:
7223e9ca 3708 case elfcpp::R_386_IRELATIVE:
6a74a719
ILT		 3709 case elfcpp::R_386_TLS_TPOFF:
3710 case elfcpp::R_386_TLS_DTPMOD32:
3711 case elfcpp::R_386_TLS_DTPOFF32:
3712 case elfcpp::R_386_TLS_TPOFF32:
3713 case elfcpp::R_386_TLS_DESC:
3714 object->error(_("unexpected reloc %u in object file"), r_type);
3715 return 0;
3716
3717 case elfcpp::R_386_32PLT:
3718 case elfcpp::R_386_TLS_GD_32:
3719 case elfcpp::R_386_TLS_GD_PUSH:
3720 case elfcpp::R_386_TLS_GD_CALL:
3721 case elfcpp::R_386_TLS_GD_POP:
3722 case elfcpp::R_386_TLS_LDM_32:
3723 case elfcpp::R_386_TLS_LDM_PUSH:
3724 case elfcpp::R_386_TLS_LDM_CALL:
3725 case elfcpp::R_386_TLS_LDM_POP:
3726 case elfcpp::R_386_USED_BY_INTEL_200:
3727 default:
3728 object->error(_("unsupported reloc %u in object file"), r_type);
3729 return 0;
3730 }
3731}
3732
3733// Scan the relocs during a relocatable link.
3734
3735void
ad0f2072 3736Target_i386::scan_relocatable_relocs(Symbol_table* symtab,
6a74a719 3737 Layout* layout,
6fa2a40b 3738 Sized_relobj_file<32, false>* object,
6a74a719
ILT		 3739 unsigned int data_shndx,
3740 unsigned int sh_type,
3741 const unsigned char* prelocs,
3742 size_t reloc_count,
3743 Output_section* output_section,
3744 bool needs_special_offset_handling,
3745 size_t local_symbol_count,
3746 const unsigned char* plocal_symbols,
3747 Relocatable_relocs* rr)
3748{
4d625b70
CC		 3749 typedef gold::Default_scan_relocatable_relocs<Classify_reloc>
3750 Scan_relocatable_relocs;
6a74a719 3751
4d625b70 3752 gold_assert(sh_type == elfcpp::SHT_REL);
6a74a719 3753
4d625b70 3754 gold::scan_relocatable_relocs<32, false, Scan_relocatable_relocs>(
6a74a719
ILT		 3755 symtab,
3756 layout,
3757 object,
3758 data_shndx,
3759 prelocs,
3760 reloc_count,
3761 output_section,
3762 needs_special_offset_handling,
3763 local_symbol_count,
3764 plocal_symbols,
3765 rr);
3766}
3767
4d625b70
CC		 3768// Scan the relocs for --emit-relocs.
3769
3770void
3771Target_i386::emit_relocs_scan(Symbol_table* symtab,
3772 Layout* layout,
3773 Sized_relobj_file<32, false>* object,
3774 unsigned int data_shndx,
3775 unsigned int sh_type,
3776 const unsigned char* prelocs,
3777 size_t reloc_count,
3778 Output_section* output_section,
3779 bool needs_special_offset_handling,
3780 size_t local_symbol_count,
3781 const unsigned char* plocal_syms,
3782 Relocatable_relocs* rr)
3783{
3784 typedef gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>
3785 Classify_reloc;
3786 typedef gold::Default_emit_relocs_strategy<Classify_reloc>
3787 Emit_relocs_strategy;
3788
3789 gold_assert(sh_type == elfcpp::SHT_REL);
3790
3791 gold::scan_relocatable_relocs<32, false, Emit_relocs_strategy>(
3792 symtab,
3793 layout,
3794 object,
3795 data_shndx,
3796 prelocs,
3797 reloc_count,
3798 output_section,
3799 needs_special_offset_handling,
3800 local_symbol_count,
3801 plocal_syms,
3802 rr);
3803}
3804
7404fe1b 3805// Emit relocations for a section.
6a74a719
ILT		 3806
3807void
7404fe1b 3808Target_i386::relocate_relocs(
6a74a719
ILT		 3809 const Relocate_info<32, false>* relinfo,
3810 unsigned int sh_type,
3811 const unsigned char* prelocs,
3812 size_t reloc_count,
3813 Output_section* output_section,
cc928013 3814 elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,
6a74a719
ILT		 3815 unsigned char* view,
3816 elfcpp::Elf_types<32>::Elf_Addr view_address,
3817 section_size_type view_size,
3818 unsigned char* reloc_view,
3819 section_size_type reloc_view_size)
3820{
3821 gold_assert(sh_type == elfcpp::SHT_REL);
3822
4d625b70 3823 gold::relocate_relocs<32, false, Classify_reloc>(
6a74a719
ILT		 3824 relinfo,
3825 prelocs,
3826 reloc_count,
3827 output_section,
3828 offset_in_output_section,
6a74a719
ILT		 3829 view,
3830 view_address,
3831 view_size,
3832 reloc_view,
3833 reloc_view_size);
3834}
3835
ab5c9e90
ILT		 3836// Return the value to use for a dynamic which requires special
3837// treatment. This is how we support equality comparisons of function
3838// pointers across shared library boundaries, as described in the
3839// processor specific ABI supplement.
3840
3841uint64_t
3842Target_i386::do_dynsym_value(const Symbol* gsym) const
3843{
3844 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
19fec8c1 3845 return this->plt_address_for_global(gsym);
ab5c9e90
ILT		 3846}
3847
c51e6221
ILT		 3848// Return a string used to fill a code section with nops to take up
3849// the specified length.
3850
3851std::string
8851ecca 3852Target_i386::do_code_fill(section_size_type length) const
c51e6221
ILT		 3853{
3854 if (length >= 16)
3855 {
3856 // Build a jmp instruction to skip over the bytes.
3857 unsigned char jmp[5];
3858 jmp[0] = 0xe9;
3859 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
3860 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
2e702c99 3861 + std::string(length - 5, static_cast<char>(0x90)));
c51e6221
ILT		 3862 }
3863
3864 // Nop sequences of various lengths.
76677ad0
CC		 3865 const char nop1[1] = { '\x90' }; // nop
3866 const char nop2[2] = { '\x66', '\x90' }; // xchg %ax %ax
3867 const char nop3[3] = { '\x8d', '\x76', '\x00' }; // leal 0(%esi),%esi
3868 const char nop4[4] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi
3869 '\x00'};
3870 const char nop5[5] = { '\x90', '\x8d', '\x74', // nop
2e702c99 3871 '\x26', '\x00' }; // leal 0(%esi,1),%esi
76677ad0 3872 const char nop6[6] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3873 '\x00', '\x00', '\x00' };
76677ad0 3874 const char nop7[7] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi
2e702c99 3875 '\x00', '\x00', '\x00',
76677ad0
CC		 3876 '\x00' };
3877 const char nop8[8] = { '\x90', '\x8d', '\xb4', // nop
2e702c99 3878 '\x26', '\x00', '\x00', // leal 0L(%esi,1),%esi
76677ad0
CC		 3879 '\x00', '\x00' };
3880 const char nop9[9] = { '\x89', '\xf6', '\x8d', // movl %esi,%esi
2e702c99 3881 '\xbc', '\x27', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3882 '\x00', '\x00', '\x00' };
3883 const char nop10[10] = { '\x8d', '\x76', '\x00', // leal 0(%esi),%esi
2e702c99 3884 '\x8d', '\xbc', '\x27', // leal 0L(%edi,1),%edi
76677ad0
CC		 3885 '\x00', '\x00', '\x00',
3886 '\x00' };
3887 const char nop11[11] = { '\x8d', '\x74', '\x26', // leal 0(%esi,1),%esi
2e702c99 3888 '\x00', '\x8d', '\xbc', // leal 0L(%edi,1),%edi
76677ad0
CC		 3889 '\x27', '\x00', '\x00',
3890 '\x00', '\x00' };
3891 const char nop12[12] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3892 '\x00', '\x00', '\x00', // leal 0L(%edi),%edi
76677ad0
CC		 3893 '\x8d', '\xbf', '\x00',
3894 '\x00', '\x00', '\x00' };
3895 const char nop13[13] = { '\x8d', '\xb6', '\x00', // leal 0L(%esi),%esi
2e702c99 3896 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3897 '\x8d', '\xbc', '\x27',
3898 '\x00', '\x00', '\x00',
2e702c99 3899 '\x00' };
76677ad0 3900 const char nop14[14] = { '\x8d', '\xb4', '\x26', // leal 0L(%esi,1),%esi
2e702c99 3901 '\x00', '\x00', '\x00', // leal 0L(%edi,1),%edi
76677ad0
CC		 3902 '\x00', '\x8d', '\xbc',
3903 '\x27', '\x00', '\x00',
2e702c99 3904 '\x00', '\x00' };
76677ad0 3905 const char nop15[15] = { '\xeb', '\x0d', '\x90', // jmp .+15
2e702c99 3906 '\x90', '\x90', '\x90', // nop,nop,nop,...
76677ad0
CC		 3907 '\x90', '\x90', '\x90',
3908 '\x90', '\x90', '\x90',
2e702c99 3909 '\x90', '\x90', '\x90' };
c51e6221
ILT		 3910
3911 const char* nops[16] = {
3912 NULL,
3913 nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3914 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3915 };
3916
3917 return std::string(nops[length], length);
3918}
3919
02d7cd44
ILT		 3920// Return the value to use for the base of a DW_EH_PE_datarel offset
3921// in an FDE. Solaris and SVR4 use DW_EH_PE_datarel because their
3922// assembler can not write out the difference between two labels in
3923// different sections, so instead of using a pc-relative value they
3924// use an offset from the GOT.
3925
3926uint64_t
3927Target_i386::do_ehframe_datarel_base() const
3928{
3929 gold_assert(this->global_offset_table_ != NULL);
3930 Symbol* sym = this->global_offset_table_;
3931 Sized_symbol<32>* ssym = static_cast<Sized_symbol<32>*>(sym);
3932 return ssym->value();
3933}
3934
b6848d3c
ILT		 3935// Return whether SYM should be treated as a call to a non-split
3936// function. We don't want that to be true of a call to a
3937// get_pc_thunk function.
3938
3939bool
4d625b70 3940Target_i386::do_is_call_to_non_split(const Symbol* sym,
bd8d853f
MK		 3941 const unsigned char*,
3942 const unsigned char*,
3943 section_size_type) const
b6848d3c
ILT		 3944{
3945 return (sym->type() == elfcpp::STT_FUNC
b6848d3c
ILT		 3946 && !is_prefix_of("__i686.get_pc_thunk.", sym->name()));
3947}
3948
364c7fa5 3949// FNOFFSET in section SHNDX in OBJECT is the start of a function
9b547ce6 3950// compiled with -fsplit-stack. The function calls non-split-stack
364c7fa5
ILT		 3951// code. We have to change the function so that it always ensures
3952// that it has enough stack space to run some random function.
3953
3954void
3955Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx,
2e702c99
RM		 3956 section_offset_type fnoffset,
3957 section_size_type fnsize,
6e0813d3
CC		 3958 const unsigned char*,
3959 size_t,
2e702c99
RM		 3960 unsigned char* view,
3961 section_size_type view_size,
3962 std::string* from,
3963 std::string* to) const
364c7fa5
ILT		 3964{
3965 // The function starts with a comparison of the stack pointer and a
3966 // field in the TCB. This is followed by a jump.
3967
3968 // cmp %gs:NN,%esp
3969 if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3)
3970 && fnsize > 7)
3971 {
3972 // We will call __morestack if the carry flag is set after this
3973 // comparison. We turn the comparison into an stc instruction
3974 // and some nops.
3975 view[fnoffset] = '\xf9';
3976 this->set_view_to_nop(view, view_size, fnoffset + 1, 6);
3977 }
3978 // lea NN(%esp),%ecx
1782c879
ILT		 3979 // lea NN(%esp),%edx
3980 else if ((this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3)
3981 || this->match_view(view, view_size, fnoffset, "\x8d\x94\x24", 3))
364c7fa5
ILT		 3982 && fnsize > 7)
3983 {
3984 // This is loading an offset from the stack pointer for a
3985 // comparison. The offset is negative, so we decrease the
3986 // offset by the amount of space we need for the stack. This
3987 // means we will avoid calling __morestack if there happens to
3988 // be plenty of space on the stack already.
3989 unsigned char* pval = view + fnoffset + 3;
3990 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
3991 val -= parameters->options().split_stack_adjust_size();
3992 elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
3993 }
3994 else
3995 {
3996 if (!object->has_no_split_stack())
3997 object->error(_("failed to match split-stack sequence at "
3998 "section %u offset %0zx"),
ac33a407 3999 shndx, static_cast<size_t>(fnoffset));
364c7fa5
ILT		 4000 return;
4001 }
4002
4003 // We have to change the function so that it calls
4004 // __morestack_non_split instead of __morestack. The former will
4005 // allocate additional stack space.
4006 *from = "__morestack";
4007 *to = "__morestack_non_split";
4008}
4009
2e702c99
RM		 4010// The selector for i386 object files. Note this is never instantiated
4011// directly. It's only used in Target_selector_i386_nacl, below.
14bfc3f5 4012
36959681 4013class Target_selector_i386 : public Target_selector_freebsd
14bfc3f5
ILT		 4014{
4015public:
4016 Target_selector_i386()
36959681 4017 : Target_selector_freebsd(elfcpp::EM_386, 32, false,
03ef7571
ILT		 4018 "elf32-i386", "elf32-i386-freebsd",
4019 "elf_i386")
14bfc3f5
ILT		 4020 { }
4021
4022 Target*
e96caa79
ILT		 4023 do_instantiate_target()
4024 { return new Target_i386(); }
14bfc3f5
ILT		 4025};
4026
2e702c99
RM		 4027// NaCl variant. It uses different PLT contents.
4028
4029class Output_data_plt_i386_nacl : public Output_data_plt_i386
4030{
4031 public:
4032 Output_data_plt_i386_nacl(Layout* layout,
57b2284c 4033 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4034 Output_data_space* got_irelative)
4035 : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)
4036 { }
4037
4038 protected:
4039 virtual unsigned int
4040 do_get_plt_entry_size() const
4041 { return plt_entry_size; }
4042
4043 virtual void
4044 do_add_eh_frame(Layout* layout)
4045 {
4046 layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,
4047 plt_eh_frame_fde, plt_eh_frame_fde_size);
4048 }
4049
4050 // The size of an entry in the PLT.
4051 static const int plt_entry_size = 64;
4052
4053 // The .eh_frame unwind information for the PLT.
4054 static const int plt_eh_frame_fde_size = 32;
4055 static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4056};
4057
4058class Output_data_plt_i386_nacl_exec : public Output_data_plt_i386_nacl
4059{
4060public:
4061 Output_data_plt_i386_nacl_exec(Layout* layout,
57b2284c 4062 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4063 Output_data_space* got_irelative)
4064 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4065 { }
4066
4067 protected:
4068 virtual void
4069 do_fill_first_plt_entry(unsigned char* pov,
4070 elfcpp::Elf_types<32>::Elf_Addr got_address);
4071
4072 virtual unsigned int
4073 do_fill_plt_entry(unsigned char* pov,
4074 elfcpp::Elf_types<32>::Elf_Addr got_address,
4075 unsigned int got_offset,
4076 unsigned int plt_offset,
4077 unsigned int plt_rel_offset);
4078
4079 private:
4080 // The first entry in the PLT for an executable.
4081 static const unsigned char first_plt_entry[plt_entry_size];
4082
4083 // Other entries in the PLT for an executable.
4084 static const unsigned char plt_entry[plt_entry_size];
4085};
4086
4087class Output_data_plt_i386_nacl_dyn : public Output_data_plt_i386_nacl
4088{
4089 public:
4090 Output_data_plt_i386_nacl_dyn(Layout* layout,
57b2284c 4091 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4092 Output_data_space* got_irelative)
4093 : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4094 { }
4095
4096 protected:
4097 virtual void
4098 do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);
4099
4100 virtual unsigned int
4101 do_fill_plt_entry(unsigned char* pov,
4102 elfcpp::Elf_types<32>::Elf_Addr,
4103 unsigned int got_offset,
4104 unsigned int plt_offset,
4105 unsigned int plt_rel_offset);
4106
4107 private:
4108 // The first entry in the PLT for a shared object.
4109 static const unsigned char first_plt_entry[plt_entry_size];
4110
4111 // Other entries in the PLT for a shared object.
4112 static const unsigned char plt_entry[plt_entry_size];
4113};
4114
4115class Target_i386_nacl : public Target_i386
4116{
4117 public:
4118 Target_i386_nacl()
4119 : Target_i386(&i386_nacl_info)
4120 { }
4121
4122 protected:
4123 virtual Output_data_plt_i386*
4124 do_make_data_plt(Layout* layout,
57b2284c 4125 Output_data_got_plt_i386* got_plt,
2e702c99
RM		 4126 Output_data_space* got_irelative,
4127 bool dyn)
4128 {
4129 if (dyn)
4130 return new Output_data_plt_i386_nacl_dyn(layout, got_plt, got_irelative);
4131 else
4132 return new Output_data_plt_i386_nacl_exec(layout, got_plt, got_irelative);
4133 }
4134
93f8221c
RM		 4135 virtual std::string
4136 do_code_fill(section_size_type length) const;
4137
2e702c99
RM		 4138 private:
4139 static const Target::Target_info i386_nacl_info;
4140};
4141
4142const Target::Target_info Target_i386_nacl::i386_nacl_info =
4143{
4144 32, // size
4145 false, // is_big_endian
4146 elfcpp::EM_386, // machine_code
4147 false, // has_make_symbol
4148 false, // has_resolve
4149 true, // has_code_fill
4150 true, // is_default_stack_executable
4151 true, // can_icf_inline_merge_sections
4152 '\0', // wrap_char
4153 "/lib/ld-nacl-x86-32.so.1", // dynamic_linker
4154 0x20000, // default_text_segment_address
4155 0x10000, // abi_pagesize (overridable by -z max-page-size)
4156 0x10000, // common_pagesize (overridable by -z common-page-size)
4157 true, // isolate_execinstr
4158 0x10000000, // rosegment_gap
4159 elfcpp::SHN_UNDEF, // small_common_shndx
4160 elfcpp::SHN_UNDEF, // large_common_shndx
4161 0, // small_common_section_flags
4162 0, // large_common_section_flags
4163 NULL, // attributes_section
a67858e0 4164 NULL, // attributes_vendor
8d9743bd
MK		 4165 "_start", // entry_symbol_name
4166 32, // hash_entry_size
2e702c99
RM		 4167};
4168
4169#define NACLMASK 0xe0 // 32-byte alignment mask
4170
4171const unsigned char
4172Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] =
4173{
4174 0xff, 0x35, // pushl contents of memory address
4175 0, 0, 0, 0, // replaced with address of .got + 4
4176 0x8b, 0x0d, // movl contents of address, %ecx
4177 0, 0, 0, 0, // replaced with address of .got + 8
4178 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4179 0xff, 0xe1, // jmp *%ecx
4180 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4181 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4182 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4183 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4184 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4185 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4186 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4187 0x90, 0x90, 0x90, 0x90, 0x90
4188};
4189
4190void
4191Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry(
4192 unsigned char* pov,
4193 elfcpp::Elf_types<32>::Elf_Addr got_address)
4194{
4195 memcpy(pov, first_plt_entry, plt_entry_size);
4196 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
4197 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
4198}
4199
4200// The first entry in the PLT for a shared object.
4201
4202const unsigned char
4203Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] =
4204{
4205 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx)
4206 0x8b, 0x4b, 0x08, // mov 0x8(%ebx), %ecx
4207 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4208 0xff, 0xe1, // jmp *%ecx
4209 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4210 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4211 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4212 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4213 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4214 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4215 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4216 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4217 0x90, 0x90, 0x90, 0x90, 0x90, // nops
4218 0x90, 0x90, 0x90, 0x90, 0x90 // nops
4219};
4220
4221void
4222Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry(
4223 unsigned char* pov,
4224 elfcpp::Elf_types<32>::Elf_Addr)
4225{
4226 memcpy(pov, first_plt_entry, plt_entry_size);
4227}
4228
4229// Subsequent entries in the PLT for an executable.
4230
4231const unsigned char
4232Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] =
4233{
4234 0x8b, 0x0d, // movl contents of address, %ecx */
4235 0, 0, 0, 0, // replaced with address of symbol in .got
4236 0x83, 0xe1, NACLMASK, // andl $NACLMASK, %ecx
4237 0xff, 0xe1, // jmp *%ecx
4238
4239 // Pad to the next 32-byte boundary with nop instructions.
4240 0x90,
4241 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4242 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4243
4244 // Lazy GOT entries point here (32-byte aligned).
4245 0x68, // pushl immediate
4246 0, 0, 0, 0, // replaced with offset into relocation table
4247 0xe9, // jmp relative
4248 0, 0, 0, 0, // replaced with offset to start of .plt
4249
4250 // Pad to the next 32-byte boundary with nop instructions.
4251 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4252 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4253 0x90, 0x90
4254};
4255
4256unsigned int
4257Output_data_plt_i386_nacl_exec::do_fill_plt_entry(
4258 unsigned char* pov,
4259 elfcpp::Elf_types<32>::Elf_Addr got_address,
4260 unsigned int got_offset,
4261 unsigned int plt_offset,
4262 unsigned int plt_rel_offset)
4263{
4264 memcpy(pov, plt_entry, plt_entry_size);
4265 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4266 got_address + got_offset);
4267 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4268 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4269 return 32;
4270}
4271
4272// Subsequent entries in the PLT for a shared object.
4273
4274const unsigned char
4275Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] =
4276{
4277 0x8b, 0x8b, // movl offset(%ebx), %ecx
4278 0, 0, 0, 0, // replaced with offset of symbol in .got
4279 0x83, 0xe1, 0xe0, // andl $NACLMASK, %ecx
4280 0xff, 0xe1, // jmp *%ecx
4281
4282 // Pad to the next 32-byte boundary with nop instructions.
4283 0x90,
4284 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4285 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4286
4287 // Lazy GOT entries point here (32-byte aligned).
4288 0x68, // pushl immediate
4289 0, 0, 0, 0, // replaced with offset into relocation table.
4290 0xe9, // jmp relative
4291 0, 0, 0, 0, // replaced with offset to start of .plt.
4292
4293 // Pad to the next 32-byte boundary with nop instructions.
4294 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4295 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4296 0x90, 0x90
4297};
4298
4299unsigned int
4300Output_data_plt_i386_nacl_dyn::do_fill_plt_entry(
4301 unsigned char* pov,
4302 elfcpp::Elf_types<32>::Elf_Addr,
4303 unsigned int got_offset,
4304 unsigned int plt_offset,
4305 unsigned int plt_rel_offset)
4306{
4307 memcpy(pov, plt_entry, plt_entry_size);
4308 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
4309 elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4310 elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4311 return 32;
4312}
4313
4314const unsigned char
4315Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] =
4316{
4317 0, 0, 0, 0, // Replaced with offset to .plt.
4318 0, 0, 0, 0, // Replaced with size of .plt.
4319 0, // Augmentation size.
4320 elfcpp::DW_CFA_def_cfa_offset, 8, // DW_CFA_def_cfa_offset: 8.
4321 elfcpp::DW_CFA_advance_loc + 6, // Advance 6 to __PLT__ + 6.
4322 elfcpp::DW_CFA_def_cfa_offset, 12, // DW_CFA_def_cfa_offset: 12.
4323 elfcpp::DW_CFA_advance_loc + 58, // Advance 58 to __PLT__ + 64.
4324 elfcpp::DW_CFA_def_cfa_expression, // DW_CFA_def_cfa_expression.
4325 13, // Block length.
4326 elfcpp::DW_OP_breg4, 4, // Push %esp + 4.
4327 elfcpp::DW_OP_breg8, 0, // Push %eip.
4328 elfcpp::DW_OP_const1u, 63, // Push 0x3f.
4329 elfcpp::DW_OP_and, // & (%eip & 0x3f).
4330 elfcpp::DW_OP_const1u, 37, // Push 0x25.
4331 elfcpp::DW_OP_ge, // >= ((%eip & 0x3f) >= 0x25)
4332 elfcpp::DW_OP_lit2, // Push 2.
4333 elfcpp::DW_OP_shl, // << (((%eip & 0x3f) >= 0x25) << 2)
4334 elfcpp::DW_OP_plus, // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4
4335 elfcpp::DW_CFA_nop, // Align to 32 bytes.
4336 elfcpp::DW_CFA_nop
4337};
4338
93f8221c
RM		 4339// Return a string used to fill a code section with nops.
4340// For NaCl, long NOPs are only valid if they do not cross
4341// bundle alignment boundaries, so keep it simple with one-byte NOPs.
4342std::string
4343Target_i386_nacl::do_code_fill(section_size_type length) const
4344{
4345 return std::string(length, static_cast<char>(0x90));
4346}
4347
2e702c99
RM		 4348// The selector for i386-nacl object files.
4349
4350class Target_selector_i386_nacl
4351 : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl>
4352{
4353 public:
4354 Target_selector_i386_nacl()
4355 : Target_selector_nacl<Target_selector_i386,
4356 Target_i386_nacl>("x86-32",
4357 "elf32-i386-nacl",
4358 "elf_i386_nacl")
4359 { }
4360};
4361
4362Target_selector_i386_nacl target_selector_i386;
14bfc3f5 4363
01f573ad
L		 4364// IAMCU variant. It uses EM_IAMCU, not EM_386.
4365
4366class Target_iamcu : public Target_i386
4367{
4368 public:
4369 Target_iamcu()
4370 : Target_i386(&iamcu_info)
4371 { }
4372
4373 private:
4374 // Information about this specific target which we pass to the
4375 // general Target structure.
4376 static const Target::Target_info iamcu_info;
4377};
4378
4379const Target::Target_info Target_iamcu::iamcu_info =
4380{
4381 32, // size
4382 false, // is_big_endian
4383 elfcpp::EM_IAMCU, // machine_code
4384 false, // has_make_symbol
4385 false, // has_resolve
4386 true, // has_code_fill
4387 true, // is_default_stack_executable
4388 true, // can_icf_inline_merge_sections
4389 '\0', // wrap_char
4390 "/usr/lib/libc.so.1", // dynamic_linker
4391 0x08048000, // default_text_segment_address
4392 0x1000, // abi_pagesize (overridable by -z max-page-size)
4393 0x1000, // common_pagesize (overridable by -z common-page-size)
4394 false, // isolate_execinstr
4395 0, // rosegment_gap
4396 elfcpp::SHN_UNDEF, // small_common_shndx
4397 elfcpp::SHN_UNDEF, // large_common_shndx
4398 0, // small_common_section_flags
4399 0, // large_common_section_flags
4400 NULL, // attributes_section
4401 NULL, // attributes_vendor
8d9743bd
MK		 4402 "_start", // entry_symbol_name
4403 32, // hash_entry_size
01f573ad
L		 4404};
4405
4406class Target_selector_iamcu : public Target_selector
4407{
4408public:
4409 Target_selector_iamcu()
4410 : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu",
4411 "elf_iamcu")
4412 { }
4413
4414 Target*
4415 do_instantiate_target()
4416 { return new Target_iamcu(); }
4417};
4418
4419Target_selector_iamcu target_selector_iamcu;
4420
14bfc3f5 4421} // End anonymous namespace.
GDB Binutils - Deliverables
This page took 0.666446 seconds and 4 git commands to generate.