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