gold/i386.cc

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