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