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