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