gold/i386.cc

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