gold/s390.cc

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