gold/i386.cc

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