contrib/binutils-2.34/gold/i386.cc

   1 // i386.cc -- i386 target support for gold.
   2
   3 // Copyright (C) 2006-2020 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 reladdr;
2961         reladdr = target->got_plt_section()->address();
2962         Relocate_functions<32, false>::pcrel32(view, object, psymval, reladdr);
2963       }
2964       break;
2965
2966     case elfcpp::R_386_GOTPC:
2967       {
2968         elfcpp::Elf_types<32>::Elf_Addr value;
2969         value = target->got_plt_section()->address();
2970         Relocate_functions<32, false>::pcrel32(view, value, address);
2971       }
2972       break;
2973
2974     case elfcpp::R_386_COPY:
2975     case elfcpp::R_386_GLOB_DAT:
2976     case elfcpp::R_386_JUMP_SLOT:
2977     case elfcpp::R_386_RELATIVE:
2978     case elfcpp::R_386_IRELATIVE:
2979       // These are outstanding tls relocs, which are unexpected when
2980       // linking.
2981     case elfcpp::R_386_TLS_TPOFF:
2982     case elfcpp::R_386_TLS_DTPMOD32:
2983     case elfcpp::R_386_TLS_DTPOFF32:
2984     case elfcpp::R_386_TLS_TPOFF32:
2985     case elfcpp::R_386_TLS_DESC:
2986       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
2987                              _("unexpected reloc %u in object file"),
2988                              r_type);
2989       break;
2990
2991       // These are initial tls relocs, which are expected when
2992       // linking.
2993     case elfcpp::R_386_TLS_GD:             // Global-dynamic
2994     case elfcpp::R_386_TLS_GOTDESC:        // Global-dynamic (from ~oliva url)
2995     case elfcpp::R_386_TLS_DESC_CALL:
2996     case elfcpp::R_386_TLS_LDM:            // Local-dynamic
2997     case elfcpp::R_386_TLS_LDO_32:         // Alternate local-dynamic
2998     case elfcpp::R_386_TLS_IE:             // Initial-exec
2999     case elfcpp::R_386_TLS_IE_32:
3000     case elfcpp::R_386_TLS_GOTIE:
3001     case elfcpp::R_386_TLS_LE:             // Local-exec
3002     case elfcpp::R_386_TLS_LE_32:
3003       this->relocate_tls(relinfo, target, relnum, rel, r_type, gsym, psymval,
3004                          view, address, view_size);
3005       break;
3006
3007     case elfcpp::R_386_32PLT:
3008     case elfcpp::R_386_TLS_GD_32:
3009     case elfcpp::R_386_TLS_GD_PUSH:
3010     case elfcpp::R_386_TLS_GD_CALL:
3011     case elfcpp::R_386_TLS_GD_POP:
3012     case elfcpp::R_386_TLS_LDM_32:
3013     case elfcpp::R_386_TLS_LDM_PUSH:
3014     case elfcpp::R_386_TLS_LDM_CALL:
3015     case elfcpp::R_386_TLS_LDM_POP:
3016     case elfcpp::R_386_USED_BY_INTEL_200:
3017     default:
3018       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3019                              _("unsupported reloc %u"),
3020                              r_type);
3021       break;
3022     }
3023
3024   return true;
3025 }
3026
3027 // Perform a TLS relocation.
3028
3029 inline void
3030 Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
3031                                     Target_i386* target,
3032                                     size_t relnum,
3033                                     const elfcpp::Rel<32, false>& rel,
3034                                     unsigned int r_type,
3035                                     const Sized_symbol<32>* gsym,
3036                                     const Symbol_value<32>* psymval,
3037                                     unsigned char* view,
3038                                     elfcpp::Elf_types<32>::Elf_Addr,
3039                                     section_size_type view_size)
3040 {
3041   Output_segment* tls_segment = relinfo->layout->tls_segment();
3042
3043   const Sized_relobj_file<32, false>* object = relinfo->object;
3044
3045   elfcpp::Elf_types<32>::Elf_Addr value = psymval->value(object, 0);
3046
3047   const bool is_final = (gsym == NULL
3048                          ? !parameters->options().shared()
3049                          : gsym->final_value_is_known());
3050   const tls::Tls_optimization optimized_type
3051       = Target_i386::optimize_tls_reloc(is_final, r_type);
3052   switch (r_type)
3053     {
3054     case elfcpp::R_386_TLS_GD:           // Global-dynamic
3055       if (optimized_type == tls::TLSOPT_TO_LE)
3056         {
3057           if (tls_segment == NULL)
3058             {
3059               gold_assert(parameters->errors()->error_count() > 0
3060                           || issue_undefined_symbol_error(gsym));
3061               return;
3062             }
3063           this->tls_gd_to_le(relinfo, relnum, tls_segment,
3064                              rel, r_type, value, view,
3065                              view_size);
3066           break;
3067         }
3068       else
3069         {
3070           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3071                                    ? GOT_TYPE_TLS_NOFFSET
3072                                    : GOT_TYPE_TLS_PAIR);
3073           unsigned int got_offset;
3074           if (gsym != NULL)
3075             {
3076               gold_assert(gsym->has_got_offset(got_type));
3077               got_offset = gsym->got_offset(got_type) - target->got_size();
3078             }
3079           else
3080             {
3081               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3082               gold_assert(object->local_has_got_offset(r_sym, got_type));
3083               got_offset = (object->local_got_offset(r_sym, got_type)
3084                             - target->got_size());
3085             }
3086           if (optimized_type == tls::TLSOPT_TO_IE)
3087             {
3088               this->tls_gd_to_ie(relinfo, relnum, rel, r_type,
3089                                  got_offset, view, view_size);
3090               break;
3091             }
3092           else if (optimized_type == tls::TLSOPT_NONE)
3093             {
3094               // Relocate the field with the offset of the pair of GOT
3095               // entries.
3096               Relocate_functions<32, false>::rel32(view, got_offset);
3097               break;
3098             }
3099         }
3100       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3101                              _("unsupported reloc %u"),
3102                              r_type);
3103       break;
3104
3105     case elfcpp::R_386_TLS_GOTDESC:      // Global-dynamic (from ~oliva url)
3106     case elfcpp::R_386_TLS_DESC_CALL:
3107       this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
3108       if (optimized_type == tls::TLSOPT_TO_LE)
3109         {
3110           if (tls_segment == NULL)
3111             {
3112               gold_assert(parameters->errors()->error_count() > 0
3113                           || issue_undefined_symbol_error(gsym));
3114               return;
3115             }
3116           this->tls_desc_gd_to_le(relinfo, relnum, tls_segment,
3117                                   rel, r_type, value, view,
3118                                   view_size);
3119           break;
3120         }
3121       else
3122         {
3123           unsigned int got_type = (optimized_type == tls::TLSOPT_TO_IE
3124                                    ? GOT_TYPE_TLS_NOFFSET
3125                                    : GOT_TYPE_TLS_DESC);
3126           unsigned int got_offset = 0;
3127           if (r_type == elfcpp::R_386_TLS_GOTDESC
3128               && optimized_type == tls::TLSOPT_NONE)
3129             {
3130               // We created GOT entries in the .got.tlsdesc portion of
3131               // the .got.plt section, but the offset stored in the
3132               // symbol is the offset within .got.tlsdesc.
3133               got_offset = (target->got_size()
3134                             + target->got_plt_section()->data_size());
3135             }
3136           if (gsym != NULL)
3137             {
3138               gold_assert(gsym->has_got_offset(got_type));
3139               got_offset += gsym->got_offset(got_type) - target->got_size();
3140             }
3141           else
3142             {
3143               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3144               gold_assert(object->local_has_got_offset(r_sym, got_type));
3145               got_offset += (object->local_got_offset(r_sym, got_type)
3146                              - target->got_size());
3147             }
3148           if (optimized_type == tls::TLSOPT_TO_IE)
3149             {
3150               this->tls_desc_gd_to_ie(relinfo, relnum, rel, r_type,
3151                                       got_offset, view, view_size);
3152               break;
3153             }
3154           else if (optimized_type == tls::TLSOPT_NONE)
3155             {
3156               if (r_type == elfcpp::R_386_TLS_GOTDESC)
3157                 {
3158                   // Relocate the field with the offset of the pair of GOT
3159                   // entries.
3160                   Relocate_functions<32, false>::rel32(view, got_offset);
3161                 }
3162               break;
3163             }
3164         }
3165       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3166                              _("unsupported reloc %u"),
3167                              r_type);
3168       break;
3169
3170     case elfcpp::R_386_TLS_LDM:          // Local-dynamic
3171       if (this->local_dynamic_type_ == LOCAL_DYNAMIC_SUN)
3172         {
3173           gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3174                                  _("both SUN and GNU model "
3175                                    "TLS relocations"));
3176           break;
3177         }
3178       this->local_dynamic_type_ = LOCAL_DYNAMIC_GNU;
3179       if (optimized_type == tls::TLSOPT_TO_LE)
3180         {
3181           if (tls_segment == NULL)
3182             {
3183               gold_assert(parameters->errors()->error_count() > 0
3184                           || issue_undefined_symbol_error(gsym));
3185               return;
3186             }
3187           this->tls_ld_to_le(relinfo, relnum, tls_segment, rel, r_type,
3188                              value, view, view_size);
3189           break;
3190         }
3191       else if (optimized_type == tls::TLSOPT_NONE)
3192         {
3193           // Relocate the field with the offset of the GOT entry for
3194           // the module index.
3195           unsigned int got_offset;
3196           got_offset = (target->got_mod_index_entry(NULL, NULL, NULL)
3197                         - target->got_size());
3198           Relocate_functions<32, false>::rel32(view, got_offset);
3199           break;
3200         }
3201       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3202                              _("unsupported reloc %u"),
3203                              r_type);
3204       break;
3205
3206     case elfcpp::R_386_TLS_LDO_32:       // Alternate local-dynamic
3207       if (optimized_type == tls::TLSOPT_TO_LE)
3208         {
3209           // This reloc can appear in debugging sections, in which
3210           // case we must not convert to local-exec.  We decide what
3211           // to do based on whether the section is marked as
3212           // containing executable code.  That is what the GNU linker
3213           // does as well.
3214           elfcpp::Shdr<32, false> shdr(relinfo->data_shdr);
3215           if ((shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0)
3216             {
3217               if (tls_segment == NULL)
3218                 {
3219                   gold_assert(parameters->errors()->error_count() > 0
3220                               || issue_undefined_symbol_error(gsym));
3221                   return;
3222                 }
3223               value -= tls_segment->memsz();
3224             }
3225         }
3226       Relocate_functions<32, false>::rel32(view, value);
3227       break;
3228
3229     case elfcpp::R_386_TLS_IE:           // Initial-exec
3230     case elfcpp::R_386_TLS_GOTIE:
3231     case elfcpp::R_386_TLS_IE_32:
3232       if (optimized_type == tls::TLSOPT_TO_LE)
3233         {
3234           if (tls_segment == NULL)
3235             {
3236               gold_assert(parameters->errors()->error_count() > 0
3237                           || issue_undefined_symbol_error(gsym));
3238               return;
3239             }
3240           Target_i386::Relocate::tls_ie_to_le(relinfo, relnum, tls_segment,
3241                                               rel, r_type, value, view,
3242                                               view_size);
3243           break;
3244         }
3245       else if (optimized_type == tls::TLSOPT_NONE)
3246         {
3247           // Relocate the field with the offset of the GOT entry for
3248           // the tp-relative offset of the symbol.
3249           unsigned int got_type = (r_type == elfcpp::R_386_TLS_IE_32
3250                                    ? GOT_TYPE_TLS_OFFSET
3251                                    : GOT_TYPE_TLS_NOFFSET);
3252           unsigned int got_offset;
3253           if (gsym != NULL)
3254             {
3255               gold_assert(gsym->has_got_offset(got_type));
3256               got_offset = gsym->got_offset(got_type);
3257             }
3258           else
3259             {
3260               unsigned int r_sym = elfcpp::elf_r_sym<32>(rel.get_r_info());
3261               gold_assert(object->local_has_got_offset(r_sym, got_type));
3262               got_offset = object->local_got_offset(r_sym, got_type);
3263             }
3264           // For the R_386_TLS_IE relocation, we need to apply the
3265           // absolute address of the GOT entry.
3266           if (r_type == elfcpp::R_386_TLS_IE)
3267             got_offset += target->got_plt_section()->address();
3268           // All GOT offsets are relative to the end of the GOT.
3269           got_offset -= target->got_size();
3270           Relocate_functions<32, false>::rel32(view, got_offset);
3271           break;
3272         }
3273       gold_error_at_location(relinfo, relnum, rel.get_r_offset(),
3274                              _("unsupported reloc %u"),
3275                              r_type);
3276       break;
3277
3278     case elfcpp::R_386_TLS_LE:           // Local-exec
3279       // If we're creating a shared library, a dynamic relocation will
3280       // have been created for this location, so do not apply it now.
3281       if (!parameters->options().shared())
3282         {
3283           if (tls_segment == NULL)
3284             {
3285               gold_assert(parameters->errors()->error_count() > 0
3286                           || issue_undefined_symbol_error(gsym));
3287               return;
3288             }
3289           value -= tls_segment->memsz();
3290           Relocate_functions<32, false>::rel32(view, value);
3291         }
3292       break;
3293
3294     case elfcpp::R_386_TLS_LE_32:
3295       // If we're creating a shared library, a dynamic relocation will
3296       // have been created for this location, so do not apply it now.
3297       if (!parameters->options().shared())
3298         {
3299           if (tls_segment == NULL)
3300             {
3301               gold_assert(parameters->errors()->error_count() > 0
3302                           || issue_undefined_symbol_error(gsym));
3303               return;
3304             }
3305           value = tls_segment->memsz() - value;
3306           Relocate_functions<32, false>::rel32(view, value);
3307         }
3308       break;
3309     }
3310 }
3311
3312 // Do a relocation in which we convert a TLS General-Dynamic to a
3313 // Local-Exec.
3314
3315 inline void
3316 Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo,
3317                                     size_t relnum,
3318                                     Output_segment* tls_segment,
3319                                     const elfcpp::Rel<32, false>& rel,
3320                                     unsigned int,
3321                                     elfcpp::Elf_types<32>::Elf_Addr value,
3322                                     unsigned char* view,
3323                                     section_size_type view_size)
3324 {
3325   // leal foo(,%ebx,1),%eax; call ___tls_get_addr@PLT
3326   //  ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3327   // leal foo(%ebx),%eax; call ___tls_get_addr@PLT
3328   //  ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3329   // leal foo(%reg),%eax; call *___tls_get_addr@GOT(%reg)
3330   //  ==> movl %gs:0,%eax; subl $foo@tpoff,%eax
3331
3332   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3333   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3334
3335   unsigned char op1 = view[-1];
3336   unsigned char op2 = view[-2];
3337   unsigned char op3 = view[4];
3338
3339   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3340                  op2 == 0x8d || op2 == 0x04);
3341   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3342                  op3 == 0xe8 || op3 == 0xff);
3343
3344   int roff = 5;
3345
3346   if (op2 == 0x04)
3347     {
3348       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3349       tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3350       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3351                      ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
3352       memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3353     }
3354   else
3355     {
3356       unsigned char reg = op1 & 7;
3357       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3358                      ((op1 & 0xf8) == 0x80
3359                       && reg != 4
3360                       && reg != 0
3361                       && (op3 == 0xe8 || (view[5] & 0x7) == reg)));
3362       if (op3 == 0xff
3363           || (rel.get_r_offset() + 9 < view_size
3364               && view[9] == 0x90))
3365         {
3366           // There is an indirect call or a trailing nop.  Use the size
3367           // byte subl.
3368           memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12);
3369           roff = 6;
3370         }
3371       else
3372         {
3373           // Use the five byte subl.
3374           memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11);
3375         }
3376     }
3377
3378   value = tls_segment->memsz() - value;
3379   Relocate_functions<32, false>::rel32(view + roff, value);
3380
3381   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3382   // We can skip it.
3383   this->skip_call_tls_get_addr_ = true;
3384 }
3385
3386 // Do a relocation in which we convert a TLS General-Dynamic to an
3387 // Initial-Exec.
3388
3389 inline void
3390 Target_i386::Relocate::tls_gd_to_ie(const Relocate_info<32, false>* relinfo,
3391                                     size_t relnum,
3392                                     const elfcpp::Rel<32, false>& rel,
3393                                     unsigned int,
3394                                     elfcpp::Elf_types<32>::Elf_Addr value,
3395                                     unsigned char* view,
3396                                     section_size_type view_size)
3397 {
3398   // leal foo(,%ebx,1),%eax; call ___tls_get_addr@PLT
3399   //  ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
3400   // leal foo(%ebx),%eax; call ___tls_get_addr@PLT; nop
3401   //  ==> movl %gs:0,%eax; addl foo@gotntpoff(%ebx),%eax
3402   // leal foo(%reg),%eax; call *___tls_get_addr@GOT(%reg)
3403   //  ==> movl %gs:0,%eax; addl foo@gotntpoff(%reg),%eax
3404
3405   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3406   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 9);
3407
3408   unsigned char op1 = view[-1];
3409   unsigned char op2 = view[-2];
3410   unsigned char op3 = view[4];
3411
3412   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3413                  op2 == 0x8d || op2 == 0x04);
3414   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3415                  op3 == 0xe8 || op3 == 0xff);
3416
3417   int roff;
3418
3419   if (op2 == 0x04)
3420     {
3421       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -3);
3422       tls::check_tls(relinfo, relnum, rel.get_r_offset(), view[-3] == 0x8d);
3423       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3424                      ((op1 & 0xc7) == 0x05 && op1 != (4 << 3)));
3425       roff = 5;
3426     }
3427   else
3428     {
3429       unsigned char reg = op1 & 7;
3430       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 10);
3431       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3432                      ((op1 & 0xf8) == 0x80
3433                       && reg != 4
3434                       && reg != 0
3435                       && ((op3 == 0xe8 && view[9] == 0x90)
3436                            || (view[5] & 0x7) == reg)));
3437       roff = 6;
3438     }
3439
3440   memcpy(view + roff - 8, "\x65\xa1\0\0\0\0\x03\x83\0\0\0", 12);
3441   Relocate_functions<32, false>::rel32(view + roff, value);
3442
3443   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3444   // We can skip it.
3445   this->skip_call_tls_get_addr_ = true;
3446 }
3447
3448 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3449 // General-Dynamic to a Local-Exec.
3450
3451 inline void
3452 Target_i386::Relocate::tls_desc_gd_to_le(
3453     const Relocate_info<32, false>* relinfo,
3454     size_t relnum,
3455     Output_segment* tls_segment,
3456     const elfcpp::Rel<32, false>& rel,
3457     unsigned int r_type,
3458     elfcpp::Elf_types<32>::Elf_Addr value,
3459     unsigned char* view,
3460     section_size_type view_size)
3461 {
3462   if (r_type == elfcpp::R_386_TLS_GOTDESC)
3463     {
3464       // leal foo@TLSDESC(%ebx), %eax
3465       // ==> leal foo@NTPOFF, %eax
3466       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3467       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3468       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3469                      view[-2] == 0x8d && view[-1] == 0x83);
3470       view[-1] = 0x05;
3471       value -= tls_segment->memsz();
3472       Relocate_functions<32, false>::rel32(view, value);
3473     }
3474   else
3475     {
3476       // call *foo@TLSCALL(%eax)
3477       // ==> nop; nop
3478       gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3479       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3480       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3481                      view[0] == 0xff && view[1] == 0x10);
3482       view[0] = 0x66;
3483       view[1] = 0x90;
3484     }
3485 }
3486
3487 // Do a relocation in which we convert a TLS_GOTDESC or TLS_DESC_CALL
3488 // General-Dynamic to an Initial-Exec.
3489
3490 inline void
3491 Target_i386::Relocate::tls_desc_gd_to_ie(
3492     const Relocate_info<32, false>* relinfo,
3493     size_t relnum,
3494     const elfcpp::Rel<32, false>& rel,
3495     unsigned int r_type,
3496     elfcpp::Elf_types<32>::Elf_Addr value,
3497     unsigned char* view,
3498     section_size_type view_size)
3499 {
3500   if (r_type == elfcpp::R_386_TLS_GOTDESC)
3501     {
3502       // leal foo@TLSDESC(%ebx), %eax
3503       // ==> movl foo@GOTNTPOFF(%ebx), %eax
3504       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3505       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3506       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3507                      view[-2] == 0x8d && view[-1] == 0x83);
3508       view[-2] = 0x8b;
3509       Relocate_functions<32, false>::rel32(view, value);
3510     }
3511   else
3512     {
3513       // call *foo@TLSCALL(%eax)
3514       // ==> nop; nop
3515       gold_assert(r_type == elfcpp::R_386_TLS_DESC_CALL);
3516       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 2);
3517       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3518                      view[0] == 0xff && view[1] == 0x10);
3519       view[0] = 0x66;
3520       view[1] = 0x90;
3521     }
3522 }
3523
3524 // Do a relocation in which we convert a TLS Local-Dynamic to a
3525 // Local-Exec.
3526
3527 inline void
3528 Target_i386::Relocate::tls_ld_to_le(const Relocate_info<32, false>* relinfo,
3529                                     size_t relnum,
3530                                     Output_segment*,
3531                                     const elfcpp::Rel<32, false>& rel,
3532                                     unsigned int,
3533                                     elfcpp::Elf_types<32>::Elf_Addr,
3534                                     unsigned char* view,
3535                                     section_size_type view_size)
3536 {
3537   // leal foo(%ebx), %eax; call ___tls_get_addr@PLT
3538   // ==> movl %gs:0,%eax; nop; leal 0(%esi,1),%esi
3539   // leal foo(%reg), %eax; call call *___tls_get_addr@GOT(%reg)
3540   // ==> movl %gs:0,%eax; leal (%esi),%esi
3541
3542   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3543
3544   unsigned char op1 = view[-1];
3545   unsigned char op2 = view[-2];
3546   unsigned char op3 = view[4];
3547
3548   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3549                  op3 == 0xe8 || op3 == 0xff);
3550   tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size,
3551                    op3 == 0xe8 ? 9 : 10);
3552
3553   // FIXME: Does this test really always pass?
3554   tls::check_tls(relinfo, relnum, rel.get_r_offset(), op2 == 0x8d);
3555
3556   unsigned char reg = op1 & 7;
3557   tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3558                  ((op1 & 0xf8) == 0x80
3559                   && reg != 4
3560                   && reg != 0
3561                   && (op3 == 0xe8 || (view[5] & 0x7) == reg)));
3562
3563   if (op3 == 0xe8)
3564     memcpy(view - 2, "\x65\xa1\0\0\0\0\x90\x8d\x74\x26\0", 11);
3565   else
3566     memcpy(view - 2, "\x65\xa1\0\0\0\0\x8d\xb6\0\0\0\0", 12);
3567
3568   // The next reloc should be a PLT32 reloc against __tls_get_addr.
3569   // We can skip it.
3570   this->skip_call_tls_get_addr_ = true;
3571 }
3572
3573 // Do a relocation in which we convert a TLS Initial-Exec to a
3574 // Local-Exec.
3575
3576 inline void
3577 Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo,
3578                                     size_t relnum,
3579                                     Output_segment* tls_segment,
3580                                     const elfcpp::Rel<32, false>& rel,
3581                                     unsigned int r_type,
3582                                     elfcpp::Elf_types<32>::Elf_Addr value,
3583                                     unsigned char* view,
3584                                     section_size_type view_size)
3585 {
3586   // We have to actually change the instructions, which means that we
3587   // need to examine the opcodes to figure out which instruction we
3588   // are looking at.
3589   if (r_type == elfcpp::R_386_TLS_IE)
3590     {
3591       // movl %gs:XX,%eax  ==>  movl $YY,%eax
3592       // movl %gs:XX,%reg  ==>  movl $YY,%reg
3593       // addl %gs:XX,%reg  ==>  addl $YY,%reg
3594       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -1);
3595       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3596
3597       unsigned char op1 = view[-1];
3598       if (op1 == 0xa1)
3599         {
3600           // movl XX,%eax  ==>  movl $YY,%eax
3601           view[-1] = 0xb8;
3602         }
3603       else
3604         {
3605           tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3606
3607           unsigned char op2 = view[-2];
3608           if (op2 == 0x8b)
3609             {
3610               // movl XX,%reg  ==>  movl $YY,%reg
3611               tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3612                              (op1 & 0xc7) == 0x05);
3613               view[-2] = 0xc7;
3614               view[-1] = 0xc0 | ((op1 >> 3) & 7);
3615             }
3616           else if (op2 == 0x03)
3617             {
3618               // addl XX,%reg  ==>  addl $YY,%reg
3619               tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3620                              (op1 & 0xc7) == 0x05);
3621               view[-2] = 0x81;
3622               view[-1] = 0xc0 | ((op1 >> 3) & 7);
3623             }
3624           else
3625             tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3626         }
3627     }
3628   else
3629     {
3630       // subl %gs:XX(%reg1),%reg2  ==>  subl $YY,%reg2
3631       // movl %gs:XX(%reg1),%reg2  ==>  movl $YY,%reg2
3632       // addl %gs:XX(%reg1),%reg2  ==>  addl $YY,$reg2
3633       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, -2);
3634       tls::check_range(relinfo, relnum, rel.get_r_offset(), view_size, 4);
3635
3636       unsigned char op1 = view[-1];
3637       unsigned char op2 = view[-2];
3638       tls::check_tls(relinfo, relnum, rel.get_r_offset(),
3639                      (op1 & 0xc0) == 0x80 && (op1 & 7) != 4);
3640       if (op2 == 0x8b)
3641         {
3642           // movl %gs:XX(%reg1),%reg2  ==>  movl $YY,%reg2
3643           view[-2] = 0xc7;
3644           view[-1] = 0xc0 | ((op1 >> 3) & 7);
3645         }
3646       else if (op2 == 0x2b)
3647         {
3648           // subl %gs:XX(%reg1),%reg2  ==>  subl $YY,%reg2
3649           view[-2] = 0x81;
3650           view[-1] = 0xe8 | ((op1 >> 3) & 7);
3651         }
3652       else if (op2 == 0x03)
3653         {
3654           // addl %gs:XX(%reg1),%reg2  ==>  addl $YY,$reg2
3655           view[-2] = 0x81;
3656           view[-1] = 0xc0 | ((op1 >> 3) & 7);
3657         }
3658       else
3659         tls::check_tls(relinfo, relnum, rel.get_r_offset(), 0);
3660     }
3661
3662   value = tls_segment->memsz() - value;
3663   if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE)
3664     value = - value;
3665
3666   Relocate_functions<32, false>::rel32(view, value);
3667 }
3668
3669 // Relocate section data.
3670
3671 void
3672 Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
3673                               unsigned int sh_type,
3674                               const unsigned char* prelocs,
3675                               size_t reloc_count,
3676                               Output_section* output_section,
3677                               bool needs_special_offset_handling,
3678                               unsigned char* view,
3679                               elfcpp::Elf_types<32>::Elf_Addr address,
3680                               section_size_type view_size,
3681                               const Reloc_symbol_changes* reloc_symbol_changes)
3682 {
3683   gold_assert(sh_type == elfcpp::SHT_REL);
3684
3685   gold::relocate_section<32, false, Target_i386, Relocate,
3686                          gold::Default_comdat_behavior, Classify_reloc>(
3687     relinfo,
3688     this,
3689     prelocs,
3690     reloc_count,
3691     output_section,
3692     needs_special_offset_handling,
3693     view,
3694     address,
3695     view_size,
3696     reloc_symbol_changes);
3697 }
3698
3699 // Return the size of a relocation while scanning during a relocatable
3700 // link.
3701
3702 unsigned int
3703 Target_i386::Classify_reloc::get_size_for_reloc(
3704     unsigned int r_type,
3705     Relobj* object)
3706 {
3707   switch (r_type)
3708     {
3709     case elfcpp::R_386_NONE:
3710     case elfcpp::R_386_GNU_VTINHERIT:
3711     case elfcpp::R_386_GNU_VTENTRY:
3712     case elfcpp::R_386_TLS_GD:            // Global-dynamic
3713     case elfcpp::R_386_TLS_GOTDESC:       // Global-dynamic (from ~oliva url)
3714     case elfcpp::R_386_TLS_DESC_CALL:
3715     case elfcpp::R_386_TLS_LDM:           // Local-dynamic
3716     case elfcpp::R_386_TLS_LDO_32:        // Alternate local-dynamic
3717     case elfcpp::R_386_TLS_IE:            // Initial-exec
3718     case elfcpp::R_386_TLS_IE_32:
3719     case elfcpp::R_386_TLS_GOTIE:
3720     case elfcpp::R_386_TLS_LE:            // Local-exec
3721     case elfcpp::R_386_TLS_LE_32:
3722       return 0;
3723
3724     case elfcpp::R_386_32:
3725     case elfcpp::R_386_PC32:
3726     case elfcpp::R_386_GOT32:
3727     case elfcpp::R_386_GOT32X:
3728     case elfcpp::R_386_PLT32:
3729     case elfcpp::R_386_GOTOFF:
3730     case elfcpp::R_386_GOTPC:
3731      return 4;
3732
3733     case elfcpp::R_386_16:
3734     case elfcpp::R_386_PC16:
3735       return 2;
3736
3737     case elfcpp::R_386_8:
3738     case elfcpp::R_386_PC8:
3739       return 1;
3740
3741       // These are relocations which should only be seen by the
3742       // dynamic linker, and should never be seen here.
3743     case elfcpp::R_386_COPY:
3744     case elfcpp::R_386_GLOB_DAT:
3745     case elfcpp::R_386_JUMP_SLOT:
3746     case elfcpp::R_386_RELATIVE:
3747     case elfcpp::R_386_IRELATIVE:
3748     case elfcpp::R_386_TLS_TPOFF:
3749     case elfcpp::R_386_TLS_DTPMOD32:
3750     case elfcpp::R_386_TLS_DTPOFF32:
3751     case elfcpp::R_386_TLS_TPOFF32:
3752     case elfcpp::R_386_TLS_DESC:
3753       object->error(_("unexpected reloc %u in object file"), r_type);
3754       return 0;
3755
3756     case elfcpp::R_386_32PLT:
3757     case elfcpp::R_386_TLS_GD_32:
3758     case elfcpp::R_386_TLS_GD_PUSH:
3759     case elfcpp::R_386_TLS_GD_CALL:
3760     case elfcpp::R_386_TLS_GD_POP:
3761     case elfcpp::R_386_TLS_LDM_32:
3762     case elfcpp::R_386_TLS_LDM_PUSH:
3763     case elfcpp::R_386_TLS_LDM_CALL:
3764     case elfcpp::R_386_TLS_LDM_POP:
3765     case elfcpp::R_386_USED_BY_INTEL_200:
3766     default:
3767       object->error(_("unsupported reloc %u in object file"), r_type);
3768       return 0;
3769     }
3770 }
3771
3772 // Scan the relocs during a relocatable link.
3773
3774 void
3775 Target_i386::scan_relocatable_relocs(Symbol_table* symtab,
3776                                      Layout* layout,
3777                                      Sized_relobj_file<32, false>* object,
3778                                      unsigned int data_shndx,
3779                                      unsigned int sh_type,
3780                                      const unsigned char* prelocs,
3781                                      size_t reloc_count,
3782                                      Output_section* output_section,
3783                                      bool needs_special_offset_handling,
3784                                      size_t local_symbol_count,
3785                                      const unsigned char* plocal_symbols,
3786                                      Relocatable_relocs* rr)
3787 {
3788   typedef gold::Default_scan_relocatable_relocs<Classify_reloc>
3789       Scan_relocatable_relocs;
3790
3791   gold_assert(sh_type == elfcpp::SHT_REL);
3792
3793   gold::scan_relocatable_relocs<32, false, Scan_relocatable_relocs>(
3794     symtab,
3795     layout,
3796     object,
3797     data_shndx,
3798     prelocs,
3799     reloc_count,
3800     output_section,
3801     needs_special_offset_handling,
3802     local_symbol_count,
3803     plocal_symbols,
3804     rr);
3805 }
3806
3807 // Scan the relocs for --emit-relocs.
3808
3809 void
3810 Target_i386::emit_relocs_scan(Symbol_table* symtab,
3811                               Layout* layout,
3812                               Sized_relobj_file<32, false>* object,
3813                               unsigned int data_shndx,
3814                               unsigned int sh_type,
3815                               const unsigned char* prelocs,
3816                               size_t reloc_count,
3817                               Output_section* output_section,
3818                               bool needs_special_offset_handling,
3819                               size_t local_symbol_count,
3820                               const unsigned char* plocal_syms,
3821                               Relocatable_relocs* rr)
3822 {
3823   typedef gold::Default_classify_reloc<elfcpp::SHT_REL, 32, false>
3824       Classify_reloc;
3825   typedef gold::Default_emit_relocs_strategy<Classify_reloc>
3826       Emit_relocs_strategy;
3827
3828   gold_assert(sh_type == elfcpp::SHT_REL);
3829
3830   gold::scan_relocatable_relocs<32, false, Emit_relocs_strategy>(
3831     symtab,
3832     layout,
3833     object,
3834     data_shndx,
3835     prelocs,
3836     reloc_count,
3837     output_section,
3838     needs_special_offset_handling,
3839     local_symbol_count,
3840     plocal_syms,
3841     rr);
3842 }
3843
3844 // Emit relocations for a section.
3845
3846 void
3847 Target_i386::relocate_relocs(
3848     const Relocate_info<32, false>* relinfo,
3849     unsigned int sh_type,
3850     const unsigned char* prelocs,
3851     size_t reloc_count,
3852     Output_section* output_section,
3853     elfcpp::Elf_types<32>::Elf_Off offset_in_output_section,
3854     unsigned char* view,
3855     elfcpp::Elf_types<32>::Elf_Addr view_address,
3856     section_size_type view_size,
3857     unsigned char* reloc_view,
3858     section_size_type reloc_view_size)
3859 {
3860   gold_assert(sh_type == elfcpp::SHT_REL);
3861
3862   gold::relocate_relocs<32, false, Classify_reloc>(
3863     relinfo,
3864     prelocs,
3865     reloc_count,
3866     output_section,
3867     offset_in_output_section,
3868     view,
3869     view_address,
3870     view_size,
3871     reloc_view,
3872     reloc_view_size);
3873 }
3874
3875 // Return the value to use for a dynamic which requires special
3876 // treatment.  This is how we support equality comparisons of function
3877 // pointers across shared library boundaries, as described in the
3878 // processor specific ABI supplement.
3879
3880 uint64_t
3881 Target_i386::do_dynsym_value(const Symbol* gsym) const
3882 {
3883   gold_assert(gsym->is_from_dynobj() && gsym->has_plt_offset());
3884   return this->plt_address_for_global(gsym);
3885 }
3886
3887 // Return a string used to fill a code section with nops to take up
3888 // the specified length.
3889
3890 std::string
3891 Target_i386::do_code_fill(section_size_type length) const
3892 {
3893   if (length >= 16)
3894     {
3895       // Build a jmp instruction to skip over the bytes.
3896       unsigned char jmp[5];
3897       jmp[0] = 0xe9;
3898       elfcpp::Swap_unaligned<32, false>::writeval(jmp + 1, length - 5);
3899       return (std::string(reinterpret_cast<char*>(&jmp[0]), 5)
3900               + std::string(length - 5, static_cast<char>(0x90)));
3901     }
3902
3903   // Nop sequences of various lengths.
3904   const char nop1[1] = { '\x90' };                   // nop
3905   const char nop2[2] = { '\x66', '\x90' };           // xchg %ax %ax
3906   const char nop3[3] = { '\x8d', '\x76', '\x00' };   // leal 0(%esi),%esi
3907   const char nop4[4] = { '\x8d', '\x74', '\x26',     // leal 0(%esi,1),%esi
3908                          '\x00'};
3909   const char nop5[5] = { '\x90', '\x8d', '\x74',     // nop
3910                          '\x26', '\x00' };           // leal 0(%esi,1),%esi
3911   const char nop6[6] = { '\x8d', '\xb6', '\x00',     // leal 0L(%esi),%esi
3912                          '\x00', '\x00', '\x00' };
3913   const char nop7[7] = { '\x8d', '\xb4', '\x26',     // leal 0L(%esi,1),%esi
3914                          '\x00', '\x00', '\x00',
3915                          '\x00' };
3916   const char nop8[8] = { '\x90', '\x8d', '\xb4',     // nop
3917                          '\x26', '\x00', '\x00',     // leal 0L(%esi,1),%esi
3918                          '\x00', '\x00' };
3919   const char nop9[9] = { '\x89', '\xf6', '\x8d',     // movl %esi,%esi
3920                          '\xbc', '\x27', '\x00',     // leal 0L(%edi,1),%edi
3921                          '\x00', '\x00', '\x00' };
3922   const char nop10[10] = { '\x8d', '\x76', '\x00',   // leal 0(%esi),%esi
3923                            '\x8d', '\xbc', '\x27',   // leal 0L(%edi,1),%edi
3924                            '\x00', '\x00', '\x00',
3925                            '\x00' };
3926   const char nop11[11] = { '\x8d', '\x74', '\x26',   // leal 0(%esi,1),%esi
3927                            '\x00', '\x8d', '\xbc',   // leal 0L(%edi,1),%edi
3928                            '\x27', '\x00', '\x00',
3929                            '\x00', '\x00' };
3930   const char nop12[12] = { '\x8d', '\xb6', '\x00',   // leal 0L(%esi),%esi
3931                            '\x00', '\x00', '\x00',   // leal 0L(%edi),%edi
3932                            '\x8d', '\xbf', '\x00',
3933                            '\x00', '\x00', '\x00' };
3934   const char nop13[13] = { '\x8d', '\xb6', '\x00',   // leal 0L(%esi),%esi
3935                            '\x00', '\x00', '\x00',   // leal 0L(%edi,1),%edi
3936                            '\x8d', '\xbc', '\x27',
3937                            '\x00', '\x00', '\x00',
3938                            '\x00' };
3939   const char nop14[14] = { '\x8d', '\xb4', '\x26',   // leal 0L(%esi,1),%esi
3940                            '\x00', '\x00', '\x00',   // leal 0L(%edi,1),%edi
3941                            '\x00', '\x8d', '\xbc',
3942                            '\x27', '\x00', '\x00',
3943                            '\x00', '\x00' };
3944   const char nop15[15] = { '\xeb', '\x0d', '\x90',   // jmp .+15
3945                            '\x90', '\x90', '\x90',   // nop,nop,nop,...
3946                            '\x90', '\x90', '\x90',
3947                            '\x90', '\x90', '\x90',
3948                            '\x90', '\x90', '\x90' };
3949
3950   const char* nops[16] = {
3951     NULL,
3952     nop1, nop2, nop3, nop4, nop5, nop6, nop7,
3953     nop8, nop9, nop10, nop11, nop12, nop13, nop14, nop15
3954   };
3955
3956   return std::string(nops[length], length);
3957 }
3958
3959 // Return the value to use for the base of a DW_EH_PE_datarel offset
3960 // in an FDE.  Solaris and SVR4 use DW_EH_PE_datarel because their
3961 // assembler can not write out the difference between two labels in
3962 // different sections, so instead of using a pc-relative value they
3963 // use an offset from the GOT.
3964
3965 uint64_t
3966 Target_i386::do_ehframe_datarel_base() const
3967 {
3968   gold_assert(this->global_offset_table_ != NULL);
3969   Symbol* sym = this->global_offset_table_;
3970   Sized_symbol<32>* ssym = static_cast<Sized_symbol<32>*>(sym);
3971   return ssym->value();
3972 }
3973
3974 // Return whether SYM should be treated as a call to a non-split
3975 // function.  We don't want that to be true of a call to a
3976 // get_pc_thunk function.
3977
3978 bool
3979 Target_i386::do_is_call_to_non_split(const Symbol* sym,
3980                                      const unsigned char*,
3981                                      const unsigned char*,
3982                                      section_size_type) const
3983 {
3984   return (sym->type() == elfcpp::STT_FUNC
3985           && !is_prefix_of("__i686.get_pc_thunk.", sym->name()));
3986 }
3987
3988 // FNOFFSET in section SHNDX in OBJECT is the start of a function
3989 // compiled with -fsplit-stack.  The function calls non-split-stack
3990 // code.  We have to change the function so that it always ensures
3991 // that it has enough stack space to run some random function.
3992
3993 void
3994 Target_i386::do_calls_non_split(Relobj* object, unsigned int shndx,
3995                                        section_offset_type fnoffset,
3996                                        section_size_type fnsize,
3997                                        const unsigned char*,
3998                                        size_t,
3999                                        unsigned char* view,
4000                                        section_size_type view_size,
4001                                        std::string* from,
4002                                        std::string* to) const
4003 {
4004   // The function starts with a comparison of the stack pointer and a
4005   // field in the TCB.  This is followed by a jump.
4006
4007   // cmp %gs:NN,%esp
4008   if (this->match_view(view, view_size, fnoffset, "\x65\x3b\x25", 3)
4009       && fnsize > 7)
4010     {
4011       // We will call __morestack if the carry flag is set after this
4012       // comparison.  We turn the comparison into an stc instruction
4013       // and some nops.
4014       view[fnoffset] = '\xf9';
4015       this->set_view_to_nop(view, view_size, fnoffset + 1, 6);
4016     }
4017   // lea NN(%esp),%ecx
4018   // lea NN(%esp),%edx
4019   else if ((this->match_view(view, view_size, fnoffset, "\x8d\x8c\x24", 3)
4020             || this->match_view(view, view_size, fnoffset, "\x8d\x94\x24", 3))
4021            && fnsize > 7)
4022     {
4023       // This is loading an offset from the stack pointer for a
4024       // comparison.  The offset is negative, so we decrease the
4025       // offset by the amount of space we need for the stack.  This
4026       // means we will avoid calling __morestack if there happens to
4027       // be plenty of space on the stack already.
4028       unsigned char* pval = view + fnoffset + 3;
4029       uint32_t val = elfcpp::Swap_unaligned<32, false>::readval(pval);
4030       val -= parameters->options().split_stack_adjust_size();
4031       elfcpp::Swap_unaligned<32, false>::writeval(pval, val);
4032     }
4033   else
4034     {
4035       if (!object->has_no_split_stack())
4036         object->error(_("failed to match split-stack sequence at "
4037                         "section %u offset %0zx"),
4038                       shndx, static_cast<size_t>(fnoffset));
4039       return;
4040     }
4041
4042   // We have to change the function so that it calls
4043   // __morestack_non_split instead of __morestack.  The former will
4044   // allocate additional stack space.
4045   *from = "__morestack";
4046   *to = "__morestack_non_split";
4047 }
4048
4049 // The selector for i386 object files.  Note this is never instantiated
4050 // directly.  It's only used in Target_selector_i386_nacl, below.
4051
4052 class Target_selector_i386 : public Target_selector_freebsd
4053 {
4054 public:
4055   Target_selector_i386()
4056     : Target_selector_freebsd(elfcpp::EM_386, 32, false,
4057                               "elf32-i386", "elf32-i386-freebsd",
4058                               "elf_i386")
4059   { }
4060
4061   Target*
4062   do_instantiate_target()
4063   { return new Target_i386(); }
4064 };
4065
4066 // NaCl variant.  It uses different PLT contents.
4067
4068 class Output_data_plt_i386_nacl : public Output_data_plt_i386
4069 {
4070  public:
4071   Output_data_plt_i386_nacl(Layout* layout,
4072                             Output_data_got_plt_i386* got_plt,
4073                             Output_data_space* got_irelative)
4074     : Output_data_plt_i386(layout, plt_entry_size, got_plt, got_irelative)
4075   { }
4076
4077  protected:
4078   virtual unsigned int
4079   do_get_plt_entry_size() const
4080   { return plt_entry_size; }
4081
4082   virtual void
4083   do_add_eh_frame(Layout* layout)
4084   {
4085     layout->add_eh_frame_for_plt(this, plt_eh_frame_cie, plt_eh_frame_cie_size,
4086                                  plt_eh_frame_fde, plt_eh_frame_fde_size);
4087   }
4088
4089   // The size of an entry in the PLT.
4090   static const int plt_entry_size = 64;
4091
4092   // The .eh_frame unwind information for the PLT.
4093   static const int plt_eh_frame_fde_size = 32;
4094   static const unsigned char plt_eh_frame_fde[plt_eh_frame_fde_size];
4095 };
4096
4097 class Output_data_plt_i386_nacl_exec : public Output_data_plt_i386_nacl
4098 {
4099 public:
4100   Output_data_plt_i386_nacl_exec(Layout* layout,
4101                                  Output_data_got_plt_i386* got_plt,
4102                                  Output_data_space* got_irelative)
4103     : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4104   { }
4105
4106  protected:
4107   virtual void
4108   do_fill_first_plt_entry(unsigned char* pov,
4109                           elfcpp::Elf_types<32>::Elf_Addr got_address);
4110
4111   virtual unsigned int
4112   do_fill_plt_entry(unsigned char* pov,
4113                     elfcpp::Elf_types<32>::Elf_Addr got_address,
4114                     unsigned int got_offset,
4115                     unsigned int plt_offset,
4116                     unsigned int plt_rel_offset);
4117
4118  private:
4119   // The first entry in the PLT for an executable.
4120   static const unsigned char first_plt_entry[plt_entry_size];
4121
4122   // Other entries in the PLT for an executable.
4123   static const unsigned char plt_entry[plt_entry_size];
4124 };
4125
4126 class Output_data_plt_i386_nacl_dyn : public Output_data_plt_i386_nacl
4127 {
4128  public:
4129   Output_data_plt_i386_nacl_dyn(Layout* layout,
4130                                 Output_data_got_plt_i386* got_plt,
4131                                 Output_data_space* got_irelative)
4132     : Output_data_plt_i386_nacl(layout, got_plt, got_irelative)
4133   { }
4134
4135  protected:
4136   virtual void
4137   do_fill_first_plt_entry(unsigned char* pov, elfcpp::Elf_types<32>::Elf_Addr);
4138
4139   virtual unsigned int
4140   do_fill_plt_entry(unsigned char* pov,
4141                     elfcpp::Elf_types<32>::Elf_Addr,
4142                     unsigned int got_offset,
4143                     unsigned int plt_offset,
4144                     unsigned int plt_rel_offset);
4145
4146  private:
4147   // The first entry in the PLT for a shared object.
4148   static const unsigned char first_plt_entry[plt_entry_size];
4149
4150   // Other entries in the PLT for a shared object.
4151   static const unsigned char plt_entry[plt_entry_size];
4152 };
4153
4154 class Target_i386_nacl : public Target_i386
4155 {
4156  public:
4157   Target_i386_nacl()
4158     : Target_i386(&i386_nacl_info)
4159   { }
4160
4161  protected:
4162   virtual Output_data_plt_i386*
4163   do_make_data_plt(Layout* layout,
4164                    Output_data_got_plt_i386* got_plt,
4165                    Output_data_space* got_irelative,
4166                    bool dyn)
4167   {
4168     if (dyn)
4169       return new Output_data_plt_i386_nacl_dyn(layout, got_plt, got_irelative);
4170     else
4171       return new Output_data_plt_i386_nacl_exec(layout, got_plt, got_irelative);
4172   }
4173
4174   virtual std::string
4175   do_code_fill(section_size_type length) const;
4176
4177  private:
4178   static const Target::Target_info i386_nacl_info;
4179 };
4180
4181 const Target::Target_info Target_i386_nacl::i386_nacl_info =
4182 {
4183   32,                   // size
4184   false,                // is_big_endian
4185   elfcpp::EM_386,       // machine_code
4186   false,                // has_make_symbol
4187   false,                // has_resolve
4188   true,                 // has_code_fill
4189   true,                 // is_default_stack_executable
4190   true,                 // can_icf_inline_merge_sections
4191   '\0',                 // wrap_char
4192   "/lib/ld-nacl-x86-32.so.1", // dynamic_linker
4193   0x20000,              // default_text_segment_address
4194   0x10000,              // abi_pagesize (overridable by -z max-page-size)
4195   0x10000,              // common_pagesize (overridable by -z common-page-size)
4196   true,                 // isolate_execinstr
4197   0x10000000,           // rosegment_gap
4198   elfcpp::SHN_UNDEF,    // small_common_shndx
4199   elfcpp::SHN_UNDEF,    // large_common_shndx
4200   0,                    // small_common_section_flags
4201   0,                    // large_common_section_flags
4202   NULL,                 // attributes_section
4203   NULL,                 // attributes_vendor
4204   "_start",             // entry_symbol_name
4205   32,                   // hash_entry_size
4206   elfcpp::SHT_PROGBITS, // unwind_section_type
4207 };
4208
4209 #define NACLMASK        0xe0            // 32-byte alignment mask
4210
4211 const unsigned char
4212 Output_data_plt_i386_nacl_exec::first_plt_entry[plt_entry_size] =
4213 {
4214   0xff, 0x35,                          // pushl contents of memory address
4215   0, 0, 0, 0,                          // replaced with address of .got + 4
4216   0x8b, 0x0d,                          // movl contents of address, %ecx
4217   0, 0, 0, 0,                          // replaced with address of .got + 8
4218   0x83, 0xe1, NACLMASK,                // andl $NACLMASK, %ecx
4219   0xff, 0xe1,                          // jmp *%ecx
4220   0x90, 0x90, 0x90, 0x90, 0x90, 0x90,  // nops
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
4228 };
4229
4230 void
4231 Output_data_plt_i386_nacl_exec::do_fill_first_plt_entry(
4232     unsigned char* pov,
4233     elfcpp::Elf_types<32>::Elf_Addr got_address)
4234 {
4235   memcpy(pov, first_plt_entry, plt_entry_size);
4236   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
4237   elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
4238 }
4239
4240 // The first entry in the PLT for a shared object.
4241
4242 const unsigned char
4243 Output_data_plt_i386_nacl_dyn::first_plt_entry[plt_entry_size] =
4244 {
4245   0xff, 0xb3, 4, 0, 0, 0,       // pushl 4(%ebx)
4246   0x8b, 0x4b, 0x08,             // mov 0x8(%ebx), %ecx
4247   0x83, 0xe1, NACLMASK,         // andl $NACLMASK, %ecx
4248   0xff, 0xe1,                   // jmp *%ecx
4249   0x90, 0x90, 0x90, 0x90, 0x90,  // nops
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 };
4260
4261 void
4262 Output_data_plt_i386_nacl_dyn::do_fill_first_plt_entry(
4263     unsigned char* pov,
4264     elfcpp::Elf_types<32>::Elf_Addr)
4265 {
4266   memcpy(pov, first_plt_entry, plt_entry_size);
4267 }
4268
4269 // Subsequent entries in the PLT for an executable.
4270
4271 const unsigned char
4272 Output_data_plt_i386_nacl_exec::plt_entry[plt_entry_size] =
4273 {
4274   0x8b, 0x0d,                    // movl contents of address, %ecx */
4275   0, 0, 0, 0,                    // replaced with address of symbol in .got
4276   0x83, 0xe1, NACLMASK,          // andl $NACLMASK, %ecx
4277   0xff, 0xe1,                    // jmp *%ecx
4278
4279   // Pad to the next 32-byte boundary with nop instructions.
4280   0x90,
4281   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4282   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4283
4284   // Lazy GOT entries point here (32-byte aligned).
4285   0x68,                       // pushl immediate
4286   0, 0, 0, 0,                 // replaced with offset into relocation table
4287   0xe9,                       // jmp relative
4288   0, 0, 0, 0,                 // replaced with offset to start of .plt
4289
4290   // Pad to the next 32-byte boundary with nop instructions.
4291   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4292   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4293   0x90, 0x90
4294 };
4295
4296 unsigned int
4297 Output_data_plt_i386_nacl_exec::do_fill_plt_entry(
4298     unsigned char* pov,
4299     elfcpp::Elf_types<32>::Elf_Addr got_address,
4300     unsigned int got_offset,
4301     unsigned int plt_offset,
4302     unsigned int plt_rel_offset)
4303 {
4304   memcpy(pov, plt_entry, plt_entry_size);
4305   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
4306                                               got_address + got_offset);
4307   elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4308   elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4309   return 32;
4310 }
4311
4312 // Subsequent entries in the PLT for a shared object.
4313
4314 const unsigned char
4315 Output_data_plt_i386_nacl_dyn::plt_entry[plt_entry_size] =
4316 {
4317   0x8b, 0x8b,          // movl offset(%ebx), %ecx
4318   0, 0, 0, 0,          // replaced with offset of symbol in .got
4319   0x83, 0xe1, 0xe0,    // andl $NACLMASK, %ecx
4320   0xff, 0xe1,          // jmp *%ecx
4321
4322   // Pad to the next 32-byte boundary with nop instructions.
4323   0x90,
4324   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4325   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4326
4327   // Lazy GOT entries point here (32-byte aligned).
4328   0x68,                // pushl immediate
4329   0, 0, 0, 0,          // replaced with offset into relocation table.
4330   0xe9,                // jmp relative
4331   0, 0, 0, 0,          // replaced with offset to start of .plt.
4332
4333   // Pad to the next 32-byte boundary with nop instructions.
4334   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4335   0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4336   0x90, 0x90
4337 };
4338
4339 unsigned int
4340 Output_data_plt_i386_nacl_dyn::do_fill_plt_entry(
4341     unsigned char* pov,
4342     elfcpp::Elf_types<32>::Elf_Addr,
4343     unsigned int got_offset,
4344     unsigned int plt_offset,
4345     unsigned int plt_rel_offset)
4346 {
4347   memcpy(pov, plt_entry, plt_entry_size);
4348   elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
4349   elfcpp::Swap_unaligned<32, false>::writeval(pov + 33, plt_rel_offset);
4350   elfcpp::Swap<32, false>::writeval(pov + 38, - (plt_offset + 38 + 4));
4351   return 32;
4352 }
4353
4354 const unsigned char
4355 Output_data_plt_i386_nacl::plt_eh_frame_fde[plt_eh_frame_fde_size] =
4356 {
4357   0, 0, 0, 0,                           // Replaced with offset to .plt.
4358   0, 0, 0, 0,                           // Replaced with size of .plt.
4359   0,                                    // Augmentation size.
4360   elfcpp::DW_CFA_def_cfa_offset, 8,     // DW_CFA_def_cfa_offset: 8.
4361   elfcpp::DW_CFA_advance_loc + 6,       // Advance 6 to __PLT__ + 6.
4362   elfcpp::DW_CFA_def_cfa_offset, 12,    // DW_CFA_def_cfa_offset: 12.
4363   elfcpp::DW_CFA_advance_loc + 58,      // Advance 58 to __PLT__ + 64.
4364   elfcpp::DW_CFA_def_cfa_expression,    // DW_CFA_def_cfa_expression.
4365   13,                                   // Block length.
4366   elfcpp::DW_OP_breg4, 4,               // Push %esp + 4.
4367   elfcpp::DW_OP_breg8, 0,               // Push %eip.
4368   elfcpp::DW_OP_const1u, 63,            // Push 0x3f.
4369   elfcpp::DW_OP_and,                    // & (%eip & 0x3f).
4370   elfcpp::DW_OP_const1u, 37,            // Push 0x25.
4371   elfcpp::DW_OP_ge,                     // >= ((%eip & 0x3f) >= 0x25)
4372   elfcpp::DW_OP_lit2,                   // Push 2.
4373   elfcpp::DW_OP_shl,                    // << (((%eip & 0x3f) >= 0x25) << 2)
4374   elfcpp::DW_OP_plus,                   // + ((((%eip&0x3f)>=0x25)<<2)+%esp+4
4375   elfcpp::DW_CFA_nop,                   // Align to 32 bytes.
4376   elfcpp::DW_CFA_nop
4377 };
4378
4379 // Return a string used to fill a code section with nops.
4380 // For NaCl, long NOPs are only valid if they do not cross
4381 // bundle alignment boundaries, so keep it simple with one-byte NOPs.
4382 std::string
4383 Target_i386_nacl::do_code_fill(section_size_type length) const
4384 {
4385   return std::string(length, static_cast<char>(0x90));
4386 }
4387
4388 // The selector for i386-nacl object files.
4389
4390 class Target_selector_i386_nacl
4391   : public Target_selector_nacl<Target_selector_i386, Target_i386_nacl>
4392 {
4393  public:
4394   Target_selector_i386_nacl()
4395     : Target_selector_nacl<Target_selector_i386,
4396                            Target_i386_nacl>("x86-32",
4397                                              "elf32-i386-nacl",
4398                                              "elf_i386_nacl")
4399   { }
4400 };
4401
4402 Target_selector_i386_nacl target_selector_i386;
4403
4404 // IAMCU variant.  It uses EM_IAMCU, not EM_386.
4405
4406 class Target_iamcu : public Target_i386
4407 {
4408  public:
4409   Target_iamcu()
4410     : Target_i386(&iamcu_info)
4411   { }
4412
4413  private:
4414   // Information about this specific target which we pass to the
4415   // general Target structure.
4416   static const Target::Target_info iamcu_info;
4417 };
4418
4419 const Target::Target_info Target_iamcu::iamcu_info =
4420 {
4421   32,                   // size
4422   false,                // is_big_endian
4423   elfcpp::EM_IAMCU,     // machine_code
4424   false,                // has_make_symbol
4425   false,                // has_resolve
4426   true,                 // has_code_fill
4427   true,                 // is_default_stack_executable
4428   true,                 // can_icf_inline_merge_sections
4429   '\0',                 // wrap_char
4430   "/usr/lib/libc.so.1", // dynamic_linker
4431   0x08048000,           // default_text_segment_address
4432   0x1000,               // abi_pagesize (overridable by -z max-page-size)
4433   0x1000,               // common_pagesize (overridable by -z common-page-size)
4434   false,                // isolate_execinstr
4435   0,                    // rosegment_gap
4436   elfcpp::SHN_UNDEF,    // small_common_shndx
4437   elfcpp::SHN_UNDEF,    // large_common_shndx
4438   0,                    // small_common_section_flags
4439   0,                    // large_common_section_flags
4440   NULL,                 // attributes_section
4441   NULL,                 // attributes_vendor
4442   "_start",             // entry_symbol_name
4443   32,                   // hash_entry_size
4444   elfcpp::SHT_PROGBITS, // unwind_section_type
4445 };
4446
4447 class Target_selector_iamcu : public Target_selector
4448 {
4449 public:
4450   Target_selector_iamcu()
4451     : Target_selector(elfcpp::EM_IAMCU, 32, false, "elf32-iamcu",
4452                       "elf_iamcu")
4453   { }
4454
4455   Target*
4456   do_instantiate_target()
4457   { return new Target_iamcu(); }
4458 };
4459
4460 Target_selector_iamcu target_selector_iamcu;
4461
4462 } // End anonymous namespace.