gold/i386.cc

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