gold/s390.cc

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