gold/i386.cc

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