gold/i386.cc

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