2009-12-05 Doug Kwan <dougkwan@google.com>
[deliverable/binutils-gdb.git] / gold / i386.cc
CommitLineData
14bfc3f5
ILT
1// i386.cc -- i386 target support for gold.
2
6d03d481 3// Copyright 2006, 2007, 2008, 2009 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"
7e1edb90 28#include "parameters.h"
92e059d8 29#include "reloc.h"
61ba1cf9
ILT
30#include "i386.h"
31#include "object.h"
ead1e424 32#include "symtab.h"
92e059d8
ILT
33#include "layout.h"
34#include "output.h"
12c0daef 35#include "copy-relocs.h"
14bfc3f5 36#include "target.h"
61ba1cf9 37#include "target-reloc.h"
14bfc3f5 38#include "target-select.h"
af6359d5 39#include "tls.h"
36959681 40#include "freebsd.h"
f345227a 41#include "gc.h"
14bfc3f5
ILT
42
43namespace
44{
45
46using namespace gold;
47
a3ad94ed
ILT
48class Output_data_plt_i386;
49
14bfc3f5 50// The i386 target class.
e041f13d
ILT
51// TLS info comes from
52// http://people.redhat.com/drepper/tls.pdf
53// http://www.lsd.ic.unicamp.br/~oliva/writeups/TLS/RFC-TLSDESC-x86.txt
14bfc3f5 54
36959681 55class Target_i386 : public Target_freebsd<32, false>
14bfc3f5
ILT
56{
57 public:
5a6f7e2d
ILT
58 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;
59
14bfc3f5 60 Target_i386()
36959681 61 : Target_freebsd<32, false>(&i386_info),
5a6f7e2d 62 got_(NULL), plt_(NULL), got_plt_(NULL), rel_dyn_(NULL),
12c0daef 63 copy_relocs_(elfcpp::R_386_COPY), dynbss_(NULL),
edfbb029 64 got_mod_index_offset_(-1U), tls_base_symbol_defined_(false)
14bfc3f5 65 { }
75f65a3e 66
6d03d481
ST
67 // Process the relocations to determine unreferenced sections for
68 // garbage collection.
69 void
ad0f2072 70 gc_process_relocs(Symbol_table* symtab,
6d03d481
ST
71 Layout* layout,
72 Sized_relobj<32, false>* object,
73 unsigned int data_shndx,
74 unsigned int sh_type,
75 const unsigned char* prelocs,
76 size_t reloc_count,
77 Output_section* output_section,
78 bool needs_special_offset_handling,
79 size_t local_symbol_count,
80 const unsigned char* plocal_symbols);
81
92e059d8 82 // Scan the relocations to look for symbol adjustments.
61ba1cf9 83 void
ad0f2072 84 scan_relocs(Symbol_table* symtab,
ead1e424 85 Layout* layout,
f6ce93d6 86 Sized_relobj<32, false>* object,
a3ad94ed 87 unsigned int data_shndx,
92e059d8
ILT
88 unsigned int sh_type,
89 const unsigned char* prelocs,
90 size_t reloc_count,
730cdc88
ILT
91 Output_section* output_section,
92 bool needs_special_offset_handling,
92e059d8 93 size_t local_symbol_count,
730cdc88 94 const unsigned char* plocal_symbols);
61ba1cf9 95
5a6f7e2d
ILT
96 // Finalize the sections.
97 void
f59f41f3 98 do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
5a6f7e2d 99
ab5c9e90
ILT
100 // Return the value to use for a dynamic which requires special
101 // treatment.
102 uint64_t
103 do_dynsym_value(const Symbol*) const;
104
92e059d8
ILT
105 // Relocate a section.
106 void
107 relocate_section(const Relocate_info<32, false>*,
108 unsigned int sh_type,
109 const unsigned char* prelocs,
110 size_t reloc_count,
730cdc88
ILT
111 Output_section* output_section,
112 bool needs_special_offset_handling,
92e059d8
ILT
113 unsigned char* view,
114 elfcpp::Elf_types<32>::Elf_Addr view_address,
364c7fa5
ILT
115 section_size_type view_size,
116 const Reloc_symbol_changes*);
92e059d8 117
6a74a719
ILT
118 // Scan the relocs during a relocatable link.
119 void
ad0f2072 120 scan_relocatable_relocs(Symbol_table* symtab,
6a74a719
ILT
121 Layout* layout,
122 Sized_relobj<32, false>* object,
123 unsigned int data_shndx,
124 unsigned int sh_type,
125 const unsigned char* prelocs,
126 size_t reloc_count,
127 Output_section* output_section,
128 bool needs_special_offset_handling,
129 size_t local_symbol_count,
130 const unsigned char* plocal_symbols,
131 Relocatable_relocs*);
132
133 // Relocate a section during a relocatable link.
134 void
135 relocate_for_relocatable(const Relocate_info<32, false>*,
136 unsigned int sh_type,
137 const unsigned char* prelocs,
138 size_t reloc_count,
139 Output_section* output_section,
140 off_t offset_in_output_section,
141 const Relocatable_relocs*,
142 unsigned char* view,
143 elfcpp::Elf_types<32>::Elf_Addr view_address,
144 section_size_type view_size,
145 unsigned char* reloc_view,
146 section_size_type reloc_view_size);
147
c51e6221
ILT
148 // Return a string used to fill a code section with nops.
149 std::string
8851ecca 150 do_code_fill(section_size_type length) const;
c51e6221 151
9a2d6984
ILT
152 // Return whether SYM is defined by the ABI.
153 bool
9c2d0ef9 154 do_is_defined_by_abi(const Symbol* sym) const
9a2d6984
ILT
155 { return strcmp(sym->name(), "___tls_get_addr") == 0; }
156
bb04269c
DK
157 // Return whether a symbol name implies a local label. The UnixWare
158 // 2.1 cc generates temporary symbols that start with .X, so we
159 // recognize them here. FIXME: do other SVR4 compilers also use .X?.
160 // If so, we should move the .X recognition into
161 // Target::do_is_local_label_name.
162 bool
163 do_is_local_label_name(const char* name) const
164 {
165 if (name[0] == '.' && name[1] == 'X')
166 return true;
167 return Target::do_is_local_label_name(name);
168 }
169
364c7fa5
ILT
170 // Adjust -fstack-split code which calls non-stack-split code.
171 void
172 do_calls_non_split(Relobj* object, unsigned int shndx,
173 section_offset_type fnoffset, section_size_type fnsize,
174 unsigned char* view, section_size_type view_size,
175 std::string* from, std::string* to) const;
176
96f2030e 177 // Return the size of the GOT section.
fe8718a4 178 section_size_type
96f2030e
ILT
179 got_size()
180 {
181 gold_assert(this->got_ != NULL);
182 return this->got_->data_size();
183 }
184
92e059d8
ILT
185 private:
186 // The class which scans relocations.
187 struct Scan
61ba1cf9
ILT
188 {
189 inline void
ad0f2072 190 local(Symbol_table* symtab, Layout* layout, Target_i386* target,
f6ce93d6 191 Sized_relobj<32, false>* object,
a3ad94ed 192 unsigned int data_shndx,
07f397ab 193 Output_section* output_section,
92e059d8
ILT
194 const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
195 const elfcpp::Sym<32, false>& lsym);
61ba1cf9 196
92e059d8 197 inline void
ad0f2072 198 global(Symbol_table* symtab, Layout* layout, Target_i386* target,
f6ce93d6 199 Sized_relobj<32, false>* object,
a3ad94ed 200 unsigned int data_shndx,
07f397ab 201 Output_section* output_section,
92e059d8
ILT
202 const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
203 Symbol* gsym);
af6359d5
ILT
204
205 static void
206 unsupported_reloc_local(Sized_relobj<32, false>*, unsigned int r_type);
207
208 static void
209 unsupported_reloc_global(Sized_relobj<32, false>*, unsigned int r_type,
210 Symbol*);
61ba1cf9
ILT
211 };
212
92e059d8
ILT
213 // The class which implements relocation.
214 class Relocate
215 {
216 public:
ead1e424 217 Relocate()
46cf9fa2 218 : skip_call_tls_get_addr_(false),
82bb573a 219 local_dynamic_type_(LOCAL_DYNAMIC_NONE)
ead1e424
ILT
220 { }
221
222 ~Relocate()
223 {
224 if (this->skip_call_tls_get_addr_)
225 {
226 // FIXME: This needs to specify the location somehow.
75f2446e 227 gold_error(_("missing expected TLS relocation"));
ead1e424
ILT
228 }
229 }
230
86849f1f
ILT
231 // Return whether the static relocation needs to be applied.
232 inline bool
233 should_apply_static_reloc(const Sized_symbol<32>* gsym,
0700cf32 234 int ref_flags,
031cdbed
ILT
235 bool is_32bit,
236 Output_section* output_section);
86849f1f 237
ead1e424
ILT
238 // Do a relocation. Return false if the caller should not issue
239 // any warnings about this relocation.
240 inline bool
031cdbed
ILT
241 relocate(const Relocate_info<32, false>*, Target_i386*, Output_section*,
242 size_t relnum, const elfcpp::Rel<32, false>&,
c06b7b0b 243 unsigned int r_type, const Sized_symbol<32>*,
b8e6aad9 244 const Symbol_value<32>*,
92e059d8 245 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
fe8718a4 246 section_size_type);
92e059d8
ILT
247
248 private:
249 // Do a TLS relocation.
ead1e424 250 inline void
07f397ab
ILT
251 relocate_tls(const Relocate_info<32, false>*, Target_i386* target,
252 size_t relnum, const elfcpp::Rel<32, false>&,
c06b7b0b 253 unsigned int r_type, const Sized_symbol<32>*,
b8e6aad9 254 const Symbol_value<32>*,
fe8718a4
ILT
255 unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
256 section_size_type);
92e059d8 257
07f397ab
ILT
258 // Do a TLS General-Dynamic to Initial-Exec transition.
259 inline void
260 tls_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,
261 Output_segment* tls_segment,
262 const elfcpp::Rel<32, false>&, unsigned int r_type,
263 elfcpp::Elf_types<32>::Elf_Addr value,
264 unsigned char* view,
fe8718a4 265 section_size_type view_size);
07f397ab 266
56622147
ILT
267 // Do a TLS General-Dynamic to Local-Exec transition.
268 inline void
269 tls_gd_to_le(const Relocate_info<32, false>*, size_t relnum,
92e059d8
ILT
270 Output_segment* tls_segment,
271 const elfcpp::Rel<32, false>&, unsigned int r_type,
272 elfcpp::Elf_types<32>::Elf_Addr value,
273 unsigned char* view,
fe8718a4 274 section_size_type view_size);
92e059d8 275
c2b45e22
CC
276 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Initial-Exec
277 // transition.
278 inline void
279 tls_desc_gd_to_ie(const Relocate_info<32, false>*, size_t relnum,
280 Output_segment* tls_segment,
281 const elfcpp::Rel<32, false>&, unsigned int r_type,
282 elfcpp::Elf_types<32>::Elf_Addr value,
283 unsigned char* view,
284 section_size_type view_size);
285
286 // Do a TLS_GOTDESC or TLS_DESC_CALL General-Dynamic to Local-Exec
287 // transition.
288 inline void
289 tls_desc_gd_to_le(const Relocate_info<32, false>*, size_t relnum,
290 Output_segment* tls_segment,
291 const elfcpp::Rel<32, false>&, unsigned int r_type,
292 elfcpp::Elf_types<32>::Elf_Addr value,
293 unsigned char* view,
294 section_size_type view_size);
295
56622147 296 // Do a TLS Local-Dynamic to Local-Exec transition.
ead1e424 297 inline void
56622147 298 tls_ld_to_le(const Relocate_info<32, false>*, size_t relnum,
ead1e424
ILT
299 Output_segment* tls_segment,
300 const elfcpp::Rel<32, false>&, unsigned int r_type,
301 elfcpp::Elf_types<32>::Elf_Addr value,
302 unsigned char* view,
fe8718a4 303 section_size_type view_size);
ead1e424 304
56622147
ILT
305 // Do a TLS Initial-Exec to Local-Exec transition.
306 static inline void
307 tls_ie_to_le(const Relocate_info<32, false>*, size_t relnum,
46cf9fa2
ILT
308 Output_segment* tls_segment,
309 const elfcpp::Rel<32, false>&, unsigned int r_type,
310 elfcpp::Elf_types<32>::Elf_Addr value,
311 unsigned char* view,
fe8718a4 312 section_size_type view_size);
46cf9fa2 313
46cf9fa2
ILT
314 // We need to keep track of which type of local dynamic relocation
315 // we have seen, so that we can optimize R_386_TLS_LDO_32 correctly.
316 enum Local_dynamic_type
317 {
318 LOCAL_DYNAMIC_NONE,
319 LOCAL_DYNAMIC_SUN,
320 LOCAL_DYNAMIC_GNU
321 };
322
ead1e424
ILT
323 // This is set if we should skip the next reloc, which should be a
324 // PLT32 reloc against ___tls_get_addr.
325 bool skip_call_tls_get_addr_;
46cf9fa2
ILT
326 // The type of local dynamic relocation we have seen in the section
327 // being relocated, if any.
328 Local_dynamic_type local_dynamic_type_;
92e059d8
ILT
329 };
330
6a74a719
ILT
331 // A class which returns the size required for a relocation type,
332 // used while scanning relocs during a relocatable link.
333 class Relocatable_size_for_reloc
334 {
335 public:
336 unsigned int
337 get_size_for_reloc(unsigned int, Relobj*);
338 };
339
92e059d8
ILT
340 // Adjust TLS relocation type based on the options and whether this
341 // is a local symbol.
af6359d5 342 static tls::Tls_optimization
7e1edb90 343 optimize_tls_reloc(bool is_final, int r_type);
92e059d8 344
ead1e424 345 // Get the GOT section, creating it if necessary.
dbe717ef 346 Output_data_got<32, false>*
7e1edb90 347 got_section(Symbol_table*, Layout*);
a3ad94ed 348
96f2030e
ILT
349 // Get the GOT PLT section.
350 Output_data_space*
351 got_plt_section() const
352 {
353 gold_assert(this->got_plt_ != NULL);
354 return this->got_plt_;
355 }
356
a3ad94ed
ILT
357 // Create a PLT entry for a global symbol.
358 void
7e1edb90 359 make_plt_entry(Symbol_table*, Layout*, Symbol*);
a3ad94ed 360
9fa33bee 361 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC
362 void
363 define_tls_base_symbol(Symbol_table*, Layout*);
364
94c4710f
ILT
365 // Create a GOT entry for the TLS module index.
366 unsigned int
367 got_mod_index_entry(Symbol_table* symtab, Layout* layout,
368 Sized_relobj<32, false>* object);
369
a3ad94ed 370 // Get the PLT section.
7bb3655e 371 const Output_data_plt_i386*
a3ad94ed
ILT
372 plt_section() const
373 {
374 gold_assert(this->plt_ != NULL);
375 return this->plt_;
376 }
377
5a6f7e2d
ILT
378 // Get the dynamic reloc section, creating it if necessary.
379 Reloc_section*
380 rel_dyn_section(Layout*);
381
12c0daef 382 // Add a potential copy relocation.
a3ad94ed 383 void
ef9beddf
ILT
384 copy_reloc(Symbol_table* symtab, Layout* layout,
385 Sized_relobj<32, false>* object,
12c0daef
ILT
386 unsigned int shndx, Output_section* output_section,
387 Symbol* sym, const elfcpp::Rel<32, false>& reloc)
388 {
389 this->copy_relocs_.copy_reloc(symtab, layout,
390 symtab->get_sized_symbol<32>(sym),
391 object, shndx, output_section, reloc,
392 this->rel_dyn_section(layout));
393 }
ead1e424 394
92e059d8
ILT
395 // Information about this specific target which we pass to the
396 // general Target structure.
75f65a3e 397 static const Target::Target_info i386_info;
ead1e424 398
0a65a3a7
CC
399 // The types of GOT entries needed for this platform.
400 enum Got_type
401 {
402 GOT_TYPE_STANDARD = 0, // GOT entry for a regular symbol
c2b45e22
CC
403 GOT_TYPE_TLS_NOFFSET = 1, // GOT entry for negative TLS offset
404 GOT_TYPE_TLS_OFFSET = 2, // GOT entry for positive TLS offset
405 GOT_TYPE_TLS_PAIR = 3, // GOT entry for TLS module/offset pair
406 GOT_TYPE_TLS_DESC = 4 // GOT entry for TLS_DESC pair
0a65a3a7
CC
407 };
408
ead1e424 409 // The GOT section.
dbe717ef 410 Output_data_got<32, false>* got_;
a3ad94ed
ILT
411 // The PLT section.
412 Output_data_plt_i386* plt_;
413 // The GOT PLT section.
414 Output_data_space* got_plt_;
5a6f7e2d
ILT
415 // The dynamic reloc section.
416 Reloc_section* rel_dyn_;
417 // Relocs saved to avoid a COPY reloc.
12c0daef 418 Copy_relocs<elfcpp::SHT_REL, 32, false> copy_relocs_;
5a6f7e2d
ILT
419 // Space for variables copied with a COPY reloc.
420 Output_data_space* dynbss_;
c2b45e22 421 // Offset of the GOT entry for the TLS module index.
94c4710f 422 unsigned int got_mod_index_offset_;
edfbb029
CC
423 // True if the _TLS_MODULE_BASE_ symbol has been defined.
424 bool tls_base_symbol_defined_;
75f65a3e
ILT
425};
426
427const Target::Target_info Target_i386::i386_info =
428{
61ba1cf9
ILT
429 32, // size
430 false, // is_big_endian
431 elfcpp::EM_386, // machine_code
432 false, // has_make_symbol
dbe717ef 433 false, // has_resolve
c51e6221 434 true, // has_code_fill
35cdfc9a 435 true, // is_default_stack_executable
0864d551 436 '\0', // wrap_char
dbe717ef 437 "/usr/lib/libc.so.1", // dynamic_linker
0c5e9c22 438 0x08048000, // default_text_segment_address
cd72c291 439 0x1000, // abi_pagesize (overridable by -z max-page-size)
8a5e3e08
ILT
440 0x1000, // common_pagesize (overridable by -z common-page-size)
441 elfcpp::SHN_UNDEF, // small_common_shndx
442 elfcpp::SHN_UNDEF, // large_common_shndx
443 0, // small_common_section_flags
444 0 // large_common_section_flags
14bfc3f5
ILT
445};
446
ead1e424
ILT
447// Get the GOT section, creating it if necessary.
448
dbe717ef 449Output_data_got<32, false>*
7e1edb90 450Target_i386::got_section(Symbol_table* symtab, Layout* layout)
ead1e424
ILT
451{
452 if (this->got_ == NULL)
453 {
7e1edb90 454 gold_assert(symtab != NULL && layout != NULL);
a3ad94ed 455
7e1edb90 456 this->got_ = new Output_data_got<32, false>();
ead1e424 457
9f1d377b
ILT
458 Output_section* os;
459 os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
460 (elfcpp::SHF_ALLOC
461 | elfcpp::SHF_WRITE),
f5c870d2 462 this->got_, false);
9f1d377b 463 os->set_is_relro();
ead1e424 464
a3ad94ed
ILT
465 // The old GNU linker creates a .got.plt section. We just
466 // create another set of data in the .got section. Note that we
467 // always create a PLT if we create a GOT, although the PLT
468 // might be empty.
7d9e3d98 469 this->got_plt_ = new Output_data_space(4, "** GOT PLT");
9f1d377b
ILT
470 os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
471 (elfcpp::SHF_ALLOC
472 | elfcpp::SHF_WRITE),
f5c870d2 473 this->got_plt_, false);
9f1d377b 474 os->set_is_relro();
a3ad94ed 475
ead1e424 476 // The first three entries are reserved.
27bc2bce 477 this->got_plt_->set_current_data_size(3 * 4);
ead1e424 478
a3ad94ed 479 // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
9b07f471 480 symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
a3ad94ed 481 this->got_plt_,
ead1e424 482 0, 0, elfcpp::STT_OBJECT,
16649710 483 elfcpp::STB_LOCAL,
ead1e424
ILT
484 elfcpp::STV_HIDDEN, 0,
485 false, false);
486 }
a3ad94ed 487
ead1e424
ILT
488 return this->got_;
489}
490
5a6f7e2d
ILT
491// Get the dynamic reloc section, creating it if necessary.
492
493Target_i386::Reloc_section*
494Target_i386::rel_dyn_section(Layout* layout)
495{
496 if (this->rel_dyn_ == NULL)
497 {
498 gold_assert(layout != NULL);
d98bc257 499 this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
5a6f7e2d 500 layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
f5c870d2 501 elfcpp::SHF_ALLOC, this->rel_dyn_, true);
5a6f7e2d
ILT
502 }
503 return this->rel_dyn_;
504}
505
a3ad94ed
ILT
506// A class to handle the PLT data.
507
508class Output_data_plt_i386 : public Output_section_data
509{
510 public:
511 typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;
512
7e1edb90 513 Output_data_plt_i386(Layout*, Output_data_space*);
a3ad94ed
ILT
514
515 // Add an entry to the PLT.
516 void
517 add_entry(Symbol* gsym);
518
16649710
ILT
519 // Return the .rel.plt section data.
520 const Reloc_section*
521 rel_plt() const
522 { return this->rel_; }
523
524 protected:
525 void
526 do_adjust_output_section(Output_section* os);
527
7d9e3d98
ILT
528 // Write to a map file.
529 void
530 do_print_to_mapfile(Mapfile* mapfile) const
531 { mapfile->print_output_data(this, _("** PLT")); }
532
a3ad94ed
ILT
533 private:
534 // The size of an entry in the PLT.
535 static const int plt_entry_size = 16;
536
537 // The first entry in the PLT for an executable.
538 static unsigned char exec_first_plt_entry[plt_entry_size];
539
540 // The first entry in the PLT for a shared object.
541 static unsigned char dyn_first_plt_entry[plt_entry_size];
542
543 // Other entries in the PLT for an executable.
544 static unsigned char exec_plt_entry[plt_entry_size];
545
546 // Other entries in the PLT for a shared object.
547 static unsigned char dyn_plt_entry[plt_entry_size];
548
549 // Set the final size.
550 void
27bc2bce 551 set_final_data_size()
a3ad94ed
ILT
552 { this->set_data_size((this->count_ + 1) * plt_entry_size); }
553
554 // Write out the PLT data.
555 void
556 do_write(Output_file*);
557
558 // The reloc section.
559 Reloc_section* rel_;
560 // The .got.plt section.
561 Output_data_space* got_plt_;
562 // The number of PLT entries.
563 unsigned int count_;
a3ad94ed
ILT
564};
565
566// Create the PLT section. The ordinary .got section is an argument,
567// since we need to refer to the start. We also create our own .got
568// section just for PLT entries.
569
570Output_data_plt_i386::Output_data_plt_i386(Layout* layout,
7e1edb90 571 Output_data_space* got_plt)
80576242 572 : Output_section_data(4), got_plt_(got_plt), count_(0)
a3ad94ed 573{
d98bc257 574 this->rel_ = new Reloc_section(false);
a3ad94ed 575 layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
f5c870d2 576 elfcpp::SHF_ALLOC, this->rel_, true);
a3ad94ed
ILT
577}
578
16649710
ILT
579void
580Output_data_plt_i386::do_adjust_output_section(Output_section* os)
581{
582 // UnixWare sets the entsize of .plt to 4, and so does the old GNU
583 // linker, and so do we.
584 os->set_entsize(4);
585}
586
a3ad94ed
ILT
587// Add an entry to the PLT.
588
589void
590Output_data_plt_i386::add_entry(Symbol* gsym)
591{
592 gold_assert(!gsym->has_plt_offset());
593
594 // Note that when setting the PLT offset we skip the initial
595 // reserved PLT entry.
596 gsym->set_plt_offset((this->count_ + 1) * plt_entry_size);
597
598 ++this->count_;
599
fe8718a4 600 section_offset_type got_offset = this->got_plt_->current_data_size();
a3ad94ed
ILT
601
602 // Every PLT entry needs a GOT entry which points back to the PLT
603 // entry (this will be changed by the dynamic linker, normally
604 // lazily when the function is called).
27bc2bce 605 this->got_plt_->set_current_data_size(got_offset + 4);
a3ad94ed
ILT
606
607 // Every PLT entry needs a reloc.
16649710 608 gsym->set_needs_dynsym_entry();
a3ad94ed
ILT
609 this->rel_->add_global(gsym, elfcpp::R_386_JUMP_SLOT, this->got_plt_,
610 got_offset);
611
612 // Note that we don't need to save the symbol. The contents of the
613 // PLT are independent of which symbols are used. The symbols only
614 // appear in the relocations.
615}
616
617// The first entry in the PLT for an executable.
618
619unsigned char Output_data_plt_i386::exec_first_plt_entry[plt_entry_size] =
620{
621 0xff, 0x35, // pushl contents of memory address
622 0, 0, 0, 0, // replaced with address of .got + 4
623 0xff, 0x25, // jmp indirect
624 0, 0, 0, 0, // replaced with address of .got + 8
625 0, 0, 0, 0 // unused
626};
627
628// The first entry in the PLT for a shared object.
629
630unsigned char Output_data_plt_i386::dyn_first_plt_entry[plt_entry_size] =
631{
632 0xff, 0xb3, 4, 0, 0, 0, // pushl 4(%ebx)
633 0xff, 0xa3, 8, 0, 0, 0, // jmp *8(%ebx)
634 0, 0, 0, 0 // unused
635};
636
637// Subsequent entries in the PLT for an executable.
638
639unsigned char Output_data_plt_i386::exec_plt_entry[plt_entry_size] =
640{
641 0xff, 0x25, // jmp indirect
642 0, 0, 0, 0, // replaced with address of symbol in .got
643 0x68, // pushl immediate
644 0, 0, 0, 0, // replaced with offset into relocation table
645 0xe9, // jmp relative
646 0, 0, 0, 0 // replaced with offset to start of .plt
647};
648
649// Subsequent entries in the PLT for a shared object.
650
651unsigned char Output_data_plt_i386::dyn_plt_entry[plt_entry_size] =
652{
653 0xff, 0xa3, // jmp *offset(%ebx)
654 0, 0, 0, 0, // replaced with offset of symbol in .got
655 0x68, // pushl immediate
656 0, 0, 0, 0, // replaced with offset into relocation table
657 0xe9, // jmp relative
658 0, 0, 0, 0 // replaced with offset to start of .plt
659};
660
661// Write out the PLT. This uses the hand-coded instructions above,
662// and adjusts them as needed. This is all specified by the i386 ELF
663// Processor Supplement.
664
665void
666Output_data_plt_i386::do_write(Output_file* of)
667{
668 const off_t offset = this->offset();
fe8718a4
ILT
669 const section_size_type oview_size =
670 convert_to_section_size_type(this->data_size());
a3ad94ed
ILT
671 unsigned char* const oview = of->get_output_view(offset, oview_size);
672
673 const off_t got_file_offset = this->got_plt_->offset();
fe8718a4
ILT
674 const section_size_type got_size =
675 convert_to_section_size_type(this->got_plt_->data_size());
a3ad94ed
ILT
676 unsigned char* const got_view = of->get_output_view(got_file_offset,
677 got_size);
678
679 unsigned char* pov = oview;
680
681 elfcpp::Elf_types<32>::Elf_Addr plt_address = this->address();
682 elfcpp::Elf_types<32>::Elf_Addr got_address = this->got_plt_->address();
683
374ad285 684 if (parameters->options().output_is_position_independent())
a3ad94ed
ILT
685 memcpy(pov, dyn_first_plt_entry, plt_entry_size);
686 else
687 {
688 memcpy(pov, exec_first_plt_entry, plt_entry_size);
689 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
690 elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
691 }
692 pov += plt_entry_size;
693
694 unsigned char* got_pov = got_view;
695
696 memset(got_pov, 0, 12);
697 got_pov += 12;
698
699 const int rel_size = elfcpp::Elf_sizes<32>::rel_size;
700
701 unsigned int plt_offset = plt_entry_size;
702 unsigned int plt_rel_offset = 0;
703 unsigned int got_offset = 12;
704 const unsigned int count = this->count_;
705 for (unsigned int i = 0;
706 i < count;
707 ++i,
708 pov += plt_entry_size,
709 got_pov += 4,
710 plt_offset += plt_entry_size,
711 plt_rel_offset += rel_size,
712 got_offset += 4)
713 {
714 // Set and adjust the PLT entry itself.
715
374ad285 716 if (parameters->options().output_is_position_independent())
a3ad94ed
ILT
717 {
718 memcpy(pov, dyn_plt_entry, plt_entry_size);
719 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
720 }
721 else
722 {
723 memcpy(pov, exec_plt_entry, plt_entry_size);
724 elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
725 (got_address
726 + got_offset));
727 }
728
729 elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset);
730 elfcpp::Swap<32, false>::writeval(pov + 12,
731 - (plt_offset + plt_entry_size));
732
733 // Set the entry in the GOT.
734 elfcpp::Swap<32, false>::writeval(got_pov, plt_address + plt_offset + 6);
735 }
736
fe8718a4
ILT
737 gold_assert(static_cast<section_size_type>(pov - oview) == oview_size);
738 gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size);
a3ad94ed
ILT
739
740 of->write_output_view(offset, oview_size, oview);
741 of->write_output_view(got_file_offset, got_size, got_view);
742}
743
744// Create a PLT entry for a global symbol.
745
746void
7e1edb90 747Target_i386::make_plt_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym)
a3ad94ed
ILT
748{
749 if (gsym->has_plt_offset())
750 return;
751
752 if (this->plt_ == NULL)
753 {
754 // Create the GOT sections first.
7e1edb90 755 this->got_section(symtab, layout);
a3ad94ed 756
7e1edb90 757 this->plt_ = new Output_data_plt_i386(layout, this->got_plt_);
16649710
ILT
758 layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
759 (elfcpp::SHF_ALLOC
760 | elfcpp::SHF_EXECINSTR),
f5c870d2 761 this->plt_, false);
a3ad94ed
ILT
762 }
763
764 this->plt_->add_entry(gsym);
765}
766
9fa33bee 767// Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
edfbb029
CC
768
769void
770Target_i386::define_tls_base_symbol(Symbol_table* symtab, Layout* layout)
771{
772 if (this->tls_base_symbol_defined_)
773 return;
774
775 Output_segment* tls_segment = layout->tls_segment();
776 if (tls_segment != NULL)
777 {
183fd0e3 778 bool is_exec = parameters->options().output_is_executable();
edfbb029
CC
779 symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
780 tls_segment, 0, 0,
781 elfcpp::STT_TLS,
782 elfcpp::STB_LOCAL,
783 elfcpp::STV_HIDDEN, 0,
183fd0e3
AO
784 (is_exec
785 ? Symbol::SEGMENT_END
786 : Symbol::SEGMENT_START),
787 true);
edfbb029
CC
788 }
789 this->tls_base_symbol_defined_ = true;
790}
791
94c4710f
ILT
792// Create a GOT entry for the TLS module index.
793
794unsigned int
795Target_i386::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
796 Sized_relobj<32, false>* object)
797{
798 if (this->got_mod_index_offset_ == -1U)
799 {
800 gold_assert(symtab != NULL && layout != NULL && object != NULL);
801 Reloc_section* rel_dyn = this->rel_dyn_section(layout);
802 Output_data_got<32, false>* got = this->got_section(symtab, layout);
803 unsigned int got_offset = got->add_constant(0);
804 rel_dyn->add_local(object, 0, elfcpp::R_386_TLS_DTPMOD32, got,
805 got_offset);
009a67a2 806 got->add_constant(0);
94c4710f
ILT
807 this->got_mod_index_offset_ = got_offset;
808 }
809 return this->got_mod_index_offset_;
810}
811
92e059d8 812// Optimize the TLS relocation type based on what we know about the
a3ad94ed
ILT
813// symbol. IS_FINAL is true if the final address of this symbol is
814// known at link time.
92e059d8 815
af6359d5 816tls::Tls_optimization
7e1edb90 817Target_i386::optimize_tls_reloc(bool is_final, int r_type)
92e059d8
ILT
818{
819 // If we are generating a shared library, then we can't do anything
820 // in the linker.
8851ecca 821 if (parameters->options().shared())
af6359d5 822 return tls::TLSOPT_NONE;
92e059d8
ILT
823
824 switch (r_type)
825 {
826 case elfcpp::R_386_TLS_GD:
827 case elfcpp::R_386_TLS_GOTDESC:
828 case elfcpp::R_386_TLS_DESC_CALL:
e041f13d 829 // These are General-Dynamic which permits fully general TLS
92e059d8
ILT
830 // access. Since we know that we are generating an executable,
831 // we can convert this to Initial-Exec. If we also know that
832 // this is a local symbol, we can further switch to Local-Exec.
a3ad94ed 833 if (is_final)
af6359d5
ILT
834 return tls::TLSOPT_TO_LE;
835 return tls::TLSOPT_TO_IE;
92e059d8
ILT
836
837 case elfcpp::R_386_TLS_LDM:
838 // This is Local-Dynamic, which refers to a local symbol in the
839 // dynamic TLS block. Since we know that we generating an
840 // executable, we can switch to Local-Exec.
af6359d5 841 return tls::TLSOPT_TO_LE;
92e059d8
ILT
842
843 case elfcpp::R_386_TLS_LDO_32:
af6359d5
ILT
844 // Another type of Local-Dynamic relocation.
845 return tls::TLSOPT_TO_LE;
92e059d8
ILT
846
847 case elfcpp::R_386_TLS_IE:
848 case elfcpp::R_386_TLS_GOTIE:
849 case elfcpp::R_386_TLS_IE_32:
850 // These are Initial-Exec relocs which get the thread offset
851 // from the GOT. If we know that we are linking against the
852 // local symbol, we can switch to Local-Exec, which links the
853 // thread offset into the instruction.
a3ad94ed 854 if (is_final)
af6359d5
ILT
855 return tls::TLSOPT_TO_LE;
856 return tls::TLSOPT_NONE;
8462ae85 857
92e059d8
ILT
858 case elfcpp::R_386_TLS_LE:
859 case elfcpp::R_386_TLS_LE_32:
860 // When we already have Local-Exec, there is nothing further we
861 // can do.
af6359d5 862 return tls::TLSOPT_NONE;
92e059d8
ILT
863
864 default:
a3ad94ed 865 gold_unreachable();
92e059d8
ILT
866 }
867}
868
af6359d5
ILT
869// Report an unsupported relocation against a local symbol.
870
871void
872Target_i386::Scan::unsupported_reloc_local(Sized_relobj<32, false>* object,
873 unsigned int r_type)
874{
75f2446e
ILT
875 gold_error(_("%s: unsupported reloc %u against local symbol"),
876 object->name().c_str(), r_type);
af6359d5
ILT
877}
878
92e059d8
ILT
879// Scan a relocation for a local symbol.
880
881inline void
ad0f2072 882Target_i386::Scan::local(Symbol_table* symtab,
ead1e424
ILT
883 Layout* layout,
884 Target_i386* target,
f6ce93d6 885 Sized_relobj<32, false>* object,
1b64748b 886 unsigned int data_shndx,
07f397ab 887 Output_section* output_section,
1b64748b 888 const elfcpp::Rel<32, false>& reloc,
a3ad94ed 889 unsigned int r_type,
7bf1f802 890 const elfcpp::Sym<32, false>& lsym)
92e059d8
ILT
891{
892 switch (r_type)
893 {
894 case elfcpp::R_386_NONE:
895 case elfcpp::R_386_GNU_VTINHERIT:
896 case elfcpp::R_386_GNU_VTENTRY:
897 break;
898
899 case elfcpp::R_386_32:
436ca963
ILT
900 // If building a shared library (or a position-independent
901 // executable), we need to create a dynamic relocation for
902 // this location. The relocation applied at link time will
903 // apply the link-time value, so we flag the location with
904 // an R_386_RELATIVE relocation so the dynamic loader can
905 // relocate it easily.
8851ecca 906 if (parameters->options().output_is_position_independent())
436ca963
ILT
907 {
908 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
e8c846c3
ILT
909 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
910 rel_dyn->add_local_relative(object, r_sym, elfcpp::R_386_RELATIVE,
911 output_section, data_shndx,
912 reloc.get_r_offset());
d61c6bd4
ILT
913 }
914 break;
915
916 case elfcpp::R_386_16:
917 case elfcpp::R_386_8:
918 // If building a shared library (or a position-independent
919 // executable), we need to create a dynamic relocation for
920 // this location. Because the addend needs to remain in the
921 // data section, we need to be careful not to apply this
922 // relocation statically.
8851ecca 923 if (parameters->options().output_is_position_independent())
d61c6bd4
ILT
924 {
925 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
d491d34e 926 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
dceae3c1 927 if (lsym.get_st_type() != elfcpp::STT_SECTION)
d491d34e
ILT
928 rel_dyn->add_local(object, r_sym, r_type, output_section,
929 data_shndx, reloc.get_r_offset());
dceae3c1
ILT
930 else
931 {
932 gold_assert(lsym.get_st_value() == 0);
d491d34e
ILT
933 unsigned int shndx = lsym.get_st_shndx();
934 bool is_ordinary;
935 shndx = object->adjust_sym_shndx(r_sym, shndx,
936 &is_ordinary);
937 if (!is_ordinary)
938 object->error(_("section symbol %u has bad shndx %u"),
939 r_sym, shndx);
940 else
941 rel_dyn->add_local_section(object, shndx,
942 r_type, output_section,
943 data_shndx, reloc.get_r_offset());
dceae3c1 944 }
436ca963 945 }
92e059d8
ILT
946 break;
947
948 case elfcpp::R_386_PC32:
949 case elfcpp::R_386_PC16:
950 case elfcpp::R_386_PC8:
951 break;
952
df2efe71
ILT
953 case elfcpp::R_386_PLT32:
954 // Since we know this is a local symbol, we can handle this as a
955 // PC32 reloc.
956 break;
957
ead1e424
ILT
958 case elfcpp::R_386_GOTOFF:
959 case elfcpp::R_386_GOTPC:
960 // We need a GOT section.
7e1edb90 961 target->got_section(symtab, layout);
ead1e424
ILT
962 break;
963
1b64748b
ILT
964 case elfcpp::R_386_GOT32:
965 {
966 // The symbol requires a GOT entry.
967 Output_data_got<32, false>* got = target->got_section(symtab, layout);
968 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
0a65a3a7 969 if (got->add_local(object, r_sym, GOT_TYPE_STANDARD))
1b64748b
ILT
970 {
971 // If we are generating a shared object, we need to add a
7bf1f802 972 // dynamic RELATIVE relocation for this symbol's GOT entry.
8851ecca 973 if (parameters->options().output_is_position_independent())
1b64748b
ILT
974 {
975 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
e8c846c3 976 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
0a65a3a7
CC
977 rel_dyn->add_local_relative(
978 object, r_sym, elfcpp::R_386_RELATIVE, got,
979 object->local_got_offset(r_sym, GOT_TYPE_STANDARD));
1b64748b
ILT
980 }
981 }
982 }
983 break;
984
af6359d5
ILT
985 // These are relocations which should only be seen by the
986 // dynamic linker, and should never be seen here.
92e059d8
ILT
987 case elfcpp::R_386_COPY:
988 case elfcpp::R_386_GLOB_DAT:
989 case elfcpp::R_386_JUMP_SLOT:
990 case elfcpp::R_386_RELATIVE:
991 case elfcpp::R_386_TLS_TPOFF:
992 case elfcpp::R_386_TLS_DTPMOD32:
993 case elfcpp::R_386_TLS_DTPOFF32:
994 case elfcpp::R_386_TLS_TPOFF32:
995 case elfcpp::R_386_TLS_DESC:
a0c4fb0a 996 gold_error(_("%s: unexpected reloc %u in object file"),
75f2446e 997 object->name().c_str(), r_type);
92e059d8
ILT
998 break;
999
af6359d5 1000 // These are initial TLS relocs, which are expected when
d61c17ea 1001 // linking.
56622147
ILT
1002 case elfcpp::R_386_TLS_GD: // Global-dynamic
1003 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1004 case elfcpp::R_386_TLS_DESC_CALL:
1005 case elfcpp::R_386_TLS_LDM: // Local-dynamic
1006 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
1007 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 1008 case elfcpp::R_386_TLS_IE_32:
56622147
ILT
1009 case elfcpp::R_386_TLS_GOTIE:
1010 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 1011 case elfcpp::R_386_TLS_LE_32:
7e1edb90 1012 {
8851ecca 1013 bool output_is_shared = parameters->options().shared();
af6359d5
ILT
1014 const tls::Tls_optimization optimized_type
1015 = Target_i386::optimize_tls_reloc(!output_is_shared, r_type);
7e1edb90
ILT
1016 switch (r_type)
1017 {
56622147 1018 case elfcpp::R_386_TLS_GD: // Global-dynamic
07f397ab
ILT
1019 if (optimized_type == tls::TLSOPT_NONE)
1020 {
1021 // Create a pair of GOT entries for the module index and
1022 // dtv-relative offset.
1023 Output_data_got<32, false>* got
1024 = target->got_section(symtab, layout);
1025 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
d491d34e
ILT
1026 unsigned int shndx = lsym.get_st_shndx();
1027 bool is_ordinary;
1028 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1029 if (!is_ordinary)
1030 object->error(_("local symbol %u has bad shndx %u"),
1031 r_sym, shndx);
1032 else
1033 got->add_local_pair_with_rel(object, r_sym, shndx,
1034 GOT_TYPE_TLS_PAIR,
1035 target->rel_dyn_section(layout),
1036 elfcpp::R_386_TLS_DTPMOD32, 0);
07f397ab
ILT
1037 }
1038 else if (optimized_type != tls::TLSOPT_TO_LE)
1039 unsupported_reloc_local(object, r_type);
1040 break;
1041
56622147 1042 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva)
edfbb029 1043 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC
1044 if (optimized_type == tls::TLSOPT_NONE)
1045 {
1046 // Create a double GOT entry with an R_386_TLS_DESC reloc.
1047 Output_data_got<32, false>* got
1048 = target->got_section(symtab, layout);
1049 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
d491d34e
ILT
1050 unsigned int shndx = lsym.get_st_shndx();
1051 bool is_ordinary;
1052 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1053 if (!is_ordinary)
1054 object->error(_("local symbol %u has bad shndx %u"),
1055 r_sym, shndx);
1056 else
1057 got->add_local_pair_with_rel(object, r_sym, shndx,
1058 GOT_TYPE_TLS_DESC,
1059 target->rel_dyn_section(layout),
1060 elfcpp::R_386_TLS_DESC, 0);
c2b45e22
CC
1061 }
1062 else if (optimized_type != tls::TLSOPT_TO_LE)
7bf1f802 1063 unsupported_reloc_local(object, r_type);
af6359d5
ILT
1064 break;
1065
c2b45e22
CC
1066 case elfcpp::R_386_TLS_DESC_CALL:
1067 break;
1068
56622147 1069 case elfcpp::R_386_TLS_LDM: // Local-dynamic
07f397ab
ILT
1070 if (optimized_type == tls::TLSOPT_NONE)
1071 {
1072 // Create a GOT entry for the module index.
94c4710f 1073 target->got_mod_index_entry(symtab, layout, object);
07f397ab
ILT
1074 }
1075 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5
ILT
1076 unsupported_reloc_local(object, r_type);
1077 break;
1078
56622147 1079 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
46cf9fa2
ILT
1080 break;
1081
56622147
ILT
1082 case elfcpp::R_386_TLS_IE: // Initial-exec
1083 case elfcpp::R_386_TLS_IE_32:
1084 case elfcpp::R_386_TLS_GOTIE:
535890bb 1085 layout->set_has_static_tls();
07f397ab
ILT
1086 if (optimized_type == tls::TLSOPT_NONE)
1087 {
7bf1f802
ILT
1088 // For the R_386_TLS_IE relocation, we need to create a
1089 // dynamic relocation when building a shared library.
1090 if (r_type == elfcpp::R_386_TLS_IE
8851ecca 1091 && parameters->options().shared())
7bf1f802
ILT
1092 {
1093 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
e8c846c3
ILT
1094 unsigned int r_sym
1095 = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1096 rel_dyn->add_local_relative(object, r_sym,
1097 elfcpp::R_386_RELATIVE,
1098 output_section, data_shndx,
1099 reloc.get_r_offset());
7bf1f802 1100 }
07f397ab
ILT
1101 // Create a GOT entry for the tp-relative offset.
1102 Output_data_got<32, false>* got
1103 = target->got_section(symtab, layout);
1104 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
7bf1f802
ILT
1105 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
1106 ? elfcpp::R_386_TLS_TPOFF32
1107 : elfcpp::R_386_TLS_TPOFF);
c2b45e22
CC
1108 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
1109 ? GOT_TYPE_TLS_OFFSET
1110 : GOT_TYPE_TLS_NOFFSET);
1111 got->add_local_with_rel(object, r_sym, got_type,
7bf1f802
ILT
1112 target->rel_dyn_section(layout),
1113 dyn_r_type);
07f397ab
ILT
1114 }
1115 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5 1116 unsupported_reloc_local(object, r_type);
7e1edb90 1117 break;
af6359d5 1118
56622147
ILT
1119 case elfcpp::R_386_TLS_LE: // Local-exec
1120 case elfcpp::R_386_TLS_LE_32:
535890bb 1121 layout->set_has_static_tls();
07f397ab 1122 if (output_is_shared)
7bf1f802
ILT
1123 {
1124 // We need to create a dynamic relocation.
dceae3c1 1125 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
7bf1f802
ILT
1126 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1127 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
1128 ? elfcpp::R_386_TLS_TPOFF32
1129 : elfcpp::R_386_TLS_TPOFF);
1130 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1131 rel_dyn->add_local(object, r_sym, dyn_r_type, output_section,
1132 data_shndx, reloc.get_r_offset());
1133 }
56622147
ILT
1134 break;
1135
af6359d5
ILT
1136 default:
1137 gold_unreachable();
7e1edb90
ILT
1138 }
1139 }
92e059d8
ILT
1140 break;
1141
92e059d8
ILT
1142 case elfcpp::R_386_32PLT:
1143 case elfcpp::R_386_TLS_GD_32:
1144 case elfcpp::R_386_TLS_GD_PUSH:
1145 case elfcpp::R_386_TLS_GD_CALL:
1146 case elfcpp::R_386_TLS_GD_POP:
1147 case elfcpp::R_386_TLS_LDM_32:
1148 case elfcpp::R_386_TLS_LDM_PUSH:
1149 case elfcpp::R_386_TLS_LDM_CALL:
1150 case elfcpp::R_386_TLS_LDM_POP:
1151 case elfcpp::R_386_USED_BY_INTEL_200:
1152 default:
af6359d5 1153 unsupported_reloc_local(object, r_type);
92e059d8
ILT
1154 break;
1155 }
1156}
1157
af6359d5
ILT
1158// Report an unsupported relocation against a global symbol.
1159
1160void
1161Target_i386::Scan::unsupported_reloc_global(Sized_relobj<32, false>* object,
1162 unsigned int r_type,
1163 Symbol* gsym)
1164{
75f2446e 1165 gold_error(_("%s: unsupported reloc %u against global symbol %s"),
a2b1aa12 1166 object->name().c_str(), r_type, gsym->demangled_name().c_str());
af6359d5
ILT
1167}
1168
92e059d8
ILT
1169// Scan a relocation for a global symbol.
1170
1171inline void
ad0f2072 1172Target_i386::Scan::global(Symbol_table* symtab,
ead1e424
ILT
1173 Layout* layout,
1174 Target_i386* target,
f6ce93d6 1175 Sized_relobj<32, false>* object,
a3ad94ed 1176 unsigned int data_shndx,
07f397ab 1177 Output_section* output_section,
a3ad94ed
ILT
1178 const elfcpp::Rel<32, false>& reloc,
1179 unsigned int r_type,
92e059d8
ILT
1180 Symbol* gsym)
1181{
1182 switch (r_type)
1183 {
1184 case elfcpp::R_386_NONE:
1185 case elfcpp::R_386_GNU_VTINHERIT:
8462ae85 1186 case elfcpp::R_386_GNU_VTENTRY:
92e059d8
ILT
1187 break;
1188
1189 case elfcpp::R_386_32:
92e059d8 1190 case elfcpp::R_386_16:
92e059d8 1191 case elfcpp::R_386_8:
96f2030e 1192 {
d61c6bd4
ILT
1193 // Make a PLT entry if necessary.
1194 if (gsym->needs_plt_entry())
1195 {
1196 target->make_plt_entry(symtab, layout, gsym);
1197 // Since this is not a PC-relative relocation, we may be
1198 // taking the address of a function. In that case we need to
1199 // set the entry in the dynamic symbol table to the address of
1200 // the PLT entry.
8851ecca 1201 if (gsym->is_from_dynobj() && !parameters->options().shared())
d61c6bd4
ILT
1202 gsym->set_needs_dynsym_value();
1203 }
1204 // Make a dynamic relocation if necessary.
0700cf32 1205 if (gsym->needs_dynamic_reloc(Symbol::ABSOLUTE_REF))
d61c6bd4 1206 {
966d4097 1207 if (gsym->may_need_copy_reloc())
d61c6bd4 1208 {
12c0daef 1209 target->copy_reloc(symtab, layout, object,
4f4c5f80 1210 data_shndx, output_section, gsym, reloc);
d61c6bd4
ILT
1211 }
1212 else if (r_type == elfcpp::R_386_32
1213 && gsym->can_use_relative_reloc(false))
1214 {
1215 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
e8c846c3
ILT
1216 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
1217 output_section, object,
1218 data_shndx, reloc.get_r_offset());
d61c6bd4
ILT
1219 }
1220 else
1221 {
96f2030e 1222 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
4f4c5f80
ILT
1223 rel_dyn->add_global(gsym, r_type, output_section, object,
1224 data_shndx, reloc.get_r_offset());
d61c6bd4
ILT
1225 }
1226 }
1227 }
1228 break;
1229
1230 case elfcpp::R_386_PC32:
1231 case elfcpp::R_386_PC16:
1232 case elfcpp::R_386_PC8:
1233 {
1234 // Make a PLT entry if necessary.
1235 if (gsym->needs_plt_entry())
7bf1f802
ILT
1236 {
1237 // These relocations are used for function calls only in
1238 // non-PIC code. For a 32-bit relocation in a shared library,
1239 // we'll need a text relocation anyway, so we can skip the
1240 // PLT entry and let the dynamic linker bind the call directly
1241 // to the target. For smaller relocations, we should use a
1242 // PLT entry to ensure that the call can reach.
8851ecca 1243 if (!parameters->options().shared()
7bf1f802
ILT
1244 || r_type != elfcpp::R_386_PC32)
1245 target->make_plt_entry(symtab, layout, gsym);
1246 }
d61c6bd4 1247 // Make a dynamic relocation if necessary.
0700cf32
ILT
1248 int flags = Symbol::NON_PIC_REF;
1249 if (gsym->type() == elfcpp::STT_FUNC)
1250 flags |= Symbol::FUNCTION_CALL;
1251 if (gsym->needs_dynamic_reloc(flags))
96f2030e 1252 {
966d4097 1253 if (gsym->may_need_copy_reloc())
d61c6bd4 1254 {
12c0daef 1255 target->copy_reloc(symtab, layout, object,
4f4c5f80 1256 data_shndx, output_section, gsym, reloc);
d61c6bd4 1257 }
86849f1f 1258 else
d61c6bd4
ILT
1259 {
1260 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
4f4c5f80
ILT
1261 rel_dyn->add_global(gsym, r_type, output_section, object,
1262 data_shndx, reloc.get_r_offset());
d61c6bd4 1263 }
96f2030e
ILT
1264 }
1265 }
92e059d8
ILT
1266 break;
1267
ead1e424 1268 case elfcpp::R_386_GOT32:
8462ae85
ILT
1269 {
1270 // The symbol requires a GOT entry.
7e1edb90 1271 Output_data_got<32, false>* got = target->got_section(symtab, layout);
7bf1f802 1272 if (gsym->final_value_is_known())
0a65a3a7 1273 got->add_global(gsym, GOT_TYPE_STANDARD);
7bf1f802
ILT
1274 else
1275 {
8462ae85 1276 // If this symbol is not fully resolved, we need to add a
7bf1f802
ILT
1277 // GOT entry with a dynamic relocation.
1278 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
8fc19601
ILT
1279 if (gsym->is_from_dynobj()
1280 || gsym->is_undefined()
1281 || gsym->is_preemptible())
0a65a3a7
CC
1282 got->add_global_with_rel(gsym, GOT_TYPE_STANDARD,
1283 rel_dyn, elfcpp::R_386_GLOB_DAT);
7bf1f802 1284 else
8462ae85 1285 {
0a65a3a7
CC
1286 if (got->add_global(gsym, GOT_TYPE_STANDARD))
1287 rel_dyn->add_global_relative(
1288 gsym, elfcpp::R_386_RELATIVE, got,
1289 gsym->got_offset(GOT_TYPE_STANDARD));
8462ae85
ILT
1290 }
1291 }
1292 }
ead1e424
ILT
1293 break;
1294
1295 case elfcpp::R_386_PLT32:
a3ad94ed
ILT
1296 // If the symbol is fully resolved, this is just a PC32 reloc.
1297 // Otherwise we need a PLT entry.
7e1edb90 1298 if (gsym->final_value_is_known())
ead1e424 1299 break;
436ca963
ILT
1300 // If building a shared library, we can also skip the PLT entry
1301 // if the symbol is defined in the output file and is protected
1302 // or hidden.
1303 if (gsym->is_defined()
1304 && !gsym->is_from_dynobj()
1305 && !gsym->is_preemptible())
1306 break;
7e1edb90 1307 target->make_plt_entry(symtab, layout, gsym);
ead1e424
ILT
1308 break;
1309
1310 case elfcpp::R_386_GOTOFF:
1311 case elfcpp::R_386_GOTPC:
1312 // We need a GOT section.
7e1edb90 1313 target->got_section(symtab, layout);
ead1e424
ILT
1314 break;
1315
af6359d5
ILT
1316 // These are relocations which should only be seen by the
1317 // dynamic linker, and should never be seen here.
92e059d8
ILT
1318 case elfcpp::R_386_COPY:
1319 case elfcpp::R_386_GLOB_DAT:
1320 case elfcpp::R_386_JUMP_SLOT:
1321 case elfcpp::R_386_RELATIVE:
1322 case elfcpp::R_386_TLS_TPOFF:
1323 case elfcpp::R_386_TLS_DTPMOD32:
1324 case elfcpp::R_386_TLS_DTPOFF32:
1325 case elfcpp::R_386_TLS_TPOFF32:
1326 case elfcpp::R_386_TLS_DESC:
75f2446e
ILT
1327 gold_error(_("%s: unexpected reloc %u in object file"),
1328 object->name().c_str(), r_type);
92e059d8
ILT
1329 break;
1330
d61c17ea
ILT
1331 // These are initial tls relocs, which are expected when
1332 // linking.
56622147
ILT
1333 case elfcpp::R_386_TLS_GD: // Global-dynamic
1334 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1335 case elfcpp::R_386_TLS_DESC_CALL:
1336 case elfcpp::R_386_TLS_LDM: // Local-dynamic
1337 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
1338 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 1339 case elfcpp::R_386_TLS_IE_32:
56622147
ILT
1340 case elfcpp::R_386_TLS_GOTIE:
1341 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 1342 case elfcpp::R_386_TLS_LE_32:
a3ad94ed 1343 {
7e1edb90 1344 const bool is_final = gsym->final_value_is_known();
af6359d5
ILT
1345 const tls::Tls_optimization optimized_type
1346 = Target_i386::optimize_tls_reloc(is_final, r_type);
a3ad94ed
ILT
1347 switch (r_type)
1348 {
56622147 1349 case elfcpp::R_386_TLS_GD: // Global-dynamic
07f397ab
ILT
1350 if (optimized_type == tls::TLSOPT_NONE)
1351 {
1352 // Create a pair of GOT entries for the module index and
1353 // dtv-relative offset.
1354 Output_data_got<32, false>* got
1355 = target->got_section(symtab, layout);
0a65a3a7 1356 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
7bf1f802
ILT
1357 target->rel_dyn_section(layout),
1358 elfcpp::R_386_TLS_DTPMOD32,
1359 elfcpp::R_386_TLS_DTPOFF32);
07f397ab
ILT
1360 }
1361 else if (optimized_type == tls::TLSOPT_TO_IE)
1362 {
1363 // Create a GOT entry for the tp-relative offset.
1364 Output_data_got<32, false>* got
1365 = target->got_section(symtab, layout);
c2b45e22 1366 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
0a65a3a7 1367 target->rel_dyn_section(layout),
c2b45e22 1368 elfcpp::R_386_TLS_TPOFF);
07f397ab
ILT
1369 }
1370 else if (optimized_type != tls::TLSOPT_TO_LE)
1371 unsupported_reloc_global(object, r_type, gsym);
1372 break;
1373
56622147 1374 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (~oliva url)
edfbb029 1375 target->define_tls_base_symbol(symtab, layout);
c2b45e22
CC
1376 if (optimized_type == tls::TLSOPT_NONE)
1377 {
1378 // Create a double GOT entry with an R_386_TLS_DESC reloc.
1379 Output_data_got<32, false>* got
1380 = target->got_section(symtab, layout);
1381 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC,
1382 target->rel_dyn_section(layout),
1383 elfcpp::R_386_TLS_DESC, 0);
1384 }
1385 else if (optimized_type == tls::TLSOPT_TO_IE)
1386 {
1387 // Create a GOT entry for the tp-relative offset.
1388 Output_data_got<32, false>* got
1389 = target->got_section(symtab, layout);
1390 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
1391 target->rel_dyn_section(layout),
1392 elfcpp::R_386_TLS_TPOFF);
1393 }
1394 else if (optimized_type != tls::TLSOPT_TO_LE)
7bf1f802 1395 unsupported_reloc_global(object, r_type, gsym);
c2b45e22
CC
1396 break;
1397
1398 case elfcpp::R_386_TLS_DESC_CALL:
af6359d5
ILT
1399 break;
1400
56622147 1401 case elfcpp::R_386_TLS_LDM: // Local-dynamic
07f397ab
ILT
1402 if (optimized_type == tls::TLSOPT_NONE)
1403 {
1404 // Create a GOT entry for the module index.
94c4710f 1405 target->got_mod_index_entry(symtab, layout, object);
07f397ab
ILT
1406 }
1407 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5
ILT
1408 unsupported_reloc_global(object, r_type, gsym);
1409 break;
1410
56622147 1411 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
46cf9fa2
ILT
1412 break;
1413
56622147
ILT
1414 case elfcpp::R_386_TLS_IE: // Initial-exec
1415 case elfcpp::R_386_TLS_IE_32:
1416 case elfcpp::R_386_TLS_GOTIE:
535890bb 1417 layout->set_has_static_tls();
07f397ab
ILT
1418 if (optimized_type == tls::TLSOPT_NONE)
1419 {
7bf1f802
ILT
1420 // For the R_386_TLS_IE relocation, we need to create a
1421 // dynamic relocation when building a shared library.
1422 if (r_type == elfcpp::R_386_TLS_IE
8851ecca 1423 && parameters->options().shared())
07f397ab 1424 {
07f397ab 1425 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
e8c846c3
ILT
1426 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
1427 output_section, object,
1428 data_shndx,
1429 reloc.get_r_offset());
07f397ab 1430 }
7bf1f802
ILT
1431 // Create a GOT entry for the tp-relative offset.
1432 Output_data_got<32, false>* got
1433 = target->got_section(symtab, layout);
1434 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
1435 ? elfcpp::R_386_TLS_TPOFF32
1436 : elfcpp::R_386_TLS_TPOFF);
c2b45e22
CC
1437 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
1438 ? GOT_TYPE_TLS_OFFSET
1439 : GOT_TYPE_TLS_NOFFSET);
1440 got->add_global_with_rel(gsym, got_type,
7bf1f802
ILT
1441 target->rel_dyn_section(layout),
1442 dyn_r_type);
07f397ab
ILT
1443 }
1444 else if (optimized_type != tls::TLSOPT_TO_LE)
af6359d5 1445 unsupported_reloc_global(object, r_type, gsym);
a3ad94ed 1446 break;
af6359d5 1447
56622147
ILT
1448 case elfcpp::R_386_TLS_LE: // Local-exec
1449 case elfcpp::R_386_TLS_LE_32:
535890bb 1450 layout->set_has_static_tls();
8851ecca 1451 if (parameters->options().shared())
7bf1f802
ILT
1452 {
1453 // We need to create a dynamic relocation.
1454 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
1455 ? elfcpp::R_386_TLS_TPOFF32
1456 : elfcpp::R_386_TLS_TPOFF);
1457 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1458 rel_dyn->add_global(gsym, dyn_r_type, output_section, object,
1459 data_shndx, reloc.get_r_offset());
1460 }
56622147
ILT
1461 break;
1462
af6359d5
ILT
1463 default:
1464 gold_unreachable();
a3ad94ed
ILT
1465 }
1466 }
92e059d8
ILT
1467 break;
1468
92e059d8
ILT
1469 case elfcpp::R_386_32PLT:
1470 case elfcpp::R_386_TLS_GD_32:
1471 case elfcpp::R_386_TLS_GD_PUSH:
1472 case elfcpp::R_386_TLS_GD_CALL:
1473 case elfcpp::R_386_TLS_GD_POP:
1474 case elfcpp::R_386_TLS_LDM_32:
1475 case elfcpp::R_386_TLS_LDM_PUSH:
1476 case elfcpp::R_386_TLS_LDM_CALL:
1477 case elfcpp::R_386_TLS_LDM_POP:
1478 case elfcpp::R_386_USED_BY_INTEL_200:
1479 default:
af6359d5 1480 unsupported_reloc_global(object, r_type, gsym);
92e059d8
ILT
1481 break;
1482 }
1483}
1484
6d03d481
ST
1485// Process relocations for gc.
1486
1487void
ad0f2072 1488Target_i386::gc_process_relocs(Symbol_table* symtab,
6d03d481
ST
1489 Layout* layout,
1490 Sized_relobj<32, false>* object,
1491 unsigned int data_shndx,
1492 unsigned int,
1493 const unsigned char* prelocs,
1494 size_t reloc_count,
1495 Output_section* output_section,
1496 bool needs_special_offset_handling,
1497 size_t local_symbol_count,
1498 const unsigned char* plocal_symbols)
1499{
1500 gold::gc_process_relocs<32, false, Target_i386, elfcpp::SHT_REL,
1501 Target_i386::Scan>(
6d03d481
ST
1502 symtab,
1503 layout,
1504 this,
1505 object,
1506 data_shndx,
1507 prelocs,
1508 reloc_count,
1509 output_section,
1510 needs_special_offset_handling,
1511 local_symbol_count,
1512 plocal_symbols);
1513}
1514
92e059d8
ILT
1515// Scan relocations for a section.
1516
1517void
ad0f2072 1518Target_i386::scan_relocs(Symbol_table* symtab,
ead1e424 1519 Layout* layout,
f6ce93d6 1520 Sized_relobj<32, false>* object,
a3ad94ed 1521 unsigned int data_shndx,
92e059d8
ILT
1522 unsigned int sh_type,
1523 const unsigned char* prelocs,
1524 size_t reloc_count,
730cdc88
ILT
1525 Output_section* output_section,
1526 bool needs_special_offset_handling,
92e059d8 1527 size_t local_symbol_count,
730cdc88 1528 const unsigned char* plocal_symbols)
92e059d8
ILT
1529{
1530 if (sh_type == elfcpp::SHT_RELA)
1531 {
75f2446e
ILT
1532 gold_error(_("%s: unsupported RELA reloc section"),
1533 object->name().c_str());
1534 return;
92e059d8
ILT
1535 }
1536
ead1e424
ILT
1537 gold::scan_relocs<32, false, Target_i386, elfcpp::SHT_REL,
1538 Target_i386::Scan>(
92e059d8 1539 symtab,
ead1e424
ILT
1540 layout,
1541 this,
92e059d8 1542 object,
a3ad94ed 1543 data_shndx,
92e059d8
ILT
1544 prelocs,
1545 reloc_count,
730cdc88
ILT
1546 output_section,
1547 needs_special_offset_handling,
92e059d8 1548 local_symbol_count,
730cdc88 1549 plocal_symbols);
92e059d8
ILT
1550}
1551
16649710 1552// Finalize the sections.
5a6f7e2d
ILT
1553
1554void
f59f41f3
DK
1555Target_i386::do_finalize_sections(
1556 Layout* layout,
1557 const Input_objects*,
1558 Symbol_table*)
5a6f7e2d 1559{
16649710
ILT
1560 // Fill in some more dynamic tags.
1561 Output_data_dynamic* const odyn = layout->dynamic_data();
1562 if (odyn != NULL)
1563 {
22b127cc
ILT
1564 if (this->got_plt_ != NULL
1565 && this->got_plt_->output_section() != NULL)
16649710
ILT
1566 odyn->add_section_address(elfcpp::DT_PLTGOT, this->got_plt_);
1567
22b127cc
ILT
1568 if (this->plt_ != NULL
1569 && this->plt_->output_section() != NULL)
16649710
ILT
1570 {
1571 const Output_data* od = this->plt_->rel_plt();
1572 odyn->add_section_size(elfcpp::DT_PLTRELSZ, od);
1573 odyn->add_section_address(elfcpp::DT_JMPREL, od);
1574 odyn->add_constant(elfcpp::DT_PLTREL, elfcpp::DT_REL);
1575 }
1576
22b127cc
ILT
1577 if (this->rel_dyn_ != NULL
1578 && this->rel_dyn_->output_section() != NULL)
16649710
ILT
1579 {
1580 const Output_data* od = this->rel_dyn_;
1581 odyn->add_section_address(elfcpp::DT_REL, od);
1582 odyn->add_section_size(elfcpp::DT_RELSZ, od);
1583 odyn->add_constant(elfcpp::DT_RELENT,
1584 elfcpp::Elf_sizes<32>::rel_size);
1585 }
1586
8851ecca 1587 if (!parameters->options().shared())
16649710
ILT
1588 {
1589 // The value of the DT_DEBUG tag is filled in by the dynamic
1590 // linker at run time, and used by the debugger.
1591 odyn->add_constant(elfcpp::DT_DEBUG, 0);
1592 }
1593 }
1594
1595 // Emit any relocs we saved in an attempt to avoid generating COPY
1596 // relocs.
12c0daef
ILT
1597 if (this->copy_relocs_.any_saved_relocs())
1598 this->copy_relocs_.emit(this->rel_dyn_section(layout));
5a6f7e2d
ILT
1599}
1600
86849f1f
ILT
1601// Return whether a direct absolute static relocation needs to be applied.
1602// In cases where Scan::local() or Scan::global() has created
1603// a dynamic relocation other than R_386_RELATIVE, the addend
1604// of the relocation is carried in the data, and we must not
1605// apply the static relocation.
1606
1607inline bool
1608Target_i386::Relocate::should_apply_static_reloc(const Sized_symbol<32>* gsym,
0700cf32 1609 int ref_flags,
031cdbed
ILT
1610 bool is_32bit,
1611 Output_section* output_section)
86849f1f 1612{
031cdbed
ILT
1613 // If the output section is not allocated, then we didn't call
1614 // scan_relocs, we didn't create a dynamic reloc, and we must apply
1615 // the reloc here.
1616 if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0)
1617 return true;
1618
d61c6bd4
ILT
1619 // For local symbols, we will have created a non-RELATIVE dynamic
1620 // relocation only if (a) the output is position independent,
1621 // (b) the relocation is absolute (not pc- or segment-relative), and
1622 // (c) the relocation is not 32 bits wide.
86849f1f 1623 if (gsym == NULL)
8851ecca 1624 return !(parameters->options().output_is_position_independent()
0700cf32 1625 && (ref_flags & Symbol::ABSOLUTE_REF)
d61c6bd4 1626 && !is_32bit);
86849f1f 1627
0700cf32
ILT
1628 // For global symbols, we use the same helper routines used in the
1629 // scan pass. If we did not create a dynamic relocation, or if we
1630 // created a RELATIVE dynamic relocation, we should apply the static
1631 // relocation.
1632 bool has_dyn = gsym->needs_dynamic_reloc(ref_flags);
1633 bool is_rel = (ref_flags & Symbol::ABSOLUTE_REF)
1634 && gsym->can_use_relative_reloc(ref_flags
1635 & Symbol::FUNCTION_CALL);
1636 return !has_dyn || is_rel;
86849f1f
ILT
1637}
1638
61ba1cf9
ILT
1639// Perform a relocation.
1640
ead1e424 1641inline bool
92e059d8 1642Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
ead1e424 1643 Target_i386* target,
031cdbed 1644 Output_section *output_section,
92e059d8
ILT
1645 size_t relnum,
1646 const elfcpp::Rel<32, false>& rel,
1647 unsigned int r_type,
c06b7b0b 1648 const Sized_symbol<32>* gsym,
b8e6aad9 1649 const Symbol_value<32>* psymval,
92e059d8
ILT
1650 unsigned char* view,
1651 elfcpp::Elf_types<32>::Elf_Addr address,
fe8718a4 1652 section_size_type view_size)
61ba1cf9 1653{
ead1e424
ILT
1654 if (this->skip_call_tls_get_addr_)
1655 {
5efc7cd2
CC
1656 if ((r_type != elfcpp::R_386_PLT32
1657 && r_type != elfcpp::R_386_PC32)
ead1e424
ILT
1658 || gsym == NULL
1659 || strcmp(gsym->name(), "___tls_get_addr") != 0)
75f2446e
ILT
1660 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1661 _("missing expected TLS relocation"));
1662 else
ead1e424 1663 {
75f2446e
ILT
1664 this->skip_call_tls_get_addr_ = false;
1665 return false;
ead1e424 1666 }
ead1e424
ILT
1667 }
1668
a3ad94ed 1669 // Pick the value to use for symbols defined in shared objects.
b8e6aad9 1670 Symbol_value<32> symval;
436ca963 1671 if (gsym != NULL
de4c45bd
ILT
1672 && gsym->use_plt_offset(r_type == elfcpp::R_386_PC8
1673 || r_type == elfcpp::R_386_PC16
1674 || r_type == elfcpp::R_386_PC32))
a3ad94ed 1675 {
b8e6aad9
ILT
1676 symval.set_output_value(target->plt_section()->address()
1677 + gsym->plt_offset());
1678 psymval = &symval;
a3ad94ed
ILT
1679 }
1680
b8e6aad9
ILT
1681 const Sized_relobj<32, false>* object = relinfo->object;
1682
1b64748b 1683 // Get the GOT offset if needed.
96f2030e
ILT
1684 // The GOT pointer points to the end of the GOT section.
1685 // We need to subtract the size of the GOT section to get
1686 // the actual offset to use in the relocation.
1b64748b
ILT
1687 bool have_got_offset = false;
1688 unsigned int got_offset = 0;
1689 switch (r_type)
1690 {
1691 case elfcpp::R_386_GOT32:
1692 if (gsym != NULL)
1693 {
0a65a3a7
CC
1694 gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
1695 got_offset = (gsym->got_offset(GOT_TYPE_STANDARD)
1696 - target->got_size());
1b64748b
ILT
1697 }
1698 else
1699 {
1700 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
0a65a3a7
CC
1701 gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
1702 got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
1703 - target->got_size());
1b64748b
ILT
1704 }
1705 have_got_offset = true;
1706 break;
1707
1708 default:
1709 break;
1710 }
1711
61ba1cf9
ILT
1712 switch (r_type)
1713 {
1714 case elfcpp::R_386_NONE:
92e059d8
ILT
1715 case elfcpp::R_386_GNU_VTINHERIT:
1716 case elfcpp::R_386_GNU_VTENTRY:
61ba1cf9
ILT
1717 break;
1718
1719 case elfcpp::R_386_32:
031cdbed
ILT
1720 if (should_apply_static_reloc(gsym, Symbol::ABSOLUTE_REF, true,
1721 output_section))
86849f1f 1722 Relocate_functions<32, false>::rel32(view, object, psymval);
61ba1cf9
ILT
1723 break;
1724
1725 case elfcpp::R_386_PC32:
d61c6bd4 1726 {
0700cf32
ILT
1727 int ref_flags = Symbol::NON_PIC_REF;
1728 if (gsym != NULL && gsym->type() == elfcpp::STT_FUNC)
1729 ref_flags |= Symbol::FUNCTION_CALL;
031cdbed 1730 if (should_apply_static_reloc(gsym, ref_flags, true, output_section))
d61c6bd4
ILT
1731 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
1732 }
92e059d8
ILT
1733 break;
1734
1735 case elfcpp::R_386_16:
031cdbed
ILT
1736 if (should_apply_static_reloc(gsym, Symbol::ABSOLUTE_REF, false,
1737 output_section))
86849f1f 1738 Relocate_functions<32, false>::rel16(view, object, psymval);
92e059d8
ILT
1739 break;
1740
1741 case elfcpp::R_386_PC16:
d61c6bd4 1742 {
0700cf32
ILT
1743 int ref_flags = Symbol::NON_PIC_REF;
1744 if (gsym != NULL && gsym->type() == elfcpp::STT_FUNC)
1745 ref_flags |= Symbol::FUNCTION_CALL;
031cdbed 1746 if (should_apply_static_reloc(gsym, ref_flags, false, output_section))
d09e9154 1747 Relocate_functions<32, false>::pcrel16(view, object, psymval, address);
d61c6bd4 1748 }
61ba1cf9
ILT
1749 break;
1750
92e059d8 1751 case elfcpp::R_386_8:
031cdbed
ILT
1752 if (should_apply_static_reloc(gsym, Symbol::ABSOLUTE_REF, false,
1753 output_section))
86849f1f 1754 Relocate_functions<32, false>::rel8(view, object, psymval);
92e059d8
ILT
1755 break;
1756
1757 case elfcpp::R_386_PC8:
d61c6bd4 1758 {
0700cf32
ILT
1759 int ref_flags = Symbol::NON_PIC_REF;
1760 if (gsym != NULL && gsym->type() == elfcpp::STT_FUNC)
1761 ref_flags |= Symbol::FUNCTION_CALL;
031cdbed
ILT
1762 if (should_apply_static_reloc(gsym, ref_flags, false,
1763 output_section))
d09e9154 1764 Relocate_functions<32, false>::pcrel8(view, object, psymval, address);
d61c6bd4 1765 }
92e059d8
ILT
1766 break;
1767
ead1e424 1768 case elfcpp::R_386_PLT32:
df2efe71
ILT
1769 gold_assert(gsym == NULL
1770 || gsym->has_plt_offset()
99f8faca
ILT
1771 || gsym->final_value_is_known()
1772 || (gsym->is_defined()
1773 && !gsym->is_from_dynobj()
1774 && !gsym->is_preemptible()));
b8e6aad9 1775 Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
ead1e424
ILT
1776 break;
1777
1778 case elfcpp::R_386_GOT32:
1b64748b
ILT
1779 gold_assert(have_got_offset);
1780 Relocate_functions<32, false>::rel32(view, got_offset);
ead1e424
ILT
1781 break;
1782
1783 case elfcpp::R_386_GOTOFF:
b8e6aad9
ILT
1784 {
1785 elfcpp::Elf_types<32>::Elf_Addr value;
1786 value = (psymval->value(object, 0)
96f2030e 1787 - target->got_plt_section()->address());
b8e6aad9
ILT
1788 Relocate_functions<32, false>::rel32(view, value);
1789 }
ead1e424
ILT
1790 break;
1791
1792 case elfcpp::R_386_GOTPC:
b8e6aad9
ILT
1793 {
1794 elfcpp::Elf_types<32>::Elf_Addr value;
96f2030e 1795 value = target->got_plt_section()->address();
b8e6aad9
ILT
1796 Relocate_functions<32, false>::pcrel32(view, value, address);
1797 }
ead1e424
ILT
1798 break;
1799
92e059d8
ILT
1800 case elfcpp::R_386_COPY:
1801 case elfcpp::R_386_GLOB_DAT:
1802 case elfcpp::R_386_JUMP_SLOT:
1803 case elfcpp::R_386_RELATIVE:
d61c17ea
ILT
1804 // These are outstanding tls relocs, which are unexpected when
1805 // linking.
92e059d8
ILT
1806 case elfcpp::R_386_TLS_TPOFF:
1807 case elfcpp::R_386_TLS_DTPMOD32:
1808 case elfcpp::R_386_TLS_DTPOFF32:
1809 case elfcpp::R_386_TLS_TPOFF32:
1810 case elfcpp::R_386_TLS_DESC:
75f2446e
ILT
1811 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1812 _("unexpected reloc %u in object file"),
1813 r_type);
92e059d8
ILT
1814 break;
1815
d61c17ea
ILT
1816 // These are initial tls relocs, which are expected when
1817 // linking.
56622147
ILT
1818 case elfcpp::R_386_TLS_GD: // Global-dynamic
1819 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1820 case elfcpp::R_386_TLS_DESC_CALL:
1821 case elfcpp::R_386_TLS_LDM: // Local-dynamic
1822 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
1823 case elfcpp::R_386_TLS_IE: // Initial-exec
92e059d8 1824 case elfcpp::R_386_TLS_IE_32:
56622147
ILT
1825 case elfcpp::R_386_TLS_GOTIE:
1826 case elfcpp::R_386_TLS_LE: // Local-exec
92e059d8 1827 case elfcpp::R_386_TLS_LE_32:
07f397ab
ILT
1828 this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval,
1829 view, address, view_size);
92e059d8
ILT
1830 break;
1831
92e059d8
ILT
1832 case elfcpp::R_386_32PLT:
1833 case elfcpp::R_386_TLS_GD_32:
1834 case elfcpp::R_386_TLS_GD_PUSH:
1835 case elfcpp::R_386_TLS_GD_CALL:
1836 case elfcpp::R_386_TLS_GD_POP:
1837 case elfcpp::R_386_TLS_LDM_32:
1838 case elfcpp::R_386_TLS_LDM_PUSH:
1839 case elfcpp::R_386_TLS_LDM_CALL:
1840 case elfcpp::R_386_TLS_LDM_POP:
1841 case elfcpp::R_386_USED_BY_INTEL_200:
61ba1cf9 1842 default:
75f2446e
ILT
1843 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1844 _("unsupported reloc %u"),
1845 r_type);
92e059d8
ILT
1846 break;
1847 }
ead1e424
ILT
1848
1849 return true;
92e059d8
ILT
1850}
1851
1852// Perform a TLS relocation.
1853
1854inline void
1855Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
07f397ab 1856 Target_i386* target,
92e059d8
ILT
1857 size_t relnum,
1858 const elfcpp::Rel<32, false>& rel,
1859 unsigned int r_type,
c06b7b0b 1860 const Sized_symbol<32>* gsym,
b8e6aad9 1861 const Symbol_value<32>* psymval,
92e059d8
ILT
1862 unsigned char* view,
1863 elfcpp::Elf_types<32>::Elf_Addr,
fe8718a4 1864 section_size_type view_size)
92e059d8
ILT
1865{
1866 Output_segment* tls_segment = relinfo->layout->tls_segment();
92e059d8 1867
07f397ab
ILT
1868 const Sized_relobj<32, false>* object = relinfo->object;
1869
1870 elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0);
b8e6aad9 1871
8851ecca
ILT
1872 const bool is_final =
1873 (gsym == NULL
1874 ? !parameters->options().output_is_position_independent()
1875 : gsym->final_value_is_known());
af6359d5
ILT
1876 const tls::Tls_optimization optimized_type
1877 = Target_i386::optimize_tls_reloc(is_final, r_type);
92e059d8
ILT
1878 switch (r_type)
1879 {
56622147 1880 case elfcpp::R_386_TLS_GD: // Global-dynamic
af6359d5 1881 if (optimized_type == tls::TLSOPT_TO_LE)
92e059d8 1882 {
07f397ab 1883 gold_assert(tls_segment != NULL);
56622147
ILT
1884 this->tls_gd_to_le(relinfo, relnum, tls_segment,
1885 rel, r_type, value, view,
1886 view_size);
92e059d8
ILT
1887 break;
1888 }
07f397ab
ILT
1889 else
1890 {
c2b45e22
CC
1891 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
1892 ? GOT_TYPE_TLS_NOFFSET
1893 : GOT_TYPE_TLS_PAIR);
07f397ab
ILT
1894 unsigned int got_offset;
1895 if (gsym != NULL)
1896 {
c2b45e22
CC
1897 gold_assert(gsym->has_got_offset(got_type));
1898 got_offset = gsym->got_offset(got_type) - target->got_size();
07f397ab
ILT
1899 }
1900 else
1901 {
1902 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
c2b45e22
CC
1903 gold_assert(object->local_has_got_offset(r_sym, got_type));
1904 got_offset = (object->local_got_offset(r_sym, got_type)
07f397ab
ILT
1905 - target->got_size());
1906 }
1907 if (optimized_type == tls::TLSOPT_TO_IE)
1908 {
1909 gold_assert(tls_segment != NULL);
7bf1f802
ILT
1910 this->tls_gd_to_ie(relinfo, relnum, tls_segment, rel, r_type,
1911 got_offset, view, view_size);
07f397ab
ILT
1912 break;
1913 }
1914 else if (optimized_type == tls::TLSOPT_NONE)
1915 {
1916 // Relocate the field with the offset of the pair of GOT
1917 // entries.
1918 Relocate_functions<32, false>::rel32(view, got_offset);
1919 break;
1920 }
1921 }
75f2446e
ILT
1922 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1923 _("unsupported reloc %u"),
1924 r_type);
92e059d8
ILT
1925 break;
1926
56622147
ILT
1927 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
1928 case elfcpp::R_386_TLS_DESC_CALL:
497897f9 1929 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
c2b45e22
CC
1930 if (optimized_type == tls::TLSOPT_TO_LE)
1931 {
1932 gold_assert(tls_segment != NULL);
1933 this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
1934 rel, r_type, value, view,
1935 view_size);
1936 break;
1937 }
1938 else
1939 {
1940 unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
1941 ? GOT_TYPE_TLS_NOFFSET
1942 : GOT_TYPE_TLS_DESC);
1943 unsigned int got_offset;
1944 if (gsym != NULL)
1945 {
1946 gold_assert(gsym->has_got_offset(got_type));
1947 got_offset = gsym->got_offset(got_type) - target->got_size();
1948 }
1949 else
1950 {
1951 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
1952 gold_assert(object->local_has_got_offset(r_sym, got_type));
1953 got_offset = (object->local_got_offset(r_sym, got_type)
1954 - target->got_size());
1955 }
1956 if (optimized_type == tls::TLSOPT_TO_IE)
1957 {
1958 gold_assert(tls_segment != NULL);
1959 this->tls_desc_gd_to_ie(relinfo, relnum, tls_segment, rel, r_type,
1960 got_offset, view, view_size);
1961 break;
1962 }
1963 else if (optimized_type == tls::TLSOPT_NONE)
1964 {
1965 if (r_type == elfcpp::R_386_TLS_GOTDESC)
1966 {
1967 // Relocate the field with the offset of the pair of GOT
1968 // entries.
1969 Relocate_functions<32, false>::rel32(view, got_offset);
1970 }
1971 break;
1972 }
1973 }
75f2446e
ILT
1974 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1975 _("unsupported reloc %u"),
1976 r_type);
ead1e424
ILT
1977 break;
1978
56622147 1979 case elfcpp::R_386_TLS_LDM: // Local-dynamic
46cf9fa2
ILT
1980 if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN)
1981 {
75f2446e
ILT
1982 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
1983 _("both SUN and GNU model "
1984 "TLS relocations"));
1985 break;
46cf9fa2
ILT
1986 }
1987 this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
af6359d5 1988 if (optimized_type == tls::TLSOPT_TO_LE)
46cf9fa2 1989 {
07f397ab 1990 gold_assert(tls_segment != NULL);
46cf9fa2
ILT
1991 this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type,
1992 value, view, view_size);
1993 break;
1994 }
07f397ab
ILT
1995 else if (optimized_type == tls::TLSOPT_NONE)
1996 {
1997 // Relocate the field with the offset of the GOT entry for
1998 // the module index.
1999 unsigned int got_offset;
94c4710f
ILT
2000 got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
2001 - target->got_size());
07f397ab
ILT
2002 Relocate_functions<32, false>::rel32(view, got_offset);
2003 break;
2004 }
75f2446e
ILT
2005 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2006 _("unsupported reloc %u"),
2007 r_type);
46cf9fa2
ILT
2008 break;
2009
56622147 2010 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
d6f22b98 2011 if (optimized_type == tls::TLSOPT_TO_LE)
e8a9fcda 2012 {
82bb573a
ILT
2013 // This reloc can appear in debugging sections, in which
2014 // case we must not convert to local-exec. We decide what
2015 // to do based on whether the section is marked as
2016 // containing executable code. That is what the GNU linker
2017 // does as well.
2018 elfcpp::Shdr<32, false> shdr(relinfo->data_shdr);
2019 if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
d6f22b98
ILT
2020 {
2021 gold_assert(tls_segment != NULL);
2022 value -= tls_segment->memsz();
2023 }
e8a9fcda 2024 }
46cf9fa2
ILT
2025 Relocate_functions<32, false>::rel32(view, value);
2026 break;
2027
56622147
ILT
2028 case elfcpp::R_386_TLS_IE: // Initial-exec
2029 case elfcpp::R_386_TLS_GOTIE:
2030 case elfcpp::R_386_TLS_IE_32:
2031 if (optimized_type == tls::TLSOPT_TO_LE)
2032 {
07f397ab 2033 gold_assert(tls_segment != NULL);
56622147
ILT
2034 Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
2035 rel, r_type, value, view,
2036 view_size);
2037 break;
2038 }
07f397ab
ILT
2039 else if (optimized_type == tls::TLSOPT_NONE)
2040 {
2041 // Relocate the field with the offset of the GOT entry for
2042 // the tp-relative offset of the symbol.
c2b45e22
CC
2043 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2044 ? GOT_TYPE_TLS_OFFSET
2045 : GOT_TYPE_TLS_NOFFSET);
07f397ab
ILT
2046 unsigned int got_offset;
2047 if (gsym != NULL)
2048 {
c2b45e22
CC
2049 gold_assert(gsym->has_got_offset(got_type));
2050 got_offset = gsym->got_offset(got_type);
07f397ab
ILT
2051 }
2052 else
2053 {
2054 unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
c2b45e22
CC
2055 gold_assert(object->local_has_got_offset(r_sym, got_type));
2056 got_offset = object->local_got_offset(r_sym, got_type);
07f397ab
ILT
2057 }
2058 // For the R_386_TLS_IE relocation, we need to apply the
2059 // absolute address of the GOT entry.
2060 if (r_type == elfcpp::R_386_TLS_IE)
2061 got_offset += target->got_plt_section()->address();
2062 // All GOT offsets are relative to the end of the GOT.
2063 got_offset -= target->got_size();
2064 Relocate_functions<32, false>::rel32(view, got_offset);
2065 break;
2066 }
75f2446e
ILT
2067 gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2068 _("unsupported reloc %u"),
2069 r_type);
92e059d8 2070 break;
92e059d8 2071
56622147 2072 case elfcpp::R_386_TLS_LE: // Local-exec
7bf1f802
ILT
2073 // If we're creating a shared library, a dynamic relocation will
2074 // have been created for this location, so do not apply it now.
8851ecca 2075 if (!parameters->options().shared())
7bf1f802
ILT
2076 {
2077 gold_assert(tls_segment != NULL);
2078 value -= tls_segment->memsz();
2079 Relocate_functions<32, false>::rel32(view, value);
2080 }
56622147 2081 break;
92e059d8 2082
56622147 2083 case elfcpp::R_386_TLS_LE_32:
7bf1f802
ILT
2084 // If we're creating a shared library, a dynamic relocation will
2085 // have been created for this location, so do not apply it now.
8851ecca 2086 if (!parameters->options().shared())
7bf1f802
ILT
2087 {
2088 gold_assert(tls_segment != NULL);
2089 value = tls_segment->memsz() - value;
2090 Relocate_functions<32, false>::rel32(view, value);
2091 }
56622147 2092 break;
92e059d8 2093 }
92e059d8
ILT
2094}
2095
e041f13d 2096// Do a relocation in which we convert a TLS General-Dynamic to a
ead1e424
ILT
2097// Local-Exec.
2098
2099inline void
2100Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo,
2101 size_t relnum,
2102 Output_segment* tls_segment,
2103 const elfcpp::Rel<32, false>& rel,
2104 unsigned int,
2105 elfcpp::Elf_types<32>::Elf_Addr value,
2106 unsigned char* view,
fe8718a4 2107 section_size_type view_size)
ead1e424
ILT
2108{
2109 // leal foo(,%reg,1),%eax; call ___tls_get_addr
46cf9fa2 2110 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
ead1e424
ILT
2111 // leal foo(%reg),%eax; call ___tls_get_addr
2112 // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
2113
af6359d5
ILT
2114 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2115 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
ead1e424
ILT
2116
2117 unsigned char op1 = view[-1];
2118 unsigned char op2 = view[-2];
2119
af6359d5
ILT
2120 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2121 op2 == 0x8d || op2 == 0x04);
2122 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
ead1e424
ILT
2123
2124 int roff = 5;
2125
2126 if (op2 == 0x04)
2127 {
af6359d5
ILT
2128 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
2129 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
2130 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2131 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
ead1e424
ILT
2132 memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2133 }
2134 else
2135 {
af6359d5
ILT
2136 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2137 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
fe8718a4 2138 if (rel.get_r_offset() + 9 < view_size
d61c17ea 2139 && view[9] == 0x90)
ead1e424
ILT
2140 {
2141 // There is a trailing nop. Use the size byte subl.
2142 memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2143 roff = 6;
2144 }
2145 else
2146 {
2147 // Use the five byte subl.
2148 memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2149 }
2150 }
2151
7bf1f802 2152 value = tls_segment->memsz() - value;
ead1e424
ILT
2153 Relocate_functions<32, false>::rel32(view + roff, value);
2154
2155 // The next reloc should be a PLT32 reloc against __tls_get_addr.
2156 // We can skip it.
2157 this->skip_call_tls_get_addr_ = true;
2158}
2159
7bf1f802 2160// Do a relocation in which we convert a TLS General-Dynamic to an
07f397ab
ILT
2161// Initial-Exec.
2162
2163inline void
2164Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo,
2165 size_t relnum,
c2b45e22 2166 Output_segment*,
07f397ab
ILT
2167 const elfcpp::Rel<32, false>& rel,
2168 unsigned int,
2169 elfcpp::Elf_types<32>::Elf_Addr value,
2170 unsigned char* view,
fe8718a4 2171 section_size_type view_size)
07f397ab
ILT
2172{
2173 // leal foo(,%ebx,1),%eax; call ___tls_get_addr
2174 // ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
2175
2176 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2177 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
2178
2179 unsigned char op1 = view[-1];
2180 unsigned char op2 = view[-2];
2181
2182 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2183 op2 == 0x8d || op2 == 0x04);
2184 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
2185
2186 int roff = 5;
2187
c2b45e22
CC
2188 // FIXME: For now, support only the first (SIB) form.
2189 tls::check_tls(relinfo, relnum, rel.get_r_offset(), op2 == 0x04);
07f397ab
ILT
2190
2191 if (op2 == 0x04)
2192 {
2193 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
2194 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
2195 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2196 ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
2197 memcpy(view - 3, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12);
2198 }
2199 else
2200 {
2201 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2202 (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
fe8718a4 2203 if (rel.get_r_offset() + 9 < view_size
07f397ab
ILT
2204 && view[9] == 0x90)
2205 {
2206 // FIXME: This is not the right instruction sequence.
2207 // There is a trailing nop. Use the size byte subl.
2208 memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
2209 roff = 6;
2210 }
2211 else
2212 {
2213 // FIXME: This is not the right instruction sequence.
2214 // Use the five byte subl.
2215 memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
2216 }
2217 }
2218
07f397ab
ILT
2219 Relocate_functions<32, false>::rel32(view + roff, value);
2220
2221 // The next reloc should be a PLT32 reloc against __tls_get_addr.
2222 // We can skip it.
2223 this->skip_call_tls_get_addr_ = true;
2224}
2225
c2b45e22
CC
2226// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
2227// General-Dynamic to a Local-Exec.
2228
2229inline void
2230Target_i386::Relocate::tls_desc_gd_to_le(
2231 const Relocate_info<32, false>* relinfo,
2232 size_t relnum,
2233 Output_segment* tls_segment,
2234 const elfcpp::Rel<32, false>& rel,
2235 unsigned int r_type,
2236 elfcpp::Elf_types<32>::Elf_Addr value,
2237 unsigned char* view,
2238 section_size_type view_size)
2239{
2240 if (r_type == elfcpp::R_386_TLS_GOTDESC)
2241 {
2242 // leal foo@TLSDESC(%ebx), %eax
2243 // ==> leal foo@NTPOFF, %eax
2244 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2245 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
2246 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2247 view[-2] == 0x8d && view[-1] == 0x83);
2248 view[-1] = 0x05;
2249 value -= tls_segment->memsz();
2250 Relocate_functions<32, false>::rel32(view, value);
2251 }
2252 else
2253 {
2254 // call *foo@TLSCALL(%eax)
2255 // ==> nop; nop
2256 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
2257 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
2258 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2259 view[0] == 0xff && view[1] == 0x10);
2260 view[0] = 0x66;
2261 view[1] = 0x90;
2262 }
2263}
2264
2265// Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
2266// General-Dynamic to an Initial-Exec.
2267
2268inline void
2269Target_i386::Relocate::tls_desc_gd_to_ie(
2270 const Relocate_info<32, false>* relinfo,
2271 size_t relnum,
2272 Output_segment*,
2273 const elfcpp::Rel<32, false>& rel,
2274 unsigned int r_type,
2275 elfcpp::Elf_types<32>::Elf_Addr value,
2276 unsigned char* view,
2277 section_size_type view_size)
2278{
2279 if (r_type == elfcpp::R_386_TLS_GOTDESC)
2280 {
2281 // leal foo@TLSDESC(%ebx), %eax
2282 // ==> movl foo@GOTNTPOFF(%ebx), %eax
2283 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2284 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
2285 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2286 view[-2] == 0x8d && view[-1] == 0x83);
2287 view[-2] = 0x8b;
2288 Relocate_functions<32, false>::rel32(view, value);
2289 }
2290 else
2291 {
2292 // call *foo@TLSCALL(%eax)
2293 // ==> nop; nop
2294 gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
2295 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
2296 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2297 view[0] == 0xff && view[1] == 0x10);
2298 view[0] = 0x66;
2299 view[1] = 0x90;
2300 }
2301}
2302
46cf9fa2
ILT
2303// Do a relocation in which we convert a TLS Local-Dynamic to a
2304// Local-Exec.
2305
2306inline void
2307Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo,
2308 size_t relnum,
2309 Output_segment*,
2310 const elfcpp::Rel<32, false>& rel,
2311 unsigned int,
2312 elfcpp::Elf_types<32>::Elf_Addr,
2313 unsigned char* view,
fe8718a4 2314 section_size_type view_size)
46cf9fa2
ILT
2315{
2316 // leal foo(%reg), %eax; call ___tls_get_addr
2317 // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi
2318
af6359d5
ILT
2319 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2320 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
46cf9fa2
ILT
2321
2322 // FIXME: Does this test really always pass?
af6359d5
ILT
2323 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2324 view[-2] == 0x8d && view[-1] == 0x83);
46cf9fa2 2325
af6359d5 2326 tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
46cf9fa2
ILT
2327
2328 memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11);
2329
2330 // The next reloc should be a PLT32 reloc against __tls_get_addr.
2331 // We can skip it.
2332 this->skip_call_tls_get_addr_ = true;
2333}
2334
56622147
ILT
2335// Do a relocation in which we convert a TLS Initial-Exec to a
2336// Local-Exec.
2337
2338inline void
2339Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo,
2340 size_t relnum,
2341 Output_segment* tls_segment,
2342 const elfcpp::Rel<32, false>& rel,
2343 unsigned int r_type,
2344 elfcpp::Elf_types<32>::Elf_Addr value,
2345 unsigned char* view,
fe8718a4 2346 section_size_type view_size)
56622147
ILT
2347{
2348 // We have to actually change the instructions, which means that we
2349 // need to examine the opcodes to figure out which instruction we
2350 // are looking at.
2351 if (r_type == elfcpp::R_386_TLS_IE)
2352 {
2353 // movl %gs:XX,%eax ==> movl $YY,%eax
2354 // movl %gs:XX,%reg ==> movl $YY,%reg
2355 // addl %gs:XX,%reg ==> addl $YY,%reg
2356 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1);
2357 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
2358
2359 unsigned char op1 = view[-1];
2360 if (op1 == 0xa1)
2361 {
2362 // movl XX,%eax ==> movl $YY,%eax
2363 view[-1] = 0xb8;
2364 }
2365 else
2366 {
2367 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2368
2369 unsigned char op2 = view[-2];
2370 if (op2 == 0x8b)
2371 {
2372 // movl XX,%reg ==> movl $YY,%reg
2373 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2374 (op1 & 0xc7) == 0x05);
2375 view[-2] = 0xc7;
2376 view[-1] = 0xc0 | ((op1 >> 3) & 7);
2377 }
2378 else if (op2 == 0x03)
2379 {
2380 // addl XX,%reg ==> addl $YY,%reg
2381 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2382 (op1 & 0xc7) == 0x05);
2383 view[-2] = 0x81;
2384 view[-1] = 0xc0 | ((op1 >> 3) & 7);
2385 }
2386 else
2387 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
2388 }
2389 }
2390 else
2391 {
2392 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
2393 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
2394 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
2395 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
2396 tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
2397
2398 unsigned char op1 = view[-1];
2399 unsigned char op2 = view[-2];
2400 tls::check_tls(relinfo, relnum, rel.get_r_offset(),
2401 (op1 & 0xc0) == 0x80 && (op1 & 7) != 4);
2402 if (op2 == 0x8b)
2403 {
2404 // movl %gs:XX(%reg1),%reg2 ==> movl $YY,%reg2
2405 view[-2] = 0xc7;
2406 view[-1] = 0xc0 | ((op1 >> 3) & 7);
2407 }
2408 else if (op2 == 0x2b)
2409 {
2410 // subl %gs:XX(%reg1),%reg2 ==> subl $YY,%reg2
2411 view[-2] = 0x81;
2412 view[-1] = 0xe8 | ((op1 >> 3) & 7);
2413 }
2414 else if (op2 == 0x03)
2415 {
2416 // addl %gs:XX(%reg1),%reg2 ==> addl $YY,$reg2
2417 view[-2] = 0x81;
2418 view[-1] = 0xc0 | ((op1 >> 3) & 7);
2419 }
2420 else
2421 tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
2422 }
2423
7bf1f802 2424 value = tls_segment->memsz() - value;
56622147
ILT
2425 if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE)
2426 value = - value;
2427
2428 Relocate_functions<32, false>::rel32(view, value);
2429}
2430
61ba1cf9
ILT
2431// Relocate section data.
2432
2433void
92e059d8 2434Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
61ba1cf9
ILT
2435 unsigned int sh_type,
2436 const unsigned char* prelocs,
2437 size_t reloc_count,
730cdc88
ILT
2438 Output_section* output_section,
2439 bool needs_special_offset_handling,
61ba1cf9
ILT
2440 unsigned char* view,
2441 elfcpp::Elf_types<32>::Elf_Addr address,
364c7fa5
ILT
2442 section_size_type view_size,
2443 const Reloc_symbol_changes* reloc_symbol_changes)
61ba1cf9 2444{
a3ad94ed 2445 gold_assert(sh_type == elfcpp::SHT_REL);
61ba1cf9 2446
ead1e424
ILT
2447 gold::relocate_section<32, false, Target_i386, elfcpp::SHT_REL,
2448 Target_i386::Relocate>(
92e059d8 2449 relinfo,
ead1e424 2450 this,
61ba1cf9
ILT
2451 prelocs,
2452 reloc_count,
730cdc88
ILT
2453 output_section,
2454 needs_special_offset_handling,
61ba1cf9
ILT
2455 view,
2456 address,
364c7fa5
ILT
2457 view_size,
2458 reloc_symbol_changes);
61ba1cf9
ILT
2459}
2460
6a74a719
ILT
2461// Return the size of a relocation while scanning during a relocatable
2462// link.
2463
2464unsigned int
2465Target_i386::Relocatable_size_for_reloc::get_size_for_reloc(
2466 unsigned int r_type,
2467 Relobj* object)
2468{
2469 switch (r_type)
2470 {
2471 case elfcpp::R_386_NONE:
2472 case elfcpp::R_386_GNU_VTINHERIT:
2473 case elfcpp::R_386_GNU_VTENTRY:
2474 case elfcpp::R_386_TLS_GD: // Global-dynamic
2475 case elfcpp::R_386_TLS_GOTDESC: // Global-dynamic (from ~oliva url)
2476 case elfcpp::R_386_TLS_DESC_CALL:
2477 case elfcpp::R_386_TLS_LDM: // Local-dynamic
2478 case elfcpp::R_386_TLS_LDO_32: // Alternate local-dynamic
2479 case elfcpp::R_386_TLS_IE: // Initial-exec
2480 case elfcpp::R_386_TLS_IE_32:
2481 case elfcpp::R_386_TLS_GOTIE:
2482 case elfcpp::R_386_TLS_LE: // Local-exec
2483 case elfcpp::R_386_TLS_LE_32:
2484 return 0;
2485
2486 case elfcpp::R_386_32:
2487 case elfcpp::R_386_PC32:
2488 case elfcpp::R_386_GOT32:
2489 case elfcpp::R_386_PLT32:
2490 case elfcpp::R_386_GOTOFF:
2491 case elfcpp::R_386_GOTPC:
2492 return 4;
2493
2494 case elfcpp::R_386_16:
2495 case elfcpp::R_386_PC16:
2496 return 2;
2497
2498 case elfcpp::R_386_8:
2499 case elfcpp::R_386_PC8:
2500 return 1;
2501
2502 // These are relocations which should only be seen by the
2503 // dynamic linker, and should never be seen here.
2504 case elfcpp::R_386_COPY:
2505 case elfcpp::R_386_GLOB_DAT:
2506 case elfcpp::R_386_JUMP_SLOT:
2507 case elfcpp::R_386_RELATIVE:
2508 case elfcpp::R_386_TLS_TPOFF:
2509 case elfcpp::R_386_TLS_DTPMOD32:
2510 case elfcpp::R_386_TLS_DTPOFF32:
2511 case elfcpp::R_386_TLS_TPOFF32:
2512 case elfcpp::R_386_TLS_DESC:
2513 object->error(_("unexpected reloc %u in object file"), r_type);
2514 return 0;
2515
2516 case elfcpp::R_386_32PLT:
2517 case elfcpp::R_386_TLS_GD_32:
2518 case elfcpp::R_386_TLS_GD_PUSH:
2519 case elfcpp::R_386_TLS_GD_CALL:
2520 case elfcpp::R_386_TLS_GD_POP:
2521 case elfcpp::R_386_TLS_LDM_32:
2522 case elfcpp::R_386_TLS_LDM_PUSH:
2523 case elfcpp::R_386_TLS_LDM_CALL:
2524 case elfcpp::R_386_TLS_LDM_POP:
2525 case elfcpp::R_386_USED_BY_INTEL_200:
2526 default:
2527 object->error(_("unsupported reloc %u in object file"), r_type);
2528 return 0;
2529 }
2530}
2531
2532// Scan the relocs during a relocatable link.
2533
2534void
ad0f2072 2535Target_i386::scan_relocatable_relocs(Symbol_table* symtab,
6a74a719
ILT
2536 Layout* layout,
2537 Sized_relobj<32, false>* object,
2538 unsigned int data_shndx,
2539 unsigned int sh_type,
2540 const unsigned char* prelocs,
2541 size_t reloc_count,
2542 Output_section* output_section,
2543 bool needs_special_offset_handling,
2544 size_t local_symbol_count,
2545 const unsigned char* plocal_symbols,
2546 Relocatable_relocs* rr)
2547{
2548 gold_assert(sh_type == elfcpp::SHT_REL);
2549
2550 typedef gold::Default_scan_relocatable_relocs<elfcpp::SHT_REL,
2551 Relocatable_size_for_reloc> Scan_relocatable_relocs;
2552
7019cd25 2553 gold::scan_relocatable_relocs<32, false, elfcpp::SHT_REL,
6a74a719 2554 Scan_relocatable_relocs>(
6a74a719
ILT
2555 symtab,
2556 layout,
2557 object,
2558 data_shndx,
2559 prelocs,
2560 reloc_count,
2561 output_section,
2562 needs_special_offset_handling,
2563 local_symbol_count,
2564 plocal_symbols,
2565 rr);
2566}
2567
2568// Relocate a section during a relocatable link.
2569
2570void
2571Target_i386::relocate_for_relocatable(
2572 const Relocate_info<32, false>* relinfo,
2573 unsigned int sh_type,
2574 const unsigned char* prelocs,
2575 size_t reloc_count,
2576 Output_section* output_section,
2577 off_t offset_in_output_section,
2578 const Relocatable_relocs* rr,
2579 unsigned char* view,
2580 elfcpp::Elf_types<32>::Elf_Addr view_address,
2581 section_size_type view_size,
2582 unsigned char* reloc_view,
2583 section_size_type reloc_view_size)
2584{
2585 gold_assert(sh_type == elfcpp::SHT_REL);
2586
7019cd25 2587 gold::relocate_for_relocatable<32, false, elfcpp::SHT_REL>(
6a74a719
ILT
2588 relinfo,
2589 prelocs,
2590 reloc_count,
2591 output_section,
2592 offset_in_output_section,
2593 rr,
2594 view,
2595 view_address,
2596 view_size,
2597 reloc_view,
2598 reloc_view_size);
2599}
2600
ab5c9e90
ILT
2601// Return the value to use for a dynamic which requires special
2602// treatment. This is how we support equality comparisons of function
2603// pointers across shared library boundaries, as described in the
2604// processor specific ABI supplement.
2605
2606uint64_t
2607Target_i386::do_dynsym_value(const Symbol* gsym) const
2608{
2609 gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
2610 return this->plt_section()->address() + gsym->plt_offset();
2611}
2612
c51e6221
ILT
2613// Return a string used to fill a code section with nops to take up
2614// the specified length.
2615
2616std::string
8851ecca 2617Target_i386::do_code_fill(section_size_type length) const
c51e6221
ILT
2618{
2619 if (length >= 16)
2620 {
2621 // Build a jmp instruction to skip over the bytes.
2622 unsigned char jmp[5];
2623 jmp[0] = 0xe9;
2624 elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
2625 return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
2626 + std::string(length - 5, '\0'));
2627 }
2628
2629 // Nop sequences of various lengths.
2630 const char nop1[1] = { 0x90 }; // nop
2631 const char nop2[2] = { 0x66, 0x90 }; // xchg %ax %ax
2632 const char nop3[3] = { 0x8d, 0x76, 0x00 }; // leal 0(%esi),%esi
2633 const char nop4[4] = { 0x8d, 0x74, 0x26, 0x00}; // leal 0(%esi,1),%esi
2634 const char nop5[5] = { 0x90, 0x8d, 0x74, 0x26, // nop
2635 0x00 }; // leal 0(%esi,1),%esi
2636 const char nop6[6] = { 0x8d, 0xb6, 0x00, 0x00, // leal 0L(%esi),%esi
2637 0x00, 0x00 };
2638 const char nop7[7] = { 0x8d, 0xb4, 0x26, 0x00, // leal 0L(%esi,1),%esi
2639 0x00, 0x00, 0x00 };
2640 const char nop8[8] = { 0x90, 0x8d, 0xb4, 0x26, // nop
2641 0x00, 0x00, 0x00, 0x00 }; // leal 0L(%esi,1),%esi
2642 const char nop9[9] = { 0x89, 0xf6, 0x8d, 0xbc, // movl %esi,%esi
2643 0x27, 0x00, 0x00, 0x00, // leal 0L(%edi,1),%edi
2644 0x00 };
2645 const char nop10[10] = { 0x8d, 0x76, 0x00, 0x8d, // leal 0(%esi),%esi
2646 0xbc, 0x27, 0x00, 0x00, // leal 0L(%edi,1),%edi
2647 0x00, 0x00 };
2648 const char nop11[11] = { 0x8d, 0x74, 0x26, 0x00, // leal 0(%esi,1),%esi
2649 0x8d, 0xbc, 0x27, 0x00, // leal 0L(%edi,1),%edi
2650 0x00, 0x00, 0x00 };
2651 const char nop12[12] = { 0x8d, 0xb6, 0x00, 0x00, // leal 0L(%esi),%esi
2652 0x00, 0x00, 0x8d, 0xbf, // leal 0L(%edi),%edi
2653 0x00, 0x00, 0x00, 0x00 };
2654 const char nop13[13] = { 0x8d, 0xb6, 0x00, 0x00, // leal 0L(%esi),%esi
2655 0x00, 0x00, 0x8d, 0xbc, // leal 0L(%edi,1),%edi
2656 0x27, 0x00, 0x00, 0x00,
2657 0x00 };
2658 const char nop14[14] = { 0x8d, 0xb4, 0x26, 0x00, // leal 0L(%esi,1),%esi
2659 0x00, 0x00, 0x00, 0x8d, // leal 0L(%edi,1),%edi
2660 0xbc, 0x27, 0x00, 0x00,
2661 0x00, 0x00 };
2662 const char nop15[15] = { 0xeb, 0x0d, 0x90, 0x90, // jmp .+15
2663 0x90, 0x90, 0x90, 0x90, // nop,nop,nop,...
2664 0x90, 0x90, 0x90, 0x90,
2665 0x90, 0x90, 0x90 };
2666
2667 const char* nops[16] = {
2668 NULL,
2669 nop1, nop2, nop3, nop4, nop5, nop6, nop7,
2670 nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
2671 };
2672
2673 return std::string(nops[length], length);
2674}
2675
364c7fa5
ILT
2676// FNOFFSET in section SHNDX in OBJECT is the start of a function
2677// compiled with -fstack-split. The function calls non-stack-split
2678// code. We have to change the function so that it always ensures
2679// that it has enough stack space to run some random function.
2680
2681void
2682Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx,
2683 section_offset_type fnoffset,
2684 section_size_type fnsize,
2685 unsigned char* view,
2686 section_size_type view_size,
2687 std::string* from,
2688 std::string* to) const
2689{
2690 // The function starts with a comparison of the stack pointer and a
2691 // field in the TCB. This is followed by a jump.
2692
2693 // cmp %gs:NN,%esp
2694 if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3)
2695 && fnsize > 7)
2696 {
2697 // We will call __morestack if the carry flag is set after this
2698 // comparison. We turn the comparison into an stc instruction
2699 // and some nops.
2700 view[fnoffset] = '\xf9';
2701 this->set_view_to_nop(view, view_size, fnoffset + 1, 6);
2702 }
2703 // lea NN(%esp),%ecx
2704 else if (this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3)
2705 && fnsize > 7)
2706 {
2707 // This is loading an offset from the stack pointer for a
2708 // comparison. The offset is negative, so we decrease the
2709 // offset by the amount of space we need for the stack. This
2710 // means we will avoid calling __morestack if there happens to
2711 // be plenty of space on the stack already.
2712 unsigned char* pval = view + fnoffset + 3;
2713 uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
2714 val -= parameters->options().split_stack_adjust_size();
2715 elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
2716 }
2717 else
2718 {
2719 if (!object->has_no_split_stack())
2720 object->error(_("failed to match split-stack sequence at "
2721 "section %u offset %0zx"),
ac33a407 2722 shndx, static_cast<size_t>(fnoffset));
364c7fa5
ILT
2723 return;
2724 }
2725
2726 // We have to change the function so that it calls
2727 // __morestack_non_split instead of __morestack. The former will
2728 // allocate additional stack space.
2729 *from = "__morestack";
2730 *to = "__morestack_non_split";
2731}
2732
14bfc3f5
ILT
2733// The selector for i386 object files.
2734
36959681 2735class Target_selector_i386 : public Target_selector_freebsd
14bfc3f5
ILT
2736{
2737public:
2738 Target_selector_i386()
36959681
ILT
2739 : Target_selector_freebsd(elfcpp::EM_386, 32, false,
2740 "elf32-i386", "elf32-i386-freebsd")
14bfc3f5
ILT
2741 { }
2742
2743 Target*
e96caa79
ILT
2744 do_instantiate_target()
2745 { return new Target_i386(); }
14bfc3f5
ILT
2746};
2747
14bfc3f5
ILT
2748Target_selector_i386 target_selector_i386;
2749
2750} // End anonymous namespace.
This page took 0.335163 seconds and 4 git commands to generate.