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