gold/i386.cc

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