gold/i386.cc

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