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