gold/x86: Handle output without PLT
[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   if (this->plt_ == NULL)
1569     return 0;
1570   return this->plt_->first_plt_entry_offset();
1571 }
1572
1573 // Return the size of each PLT entry.
1574
1575 unsigned int
1576 Target_i386::plt_entry_size() const
1577 {
1578   if (this->plt_ == NULL)
1579     return 0;
1580   return this->plt_->get_plt_entry_size();
1581 }
1582
1583 // Get the section to use for TLS_DESC relocations.
1584
1585 Target_i386::Reloc_section*
1586 Target_i386::rel_tls_desc_section(Layout* layout) const
1587 {
1588   return this->plt_section()->rel_tls_desc(layout);
1589 }
1590
1591 // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
1592
1593 void
1594 Target_i386::define_tls_base_symbol(Symbol_table* symtab, Layout* layout)
1595 {
1596   if (this->tls_base_symbol_defined_)
1597     return;
1598
1599   Output_segment* tls_segment = layout->tls_segment();
1600   if (tls_segment != NULL)
1601     {
1602       bool is_exec = parameters->options().output_is_executable();
1603       symtab->define_in_output_segment("_TLS_MODULE_BASE_", NULL,
1604                                        Symbol_table::PREDEFINED,
1605                                        tls_segment, 0, 0,
1606                                        elfcpp::STT_TLS,
1607                                        elfcpp::STB_LOCAL,
1608                                        elfcpp::STV_HIDDEN, 0,
1609                                        (is_exec
1610                                         ? Symbol::SEGMENT_END
1611                                         : Symbol::SEGMENT_START),
1612                                        true);
1613     }
1614   this->tls_base_symbol_defined_ = true;
1615 }
1616
1617 // Create a GOT entry for the TLS module index.
1618
1619 unsigned int
1620 Target_i386::got_mod_index_entry(Symbol_table* symtab, Layout* layout,
1621                                  Sized_relobj_file<32, false>* object)
1622 {
1623   if (this->got_mod_index_offset_ == -1U)
1624     {
1625       gold_assert(symtab != NULL && layout != NULL && object != NULL);
1626       Reloc_section* rel_dyn = this->rel_dyn_section(layout);
1627       Output_data_got<32, false>* got = this->got_section(symtab, layout);
1628       unsigned int got_offset = got->add_constant(0);
1629       rel_dyn->add_local(object, 0, elfcpp::R_386_TLS_DTPMOD32, got,
1630                          got_offset);
1631       got->add_constant(0);
1632       this->got_mod_index_offset_ = got_offset;
1633     }
1634   return this->got_mod_index_offset_;
1635 }
1636
1637 // Optimize the TLS relocation type based on what we know about the
1638 // symbol.  IS_FINAL is true if the final address of this symbol is
1639 // known at link time.
1640
1641 tls::Tls_optimization
1642 Target_i386::optimize_tls_reloc(bool is_final, int r_type)
1643 {
1644   // If we are generating a shared library, then we can't do anything
1645   // in the linker.
1646   if (parameters->options().shared())
1647     return tls::TLSOPT_NONE;
1648
1649   switch (r_type)
1650     {
1651     case elfcpp::R_386_TLS_GD:
1652     case elfcpp::R_386_TLS_GOTDESC:
1653     case elfcpp::R_386_TLS_DESC_CALL:
1654       // These are General-Dynamic which permits fully general TLS
1655       // access.  Since we know that we are generating an executable,
1656       // we can convert this to Initial-Exec.  If we also know that
1657       // this is a local symbol, we can further switch to Local-Exec.
1658       if (is_final)
1659         return tls::TLSOPT_TO_LE;
1660       return tls::TLSOPT_TO_IE;
1661
1662     case elfcpp::R_386_TLS_LDM:
1663       // This is Local-Dynamic, which refers to a local symbol in the
1664       // dynamic TLS block.  Since we know that we generating an
1665       // executable, we can switch to Local-Exec.
1666       return tls::TLSOPT_TO_LE;
1667
1668     case elfcpp::R_386_TLS_LDO_32:
1669       // Another type of Local-Dynamic relocation.
1670       return tls::TLSOPT_TO_LE;
1671
1672     case elfcpp::R_386_TLS_IE:
1673     case elfcpp::R_386_TLS_GOTIE:
1674     case elfcpp::R_386_TLS_IE_32:
1675       // These are Initial-Exec relocs which get the thread offset
1676       // from the GOT.  If we know that we are linking against the
1677       // local symbol, we can switch to Local-Exec, which links the
1678       // thread offset into the instruction.
1679       if (is_final)
1680         return tls::TLSOPT_TO_LE;
1681       return tls::TLSOPT_NONE;
1682
1683     case elfcpp::R_386_TLS_LE:
1684     case elfcpp::R_386_TLS_LE_32:
1685       // When we already have Local-Exec, there is nothing further we
1686       // can do.
1687       return tls::TLSOPT_NONE;
1688
1689     default:
1690       gold_unreachable();
1691     }
1692 }
1693
1694 // Get the Reference_flags for a particular relocation.
1695
1696 int
1697 Target_i386::Scan::get_reference_flags(unsigned int r_type)
1698 {
1699   switch (r_type)
1700     {
1701     case elfcpp::R_386_NONE:
1702     case elfcpp::R_386_GNU_VTINHERIT:
1703     case elfcpp::R_386_GNU_VTENTRY:
1704     case elfcpp::R_386_GOTPC:
1705       // No symbol reference.
1706       return 0;
1707
1708     case elfcpp::R_386_32:
1709     case elfcpp::R_386_16:
1710     case elfcpp::R_386_8:
1711       return Symbol::ABSOLUTE_REF;
1712
1713     case elfcpp::R_386_PC32:
1714     case elfcpp::R_386_PC16:
1715     case elfcpp::R_386_PC8:
1716     case elfcpp::R_386_GOTOFF:
1717       return Symbol::RELATIVE_REF;
1718
1719     case elfcpp::R_386_PLT32:
1720       return Symbol::FUNCTION_CALL | Symbol::RELATIVE_REF;
1721
1722     case elfcpp::R_386_GOT32:
1723     case elfcpp::R_386_GOT32X:
1724       // Absolute in GOT.
1725       return Symbol::ABSOLUTE_REF;
1726
1727     case elfcpp::R_386_TLS_GD:            // Global-dynamic
1728     case elfcpp::R_386_TLS_GOTDESC:       // Global-dynamic (from ~oliva url)
1729     case elfcpp::R_386_TLS_DESC_CALL:
1730     case elfcpp::R_386_TLS_LDM:           // Local-dynamic
1731     case elfcpp::R_386_TLS_LDO_32:        // Alternate local-dynamic
1732     case elfcpp::R_386_TLS_IE:            // Initial-exec
1733     case elfcpp::R_386_TLS_IE_32:
1734     case elfcpp::R_386_TLS_GOTIE:
1735     case elfcpp::R_386_TLS_LE:            // Local-exec
1736     case elfcpp::R_386_TLS_LE_32:
1737       return Symbol::TLS_REF;
1738
1739     case elfcpp::R_386_COPY:
1740     case elfcpp::R_386_GLOB_DAT:
1741     case elfcpp::R_386_JUMP_SLOT:
1742     case elfcpp::R_386_RELATIVE:
1743     case elfcpp::R_386_IRELATIVE:
1744     case elfcpp::R_386_TLS_TPOFF:
1745     case elfcpp::R_386_TLS_DTPMOD32:
1746     case elfcpp::R_386_TLS_DTPOFF32:
1747     case elfcpp::R_386_TLS_TPOFF32:
1748     case elfcpp::R_386_TLS_DESC:
1749     case elfcpp::R_386_32PLT:
1750     case elfcpp::R_386_TLS_GD_32:
1751     case elfcpp::R_386_TLS_GD_PUSH:
1752     case elfcpp::R_386_TLS_GD_CALL:
1753     case elfcpp::R_386_TLS_GD_POP:
1754     case elfcpp::R_386_TLS_LDM_32:
1755     case elfcpp::R_386_TLS_LDM_PUSH:
1756     case elfcpp::R_386_TLS_LDM_CALL:
1757     case elfcpp::R_386_TLS_LDM_POP:
1758     case elfcpp::R_386_USED_BY_INTEL_200:
1759     default:
1760       // Not expected.  We will give an error later.
1761       return 0;
1762     }
1763 }
1764
1765 // Report an unsupported relocation against a local symbol.
1766
1767 void
1768 Target_i386::Scan::unsupported_reloc_local(Sized_relobj_file<32, false>* object,
1769                                            unsigned int r_type)
1770 {
1771   gold_error(_("%s: unsupported reloc %u against local symbol"),
1772              object->name().c_str(), r_type);
1773 }
1774
1775 // Return whether we need to make a PLT entry for a relocation of a
1776 // given type against a STT_GNU_IFUNC symbol.
1777
1778 bool
1779 Target_i386::Scan::reloc_needs_plt_for_ifunc(
1780     Sized_relobj_file<32, false>* object,
1781     unsigned int r_type)
1782 {
1783   int flags = Scan::get_reference_flags(r_type);
1784   if (flags & Symbol::TLS_REF)
1785     gold_error(_("%s: unsupported TLS reloc %u for IFUNC symbol"),
1786                object->name().c_str(), r_type);
1787   return flags != 0;
1788 }
1789
1790 // Scan a relocation for a local symbol.
1791
1792 inline void
1793 Target_i386::Scan::local(Symbol_table* symtab,
1794                          Layout* layout,
1795                          Target_i386* target,
1796                          Sized_relobj_file<32, false>* object,
1797                          unsigned int data_shndx,
1798                          Output_section* output_section,
1799                          const elfcpp::Rel<32, false>& reloc,
1800                          unsigned int r_type,
1801                          const elfcpp::Sym<32, false>& lsym,
1802                          bool is_discarded)
1803 {
1804   if (is_discarded)
1805     return;
1806
1807   // A local STT_GNU_IFUNC symbol may require a PLT entry.
1808   if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC
1809       && this->reloc_needs_plt_for_ifunc(object, r_type))
1810     {
1811       unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1812       target->make_local_ifunc_plt_entry(symtab, layout, object, r_sym);
1813     }
1814
1815   switch (r_type)
1816     {
1817     case elfcpp::R_386_NONE:
1818     case elfcpp::R_386_GNU_VTINHERIT:
1819     case elfcpp::R_386_GNU_VTENTRY:
1820       break;
1821
1822     case elfcpp::R_386_32:
1823       // If building a shared library (or a position-independent
1824       // executable), we need to create a dynamic relocation for
1825       // this location. The relocation applied at link time will
1826       // apply the link-time value, so we flag the location with
1827       // an R_386_RELATIVE relocation so the dynamic loader can
1828       // relocate it easily.
1829       if (parameters->options().output_is_position_independent())
1830         {
1831           Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1832           unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1833           rel_dyn->add_local_relative(object, r_sym, elfcpp::R_386_RELATIVE,
1834                                       output_section, data_shndx,
1835                                       reloc.get_r_offset());
1836         }
1837       break;
1838
1839     case elfcpp::R_386_16:
1840     case elfcpp::R_386_8:
1841       // If building a shared library (or a position-independent
1842       // executable), we need to create a dynamic relocation for
1843       // this location. Because the addend needs to remain in the
1844       // data section, we need to be careful not to apply this
1845       // relocation statically.
1846       if (parameters->options().output_is_position_independent())
1847         {
1848           Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1849           unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1850           if (lsym.get_st_type() != elfcpp::STT_SECTION)
1851             rel_dyn->add_local(object, r_sym, r_type, output_section,
1852                                data_shndx, reloc.get_r_offset());
1853           else
1854             {
1855               gold_assert(lsym.get_st_value() == 0);
1856               unsigned int shndx = lsym.get_st_shndx();
1857               bool is_ordinary;
1858               shndx = object->adjust_sym_shndx(r_sym, shndx,
1859                                                &is_ordinary);
1860               if (!is_ordinary)
1861                 object->error(_("section symbol %u has bad shndx %u"),
1862                               r_sym, shndx);
1863               else
1864                 rel_dyn->add_local_section(object, shndx,
1865                                            r_type, output_section,
1866                                            data_shndx, reloc.get_r_offset());
1867             }
1868         }
1869       break;
1870
1871     case elfcpp::R_386_PC32:
1872     case elfcpp::R_386_PC16:
1873     case elfcpp::R_386_PC8:
1874       break;
1875
1876     case elfcpp::R_386_PLT32:
1877       // Since we know this is a local symbol, we can handle this as a
1878       // PC32 reloc.
1879       break;
1880
1881     case elfcpp::R_386_GOTOFF:
1882     case elfcpp::R_386_GOTPC:
1883       // We need a GOT section.
1884       target->got_section(symtab, layout);
1885       break;
1886
1887     case elfcpp::R_386_GOT32:
1888     case elfcpp::R_386_GOT32X:
1889       {
1890         // We need GOT section.
1891         Output_data_got<32, false>* got = target->got_section(symtab, layout);
1892
1893         // If the relocation symbol isn't IFUNC,
1894         // and is local, then we will convert
1895         // mov foo@GOT(%reg), %reg
1896         // to
1897         // lea foo@GOTOFF(%reg), %reg
1898         // in Relocate::relocate.
1899         if (reloc.get_r_offset() >= 2
1900             && lsym.get_st_type() != elfcpp::STT_GNU_IFUNC)
1901           {
1902             section_size_type stype;
1903             const unsigned char* view = object->section_contents(data_shndx,
1904                                                                  &stype, true);
1905             if (view[reloc.get_r_offset() - 2] == 0x8b)
1906               break;
1907           }
1908
1909         // Otherwise, the symbol requires a GOT entry.
1910         unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1911
1912         // For a STT_GNU_IFUNC symbol we want the PLT offset.  That
1913         // lets function pointers compare correctly with shared
1914         // libraries.  Otherwise we would need an IRELATIVE reloc.
1915         bool is_new;
1916         if (lsym.get_st_type() == elfcpp::STT_GNU_IFUNC)
1917           is_new = got->add_local_plt(object, r_sym, GOT_TYPE_STANDARD);
1918         else
1919           is_new = got->add_local(object, r_sym, GOT_TYPE_STANDARD);
1920         if (is_new)
1921           {
1922             // If we are generating a shared object, we need to add a
1923             // dynamic RELATIVE relocation for this symbol's GOT entry.
1924             if (parameters->options().output_is_position_independent())
1925               {
1926                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
1927                 unsigned int got_offset =
1928                   object->local_got_offset(r_sym, GOT_TYPE_STANDARD);
1929                 rel_dyn->add_local_relative(object, r_sym,
1930                                             elfcpp::R_386_RELATIVE,
1931                                             got, got_offset);
1932               }
1933           }
1934       }
1935       break;
1936
1937       // These are relocations which should only be seen by the
1938       // dynamic linker, and should never be seen here.
1939     case elfcpp::R_386_COPY:
1940     case elfcpp::R_386_GLOB_DAT:
1941     case elfcpp::R_386_JUMP_SLOT:
1942     case elfcpp::R_386_RELATIVE:
1943     case elfcpp::R_386_IRELATIVE:
1944     case elfcpp::R_386_TLS_TPOFF:
1945     case elfcpp::R_386_TLS_DTPMOD32:
1946     case elfcpp::R_386_TLS_DTPOFF32:
1947     case elfcpp::R_386_TLS_TPOFF32:
1948     case elfcpp::R_386_TLS_DESC:
1949       gold_error(_("%s: unexpected reloc %u in object file"),
1950                  object->name().c_str(), r_type);
1951       break;
1952
1953       // These are initial TLS relocs, which are expected when
1954       // linking.
1955     case elfcpp::R_386_TLS_GD:            // Global-dynamic
1956     case elfcpp::R_386_TLS_GOTDESC:       // Global-dynamic (from ~oliva url)
1957     case elfcpp::R_386_TLS_DESC_CALL:
1958     case elfcpp::R_386_TLS_LDM:           // Local-dynamic
1959     case elfcpp::R_386_TLS_LDO_32:        // Alternate local-dynamic
1960     case elfcpp::R_386_TLS_IE:            // Initial-exec
1961     case elfcpp::R_386_TLS_IE_32:
1962     case elfcpp::R_386_TLS_GOTIE:
1963     case elfcpp::R_386_TLS_LE:            // Local-exec
1964     case elfcpp::R_386_TLS_LE_32:
1965       {
1966         bool output_is_shared = parameters->options().shared();
1967         const tls::Tls_optimization optimized_type
1968             = Target_i386::optimize_tls_reloc(!output_is_shared, r_type);
1969         switch (r_type)
1970           {
1971           case elfcpp::R_386_TLS_GD:          // Global-dynamic
1972             if (optimized_type == tls::TLSOPT_NONE)
1973               {
1974                 // Create a pair of GOT entries for the module index and
1975                 // dtv-relative offset.
1976                 Output_data_got<32, false>* got
1977                     = target->got_section(symtab, layout);
1978                 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
1979                 unsigned int shndx = lsym.get_st_shndx();
1980                 bool is_ordinary;
1981                 shndx = object->adjust_sym_shndx(r_sym, shndx, &is_ordinary);
1982                 if (!is_ordinary)
1983                   object->error(_("local symbol %u has bad shndx %u"),
1984                               r_sym, shndx);
1985                 else
1986                   got->add_local_pair_with_rel(object, r_sym, shndx,
1987                                                GOT_TYPE_TLS_PAIR,
1988                                                target->rel_dyn_section(layout),
1989                                                elfcpp::R_386_TLS_DTPMOD32);
1990               }
1991             else if (optimized_type != tls::TLSOPT_TO_LE)
1992               unsupported_reloc_local(object, r_type);
1993             break;
1994
1995           case elfcpp::R_386_TLS_GOTDESC:     // Global-dynamic (from ~oliva)
1996             target->define_tls_base_symbol(symtab, layout);
1997             if (optimized_type == tls::TLSOPT_NONE)
1998               {
1999                 // Create a double GOT entry with an R_386_TLS_DESC
2000                 // reloc.  The R_386_TLS_DESC reloc is resolved
2001                 // lazily, so the GOT entry needs to be in an area in
2002                 // .got.plt, not .got.  Call got_section to make sure
2003                 // the section has been created.
2004                 target->got_section(symtab, layout);
2005                 Output_data_got<32, false>* got = target->got_tlsdesc_section();
2006                 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2007                 if (!object->local_has_got_offset(r_sym, GOT_TYPE_TLS_DESC))
2008                   {
2009                     unsigned int got_offset = got->add_constant(0);
2010                     // The local symbol value is stored in the second
2011                     // GOT entry.
2012                     got->add_local(object, r_sym, GOT_TYPE_TLS_DESC);
2013                     // That set the GOT offset of the local symbol to
2014                     // point to the second entry, but we want it to
2015                     // point to the first.
2016                     object->set_local_got_offset(r_sym, GOT_TYPE_TLS_DESC,
2017                                                  got_offset);
2018                     Reloc_section* rt = target->rel_tls_desc_section(layout);
2019                     rt->add_absolute(elfcpp::R_386_TLS_DESC, got, got_offset);
2020                   }
2021               }
2022             else if (optimized_type != tls::TLSOPT_TO_LE)
2023               unsupported_reloc_local(object, r_type);
2024             break;
2025
2026           case elfcpp::R_386_TLS_DESC_CALL:
2027             break;
2028
2029           case elfcpp::R_386_TLS_LDM:         // Local-dynamic
2030             if (optimized_type == tls::TLSOPT_NONE)
2031               {
2032                 // Create a GOT entry for the module index.
2033                 target->got_mod_index_entry(symtab, layout, object);
2034               }
2035             else if (optimized_type != tls::TLSOPT_TO_LE)
2036               unsupported_reloc_local(object, r_type);
2037             break;
2038
2039           case elfcpp::R_386_TLS_LDO_32:      // Alternate local-dynamic
2040             break;
2041
2042           case elfcpp::R_386_TLS_IE:          // Initial-exec
2043           case elfcpp::R_386_TLS_IE_32:
2044           case elfcpp::R_386_TLS_GOTIE:
2045             layout->set_has_static_tls();
2046             if (optimized_type == tls::TLSOPT_NONE)
2047               {
2048                 // For the R_386_TLS_IE relocation, we need to create a
2049                 // dynamic relocation when building a shared library.
2050                 if (r_type == elfcpp::R_386_TLS_IE
2051                     && parameters->options().shared())
2052                   {
2053                     Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2054                     unsigned int r_sym
2055                         = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2056                     rel_dyn->add_local_relative(object, r_sym,
2057                                                 elfcpp::R_386_RELATIVE,
2058                                                 output_section, data_shndx,
2059                                                 reloc.get_r_offset());
2060                   }
2061                 // Create a GOT entry for the tp-relative offset.
2062                 Output_data_got<32, false>* got
2063                     = target->got_section(symtab, layout);
2064                 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2065                 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
2066                                            ? elfcpp::R_386_TLS_TPOFF32
2067                                            : elfcpp::R_386_TLS_TPOFF);
2068                 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2069                                          ? GOT_TYPE_TLS_OFFSET
2070                                          : GOT_TYPE_TLS_NOFFSET);
2071                 got->add_local_with_rel(object, r_sym, got_type,
2072                                         target->rel_dyn_section(layout),
2073                                         dyn_r_type);
2074               }
2075             else if (optimized_type != tls::TLSOPT_TO_LE)
2076               unsupported_reloc_local(object, r_type);
2077             break;
2078
2079           case elfcpp::R_386_TLS_LE:          // Local-exec
2080           case elfcpp::R_386_TLS_LE_32:
2081             layout->set_has_static_tls();
2082             if (output_is_shared)
2083               {
2084                 // We need to create a dynamic relocation.
2085                 gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
2086                 unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
2087                 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
2088                                            ? elfcpp::R_386_TLS_TPOFF32
2089                                            : elfcpp::R_386_TLS_TPOFF);
2090                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2091                 rel_dyn->add_local(object, r_sym, dyn_r_type, output_section,
2092                                    data_shndx, reloc.get_r_offset());
2093               }
2094             break;
2095
2096           default:
2097             gold_unreachable();
2098           }
2099       }
2100       break;
2101
2102     case elfcpp::R_386_32PLT:
2103     case elfcpp::R_386_TLS_GD_32:
2104     case elfcpp::R_386_TLS_GD_PUSH:
2105     case elfcpp::R_386_TLS_GD_CALL:
2106     case elfcpp::R_386_TLS_GD_POP:
2107     case elfcpp::R_386_TLS_LDM_32:
2108     case elfcpp::R_386_TLS_LDM_PUSH:
2109     case elfcpp::R_386_TLS_LDM_CALL:
2110     case elfcpp::R_386_TLS_LDM_POP:
2111     case elfcpp::R_386_USED_BY_INTEL_200:
2112     default:
2113       unsupported_reloc_local(object, r_type);
2114       break;
2115     }
2116 }
2117
2118 // Report an unsupported relocation against a global symbol.
2119
2120 void
2121 Target_i386::Scan::unsupported_reloc_global(
2122     Sized_relobj_file<32, false>* object,
2123     unsigned int r_type,
2124     Symbol* gsym)
2125 {
2126   gold_error(_("%s: unsupported reloc %u against global symbol %s"),
2127              object->name().c_str(), r_type, gsym->demangled_name().c_str());
2128 }
2129
2130 inline bool
2131 Target_i386::Scan::possible_function_pointer_reloc(unsigned int r_type)
2132 {
2133   switch (r_type)
2134     {
2135     case elfcpp::R_386_32:
2136     case elfcpp::R_386_16:
2137     case elfcpp::R_386_8:
2138     case elfcpp::R_386_GOTOFF:
2139     case elfcpp::R_386_GOT32:
2140     case elfcpp::R_386_GOT32X:
2141       {
2142         return true;
2143       }
2144     default:
2145       return false;
2146     }
2147   return false;
2148 }
2149
2150 inline bool
2151 Target_i386::Scan::local_reloc_may_be_function_pointer(
2152   Symbol_table* ,
2153   Layout* ,
2154   Target_i386* ,
2155   Sized_relobj_file<32, false>* ,
2156   unsigned int ,
2157   Output_section* ,
2158   const elfcpp::Rel<32, false>& ,
2159   unsigned int r_type,
2160   const elfcpp::Sym<32, false>&)
2161 {
2162   return possible_function_pointer_reloc(r_type);
2163 }
2164
2165 inline bool
2166 Target_i386::Scan::global_reloc_may_be_function_pointer(
2167   Symbol_table* ,
2168   Layout* ,
2169   Target_i386* ,
2170   Sized_relobj_file<32, false>* ,
2171   unsigned int ,
2172   Output_section* ,
2173   const elfcpp::Rel<32, false>& ,
2174   unsigned int r_type,
2175   Symbol*)
2176 {
2177   return possible_function_pointer_reloc(r_type);
2178 }
2179
2180 // Scan a relocation for a global symbol.
2181
2182 inline void
2183 Target_i386::Scan::global(Symbol_table* symtab,
2184                                  Layout* layout,
2185                                  Target_i386* target,
2186                                  Sized_relobj_file<32, false>* object,
2187                                  unsigned int data_shndx,
2188                                  Output_section* output_section,
2189                                  const elfcpp::Rel<32, false>& reloc,
2190                                  unsigned int r_type,
2191                                  Symbol* gsym)
2192 {
2193   // A STT_GNU_IFUNC symbol may require a PLT entry.
2194   if (gsym->type() == elfcpp::STT_GNU_IFUNC
2195       && this->reloc_needs_plt_for_ifunc(object, r_type))
2196     target->make_plt_entry(symtab, layout, gsym);
2197
2198   switch (r_type)
2199     {
2200     case elfcpp::R_386_NONE:
2201     case elfcpp::R_386_GNU_VTINHERIT:
2202     case elfcpp::R_386_GNU_VTENTRY:
2203       break;
2204
2205     case elfcpp::R_386_32:
2206     case elfcpp::R_386_16:
2207     case elfcpp::R_386_8:
2208       {
2209         // Make a PLT entry if necessary.
2210         if (gsym->needs_plt_entry())
2211           {
2212             target->make_plt_entry(symtab, layout, gsym);
2213             // Since this is not a PC-relative relocation, we may be
2214             // taking the address of a function. In that case we need to
2215             // set the entry in the dynamic symbol table to the address of
2216             // the PLT entry.
2217             if (gsym->is_from_dynobj() && !parameters->options().shared())
2218               gsym->set_needs_dynsym_value();
2219           }
2220         // Make a dynamic relocation if necessary.
2221         if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2222           {
2223             if (!parameters->options().output_is_position_independent()
2224                 && gsym->may_need_copy_reloc())
2225               {
2226                 target->copy_reloc(symtab, layout, object,
2227                                    data_shndx, output_section, gsym, reloc);
2228               }
2229             else if (r_type == elfcpp::R_386_32
2230                      && gsym->type() == elfcpp::STT_GNU_IFUNC
2231                      && gsym->can_use_relative_reloc(false)
2232                      && !gsym->is_from_dynobj()
2233                      && !gsym->is_undefined()
2234                      && !gsym->is_preemptible())
2235               {
2236                 // Use an IRELATIVE reloc for a locally defined
2237                 // STT_GNU_IFUNC symbol.  This makes a function
2238                 // address in a PIE executable match the address in a
2239                 // shared library that it links against.
2240                 Reloc_section* rel_dyn = target->rel_irelative_section(layout);
2241                 rel_dyn->add_symbolless_global_addend(gsym,
2242                                                       elfcpp::R_386_IRELATIVE,
2243                                                       output_section,
2244                                                       object, data_shndx,
2245                                                       reloc.get_r_offset());
2246               }
2247             else if (r_type == elfcpp::R_386_32
2248                      && gsym->can_use_relative_reloc(false))
2249               {
2250                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2251                 rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2252                                              output_section, object,
2253                                              data_shndx, reloc.get_r_offset());
2254               }
2255             else
2256               {
2257                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2258                 rel_dyn->add_global(gsym, r_type, output_section, object,
2259                                     data_shndx, reloc.get_r_offset());
2260               }
2261           }
2262       }
2263       break;
2264
2265     case elfcpp::R_386_PC32:
2266     case elfcpp::R_386_PC16:
2267     case elfcpp::R_386_PC8:
2268       {
2269         // Make a PLT entry if necessary.
2270         if (gsym->needs_plt_entry())
2271           {
2272             // These relocations are used for function calls only in
2273             // non-PIC code.  For a 32-bit relocation in a shared library,
2274             // we'll need a text relocation anyway, so we can skip the
2275             // PLT entry and let the dynamic linker bind the call directly
2276             // to the target.  For smaller relocations, we should use a
2277             // PLT entry to ensure that the call can reach.
2278             if (!parameters->options().shared()
2279                 || r_type != elfcpp::R_386_PC32)
2280               target->make_plt_entry(symtab, layout, gsym);
2281           }
2282         // Make a dynamic relocation if necessary.
2283         if (gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type)))
2284           {
2285             if (parameters->options().output_is_executable()
2286                 && gsym->may_need_copy_reloc())
2287               {
2288                 target->copy_reloc(symtab, layout, object,
2289                                    data_shndx, output_section, gsym, reloc);
2290               }
2291             else
2292               {
2293                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2294                 rel_dyn->add_global(gsym, r_type, output_section, object,
2295                                     data_shndx, reloc.get_r_offset());
2296               }
2297           }
2298       }
2299       break;
2300
2301     case elfcpp::R_386_GOT32:
2302     case elfcpp::R_386_GOT32X:
2303       {
2304         // The symbol requires a GOT section.
2305         Output_data_got<32, false>* got = target->got_section(symtab, layout);
2306
2307         // If we convert this from
2308         // mov foo@GOT(%reg), %reg
2309         // to
2310         // lea foo@GOTOFF(%reg), %reg
2311         // in Relocate::relocate, then there is nothing to do here.
2312         if (reloc.get_r_offset() >= 2
2313             && Target_i386::can_convert_mov_to_lea(gsym))
2314           {
2315             section_size_type stype;
2316             const unsigned char* view = object->section_contents(data_shndx,
2317                                                                  &stype, true);
2318             if (view[reloc.get_r_offset() - 2] == 0x8b)
2319               break;
2320           }
2321
2322         if (gsym->final_value_is_known())
2323           {
2324             // For a STT_GNU_IFUNC symbol we want the PLT address.
2325             if (gsym->type() == elfcpp::STT_GNU_IFUNC)
2326               got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2327             else
2328               got->add_global(gsym, GOT_TYPE_STANDARD);
2329           }
2330         else
2331           {
2332             // If this symbol is not fully resolved, we need to add a
2333             // GOT entry with a dynamic relocation.
2334             Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2335
2336             // Use a GLOB_DAT rather than a RELATIVE reloc if:
2337             //
2338             // 1) The symbol may be defined in some other module.
2339             //
2340             // 2) We are building a shared library and this is a
2341             // protected symbol; using GLOB_DAT means that the dynamic
2342             // linker can use the address of the PLT in the main
2343             // executable when appropriate so that function address
2344             // comparisons work.
2345             //
2346             // 3) This is a STT_GNU_IFUNC symbol in position dependent
2347             // code, again so that function address comparisons work.
2348             if (gsym->is_from_dynobj()
2349                 || gsym->is_undefined()
2350                 || gsym->is_preemptible()
2351                 || (gsym->visibility() == elfcpp::STV_PROTECTED
2352                     && parameters->options().shared())
2353                 || (gsym->type() == elfcpp::STT_GNU_IFUNC
2354                     && parameters->options().output_is_position_independent()))
2355               got->add_global_with_rel(gsym, GOT_TYPE_STANDARD,
2356                                        rel_dyn, elfcpp::R_386_GLOB_DAT);
2357             else
2358               {
2359                 // For a STT_GNU_IFUNC symbol we want to write the PLT
2360                 // offset into the GOT, so that function pointer
2361                 // comparisons work correctly.
2362                 bool is_new;
2363                 if (gsym->type() != elfcpp::STT_GNU_IFUNC)
2364                   is_new = got->add_global(gsym, GOT_TYPE_STANDARD);
2365                 else
2366                   {
2367                     is_new = got->add_global_plt(gsym, GOT_TYPE_STANDARD);
2368                     // Tell the dynamic linker to use the PLT address
2369                     // when resolving relocations.
2370                     if (gsym->is_from_dynobj()
2371                         && !parameters->options().shared())
2372                       gsym->set_needs_dynsym_value();
2373                   }
2374                 if (is_new)
2375                   {
2376                     unsigned int got_off = gsym->got_offset(GOT_TYPE_STANDARD);
2377                     rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2378                                                  got, got_off);
2379                   }
2380               }
2381           }
2382       }
2383       break;
2384
2385     case elfcpp::R_386_PLT32:
2386       // If the symbol is fully resolved, this is just a PC32 reloc.
2387       // Otherwise we need a PLT entry.
2388       if (gsym->final_value_is_known())
2389         break;
2390       // If building a shared library, we can also skip the PLT entry
2391       // if the symbol is defined in the output file and is protected
2392       // or hidden.
2393       if (gsym->is_defined()
2394           && !gsym->is_from_dynobj()
2395           && !gsym->is_preemptible())
2396         break;
2397       target->make_plt_entry(symtab, layout, gsym);
2398       break;
2399
2400     case elfcpp::R_386_GOTOFF:
2401       // A GOT-relative reference must resolve locally.
2402       if (!gsym->is_defined())
2403         gold_error(_("%s: relocation R_386_GOTOFF against undefined symbol %s"
2404                      " cannot be used when making a shared object"),
2405                    object->name().c_str(), gsym->name());
2406       else if (gsym->is_from_dynobj())
2407         gold_error(_("%s: relocation R_386_GOTOFF against external symbol %s"
2408                      " cannot be used when making a shared object"),
2409                    object->name().c_str(), gsym->name());
2410       else if (gsym->is_preemptible())
2411         gold_error(_("%s: relocation R_386_GOTOFF against preemptible symbol %s"
2412                      " cannot be used when making a shared object"),
2413                    object->name().c_str(), gsym->name());
2414       // We need a GOT section.
2415       target->got_section(symtab, layout);
2416       break;
2417
2418     case elfcpp::R_386_GOTPC:
2419       // We need a GOT section.
2420       target->got_section(symtab, layout);
2421       break;
2422
2423       // These are relocations which should only be seen by the
2424       // dynamic linker, and should never be seen here.
2425     case elfcpp::R_386_COPY:
2426     case elfcpp::R_386_GLOB_DAT:
2427     case elfcpp::R_386_JUMP_SLOT:
2428     case elfcpp::R_386_RELATIVE:
2429     case elfcpp::R_386_IRELATIVE:
2430     case elfcpp::R_386_TLS_TPOFF:
2431     case elfcpp::R_386_TLS_DTPMOD32:
2432     case elfcpp::R_386_TLS_DTPOFF32:
2433     case elfcpp::R_386_TLS_TPOFF32:
2434     case elfcpp::R_386_TLS_DESC:
2435       gold_error(_("%s: unexpected reloc %u in object file"),
2436                  object->name().c_str(), r_type);
2437       break;
2438
2439       // These are initial tls relocs, which are expected when
2440       // linking.
2441     case elfcpp::R_386_TLS_GD:            // Global-dynamic
2442     case elfcpp::R_386_TLS_GOTDESC:       // Global-dynamic (from ~oliva url)
2443     case elfcpp::R_386_TLS_DESC_CALL:
2444     case elfcpp::R_386_TLS_LDM:           // Local-dynamic
2445     case elfcpp::R_386_TLS_LDO_32:        // Alternate local-dynamic
2446     case elfcpp::R_386_TLS_IE:            // Initial-exec
2447     case elfcpp::R_386_TLS_IE_32:
2448     case elfcpp::R_386_TLS_GOTIE:
2449     case elfcpp::R_386_TLS_LE:            // Local-exec
2450     case elfcpp::R_386_TLS_LE_32:
2451       {
2452         const bool is_final = gsym->final_value_is_known();
2453         const tls::Tls_optimization optimized_type
2454             = Target_i386::optimize_tls_reloc(is_final, r_type);
2455         switch (r_type)
2456           {
2457           case elfcpp::R_386_TLS_GD:          // Global-dynamic
2458             if (optimized_type == tls::TLSOPT_NONE)
2459               {
2460                 // Create a pair of GOT entries for the module index and
2461                 // dtv-relative offset.
2462                 Output_data_got<32, false>* got
2463                     = target->got_section(symtab, layout);
2464                 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_PAIR,
2465                                              target->rel_dyn_section(layout),
2466                                              elfcpp::R_386_TLS_DTPMOD32,
2467                                              elfcpp::R_386_TLS_DTPOFF32);
2468               }
2469             else if (optimized_type == tls::TLSOPT_TO_IE)
2470               {
2471                 // Create a GOT entry for the tp-relative offset.
2472                 Output_data_got<32, false>* got
2473                     = target->got_section(symtab, layout);
2474                 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
2475                                          target->rel_dyn_section(layout),
2476                                          elfcpp::R_386_TLS_TPOFF);
2477               }
2478             else if (optimized_type != tls::TLSOPT_TO_LE)
2479               unsupported_reloc_global(object, r_type, gsym);
2480             break;
2481
2482           case elfcpp::R_386_TLS_GOTDESC:     // Global-dynamic (~oliva url)
2483             target->define_tls_base_symbol(symtab, layout);
2484             if (optimized_type == tls::TLSOPT_NONE)
2485               {
2486                 // Create a double GOT entry with an R_386_TLS_DESC
2487                 // reloc.  The R_386_TLS_DESC reloc is resolved
2488                 // lazily, so the GOT entry needs to be in an area in
2489                 // .got.plt, not .got.  Call got_section to make sure
2490                 // the section has been created.
2491                 target->got_section(symtab, layout);
2492                 Output_data_got<32, false>* got = target->got_tlsdesc_section();
2493                 Reloc_section* rt = target->rel_tls_desc_section(layout);
2494                 got->add_global_pair_with_rel(gsym, GOT_TYPE_TLS_DESC, rt,
2495                                              elfcpp::R_386_TLS_DESC, 0);
2496               }
2497             else if (optimized_type == tls::TLSOPT_TO_IE)
2498               {
2499                 // Create a GOT entry for the tp-relative offset.
2500                 Output_data_got<32, false>* got
2501                     = target->got_section(symtab, layout);
2502                 got->add_global_with_rel(gsym, GOT_TYPE_TLS_NOFFSET,
2503                                          target->rel_dyn_section(layout),
2504                                          elfcpp::R_386_TLS_TPOFF);
2505               }
2506             else if (optimized_type != tls::TLSOPT_TO_LE)
2507               unsupported_reloc_global(object, r_type, gsym);
2508             break;
2509
2510           case elfcpp::R_386_TLS_DESC_CALL:
2511             break;
2512
2513           case elfcpp::R_386_TLS_LDM:         // Local-dynamic
2514             if (optimized_type == tls::TLSOPT_NONE)
2515               {
2516                 // Create a GOT entry for the module index.
2517                 target->got_mod_index_entry(symtab, layout, object);
2518               }
2519             else if (optimized_type != tls::TLSOPT_TO_LE)
2520               unsupported_reloc_global(object, r_type, gsym);
2521             break;
2522
2523           case elfcpp::R_386_TLS_LDO_32:      // Alternate local-dynamic
2524             break;
2525
2526           case elfcpp::R_386_TLS_IE:          // Initial-exec
2527           case elfcpp::R_386_TLS_IE_32:
2528           case elfcpp::R_386_TLS_GOTIE:
2529             layout->set_has_static_tls();
2530             if (optimized_type == tls::TLSOPT_NONE)
2531               {
2532                 // For the R_386_TLS_IE relocation, we need to create a
2533                 // dynamic relocation when building a shared library.
2534                 if (r_type == elfcpp::R_386_TLS_IE
2535                     && parameters->options().shared())
2536                   {
2537                     Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2538                     rel_dyn->add_global_relative(gsym, elfcpp::R_386_RELATIVE,
2539                                                  output_section, object,
2540                                                  data_shndx,
2541                                                  reloc.get_r_offset());
2542                   }
2543                 // Create a GOT entry for the tp-relative offset.
2544                 Output_data_got<32, false>* got
2545                     = target->got_section(symtab, layout);
2546                 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_IE_32
2547                                            ? elfcpp::R_386_TLS_TPOFF32
2548                                            : elfcpp::R_386_TLS_TPOFF);
2549                 unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
2550                                          ? GOT_TYPE_TLS_OFFSET
2551                                          : GOT_TYPE_TLS_NOFFSET);
2552                 got->add_global_with_rel(gsym, got_type,
2553                                          target->rel_dyn_section(layout),
2554                                          dyn_r_type);
2555               }
2556             else if (optimized_type != tls::TLSOPT_TO_LE)
2557               unsupported_reloc_global(object, r_type, gsym);
2558             break;
2559
2560           case elfcpp::R_386_TLS_LE:          // Local-exec
2561           case elfcpp::R_386_TLS_LE_32:
2562             layout->set_has_static_tls();
2563             if (parameters->options().shared())
2564               {
2565                 // We need to create a dynamic relocation.
2566                 unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
2567                                            ? elfcpp::R_386_TLS_TPOFF32
2568                                            : elfcpp::R_386_TLS_TPOFF);
2569                 Reloc_section* rel_dyn = target->rel_dyn_section(layout);
2570                 rel_dyn->add_global(gsym, dyn_r_type, output_section, object,
2571                                     data_shndx, reloc.get_r_offset());
2572               }
2573             break;
2574
2575           default:
2576             gold_unreachable();
2577           }
2578       }
2579       break;
2580
2581     case elfcpp::R_386_32PLT:
2582     case elfcpp::R_386_TLS_GD_32:
2583     case elfcpp::R_386_TLS_GD_PUSH:
2584     case elfcpp::R_386_TLS_GD_CALL:
2585     case elfcpp::R_386_TLS_GD_POP:
2586     case elfcpp::R_386_TLS_LDM_32:
2587     case elfcpp::R_386_TLS_LDM_PUSH:
2588     case elfcpp::R_386_TLS_LDM_CALL:
2589     case elfcpp::R_386_TLS_LDM_POP:
2590     case elfcpp::R_386_USED_BY_INTEL_200:
2591     default:
2592       unsupported_reloc_global(object, r_type, gsym);
2593       break;
2594     }
2595 }
2596
2597 // Process relocations for gc.
2598
2599 void
2600 Target_i386::gc_process_relocs(Symbol_table* symtab,
2601                                       Layout* layout,
2602                                       Sized_relobj_file<32, false>* object,
2603                                       unsigned int data_shndx,
2604                                       unsigned int,
2605                                       const unsigned char* prelocs,
2606                                       size_t reloc_count,
2607                                       Output_section* output_section,
2608                                       bool needs_special_offset_handling,
2609                                       size_t local_symbol_count,
2610                                       const unsigned char* plocal_symbols)
2611 {
2612   gold::gc_process_relocs<32, false, Target_i386, Scan, Classify_reloc>(
2613     symtab,
2614     layout,
2615     this,
2616     object,
2617     data_shndx,
2618     prelocs,
2619     reloc_count,
2620     output_section,
2621     needs_special_offset_handling,
2622     local_symbol_count,
2623     plocal_symbols);
2624 }
2625
2626 // Scan relocations for a section.
2627
2628 void
2629 Target_i386::scan_relocs(Symbol_table* symtab,
2630                                 Layout* layout,
2631                                 Sized_relobj_file<32, false>* object,
2632                                 unsigned int data_shndx,
2633                                 unsigned int sh_type,
2634                                 const unsigned char* prelocs,
2635                                 size_t reloc_count,
2636                                 Output_section* output_section,
2637                                 bool needs_special_offset_handling,
2638                                 size_t local_symbol_count,
2639                                 const unsigned char* plocal_symbols)
2640 {
2641   if (sh_type == elfcpp::SHT_RELA)
2642     {
2643       gold_error(_("%s: unsupported RELA reloc section"),
2644                  object->name().c_str());
2645       return;
2646     }
2647
2648   gold::scan_relocs<32, false, Target_i386, Scan, Classify_reloc>(
2649     symtab,
2650     layout,
2651     this,
2652     object,
2653     data_shndx,
2654     prelocs,
2655     reloc_count,
2656     output_section,
2657     needs_special_offset_handling,
2658     local_symbol_count,
2659     plocal_symbols);
2660 }
2661
2662 // Finalize the sections.
2663
2664 void
2665 Target_i386::do_finalize_sections(
2666     Layout* layout,
2667     const Input_objects*,
2668     Symbol_table* symtab)
2669 {
2670   const Reloc_section* rel_plt = (this->plt_ == NULL
2671                                   ? NULL
2672                                   : this->plt_->rel_plt());
2673   layout->add_target_dynamic_tags(true, this->got_plt_, rel_plt,
2674                                   this->rel_dyn_, true, false);
2675
2676   // Emit any relocs we saved in an attempt to avoid generating COPY
2677   // relocs.
2678   if (this->copy_relocs_.any_saved_relocs())
2679     this->copy_relocs_.emit(this->rel_dyn_section(layout));
2680
2681   // Set the size of the _GLOBAL_OFFSET_TABLE_ symbol to the size of
2682   // the .got.plt section.
2683   Symbol* sym = this->global_offset_table_;
2684   if (sym != NULL)
2685     {
2686       uint32_t data_size = this->got_plt_->current_data_size();
2687       symtab->get_sized_symbol<32>(sym)->set_symsize(data_size);
2688     }
2689
2690   if (parameters->doing_static_link()
2691       && (this->plt_ == NULL || !this->plt_->has_irelative_section()))
2692     {
2693       // If linking statically, make sure that the __rel_iplt symbols
2694       // were defined if necessary, even if we didn't create a PLT.
2695       static const Define_symbol_in_segment syms[] =
2696         {
2697           {
2698             "__rel_iplt_start",         // name
2699             elfcpp::PT_LOAD,            // segment_type
2700             elfcpp::PF_W,               // segment_flags_set
2701             elfcpp::PF(0),              // segment_flags_clear
2702             0,                          // value
2703             0,                          // size
2704             elfcpp::STT_NOTYPE,         // type
2705             elfcpp::STB_GLOBAL,         // binding
2706             elfcpp::STV_HIDDEN,         // visibility
2707             0,                          // nonvis
2708             Symbol::SEGMENT_START,      // offset_from_base
2709             true                        // only_if_ref
2710           },
2711           {
2712             "__rel_iplt_end",           // name
2713             elfcpp::PT_LOAD,            // segment_type
2714             elfcpp::PF_W,               // segment_flags_set
2715             elfcpp::PF(0),              // segment_flags_clear
2716             0,                          // value
2717             0,                          // size
2718             elfcpp::STT_NOTYPE,         // type
2719             elfcpp::STB_GLOBAL,         // binding
2720             elfcpp::STV_HIDDEN,         // visibility
2721             0,                          // nonvis
2722             Symbol::SEGMENT_START,      // offset_from_base
2723             true                        // only_if_ref
2724           }
2725         };
2726
2727       symtab->define_symbols(layout, 2, syms,
2728                              layout->script_options()->saw_sections_clause());
2729     }
2730 }
2731
2732 // Return whether a direct absolute static relocation needs to be applied.
2733 // In cases where Scan::local() or Scan::global() has created
2734 // a dynamic relocation other than R_386_RELATIVE, the addend
2735 // of the relocation is carried in the data, and we must not
2736 // apply the static relocation.
2737
2738 inline bool
2739 Target_i386::Relocate::should_apply_static_reloc(const Sized_symbol<32>* gsym,
2740                                                  unsigned int r_type,
2741                                                  bool is_32bit,
2742                                                  Output_section* output_section)
2743 {
2744   // If the output section is not allocated, then we didn't call
2745   // scan_relocs, we didn't create a dynamic reloc, and we must apply
2746   // the reloc here.
2747   if ((output_section->flags() & elfcpp::SHF_ALLOC) == 0)
2748     return true;
2749
2750   int ref_flags = Scan::get_reference_flags(r_type);
2751
2752   // For local symbols, we will have created a non-RELATIVE dynamic
2753   // relocation only if (a) the output is position independent,
2754   // (b) the relocation is absolute (not pc- or segment-relative), and
2755   // (c) the relocation is not 32 bits wide.
2756   if (gsym == NULL)
2757     return !(parameters->options().output_is_position_independent()
2758              && (ref_flags & Symbol::ABSOLUTE_REF)
2759              && !is_32bit);
2760
2761   // For global symbols, we use the same helper routines used in the
2762   // scan pass.  If we did not create a dynamic relocation, or if we
2763   // created a RELATIVE dynamic relocation, we should apply the static
2764   // relocation.
2765   bool has_dyn = gsym->needs_dynamic_reloc(ref_flags);
2766   bool is_rel = (ref_flags & Symbol::ABSOLUTE_REF)
2767                 && gsym->can_use_relative_reloc(ref_flags
2768                                                 & Symbol::FUNCTION_CALL);
2769   return !has_dyn || is_rel;
2770 }
2771
2772 // Perform a relocation.
2773
2774 inline bool
2775 Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
2776                                 unsigned int,
2777                                 Target_i386* target,
2778                                 Output_section* output_section,
2779                                 size_t relnum,
2780                                 const unsigned char* preloc,
2781                                 const Sized_symbol<32>* gsym,
2782                                 const Symbol_value<32>* psymval,
2783                                 unsigned char* view,
2784                                 elfcpp::Elf_types<32>::Elf_Addr address,
2785                                 section_size_type view_size)
2786 {
2787   const elfcpp::Rel<32, false> rel(preloc);
2788   unsigned int r_type = elfcpp::elf_r_type<32>(rel.get_r_info());
2789
2790   if (this->skip_call_tls_get_addr_)
2791     {
2792       if ((r_type != elfcpp::R_386_PLT32
2793            && r_type != elfcpp::R_386_PC32)
2794           || gsym == NULL
2795           || strcmp(gsym->name(), "___tls_get_addr") != 0)
2796         gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2797                                _("missing expected TLS relocation"));
2798       else
2799         {
2800           this->skip_call_tls_get_addr_ = false;
2801           return false;
2802         }
2803     }
2804
2805   if (view == NULL)
2806     return true;
2807
2808   const Sized_relobj_file<32, false>* object = relinfo->object;
2809
2810   // Pick the value to use for symbols defined in shared objects.
2811   Symbol_value<32> symval;
2812   if (gsym != NULL
2813       && gsym->type() == elfcpp::STT_GNU_IFUNC
2814       && r_type == elfcpp::R_386_32
2815       && gsym->needs_dynamic_reloc(Scan::get_reference_flags(r_type))
2816       && gsym->can_use_relative_reloc(false)
2817       && !gsym->is_from_dynobj()
2818       && !gsym->is_undefined()
2819       && !gsym->is_preemptible())
2820     {
2821       // In this case we are generating a R_386_IRELATIVE reloc.  We
2822       // want to use the real value of the symbol, not the PLT offset.
2823     }
2824   else if (gsym != NULL
2825            && gsym->use_plt_offset(Scan::get_reference_flags(r_type)))
2826     {
2827       symval.set_output_value(target->plt_address_for_global(gsym));
2828       psymval = &symval;
2829     }
2830   else if (gsym == NULL && psymval->is_ifunc_symbol())
2831     {
2832       unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2833       if (object->local_has_plt_offset(r_sym))
2834         {
2835           symval.set_output_value(target->plt_address_for_local(object, r_sym));
2836           psymval = &symval;
2837         }
2838     }
2839
2840   bool baseless;
2841
2842   switch (r_type)
2843     {
2844     case elfcpp::R_386_NONE:
2845     case elfcpp::R_386_GNU_VTINHERIT:
2846     case elfcpp::R_386_GNU_VTENTRY:
2847       break;
2848
2849     case elfcpp::R_386_32:
2850       if (should_apply_static_reloc(gsym, r_type, true, output_section))
2851         Relocate_functions<32, false>::rel32(view, object, psymval);
2852       break;
2853
2854     case elfcpp::R_386_PC32:
2855       if (should_apply_static_reloc(gsym, r_type, true, output_section))
2856         Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
2857       break;
2858
2859     case elfcpp::R_386_16:
2860       if (should_apply_static_reloc(gsym, r_type, false, output_section))
2861         Relocate_functions<32, false>::rel16(view, object, psymval);
2862       break;
2863
2864     case elfcpp::R_386_PC16:
2865       if (should_apply_static_reloc(gsym, r_type, false, output_section))
2866         Relocate_functions<32, false>::pcrel16(view, object, psymval, address);
2867       break;
2868
2869     case elfcpp::R_386_8:
2870       if (should_apply_static_reloc(gsym, r_type, false, output_section))
2871         Relocate_functions<32, false>::rel8(view, object, psymval);
2872       break;
2873
2874     case elfcpp::R_386_PC8:
2875       if (should_apply_static_reloc(gsym, r_type, false, output_section))
2876         Relocate_functions<32, false>::pcrel8(view, object, psymval, address);
2877       break;
2878
2879     case elfcpp::R_386_PLT32:
2880       gold_assert(gsym == NULL
2881                   || gsym->has_plt_offset()
2882                   || gsym->final_value_is_known()
2883                   || (gsym->is_defined()
2884                       && !gsym->is_from_dynobj()
2885                       && !gsym->is_preemptible()));
2886       Relocate_functions<32, false>::pcrel32(view, object, psymval, address);
2887       break;
2888
2889     case elfcpp::R_386_GOT32:
2890     case elfcpp::R_386_GOT32X:
2891       baseless = (view[-1] & 0xc7) == 0x5;
2892       // R_386_GOT32 and R_386_GOT32X don't work without base register
2893       // when generating a position-independent output file.
2894       if (baseless
2895           && parameters->options().output_is_position_independent())
2896         {
2897           if(gsym)
2898             gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2899                                    _("unexpected reloc %u against global symbol %s without base register in object file when generating a position-independent output file"),
2900                                    r_type, gsym->demangled_name().c_str());
2901           else
2902             gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2903                                    _("unexpected reloc %u against local symbol without base register in object file when generating a position-independent output file"),
2904                                    r_type);
2905         }
2906
2907       // Convert
2908       // mov foo@GOT(%reg), %reg
2909       // to
2910       // lea foo@GOTOFF(%reg), %reg
2911       // if possible.
2912       if (rel.get_r_offset() >= 2
2913           && view[-2] == 0x8b
2914           && ((gsym == NULL && !psymval->is_ifunc_symbol())
2915               || (gsym != NULL
2916                   && Target_i386::can_convert_mov_to_lea(gsym))))
2917         {
2918           view[-2] = 0x8d;
2919           elfcpp::Elf_types<32>::Elf_Addr value;
2920           value = psymval->value(object, 0);
2921           // Don't subtract the .got.plt section address for baseless
2922           // addressing.
2923           if (!baseless)
2924             value -= target->got_plt_section()->address();
2925           Relocate_functions<32, false>::rel32(view, value);
2926         }
2927       else
2928         {
2929           // The GOT pointer points to the end of the GOT section.
2930           // We need to subtract the size of the GOT section to get
2931           // the actual offset to use in the relocation.
2932           unsigned int got_offset = 0;
2933           if (gsym != NULL)
2934             {
2935               gold_assert(gsym->has_got_offset(GOT_TYPE_STANDARD));
2936               got_offset = (gsym->got_offset(GOT_TYPE_STANDARD)
2937                             - target->got_size());
2938             }
2939           else
2940             {
2941               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
2942               gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_STANDARD));
2943               got_offset = (object->local_got_offset(r_sym, GOT_TYPE_STANDARD)
2944                             - target->got_size());
2945             }
2946           // Add the .got.plt section address for baseless addressing.
2947           if (baseless)
2948             got_offset += target->got_plt_section()->address();
2949           Relocate_functions<32, false>::rel32(view, got_offset);
2950         }
2951       break;
2952
2953     case elfcpp::R_386_GOTOFF:
2954       {
2955         elfcpp::Elf_types<32>::Elf_Addr value;
2956         value = (psymval->value(object, 0)
2957                  - target->got_plt_section()->address());
2958         Relocate_functions<32, false>::rel32(view, value);
2959       }
2960       break;
2961
2962     case elfcpp::R_386_GOTPC:
2963       {
2964         elfcpp::Elf_types<32>::Elf_Addr value;
2965         value = target->got_plt_section()->address();
2966         Relocate_functions<32, false>::pcrel32(view, value, address);
2967       }
2968       break;
2969
2970     case elfcpp::R_386_COPY:
2971     case elfcpp::R_386_GLOB_DAT:
2972     case elfcpp::R_386_JUMP_SLOT:
2973     case elfcpp::R_386_RELATIVE:
2974     case elfcpp::R_386_IRELATIVE:
2975       // These are outstanding tls relocs, which are unexpected when
2976       // linking.
2977     case elfcpp::R_386_TLS_TPOFF:
2978     case elfcpp::R_386_TLS_DTPMOD32:
2979     case elfcpp::R_386_TLS_DTPOFF32:
2980     case elfcpp::R_386_TLS_TPOFF32:
2981     case elfcpp::R_386_TLS_DESC:
2982       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2983                              _("unexpected reloc %u in object file"),
2984                              r_type);
2985       break;
2986
2987       // These are initial tls relocs, which are expected when
2988       // linking.
2989     case elfcpp::R_386_TLS_GD:             // Global-dynamic
2990     case elfcpp::R_386_TLS_GOTDESC:        // Global-dynamic (from ~oliva url)
2991     case elfcpp::R_386_TLS_DESC_CALL:
2992     case elfcpp::R_386_TLS_LDM:            // Local-dynamic
2993     case elfcpp::R_386_TLS_LDO_32:         // Alternate local-dynamic
2994     case elfcpp::R_386_TLS_IE:             // Initial-exec
2995     case elfcpp::R_386_TLS_IE_32:
2996     case elfcpp::R_386_TLS_GOTIE:
2997     case elfcpp::R_386_TLS_LE:             // Local-exec
2998     case elfcpp::R_386_TLS_LE_32:
2999       this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval,
3000                          view, address, view_size);
3001       break;
3002
3003     case elfcpp::R_386_32PLT:
3004     case elfcpp::R_386_TLS_GD_32:
3005     case elfcpp::R_386_TLS_GD_PUSH:
3006     case elfcpp::R_386_TLS_GD_CALL:
3007     case elfcpp::R_386_TLS_GD_POP:
3008     case elfcpp::R_386_TLS_LDM_32:
3009     case elfcpp::R_386_TLS_LDM_PUSH:
3010     case elfcpp::R_386_TLS_LDM_CALL:
3011     case elfcpp::R_386_TLS_LDM_POP:
3012     case elfcpp::R_386_USED_BY_INTEL_200:
3013     default:
3014       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3015                              _("unsupported reloc %u"),
3016                              r_type);
3017       break;
3018     }
3019
3020   return true;
3021 }
3022
3023 // Perform a TLS relocation.
3024
3025 inline void
3026 Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
3027                                     Target_i386* target,
3028                                     size_t relnum,
3029                                     const elfcpp::Rel<32, false>& rel,
3030                                     unsigned int r_type,
3031                                     const Sized_symbol<32>* gsym,
3032                                     const Symbol_value<32>* psymval,
3033                                     unsigned char* view,
3034                                     elfcpp::Elf_types<32>::Elf_Addr,
3035                                     section_size_type view_size)
3036 {
3037   Output_segment* tls_segment = relinfo->layout->tls_segment();
3038
3039   const Sized_relobj_file<32, false>* object = relinfo->object;
3040
3041   elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0);
3042
3043   const bool is_final = (gsym == NULL
3044                          ? !parameters->options().shared()
3045                          : gsym->final_value_is_known());
3046   const tls::Tls_optimization optimized_type
3047       = Target_i386::optimize_tls_reloc(is_final, r_type);
3048   switch (r_type)
3049     {
3050     case elfcpp::R_386_TLS_GD:           // Global-dynamic
3051       if (optimized_type == tls::TLSOPT_TO_LE)
3052         {
3053           if (tls_segment == NULL)
3054             {
3055               gold_assert(parameters->errors()->error_count() > 0
3056                           || issue_undefined_symbol_error(gsym));
3057               return;
3058             }
3059           this->tls_gd_to_le(relinfo, relnum, tls_segment,
3060                              rel, r_type, value, view,
3061                              view_size);
3062           break;
3063         }
3064       else
3065         {
3066           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3067                                    ? GOT_TYPE_TLS_NOFFSET
3068                                    : GOT_TYPE_TLS_PAIR);
3069           unsigned int got_offset;
3070           if (gsym != NULL)
3071             {
3072               gold_assert(gsym->has_got_offset(got_type));
3073               got_offset = gsym->got_offset(got_type) - target->got_size();
3074             }
3075           else
3076             {
3077               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3078               gold_assert(object->local_has_got_offset(r_sym, got_type));
3079               got_offset = (object->local_got_offset(r_sym, got_type)
3080                             - target->got_size());
3081             }
3082           if (optimized_type == tls::TLSOPT_TO_IE)
3083             {
3084               this->tls_gd_to_ie(relinfo, relnum, rel, r_type,
3085                                  got_offset, view, view_size);
3086               break;
3087             }
3088           else if (optimized_type == tls::TLSOPT_NONE)
3089             {
3090               // Relocate the field with the offset of the pair of GOT
3091               // entries.
3092               Relocate_functions<32, false>::rel32(view, got_offset);
3093               break;
3094             }
3095         }
3096       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3097                              _("unsupported reloc %u"),
3098                              r_type);
3099       break;
3100
3101     case elfcpp::R_386_TLS_GOTDESC:      // Global-dynamic (from ~oliva url)
3102     case elfcpp::R_386_TLS_DESC_CALL:
3103       this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
3104       if (optimized_type == tls::TLSOPT_TO_LE)
3105         {
3106           if (tls_segment == NULL)
3107             {
3108               gold_assert(parameters->errors()->error_count() > 0
3109                           || issue_undefined_symbol_error(gsym));
3110               return;
3111             }
3112           this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
3113                                   rel, r_type, value, view,
3114                                   view_size);
3115           break;
3116         }
3117       else
3118         {
3119           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3120                                    ? GOT_TYPE_TLS_NOFFSET
3121                                    : GOT_TYPE_TLS_DESC);
3122           unsigned int got_offset = 0;
3123           if (r_type == elfcpp::R_386_TLS_GOTDESC
3124               && optimized_type == tls::TLSOPT_NONE)
3125             {
3126               // We created GOT entries in the .got.tlsdesc portion of
3127               // the .got.plt section, but the offset stored in the
3128               // symbol is the offset within .got.tlsdesc.
3129               got_offset = (target->got_size()
3130                             + target->got_plt_section()->data_size());
3131             }
3132           if (gsym != NULL)
3133             {
3134               gold_assert(gsym->has_got_offset(got_type));
3135               got_offset += gsym->got_offset(got_type) - target->got_size();
3136             }
3137           else
3138             {
3139               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3140               gold_assert(object->local_has_got_offset(r_sym, got_type));
3141               got_offset += (object->local_got_offset(r_sym, got_type)
3142                              - target->got_size());
3143             }
3144           if (optimized_type == tls::TLSOPT_TO_IE)
3145             {
3146               this->tls_desc_gd_to_ie(relinfo, relnum, rel, r_type,
3147                                       got_offset, view, view_size);
3148               break;
3149             }
3150           else if (optimized_type == tls::TLSOPT_NONE)
3151             {
3152               if (r_type == elfcpp::R_386_TLS_GOTDESC)
3153                 {
3154                   // Relocate the field with the offset of the pair of GOT
3155                   // entries.
3156                   Relocate_functions<32, false>::rel32(view, got_offset);
3157                 }
3158               break;
3159             }
3160         }
3161       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3162                              _("unsupported reloc %u"),
3163                              r_type);
3164       break;
3165
3166     case elfcpp::R_386_TLS_LDM:          // Local-dynamic
3167       if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN)
3168         {
3169           gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3170                                  _("both SUN and GNU model "
3171                                    "TLS relocations"));
3172           break;
3173         }
3174       this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
3175       if (optimized_type == tls::TLSOPT_TO_LE)
3176         {
3177           if (tls_segment == NULL)
3178             {
3179               gold_assert(parameters->errors()->error_count() > 0
3180                           || issue_undefined_symbol_error(gsym));
3181               return;
3182             }
3183           this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type,
3184                              value, view, view_size);
3185           break;
3186         }
3187       else if (optimized_type == tls::TLSOPT_NONE)
3188         {
3189           // Relocate the field with the offset of the GOT entry for
3190           // the module index.
3191           unsigned int got_offset;
3192           got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
3193                         - target->got_size());
3194           Relocate_functions<32, false>::rel32(view, got_offset);
3195           break;
3196         }
3197       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3198                              _("unsupported reloc %u"),
3199                              r_type);
3200       break;
3201
3202     case elfcpp::R_386_TLS_LDO_32:       // Alternate local-dynamic
3203       if (optimized_type == tls::TLSOPT_TO_LE)
3204         {
3205           // This reloc can appear in debugging sections, in which
3206           // case we must not convert to local-exec.  We decide what
3207           // to do based on whether the section is marked as
3208           // containing executable code.  That is what the GNU linker
3209           // does as well.
3210           elfcpp::Shdr<32, false> shdr(relinfo->data_shdr);
3211           if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
3212             {
3213               if (tls_segment == NULL)
3214                 {
3215                   gold_assert(parameters->errors()->error_count() > 0
3216                               || issue_undefined_symbol_error(gsym));
3217                   return;
3218                 }
3219               value -= tls_segment->memsz();
3220             }
3221         }
3222       Relocate_functions<32, false>::rel32(view, value);
3223       break;
3224
3225     case elfcpp::R_386_TLS_IE:           // Initial-exec
3226     case elfcpp::R_386_TLS_GOTIE:
3227     case elfcpp::R_386_TLS_IE_32:
3228       if (optimized_type == tls::TLSOPT_TO_LE)
3229         {
3230           if (tls_segment == NULL)
3231             {
3232               gold_assert(parameters->errors()->error_count() > 0
3233                           || issue_undefined_symbol_error(gsym));
3234               return;
3235             }
3236           Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3237                                               rel, r_type, value, view,
3238                                               view_size);
3239           break;
3240         }
3241       else if (optimized_type == tls::TLSOPT_NONE)
3242         {
3243           // Relocate the field with the offset of the GOT entry for
3244           // the tp-relative offset of the symbol.
3245           unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
3246                                    ? GOT_TYPE_TLS_OFFSET
3247                                    : GOT_TYPE_TLS_NOFFSET);
3248           unsigned int got_offset;
3249           if (gsym != NULL)
3250             {
3251               gold_assert(gsym->has_got_offset(got_type));
3252               got_offset = gsym->got_offset(got_type);
3253             }
3254           else
3255             {
3256               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3257               gold_assert(object->local_has_got_offset(r_sym, got_type));
3258               got_offset = object->local_got_offset(r_sym, got_type);
3259             }
3260           // For the R_386_TLS_IE relocation, we need to apply the
3261           // absolute address of the GOT entry.
3262           if (r_type == elfcpp::R_386_TLS_IE)
3263             got_offset += target->got_plt_section()->address();
3264           // All GOT offsets are relative to the end of the GOT.
3265           got_offset -= target->got_size();
3266           Relocate_functions<32, false>::rel32(view, got_offset);
3267           break;
3268         }
3269       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3270                              _("unsupported reloc %u"),
3271                              r_type);
3272       break;
3273
3274     case elfcpp::R_386_TLS_LE:           // Local-exec
3275       // If we're creating a shared library, a dynamic relocation will
3276       // have been created for this location, so do not apply it now.
3277       if (!parameters->options().shared())
3278         {
3279           if (tls_segment == NULL)
3280             {
3281               gold_assert(parameters->errors()->error_count() > 0
3282                           || issue_undefined_symbol_error(gsym));
3283               return;
3284             }
3285           value -= tls_segment->memsz();
3286           Relocate_functions<32, false>::rel32(view, value);
3287         }
3288       break;
3289
3290     case elfcpp::R_386_TLS_LE_32:
3291       // If we're creating a shared library, a dynamic relocation will
3292       // have been created for this location, so do not apply it now.
3293       if (!parameters->options().shared())
3294         {
3295           if (tls_segment == NULL)
3296             {
3297               gold_assert(parameters->errors()->error_count() > 0
3298                           || issue_undefined_symbol_error(gsym));
3299               return;
3300             }
3301           value = tls_segment->memsz() - value;
3302           Relocate_functions<32, false>::rel32(view, value);
3303         }
3304       break;
3305     }
3306 }
3307
3308 // Do a relocation in which we convert a TLS General-Dynamic to a
3309 // Local-Exec.
3310
3311 inline void
3312 Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo,
3313                                     size_t relnum,
3314                                     Output_segment* tls_segment,
3315                                     const elfcpp::Rel<32, false>& rel,
3316                                     unsigned int,
3317                                     elfcpp::Elf_types<32>::Elf_Addr value,
3318                                     unsigned char* view,
3319                                     section_size_type view_size)
3320 {
3321   // leal foo(,%reg,1),%eax; call ___tls_get_addr
3322   //  ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3323   // leal foo(%reg),%eax; call ___tls_get_addr
3324   //  ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3325
3326   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3327   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3328
3329   unsigned char op1 = view[-1];
3330   unsigned char op2 = view[-2];
3331
3332   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3333                  op2 == 0x8d || op2 == 0x04);
3334   tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
3335
3336   int roff = 5;
3337
3338   if (op2 == 0x04)
3339     {
3340       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3341       tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3342       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3343                      ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
3344       memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3345     }
3346   else
3347     {
3348       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3349                      (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
3350       if (rel.get_r_offset() + 9 < view_size
3351           && view[9] == 0x90)
3352         {
3353           // There is a trailing nop.  Use the size byte subl.
3354           memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3355           roff = 6;
3356         }
3357       else
3358         {
3359           // Use the five byte subl.
3360           memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
3361         }
3362     }
3363
3364   value = tls_segment->memsz() - value;
3365   Relocate_functions<32, false>::rel32(view + roff, value);
3366
3367   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3368   // We can skip it.
3369   this->skip_call_tls_get_addr_ = true;
3370 }
3371
3372 // Do a relocation in which we convert a TLS General-Dynamic to an
3373 // Initial-Exec.
3374
3375 inline void
3376 Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo,
3377                                     size_t relnum,
3378                                     const elfcpp::Rel<32, false>& rel,
3379                                     unsigned int,
3380                                     elfcpp::Elf_types<32>::Elf_Addr value,
3381                                     unsigned char* view,
3382                                     section_size_type view_size)
3383 {
3384   // leal foo(,%ebx,1),%eax; call ___tls_get_addr
3385   //  ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
3386   // leal foo(%ebx),%eax; call ___tls_get_addr; nop
3387   //  ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
3388
3389   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3390   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3391
3392   unsigned char op1 = view[-1];
3393   unsigned char op2 = view[-2];
3394
3395   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3396                  op2 == 0x8d || op2 == 0x04);
3397   tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
3398
3399   int roff;
3400
3401   if (op2 == 0x04)
3402     {
3403       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3404       tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3405       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3406                      ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
3407       roff = 5;
3408     }
3409   else
3410     {
3411       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 10);
3412       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3413                      (op1 & 0xf8) == 0x80 && (op1 & 7) != 4);
3414       tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[9] == 0x90);
3415       roff = 6;
3416     }
3417
3418   memcpy(view + roff - 8, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12);
3419   Relocate_functions<32, false>::rel32(view + roff, value);
3420
3421   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3422   // We can skip it.
3423   this->skip_call_tls_get_addr_ = true;
3424 }
3425
3426 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3427 // General-Dynamic to a Local-Exec.
3428
3429 inline void
3430 Target_i386::Relocate::tls_desc_gd_to_le(
3431     const Relocate_info<32, false>* relinfo,
3432     size_t relnum,
3433     Output_segment* tls_segment,
3434     const elfcpp::Rel<32, false>& rel,
3435     unsigned int r_type,
3436     elfcpp::Elf_types<32>::Elf_Addr value,
3437     unsigned char* view,
3438     section_size_type view_size)
3439 {
3440   if (r_type == elfcpp::R_386_TLS_GOTDESC)
3441     {
3442       // leal foo@TLSDESC(%ebx), %eax
3443       // ==> leal foo@NTPOFF, %eax
3444       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3445       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3446       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3447                      view[-2] == 0x8d && view[-1] == 0x83);
3448       view[-1] = 0x05;
3449       value -= tls_segment->memsz();
3450       Relocate_functions<32, false>::rel32(view, value);
3451     }
3452   else
3453     {
3454       // call *foo@TLSCALL(%eax)
3455       // ==> nop; nop
3456       gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3457       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3458       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3459                      view[0] == 0xff && view[1] == 0x10);
3460       view[0] = 0x66;
3461       view[1] = 0x90;
3462     }
3463 }
3464
3465 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3466 // General-Dynamic to an Initial-Exec.
3467
3468 inline void
3469 Target_i386::Relocate::tls_desc_gd_to_ie(
3470     const Relocate_info<32, false>* relinfo,
3471     size_t relnum,
3472     const elfcpp::Rel<32, false>& rel,
3473     unsigned int r_type,
3474     elfcpp::Elf_types<32>::Elf_Addr value,
3475     unsigned char* view,
3476     section_size_type view_size)
3477 {
3478   if (r_type == elfcpp::R_386_TLS_GOTDESC)
3479     {
3480       // leal foo@TLSDESC(%ebx), %eax
3481       // ==> movl foo@GOTNTPOFF(%ebx), %eax
3482       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3483       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3484       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3485                      view[-2] == 0x8d && view[-1] == 0x83);
3486       view[-2] = 0x8b;
3487       Relocate_functions<32, false>::rel32(view, value);
3488     }
3489   else
3490     {
3491       // call *foo@TLSCALL(%eax)
3492       // ==> nop; nop
3493       gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3494       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3495       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3496                      view[0] == 0xff && view[1] == 0x10);
3497       view[0] = 0x66;
3498       view[1] = 0x90;
3499     }
3500 }
3501
3502 // Do a relocation in which we convert a TLS Local-Dynamic to a
3503 // Local-Exec.
3504
3505 inline void
3506 Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo,
3507                                     size_t relnum,
3508                                     Output_segment*,
3509                                     const elfcpp::Rel<32, false>& rel,
3510                                     unsigned int,
3511                                     elfcpp::Elf_types<32>::Elf_Addr,
3512                                     unsigned char* view,
3513                                     section_size_type view_size)
3514 {
3515   // leal foo(%reg), %eax; call ___tls_get_addr
3516   // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi
3517
3518   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3519   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3520
3521   // FIXME: Does this test really always pass?
3522   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3523                  view[-2] == 0x8d && view[-1] == 0x83);
3524
3525   tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[4] == 0xe8);
3526
3527   memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11);
3528
3529   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3530   // We can skip it.
3531   this->skip_call_tls_get_addr_ = true;
3532 }
3533
3534 // Do a relocation in which we convert a TLS Initial-Exec to a
3535 // Local-Exec.
3536
3537 inline void
3538 Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo,
3539                                     size_t relnum,
3540                                     Output_segment* tls_segment,
3541                                     const elfcpp::Rel<32, false>& rel,
3542                                     unsigned int r_type,
3543                                     elfcpp::Elf_types<32>::Elf_Addr value,
3544                                     unsigned char* view,
3545                                     section_size_type view_size)
3546 {
3547   // We have to actually change the instructions, which means that we
3548   // need to examine the opcodes to figure out which instruction we
3549   // are looking at.
3550   if (r_type == elfcpp::R_386_TLS_IE)
3551     {
3552       // movl %gs:XX,%eax  ==>  movl $YY,%eax
3553       // movl %gs:XX,%reg  ==>  movl $YY,%reg
3554       // addl %gs:XX,%reg  ==>  addl $YY,%reg
3555       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1);
3556       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3557
3558       unsigned char op1 = view[-1];
3559       if (op1 == 0xa1)
3560         {
3561           // movl XX,%eax  ==>  movl $YY,%eax
3562           view[-1] = 0xb8;
3563         }
3564       else
3565         {
3566           tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3567
3568           unsigned char op2 = view[-2];
3569           if (op2 == 0x8b)
3570             {
3571               // movl XX,%reg  ==>  movl $YY,%reg
3572               tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3573                              (op1 & 0xc7) == 0x05);
3574               view[-2] = 0xc7;
3575               view[-1] = 0xc0 | ((op1 >> 3) & 7);
3576             }
3577           else if (op2 == 0x03)
3578             {
3579               // addl XX,%reg  ==>  addl $YY,%reg
3580               tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3581                              (op1 & 0xc7) == 0x05);
3582               view[-2] = 0x81;
3583               view[-1] = 0xc0 | ((op1 >> 3) & 7);
3584             }
3585           else
3586             tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3587         }
3588     }
3589   else
3590     {
3591       // subl %gs:XX(%reg1),%reg2  ==>  subl $YY,%reg2
3592       // movl %gs:XX(%reg1),%reg2  ==>  movl $YY,%reg2
3593       // addl %gs:XX(%reg1),%reg2  ==>  addl $YY,$reg2
3594       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3595       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3596
3597       unsigned char op1 = view[-1];
3598       unsigned char op2 = view[-2];
3599       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3600                      (op1 & 0xc0) == 0x80 && (op1 & 7) != 4);
3601       if (op2 == 0x8b)
3602         {
3603           // movl %gs:XX(%reg1),%reg2  ==>  movl $YY,%reg2
3604           view[-2] = 0xc7;
3605           view[-1] = 0xc0 | ((op1 >> 3) & 7);
3606         }
3607       else if (op2 == 0x2b)
3608         {
3609           // subl %gs:XX(%reg1),%reg2  ==>  subl $YY,%reg2
3610           view[-2] = 0x81;
3611           view[-1] = 0xe8 | ((op1 >> 3) & 7);
3612         }
3613       else if (op2 == 0x03)
3614         {
3615           // addl %gs:XX(%reg1),%reg2  ==>  addl $YY,$reg2
3616           view[-2] = 0x81;
3617           view[-1] = 0xc0 | ((op1 >> 3) & 7);
3618         }
3619       else
3620         tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3621     }
3622
3623   value = tls_segment->memsz() - value;
3624   if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE)
3625     value = - value;
3626
3627   Relocate_functions<32, false>::rel32(view, value);
3628 }
3629
3630 // Relocate section data.
3631
3632 void
3633 Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
3634                               unsigned int sh_type,
3635                               const unsigned char* prelocs,
3636                               size_t reloc_count,
3637                               Output_section* output_section,
3638                               bool needs_special_offset_handling,
3639                               unsigned char* view,
3640                               elfcpp::Elf_types<32>::Elf_Addr address,
3641                               section_size_type view_size,
3642                               const Reloc_symbol_changes* reloc_symbol_changes)
3643 {
3644   gold_assert(sh_type == elfcpp::SHT_REL);
3645
3646   gold::relocate_section<32, false, Target_i386, Relocate,
3647                          gold::Default_comdat_behavior, Classify_reloc>(
3648     relinfo,
3649     this,
3650     prelocs,
3651     reloc_count,
3652     output_section,
3653     needs_special_offset_handling,
3654     view,
3655     address,
3656     view_size,
3657     reloc_symbol_changes);
3658 }
3659
3660 // Return the size of a relocation while scanning during a relocatable
3661 // link.
3662
3663 unsigned int
3664 Target_i386::Classify_reloc::get_size_for_reloc(
3665     unsigned int r_type,
3666     Relobj* object)
3667 {
3668   switch (r_type)
3669     {
3670     case elfcpp::R_386_NONE:
3671     case elfcpp::R_386_GNU_VTINHERIT:
3672     case elfcpp::R_386_GNU_VTENTRY:
3673     case elfcpp::R_386_TLS_GD:            // Global-dynamic
3674     case elfcpp::R_386_TLS_GOTDESC:       // Global-dynamic (from ~oliva url)
3675     case elfcpp::R_386_TLS_DESC_CALL:
3676     case elfcpp::R_386_TLS_LDM:           // Local-dynamic
3677     case elfcpp::R_386_TLS_LDO_32:        // Alternate local-dynamic
3678     case elfcpp::R_386_TLS_IE:            // Initial-exec
3679     case elfcpp::R_386_TLS_IE_32:
3680     case elfcpp::R_386_TLS_GOTIE:
3681     case elfcpp::R_386_TLS_LE:            // Local-exec
3682     case elfcpp::R_386_TLS_LE_32:
3683       return 0;
3684
3685     case elfcpp::R_386_32:
3686     case elfcpp::R_386_PC32:
3687     case elfcpp::R_386_GOT32:
3688     case elfcpp::R_386_GOT32X:
3689     case elfcpp::R_386_PLT32:
3690     case elfcpp::R_386_GOTOFF:
3691     case elfcpp::R_386_GOTPC:
3692      return 4;
3693
3694     case elfcpp::R_386_16:
3695     case elfcpp::R_386_PC16:
3696       return 2;
3697
3698     case elfcpp::R_386_8:
3699     case elfcpp::R_386_PC8:
3700       return 1;
3701
3702       // These are relocations which should only be seen by the
3703       // dynamic linker, and should never be seen here.
3704     case elfcpp::R_386_COPY:
3705     case elfcpp::R_386_GLOB_DAT:
3706     case elfcpp::R_386_JUMP_SLOT:
3707     case elfcpp::R_386_RELATIVE:
3708     case elfcpp::R_386_IRELATIVE:
3709     case elfcpp::R_386_TLS_TPOFF:
3710     case elfcpp::R_386_TLS_DTPMOD32:
3711     case elfcpp::R_386_TLS_DTPOFF32:
3712     case elfcpp::R_386_TLS_TPOFF32:
3713     case elfcpp::R_386_TLS_DESC:
3714       object->error(_("unexpected reloc %u in object file"), r_type);
3715       return 0;
3716
3717     case elfcpp::R_386_32PLT:
3718     case elfcpp::R_386_TLS_GD_32:
3719     case elfcpp::R_386_TLS_GD_PUSH:
3720     case elfcpp::R_386_TLS_GD_CALL:
3721     case elfcpp::R_386_TLS_GD_POP:
3722     case elfcpp::R_386_TLS_LDM_32:
3723     case elfcpp::R_386_TLS_LDM_PUSH:
3724     case elfcpp::R_386_TLS_LDM_CALL:
3725     case elfcpp::R_386_TLS_LDM_POP:
3726     case elfcpp::R_386_USED_BY_INTEL_200:
3727     default:
3728       object->error(_("unsupported reloc %u in object file"), r_type);
3729       return 0;
3730     }
3731 }
3732
3733 // Scan the relocs during a relocatable link.
3734
3735 void
3736 Target_i386::scan_relocatable_relocs(Symbol_table* symtab,
3737                                      Layout* layout,
3738                                      Sized_relobj_file<32, false>* object,
3739                                      unsigned int data_shndx,
3740                                      unsigned int sh_type,
3741                                      const unsigned char* prelocs,
3742                                      size_t reloc_count,
3743                                      Output_section* output_section,
3744                                      bool needs_special_offset_handling,
3745                                      size_t local_symbol_count,
3746                                      const unsigned char* plocal_symbols,
3747                                      Relocatable_relocs* rr)
3748 {
3749   typedef gold::Default_scan_relocatable_relocs<Classify_reloc>
3750       Scan_relocatable_relocs;
3751
3752   gold_assert(sh_type == elfcpp::SHT_REL);
3753
3754   gold::scan_relocatable_relocs<32, false, Scan_relocatable_relocs>(
3755     symtab,
3756     layout,
3757     object,
3758     data_shndx,
3759     prelocs,
3760     reloc_count,
3761     output_section,
3762     needs_special_offset_handling,
3763     local_symbol_count,
3764     plocal_symbols,
3765     rr);
3766 }
3767
3768 // Scan the relocs for --emit-relocs.
3769
3770 void
3771 Target_i386::emit_relocs_scan(Symbol_table* symtab,
3772                               Layout* layout,
3773                               Sized_relobj_file<32, false>* object,
3774                               unsigned int data_shndx,
3775                               unsigned int sh_type,
3776                               const unsigned char* prelocs,
3777                               size_t reloc_count,
3778                               Output_section* output_section,
3779                               bool needs_special_offset_handling,
3780                               size_t local_symbol_count,
3781                               const unsigned char* plocal_syms,
3782                               Relocatable_relocs* rr)
3783 {
3784   typedef gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>
3785       Classify_reloc;
3786   typedef gold::Default_emit_relocs_strategy<Classify_reloc>
3787       Emit_relocs_strategy;
3788
3789   gold_assert(sh_type == elfcpp::SHT_REL);
3790
3791   gold::scan_relocatable_relocs<32, false, Emit_relocs_strategy>(
3792     symtab,
3793     layout,
3794     object,
3795     data_shndx,
3796     prelocs,
3797     reloc_count,
3798     output_section,
3799     needs_special_offset_handling,
3800     local_symbol_count,
3801     plocal_syms,
3802     rr);
3803 }
3804
3805 // Emit relocations for a section.
3806
3807 void
3808 Target_i386::relocate_relocs(
3809     const Relocate_info<32, false>* relinfo,
3810     unsigned int sh_type,
3811     const unsigned char* prelocs,
3812     size_t reloc_count,
3813     Output_section* output_section,
3814     elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,
3815     unsigned char* view,
3816     elfcpp::Elf_types<32>::Elf_Addr view_address,
3817     section_size_type view_size,
3818     unsigned char* reloc_view,
3819     section_size_type reloc_view_size)
3820 {
3821   gold_assert(sh_type == elfcpp::SHT_REL);
3822
3823   gold::relocate_relocs<32, false, Classify_reloc>(
3824     relinfo,
3825     prelocs,
3826     reloc_count,
3827     output_section,
3828     offset_in_output_section,
3829     view,
3830     view_address,
3831     view_size,
3832     reloc_view,
3833     reloc_view_size);
3834 }
3835
3836 // Return the value to use for a dynamic which requires special
3837 // treatment.  This is how we support equality comparisons of function
3838 // pointers across shared library boundaries, as described in the
3839 // processor specific ABI supplement.
3840
3841 uint64_t
3842 Target_i386::do_dynsym_value(const Symbol* gsym) const
3843 {
3844   gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3845   return this->plt_address_for_global(gsym);
3846 }
3847
3848 // Return a string used to fill a code section with nops to take up
3849 // the specified length.
3850
3851 std::string
3852 Target_i386::do_code_fill(section_size_type length) const
3853 {
3854   if (length >= 16)
3855     {
3856       // Build a jmp instruction to skip over the bytes.
3857       unsigned char jmp[5];
3858       jmp[0] = 0xe9;
3859       elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
3860       return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
3861               + std::string(length - 5, static_cast<char>(0x90)));
3862     }
3863
3864   // Nop sequences of various lengths.
3865   const char nop1[1] = { '\x90' };                   // nop
3866   const char nop2[2] = { '\x66', '\x90' };           // xchg %ax %ax
3867   const char nop3[3] = { '\x8d', '\x76', '\x00' };   // leal 0(%esi),%esi
3868   const char nop4[4] = { '\x8d', '\x74', '\x26',     // leal 0(%esi,1),%esi
3869                          '\x00'};
3870   const char nop5[5] = { '\x90', '\x8d', '\x74',     // nop
3871                          '\x26', '\x00' };           // leal 0(%esi,1),%esi
3872   const char nop6[6] = { '\x8d', '\xb6', '\x00',     // leal 0L(%esi),%esi
3873                          '\x00', '\x00', '\x00' };
3874   const char nop7[7] = { '\x8d', '\xb4', '\x26',     // leal 0L(%esi,1),%esi
3875                          '\x00', '\x00', '\x00',
3876                          '\x00' };
3877   const char nop8[8] = { '\x90', '\x8d', '\xb4',     // nop
3878                          '\x26', '\x00', '\x00',     // leal 0L(%esi,1),%esi
3879                          '\x00', '\x00' };
3880   const char nop9[9] = { '\x89', '\xf6', '\x8d',     // movl %esi,%esi
3881                          '\xbc', '\x27', '\x00',     // leal 0L(%edi,1),%edi
3882                          '\x00', '\x00', '\x00' };
3883   const char nop10[10] = { '\x8d', '\x76', '\x00',   // leal 0(%esi),%esi
3884                            '\x8d', '\xbc', '\x27',   // leal 0L(%edi,1),%edi
3885                            '\x00', '\x00', '\x00',
3886                            '\x00' };
3887   const char nop11[11] = { '\x8d', '\x74', '\x26',   // leal 0(%esi,1),%esi
3888                            '\x00', '\x8d', '\xbc',   // leal 0L(%edi,1),%edi
3889                            '\x27', '\x00', '\x00',
3890                            '\x00', '\x00' };
3891   const char nop12[12] = { '\x8d', '\xb6', '\x00',   // leal 0L(%esi),%esi
3892                            '\x00', '\x00', '\x00',   // leal 0L(%edi),%edi
3893                            '\x8d', '\xbf', '\x00',
3894                            '\x00', '\x00', '\x00' };
3895   const char nop13[13] = { '\x8d', '\xb6', '\x00',   // leal 0L(%esi),%esi
3896                            '\x00', '\x00', '\x00',   // leal 0L(%edi,1),%edi
3897                            '\x8d', '\xbc', '\x27',
3898                            '\x00', '\x00', '\x00',
3899                            '\x00' };
3900   const char nop14[14] = { '\x8d', '\xb4', '\x26',   // leal 0L(%esi,1),%esi
3901                            '\x00', '\x00', '\x00',   // leal 0L(%edi,1),%edi
3902                            '\x00', '\x8d', '\xbc',
3903                            '\x27', '\x00', '\x00',
3904                            '\x00', '\x00' };
3905   const char nop15[15] = { '\xeb', '\x0d', '\x90',   // jmp .+15
3906                            '\x90', '\x90', '\x90',   // nop,nop,nop,...
3907                            '\x90', '\x90', '\x90',
3908                            '\x90', '\x90', '\x90',
3909                            '\x90', '\x90', '\x90' };
3910
3911   const char* nops[16] = {
3912     NULL,
3913     nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3914     nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3915   };
3916
3917   return std::string(nops[length], length);
3918 }
3919
3920 // Return the value to use for the base of a DW_EH_PE_datarel offset
3921 // in an FDE.  Solaris and SVR4 use DW_EH_PE_datarel because their
3922 // assembler can not write out the difference between two labels in
3923 // different sections, so instead of using a pc-relative value they
3924 // use an offset from the GOT.
3925
3926 uint64_t
3927 Target_i386::do_ehframe_datarel_base() const
3928 {
3929   gold_assert(this->global_offset_table_ != NULL);
3930   Symbol* sym = this->global_offset_table_;
3931   Sized_symbol<32>* ssym = static_cast<Sized_symbol<32>*>(sym);
3932   return ssym->value();
3933 }
3934
3935 // Return whether SYM should be treated as a call to a non-split
3936 // function.  We don't want that to be true of a call to a
3937 // get_pc_thunk function.
3938
3939 bool
3940 Target_i386::do_is_call_to_non_split(const Symbol* sym,
3941                                      const unsigned char*,
3942                                      const unsigned char*,
3943                                      section_size_type) const
3944 {
3945   return (sym->type() == elfcpp::STT_FUNC
3946           && !is_prefix_of("__i686.get_pc_thunk.", sym->name()));
3947 }
3948
3949 // FNOFFSET in section SHNDX in OBJECT is the start of a function
3950 // compiled with -fsplit-stack.  The function calls non-split-stack
3951 // code.  We have to change the function so that it always ensures
3952 // that it has enough stack space to run some random function.
3953
3954 void
3955 Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx,
3956                                        section_offset_type fnoffset,
3957                                        section_size_type fnsize,
3958                                        const unsigned char*,
3959                                        size_t,
3960                                        unsigned char* view,
3961                                        section_size_type view_size,
3962                                        std::string* from,
3963                                        std::string* to) const
3964 {
3965   // The function starts with a comparison of the stack pointer and a
3966   // field in the TCB.  This is followed by a jump.
3967
3968   // cmp %gs:NN,%esp
3969   if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3)
3970       && fnsize > 7)
3971     {
3972       // We will call __morestack if the carry flag is set after this
3973       // comparison.  We turn the comparison into an stc instruction
3974       // and some nops.
3975       view[fnoffset] = '\xf9';
3976       this->set_view_to_nop(view, view_size, fnoffset + 1, 6);
3977     }
3978   // lea NN(%esp),%ecx
3979   // lea NN(%esp),%edx
3980   else if ((this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3)
3981             || this->match_view(view, view_size, fnoffset, "\x8d\x94\x24", 3))
3982            && fnsize > 7)
3983     {
3984       // This is loading an offset from the stack pointer for a
3985       // comparison.  The offset is negative, so we decrease the
3986       // offset by the amount of space we need for the stack.  This
3987       // means we will avoid calling __morestack if there happens to
3988       // be plenty of space on the stack already.
3989       unsigned char* pval = view + fnoffset + 3;
3990       uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
3991       val -= parameters->options().split_stack_adjust_size();
3992       elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
3993     }
3994   else
3995     {
3996       if (!object->has_no_split_stack())
3997         object->error(_("failed to match split-stack sequence at "
3998                         "section %u offset %0zx"),
3999                       shndx, static_cast<size_t>(fnoffset));
4000       return;
4001     }
4002
4003   // We have to change the function so that it calls
4004   // __morestack_non_split instead of __morestack.  The former will
4005   // allocate additional stack space.
4006   *from = "__morestack";
4007   *to = "__morestack_non_split";
4008 }
4009
4010 // The selector for i386 object files.  Note this is never instantiated
4011 // directly.  It's only used in Target_selector_i386_nacl, below.
4012
4013 class Target_selector_i386 : public Target_selector_freebsd
4014 {
4015 public:
4016   Target_selector_i386()
4017     : Target_selector_freebsd(elfcpp::EM_386, 32, false,
4018                               "elf32-i386", "elf32-i386-freebsd",
4019                               "elf_i386")
4020   { }
4021
4022   Target*
4023   do_instantiate_target()
4024   { return new Target_i386(); }
4025 };
4026
4027 // NaCl variant.  It uses different PLT contents.
4028
4029 class Output_data_plt_i386_nacl : public Output_data_plt_i386
4030 {
4031  public:
4032   Output_data_plt_i386_nacl(Layout* layout,
4033                             Output_data_got_plt_i386* got_plt,
4034                             Output_data_space* got_irelative)
4035     : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)
4036   { }
4037
4038  protected:
4039   virtual unsigned int
4040   do_get_plt_entry_size() const
4041   { return plt_entry_size; }
4042
4043   virtual void
4044   do_add_eh_frame(Layout* layout)
4045   {
4046     layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,
4047                                  plt_eh_frame_fde, plt_eh_frame_fde_size);
4048   }
4049
4050   // The size of an entry in the PLT.
4051   static const int plt_entry_size = 64;
4052
4053   // The .eh_frame unwind information for the PLT.
4054   static const int plt_eh_frame_fde_size = 32;
4055   static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4056 };
4057
4058 class Output_data_plt_i386_nacl_exec : public Output_data_plt_i386_nacl
4059 {
4060 public:
4061   Output_data_plt_i386_nacl_exec(Layout* layout,
4062                                  Output_data_got_plt_i386* got_plt,
4063                                  Output_data_space* got_irelative)
4064     : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4065   { }
4066
4067  protected:
4068   virtual void
4069   do_fill_first_plt_entry(unsigned char* pov,
4070                           elfcpp::Elf_types<32>::Elf_Addr got_address);
4071
4072   virtual unsigned int
4073   do_fill_plt_entry(unsigned char* pov,
4074                     elfcpp::Elf_types<32>::Elf_Addr got_address,
4075                     unsigned int got_offset,
4076                     unsigned int plt_offset,
4077                     unsigned int plt_rel_offset);
4078
4079  private:
4080   // The first entry in the PLT for an executable.
4081   static const unsigned char first_plt_entry[plt_entry_size];
4082
4083   // Other entries in the PLT for an executable.
4084   static const unsigned char plt_entry[plt_entry_size];
4085 };
4086
4087 class Output_data_plt_i386_nacl_dyn : public Output_data_plt_i386_nacl
4088 {
4089  public:
4090   Output_data_plt_i386_nacl_dyn(Layout* layout,
4091                                 Output_data_got_plt_i386* got_plt,
4092                                 Output_data_space* got_irelative)
4093     : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4094   { }
4095
4096  protected:
4097   virtual void
4098   do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);
4099
4100   virtual unsigned int
4101   do_fill_plt_entry(unsigned char* pov,
4102                     elfcpp::Elf_types<32>::Elf_Addr,
4103                     unsigned int got_offset,
4104                     unsigned int plt_offset,
4105                     unsigned int plt_rel_offset);
4106
4107  private:
4108   // The first entry in the PLT for a shared object.
4109   static const unsigned char first_plt_entry[plt_entry_size];
4110
4111   // Other entries in the PLT for a shared object.
4112   static const unsigned char plt_entry[plt_entry_size];
4113 };
4114
4115 class Target_i386_nacl : public Target_i386
4116 {
4117  public:
4118   Target_i386_nacl()
4119     : Target_i386(&i386_nacl_info)
4120   { }
4121
4122  protected:
4123   virtual Output_data_plt_i386*
4124   do_make_data_plt(Layout* layout,
4125                    Output_data_got_plt_i386* got_plt,
4126                    Output_data_space* got_irelative,
4127                    bool dyn)
4128   {
4129     if (dyn)
4130       return new Output_data_plt_i386_nacl_dyn(layout, got_plt, got_irelative);
4131     else
4132       return new Output_data_plt_i386_nacl_exec(layout, got_plt, got_irelative);
4133   }
4134
4135   virtual std::string
4136   do_code_fill(section_size_type length) const;
4137
4138  private:
4139   static const Target::Target_info i386_nacl_info;
4140 };
4141
4142 const Target::Target_info Target_i386_nacl::i386_nacl_info =
4143 {
4144   32,                   // size
4145   false,                // is_big_endian
4146   elfcpp::EM_386,       // machine_code
4147   false,                // has_make_symbol
4148   false,                // has_resolve
4149   true,                 // has_code_fill
4150   true,                 // is_default_stack_executable
4151   true,                 // can_icf_inline_merge_sections
4152   '\0',                 // wrap_char
4153   "/lib/ld-nacl-x86-32.so.1", // dynamic_linker
4154   0x20000,              // default_text_segment_address
4155   0x10000,              // abi_pagesize (overridable by -z max-page-size)
4156   0x10000,              // common_pagesize (overridable by -z common-page-size)
4157   true,                 // isolate_execinstr
4158   0x10000000,           // rosegment_gap
4159   elfcpp::SHN_UNDEF,    // small_common_shndx
4160   elfcpp::SHN_UNDEF,    // large_common_shndx
4161   0,                    // small_common_section_flags
4162   0,                    // large_common_section_flags
4163   NULL,                 // attributes_section
4164   NULL,                 // attributes_vendor
4165   "_start",             // entry_symbol_name
4166   32,                   // hash_entry_size
4167 };
4168
4169 #define NACLMASK        0xe0            // 32-byte alignment mask
4170
4171 const unsigned char
4172 Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] =
4173 {
4174   0xff, 0x35,                          // pushl contents of memory address
4175   0, 0, 0, 0,                          // replaced with address of .got + 4
4176   0x8b, 0x0d,                          // movl contents of address, %ecx
4177   0, 0, 0, 0,                          // replaced with address of .got + 8
4178   0x83, 0xe1, NACLMASK,                // andl $NACLMASK, %ecx
4179   0xff, 0xe1,                          // jmp *%ecx
4180   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4181   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4182   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4183   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4184   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4185   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4186   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4187   0x90, 0x90, 0x90, 0x90, 0x90
4188 };
4189
4190 void
4191 Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry(
4192     unsigned char* pov,
4193     elfcpp::Elf_types<32>::Elf_Addr got_address)
4194 {
4195   memcpy(pov, first_plt_entry, plt_entry_size);
4196   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
4197   elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
4198 }
4199
4200 // The first entry in the PLT for a shared object.
4201
4202 const unsigned char
4203 Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] =
4204 {
4205   0xff, 0xb3, 4, 0, 0, 0,       // pushl 4(%ebx)
4206   0x8b, 0x4b, 0x08,             // mov 0x8(%ebx), %ecx
4207   0x83, 0xe1, NACLMASK,         // andl $NACLMASK, %ecx
4208   0xff, 0xe1,                   // jmp *%ecx
4209   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4210   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4211   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4212   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4213   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4214   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4215   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4216   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4217   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
4218   0x90, 0x90, 0x90, 0x90, 0x90   // nops
4219 };
4220
4221 void
4222 Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry(
4223     unsigned char* pov,
4224     elfcpp::Elf_types<32>::Elf_Addr)
4225 {
4226   memcpy(pov, first_plt_entry, plt_entry_size);
4227 }
4228
4229 // Subsequent entries in the PLT for an executable.
4230
4231 const unsigned char
4232 Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] =
4233 {
4234   0x8b, 0x0d,                    // movl contents of address, %ecx */
4235   0, 0, 0, 0,                    // replaced with address of symbol in .got
4236   0x83, 0xe1, NACLMASK,          // andl $NACLMASK, %ecx
4237   0xff, 0xe1,                    // jmp *%ecx
4238
4239   // Pad to the next 32-byte boundary with nop instructions.
4240   0x90,
4241   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4242   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4243
4244   // Lazy GOT entries point here (32-byte aligned).
4245   0x68,                       // pushl immediate
4246   0, 0, 0, 0,                 // replaced with offset into relocation table
4247   0xe9,                       // jmp relative
4248   0, 0, 0, 0,                 // replaced with offset to start of .plt
4249
4250   // Pad to the next 32-byte boundary with nop instructions.
4251   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4252   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4253   0x90, 0x90
4254 };
4255
4256 unsigned int
4257 Output_data_plt_i386_nacl_exec::do_fill_plt_entry(
4258     unsigned char* pov,
4259     elfcpp::Elf_types<32>::Elf_Addr got_address,
4260     unsigned int got_offset,
4261     unsigned int plt_offset,
4262     unsigned int plt_rel_offset)
4263 {
4264   memcpy(pov, plt_entry, plt_entry_size);
4265   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4266                                               got_address + got_offset);
4267   elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4268   elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4269   return 32;
4270 }
4271
4272 // Subsequent entries in the PLT for a shared object.
4273
4274 const unsigned char
4275 Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] =
4276 {
4277   0x8b, 0x8b,          // movl offset(%ebx), %ecx
4278   0, 0, 0, 0,          // replaced with offset of symbol in .got
4279   0x83, 0xe1, 0xe0,    // andl $NACLMASK, %ecx
4280   0xff, 0xe1,          // jmp *%ecx
4281
4282   // Pad to the next 32-byte boundary with nop instructions.
4283   0x90,
4284   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4285   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4286
4287   // Lazy GOT entries point here (32-byte aligned).
4288   0x68,                // pushl immediate
4289   0, 0, 0, 0,          // replaced with offset into relocation table.
4290   0xe9,                // jmp relative
4291   0, 0, 0, 0,          // replaced with offset to start of .plt.
4292
4293   // Pad to the next 32-byte boundary with nop instructions.
4294   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4295   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4296   0x90, 0x90
4297 };
4298
4299 unsigned int
4300 Output_data_plt_i386_nacl_dyn::do_fill_plt_entry(
4301     unsigned char* pov,
4302     elfcpp::Elf_types<32>::Elf_Addr,
4303     unsigned int got_offset,
4304     unsigned int plt_offset,
4305     unsigned int plt_rel_offset)
4306 {
4307   memcpy(pov, plt_entry, plt_entry_size);
4308   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
4309   elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4310   elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4311   return 32;
4312 }
4313
4314 const unsigned char
4315 Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] =
4316 {
4317   0, 0, 0, 0,                           // Replaced with offset to .plt.
4318   0, 0, 0, 0,                           // Replaced with size of .plt.
4319   0,                                    // Augmentation size.
4320   elfcpp::DW_CFA_def_cfa_offset, 8,     // DW_CFA_def_cfa_offset: 8.
4321   elfcpp::DW_CFA_advance_loc + 6,       // Advance 6 to __PLT__ + 6.
4322   elfcpp::DW_CFA_def_cfa_offset, 12,    // DW_CFA_def_cfa_offset: 12.
4323   elfcpp::DW_CFA_advance_loc + 58,      // Advance 58 to __PLT__ + 64.
4324   elfcpp::DW_CFA_def_cfa_expression,    // DW_CFA_def_cfa_expression.
4325   13,                                   // Block length.
4326   elfcpp::DW_OP_breg4, 4,               // Push %esp + 4.
4327   elfcpp::DW_OP_breg8, 0,               // Push %eip.
4328   elfcpp::DW_OP_const1u, 63,            // Push 0x3f.
4329   elfcpp::DW_OP_and,                    // & (%eip & 0x3f).
4330   elfcpp::DW_OP_const1u, 37,            // Push 0x25.
4331   elfcpp::DW_OP_ge,                     // >= ((%eip & 0x3f) >= 0x25)
4332   elfcpp::DW_OP_lit2,                   // Push 2.
4333   elfcpp::DW_OP_shl,                    // << (((%eip & 0x3f) >= 0x25) << 2)
4334   elfcpp::DW_OP_plus,                   // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4
4335   elfcpp::DW_CFA_nop,                   // Align to 32 bytes.
4336   elfcpp::DW_CFA_nop
4337 };
4338
4339 // Return a string used to fill a code section with nops.
4340 // For NaCl, long NOPs are only valid if they do not cross
4341 // bundle alignment boundaries, so keep it simple with one-byte NOPs.
4342 std::string
4343 Target_i386_nacl::do_code_fill(section_size_type length) const
4344 {
4345   return std::string(length, static_cast<char>(0x90));
4346 }
4347
4348 // The selector for i386-nacl object files.
4349
4350 class Target_selector_i386_nacl
4351   : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl>
4352 {
4353  public:
4354   Target_selector_i386_nacl()
4355     : Target_selector_nacl<Target_selector_i386,
4356                            Target_i386_nacl>("x86-32",
4357                                              "elf32-i386-nacl",
4358                                              "elf_i386_nacl")
4359   { }
4360 };
4361
4362 Target_selector_i386_nacl target_selector_i386;
4363
4364 // IAMCU variant.  It uses EM_IAMCU, not EM_386.
4365
4366 class Target_iamcu : public Target_i386
4367 {
4368  public:
4369   Target_iamcu()
4370     : Target_i386(&iamcu_info)
4371   { }
4372
4373  private:
4374   // Information about this specific target which we pass to the
4375   // general Target structure.
4376   static const Target::Target_info iamcu_info;
4377 };
4378
4379 const Target::Target_info Target_iamcu::iamcu_info =
4380 {
4381   32,                   // size
4382   false,                // is_big_endian
4383   elfcpp::EM_IAMCU,     // machine_code
4384   false,                // has_make_symbol
4385   false,                // has_resolve
4386   true,                 // has_code_fill
4387   true,                 // is_default_stack_executable
4388   true,                 // can_icf_inline_merge_sections
4389   '\0',                 // wrap_char
4390   "/usr/lib/libc.so.1", // dynamic_linker
4391   0x08048000,           // default_text_segment_address
4392   0x1000,               // abi_pagesize (overridable by -z max-page-size)
4393   0x1000,               // common_pagesize (overridable by -z common-page-size)
4394   false,                // isolate_execinstr
4395   0,                    // rosegment_gap
4396   elfcpp::SHN_UNDEF,    // small_common_shndx
4397   elfcpp::SHN_UNDEF,    // large_common_shndx
4398   0,                    // small_common_section_flags
4399   0,                    // large_common_section_flags
4400   NULL,                 // attributes_section
4401   NULL,                 // attributes_vendor
4402   "_start",             // entry_symbol_name
4403   32,                   // hash_entry_size
4404 };
4405
4406 class Target_selector_iamcu : public Target_selector
4407 {
4408 public:
4409   Target_selector_iamcu()
4410     : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu",
4411                       "elf_iamcu")
4412   { }
4413
4414   Target*
4415   do_instantiate_target()
4416   { return new Target_iamcu(); }
4417 };
4418
4419 Target_selector_iamcu target_selector_iamcu;
4420
4421 } // End anonymous namespace.