bfd/elf64-hppa.c

   1 /* Generic support for 64-bit ELF
   2    Copyright 1999, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/hppa.h"
  25 #include "libhppa.h"
  26 #include "elf64-hppa.h"
  27 #define ARCH_SIZE              64
  28
  29 #define PLT_ENTRY_SIZE 0x10
  30 #define DLT_ENTRY_SIZE 0x8
  31 #define OPD_ENTRY_SIZE 0x20
  32
  33 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
  34
  35 /* The stub is supposed to load the target address and target's DP
  36    value out of the PLT, then do an external branch to the target
  37    address.
  38
  39    LDD PLTOFF(%r27),%r1
  40    BVE (%r1)
  41    LDD PLTOFF+8(%r27),%r27
  42
  43    Note that we must use the LDD with a 14 bit displacement, not the one
  44    with a 5 bit displacement.  */
  45 static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
  46                           0x53, 0x7b, 0x00, 0x00 };
  47
  48 struct elf64_hppa_dyn_hash_entry
  49 {
  50   struct bfd_hash_entry root;
  51
  52   /* Offsets for this symbol in various linker sections.  */
  53   bfd_vma dlt_offset;
  54   bfd_vma plt_offset;
  55   bfd_vma opd_offset;
  56   bfd_vma stub_offset;
  57
  58   /* The symbol table entry, if any, that this was derrived from.  */
  59   struct elf_link_hash_entry *h;
  60
  61   /* The index of the (possibly local) symbol in the input bfd and its
  62      associated BFD.  Needed so that we can have relocs against local
  63      symbols in shared libraries.  */
  64   unsigned long sym_indx;
  65   bfd *owner;
  66
  67   /* Dynamic symbols may need to have two different values.  One for
  68      the dynamic symbol table, one for the normal symbol table.
  69
  70      In such cases we store the symbol's real value and section
  71      index here so we can restore the real value before we write
  72      the normal symbol table.  */
  73   bfd_vma st_value;
  74   int st_shndx;
  75
  76   /* Used to count non-got, non-plt relocations for delayed sizing
  77      of relocation sections.  */
  78   struct elf64_hppa_dyn_reloc_entry
  79   {
  80     /* Next relocation in the chain.  */
  81     struct elf64_hppa_dyn_reloc_entry *next;
  82
  83     /* The type of the relocation.  */
  84     int type;
  85
  86     /* The input section of the relocation.  */
  87     asection *sec;
  88
  89     /* The index of the section symbol for the input section of
  90        the relocation.  Only needed when building shared libraries.  */
  91     int sec_symndx;
  92
  93     /* The offset within the input section of the relocation.  */
  94     bfd_vma offset;
  95
  96     /* The addend for the relocation.  */
  97     bfd_vma addend;
  98
  99   } *reloc_entries;
 100
 101   /* Nonzero if this symbol needs an entry in one of the linker
 102      sections.  */
 103   unsigned want_dlt;
 104   unsigned want_plt;
 105   unsigned want_opd;
 106   unsigned want_stub;
 107 };
 108
 109 struct elf64_hppa_dyn_hash_table
 110 {
 111   struct bfd_hash_table root;
 112 };
 113
 114 struct elf64_hppa_link_hash_table
 115 {
 116   struct elf_link_hash_table root;
 117
 118   /* Shortcuts to get to the various linker defined sections.  */
 119   asection *dlt_sec;
 120   asection *dlt_rel_sec;
 121   asection *plt_sec;
 122   asection *plt_rel_sec;
 123   asection *opd_sec;
 124   asection *opd_rel_sec;
 125   asection *other_rel_sec;
 126
 127   /* Offset of __gp within .plt section.  When the PLT gets large we want
 128      to slide __gp into the PLT section so that we can continue to use
 129      single DP relative instructions to load values out of the PLT.  */
 130   bfd_vma gp_offset;
 131
 132   /* Note this is not strictly correct.  We should create a stub section for
 133      each input section with calls.  The stub section should be placed before
 134      the section with the call.  */
 135   asection *stub_sec;
 136
 137   bfd_vma text_segment_base;
 138   bfd_vma data_segment_base;
 139
 140   struct elf64_hppa_dyn_hash_table dyn_hash_table;
 141
 142   /* We build tables to map from an input section back to its
 143      symbol index.  This is the BFD for which we currently have
 144      a map.  */
 145   bfd *section_syms_bfd;
 146
 147   /* Array of symbol numbers for each input section attached to the
 148      current BFD.  */
 149   int *section_syms;
 150 };
 151
 152 #define elf64_hppa_hash_table(p) \
 153   ((struct elf64_hppa_link_hash_table *) ((p)->hash))
 154
 155 typedef struct bfd_hash_entry *(*new_hash_entry_func)
 156   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 157
 158 static boolean elf64_hppa_dyn_hash_table_init
 159   PARAMS ((struct elf64_hppa_dyn_hash_table *ht, bfd *abfd,
 160            new_hash_entry_func new));
 161 static struct bfd_hash_entry *elf64_hppa_new_dyn_hash_entry
 162   PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
 163            const char *string));
 164 static struct bfd_link_hash_table *elf64_hppa_hash_table_create
 165   PARAMS ((bfd *abfd));
 166 static struct elf64_hppa_dyn_hash_entry *elf64_hppa_dyn_hash_lookup
 167   PARAMS ((struct elf64_hppa_dyn_hash_table *table, const char *string,
 168            boolean create, boolean copy));
 169 static void elf64_hppa_dyn_hash_traverse
 170   PARAMS ((struct elf64_hppa_dyn_hash_table *table,
 171            boolean (*func)(struct elf64_hppa_dyn_hash_entry *, PTR),
 172            PTR info));
 173
 174 static const char *get_dyn_name
 175   PARAMS ((bfd *abfd, struct elf_link_hash_entry *h,
 176            const Elf_Internal_Rela *rel, char **pbuf, size_t *plen));
 177
 178
 179 /* This must follow the definitions of the various derived linker
 180    hash tables and shared functions.  */
 181 #include "elf-hppa.h"
 182
 183
 184 static boolean elf64_hppa_object_p
 185   PARAMS ((bfd *));
 186
 187 static boolean elf64_hppa_section_from_shdr
 188   PARAMS ((bfd *, Elf64_Internal_Shdr *, char *));
 189
 190 static void elf64_hppa_post_process_headers
 191   PARAMS ((bfd *, struct bfd_link_info *));
 192
 193 static boolean elf64_hppa_create_dynamic_sections
 194   PARAMS ((bfd *, struct bfd_link_info *));
 195
 196 static boolean elf64_hppa_adjust_dynamic_symbol
 197   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 198
 199 static boolean elf64_hppa_size_dynamic_sections
 200   PARAMS ((bfd *, struct bfd_link_info *));
 201
 202 static boolean elf64_hppa_finish_dynamic_symbol
 203   PARAMS ((bfd *, struct bfd_link_info *,
 204            struct elf_link_hash_entry *, Elf_Internal_Sym *));
 205
 206 static boolean elf64_hppa_finish_dynamic_sections
 207   PARAMS ((bfd *, struct bfd_link_info *));
 208
 209 static boolean elf64_hppa_check_relocs
 210   PARAMS ((bfd *, struct bfd_link_info *,
 211            asection *, const Elf_Internal_Rela *));
 212
 213 static boolean elf64_hppa_dynamic_symbol_p
 214   PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
 215
 216 static boolean elf64_hppa_mark_exported_functions
 217   PARAMS ((struct elf_link_hash_entry *, PTR));
 218
 219 static boolean elf64_hppa_finalize_opd
 220   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 221
 222 static boolean elf64_hppa_finalize_dlt
 223   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 224
 225 static boolean allocate_global_data_dlt
 226   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 227
 228 static boolean allocate_global_data_plt
 229   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 230
 231 static boolean allocate_global_data_stub
 232   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 233
 234 static boolean allocate_global_data_opd
 235   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 236
 237 static boolean get_reloc_section
 238   PARAMS ((bfd *, struct elf64_hppa_link_hash_table *, asection *));
 239
 240 static boolean count_dyn_reloc
 241   PARAMS ((bfd *, struct elf64_hppa_dyn_hash_entry *,
 242            int, asection *, int, bfd_vma, bfd_vma));
 243
 244 static boolean allocate_dynrel_entries
 245   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 246
 247 static boolean elf64_hppa_finalize_dynreloc
 248   PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 249
 250 static boolean get_opd
 251   PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
 252
 253 static boolean get_plt
 254   PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
 255
 256 static boolean get_dlt
 257   PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
 258
 259 static boolean get_stub
 260   PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
 261
 262 static boolean
 263 elf64_hppa_dyn_hash_table_init (ht, abfd, new)
 264      struct elf64_hppa_dyn_hash_table *ht;
 265      bfd *abfd;
 266      new_hash_entry_func new;
 267 {
 268   memset (ht, 0, sizeof(*ht));
 269   return bfd_hash_table_init (&ht->root, new);
 270 }
 271
 272 static struct bfd_hash_entry*
 273 elf64_hppa_new_dyn_hash_entry (entry, table, string)
 274      struct bfd_hash_entry *entry;
 275      struct bfd_hash_table *table;
 276      const char *string;
 277 {
 278   struct elf64_hppa_dyn_hash_entry *ret;
 279   ret = (struct elf64_hppa_dyn_hash_entry *) entry;
 280
 281   /* Allocate the structure if it has not already been allocated by a
 282      subclass.  */
 283   if (!ret)
 284     ret = bfd_hash_allocate (table, sizeof (*ret));
 285
 286   if (!ret)
 287     return 0;
 288
 289   /* Initialize our local data.  All zeros, and definitely easier
 290      than setting 8 bit fields.  */
 291   memset (ret, 0, sizeof(*ret));
 292
 293   /* Call the allocation method of the superclass.  */
 294   ret = ((struct elf64_hppa_dyn_hash_entry *)
 295          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 296
 297   return &ret->root;
 298 }
 299
 300 /* Create the derived linker hash table.  The PA64 ELF port uses this
 301    derived hash table to keep information specific to the PA ElF
 302    linker (without using static variables).  */
 303
 304 static struct bfd_link_hash_table*
 305 elf64_hppa_hash_table_create (abfd)
 306      bfd *abfd;
 307 {
 308   struct elf64_hppa_link_hash_table *ret;
 309
 310   ret = bfd_zalloc (abfd, sizeof (*ret));
 311   if (!ret)
 312     return 0;
 313   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 314                                       _bfd_elf_link_hash_newfunc))
 315     {
 316       bfd_release (abfd, ret);
 317       return 0;
 318     }
 319
 320   if (!elf64_hppa_dyn_hash_table_init (&ret->dyn_hash_table, abfd,
 321                                        elf64_hppa_new_dyn_hash_entry))
 322     return 0;
 323   return &ret->root.root;
 324 }
 325
 326 /* Look up an entry in a PA64 ELF linker hash table.  */
 327
 328 static struct elf64_hppa_dyn_hash_entry *
 329 elf64_hppa_dyn_hash_lookup(table, string, create, copy)
 330      struct elf64_hppa_dyn_hash_table *table;
 331      const char *string;
 332      boolean create, copy;
 333 {
 334   return ((struct elf64_hppa_dyn_hash_entry *)
 335           bfd_hash_lookup (&table->root, string, create, copy));
 336 }
 337
 338 /* Traverse a PA64 ELF linker hash table.  */
 339
 340 static void
 341 elf64_hppa_dyn_hash_traverse (table, func, info)
 342      struct elf64_hppa_dyn_hash_table *table;
 343      boolean (*func) PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
 344      PTR info;
 345 {
 346   (bfd_hash_traverse
 347    (&table->root,
 348     (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) func,
 349     info));
 350 }
 351 \f
 352 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
 353
 354    Additionally we set the default architecture and machine.  */
 355 static boolean
 356 elf64_hppa_object_p (abfd)
 357      bfd *abfd;
 358 {
 359   /* Set the right machine number for an HPPA ELF file.  */
 360   return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
 361 }
 362
 363 /* Given section type (hdr->sh_type), return a boolean indicating
 364    whether or not the section is an elf64-hppa specific section.  */
 365 static boolean
 366 elf64_hppa_section_from_shdr (abfd, hdr, name)
 367      bfd *abfd;
 368      Elf64_Internal_Shdr *hdr;
 369      char *name;
 370 {
 371   asection *newsect;
 372
 373   switch (hdr->sh_type)
 374     {
 375     case SHT_PARISC_EXT:
 376       if (strcmp (name, ".PARISC.archext") != 0)
 377         return false;
 378       break;
 379     case SHT_PARISC_UNWIND:
 380       if (strcmp (name, ".PARISC.unwind") != 0)
 381         return false;
 382       break;
 383     case SHT_PARISC_DOC:
 384     case SHT_PARISC_ANNOT:
 385     default:
 386       return false;
 387     }
 388
 389   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
 390     return false;
 391   newsect = hdr->bfd_section;
 392
 393   return true;
 394 }
 395
 396
 397 /* Construct a string for use in the elf64_hppa_dyn_hash_table.  The
 398    name describes what was once potentially anonymous memory.  We
 399    allocate memory as necessary, possibly reusing PBUF/PLEN.  */
 400
 401 static const char *
 402 get_dyn_name (abfd, h, rel, pbuf, plen)
 403      bfd *abfd;
 404      struct elf_link_hash_entry *h;
 405      const Elf_Internal_Rela *rel;
 406      char **pbuf;
 407      size_t *plen;
 408 {
 409   size_t nlen, tlen;
 410   char *buf;
 411   size_t len;
 412
 413   if (h && rel->r_addend == 0)
 414     return h->root.root.string;
 415
 416   if (h)
 417     nlen = strlen (h->root.root.string);
 418   else
 419     {
 420       nlen = sizeof(void*)*2 + 1 + sizeof(bfd_vma)*4 + 1 + 1;
 421       nlen += 10;       /* %p slop */
 422     }
 423   tlen = nlen + 1 + 16 + 1;
 424
 425   len = *plen;
 426   buf = *pbuf;
 427   if (len < tlen)
 428     {
 429       if (buf)
 430         free (buf);
 431       *pbuf = buf = malloc (tlen);
 432       *plen = len = tlen;
 433       if (!buf)
 434         return NULL;
 435     }
 436
 437   if (h)
 438     {
 439       memcpy (buf, h->root.root.string, nlen);
 440       sprintf_vma (buf + nlen, rel->r_addend);
 441     }
 442   else
 443     {
 444       nlen = sprintf (buf, "%p:%lx", abfd, ELF64_R_SYM (rel->r_info));
 445       if (rel->r_addend)
 446         {
 447           buf[nlen++] = '+';
 448           sprintf_vma (buf + nlen, rel->r_addend);
 449         }
 450     }
 451
 452   return buf;
 453 }
 454
 455 /* SEC is a section containing relocs for an input BFD when linking; return
 456    a suitable section for holding relocs in the output BFD for a link.  */
 457
 458 static boolean
 459 get_reloc_section (abfd, hppa_info, sec)
 460      bfd *abfd;
 461      struct elf64_hppa_link_hash_table *hppa_info;
 462      asection *sec;
 463 {
 464   const char *srel_name;
 465   asection *srel;
 466   bfd *dynobj;
 467
 468   srel_name = (bfd_elf_string_from_elf_section
 469                (abfd, elf_elfheader(abfd)->e_shstrndx,
 470                 elf_section_data(sec)->rel_hdr.sh_name));
 471   if (srel_name == NULL)
 472     return false;
 473
 474   BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
 475                && strcmp (bfd_get_section_name (abfd, sec),
 476                           srel_name+5) == 0)
 477               || (strncmp (srel_name, ".rel", 4) == 0
 478                   && strcmp (bfd_get_section_name (abfd, sec),
 479                              srel_name+4) == 0));
 480
 481   dynobj = hppa_info->root.dynobj;
 482   if (!dynobj)
 483     hppa_info->root.dynobj = dynobj = abfd;
 484
 485   srel = bfd_get_section_by_name (dynobj, srel_name);
 486   if (srel == NULL)
 487     {
 488       srel = bfd_make_section (dynobj, srel_name);
 489       if (srel == NULL
 490           || !bfd_set_section_flags (dynobj, srel,
 491                                      (SEC_ALLOC
 492                                       | SEC_LOAD
 493                                       | SEC_HAS_CONTENTS
 494                                       | SEC_IN_MEMORY
 495                                       | SEC_LINKER_CREATED
 496                                       | SEC_READONLY))
 497           || !bfd_set_section_alignment (dynobj, srel, 3))
 498         return false;
 499     }
 500
 501   hppa_info->other_rel_sec = srel;
 502   return true;
 503 }
 504
 505 /* Add a new entry to the list of dynamic relocations against DYN_H.
 506
 507    We use this to keep a record of all the FPTR relocations against a
 508    particular symbol so that we can create FPTR relocations in the
 509    output file.  */
 510
 511 static boolean
 512 count_dyn_reloc (abfd, dyn_h, type, sec, sec_symndx, offset, addend)
 513      bfd *abfd;
 514      struct elf64_hppa_dyn_hash_entry *dyn_h;
 515      int type;
 516      asection *sec;
 517      int sec_symndx;
 518      bfd_vma offset;
 519      bfd_vma addend;
 520 {
 521   struct elf64_hppa_dyn_reloc_entry *rent;
 522
 523   rent = (struct elf64_hppa_dyn_reloc_entry *)
 524   bfd_alloc (abfd, sizeof (*rent));
 525   if (!rent)
 526     return false;
 527
 528   rent->next = dyn_h->reloc_entries;
 529   rent->type = type;
 530   rent->sec = sec;
 531   rent->sec_symndx = sec_symndx;
 532   rent->offset = offset;
 533   rent->addend = addend;
 534   dyn_h->reloc_entries = rent;
 535
 536   return true;
 537 }
 538
 539 /* Scan the RELOCS and record the type of dynamic entries that each
 540    referenced symbol needs.  */
 541
 542 static boolean
 543 elf64_hppa_check_relocs (abfd, info, sec, relocs)
 544      bfd *abfd;
 545      struct bfd_link_info *info;
 546      asection *sec;
 547      const Elf_Internal_Rela *relocs;
 548 {
 549   struct elf64_hppa_link_hash_table *hppa_info;
 550   const Elf_Internal_Rela *relend;
 551   Elf_Internal_Shdr *symtab_hdr;
 552   const Elf_Internal_Rela *rel;
 553   asection *dlt, *plt, *stubs;
 554   char *buf;
 555   size_t buf_len;
 556   int sec_symndx;
 557
 558   if (info->relocateable)
 559     return true;
 560
 561   /* If this is the first dynamic object found in the link, create
 562      the special sections required for dynamic linking.  */
 563   if (! elf_hash_table (info)->dynamic_sections_created)
 564     {
 565       if (! bfd_elf64_link_create_dynamic_sections (abfd, info))
 566         return false;
 567     }
 568
 569   hppa_info = elf64_hppa_hash_table (info);
 570   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 571
 572   /* If necessary, build a new table holding section symbols indices
 573      for this BFD.  This is disgusting.  */
 574
 575   if (info->shared && hppa_info->section_syms_bfd != abfd)
 576     {
 577       int i, highest_shndx;
 578       asection *section;
 579       Elf_Internal_Sym *local_syms, *isym;
 580       Elf64_External_Sym *ext_syms, *esym;
 581
 582       /* We're done with the old cache of section index to section symbol
 583          index information.  Free it.
 584
 585          ?!? Note we leak the last section_syms array.  Presumably we
 586          could free it in one of the later routines in this file.  */
 587       if (hppa_info->section_syms)
 588         free (hppa_info->section_syms);
 589
 590       /* Allocate memory for the internal and external symbols.  */
 591       local_syms
 592         = (Elf_Internal_Sym *) bfd_malloc (symtab_hdr->sh_info
 593                                            * sizeof (Elf_Internal_Sym));
 594       if (local_syms == NULL)
 595         return false;
 596
 597       ext_syms
 598         = (Elf64_External_Sym *) bfd_malloc (symtab_hdr->sh_info
 599                                              * sizeof (Elf64_External_Sym));
 600       if (ext_syms == NULL)
 601         {
 602           free (local_syms);
 603           return false;
 604         }
 605
 606       /* Read in the local symbols.  */
 607       if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 608           || bfd_read (ext_syms, 1,
 609                        (symtab_hdr->sh_info
 610                         * sizeof (Elf64_External_Sym)), abfd)
 611           != (symtab_hdr->sh_info * sizeof (Elf64_External_Sym)))
 612         {
 613           free (local_syms);
 614           free (ext_syms);
 615           return false;
 616         }
 617
 618       /* Swap in the local symbols, also record the highest section index
 619          referenced by the local symbols.  */
 620       isym = local_syms;
 621       esym = ext_syms;
 622       highest_shndx = 0;
 623       for (i = 0; i < symtab_hdr->sh_info; i++, esym++, isym++)
 624         {
 625           bfd_elf64_swap_symbol_in (abfd, esym, isym);
 626           if (isym->st_shndx > highest_shndx)
 627             highest_shndx = isym->st_shndx;
 628         }
 629
 630       /* Now we can free the external symbols.  */
 631       free (ext_syms);
 632
 633       /* Allocate an array to hold the section index to section symbol index
 634          mapping.  Bump by one since we start counting at zero.  */
 635       highest_shndx++;
 636       hppa_info->section_syms = (int *) bfd_malloc (highest_shndx
 637                                                     * sizeof (int));
 638
 639       /* Now walk the local symbols again.  If we find a section symbol,
 640          record the index of the symbol into the section_syms array.  */
 641       for (isym = local_syms, i = 0; i < symtab_hdr->sh_info; i++, isym++)
 642         {
 643           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
 644             hppa_info->section_syms[isym->st_shndx] = i;
 645         }
 646
 647       /* We are finished with the local symbols.  Get rid of them.  */
 648       free (local_syms);
 649
 650       /* Record which BFD we built the section_syms mapping for.  */
 651       hppa_info->section_syms_bfd = abfd;
 652     }
 653
 654   /* Record the symbol index for this input section.  We may need it for
 655      relocations when building shared libraries.  When not building shared
 656      libraries this value is never really used, but assign it to zero to
 657      prevent out of bounds memory accesses in other routines.  */
 658   if (info->shared)
 659     {
 660       sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);
 661
 662       /* If we did not find a section symbol for this section, then
 663          something went terribly wrong above.  */
 664       if (sec_symndx == -1)
 665         return false;
 666
 667       sec_symndx = hppa_info->section_syms[sec_symndx];
 668     }
 669   else
 670     sec_symndx = 0;
 671
 672   dlt = plt = stubs = NULL;
 673   buf = NULL;
 674   buf_len = 0;
 675
 676   relend = relocs + sec->reloc_count;
 677   for (rel = relocs; rel < relend; ++rel)
 678     {
 679       enum {
 680         NEED_DLT = 1,
 681         NEED_PLT = 2,
 682         NEED_STUB = 4,
 683         NEED_OPD = 8,
 684         NEED_DYNREL = 16,
 685       };
 686
 687       struct elf_link_hash_entry *h = NULL;
 688       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
 689       struct elf64_hppa_dyn_hash_entry *dyn_h;
 690       int need_entry;
 691       const char *addr_name;
 692       boolean maybe_dynamic;
 693       int dynrel_type = R_PARISC_NONE;
 694       static reloc_howto_type *howto;
 695
 696       if (r_symndx >= symtab_hdr->sh_info)
 697         {
 698           /* We're dealing with a global symbol -- find its hash entry
 699              and mark it as being referenced.  */
 700           long indx = r_symndx - symtab_hdr->sh_info;
 701           h = elf_sym_hashes (abfd)[indx];
 702           while (h->root.type == bfd_link_hash_indirect
 703                  || h->root.type == bfd_link_hash_warning)
 704             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 705
 706           h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
 707         }
 708
 709       /* We can only get preliminary data on whether a symbol is
 710          locally or externally defined, as not all of the input files
 711          have yet been processed.  Do something with what we know, as
 712          this may help reduce memory usage and processing time later.  */
 713       maybe_dynamic = false;
 714       if (h && ((info->shared && ! info->symbolic)
 715                 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
 716                 || h->root.type == bfd_link_hash_defweak))
 717         maybe_dynamic = true;
 718
 719       howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);
 720       need_entry = 0;
 721       switch (howto->type)
 722         {
 723         /* These are simple indirect references to symbols through the
 724            DLT.  We need to create a DLT entry for any symbols which
 725            appears in a DLTIND relocation.  */
 726         case R_PARISC_DLTIND21L:
 727         case R_PARISC_DLTIND14R:
 728         case R_PARISC_DLTIND14F:
 729         case R_PARISC_DLTIND14WR:
 730         case R_PARISC_DLTIND14DR:
 731           need_entry = NEED_DLT;
 732           break;
 733
 734         /* ?!?  These need a DLT entry.  But I have no idea what to do with
 735            the "link time TP value.  */
 736         case R_PARISC_LTOFF_TP21L:
 737         case R_PARISC_LTOFF_TP14R:
 738         case R_PARISC_LTOFF_TP14F:
 739         case R_PARISC_LTOFF_TP64:
 740         case R_PARISC_LTOFF_TP14WR:
 741         case R_PARISC_LTOFF_TP14DR:
 742         case R_PARISC_LTOFF_TP16F:
 743         case R_PARISC_LTOFF_TP16WF:
 744         case R_PARISC_LTOFF_TP16DF:
 745           need_entry = NEED_DLT;
 746           break;
 747
 748         /* These are function calls.  Depending on their precise target we
 749            may need to make a stub for them.  The stub uses the PLT, so we
 750            need to create PLT entries for these symbols too.  */
 751         case R_PARISC_PCREL17F:
 752         case R_PARISC_PCREL22F:
 753         case R_PARISC_PCREL32:
 754         case R_PARISC_PCREL64:
 755         case R_PARISC_PCREL21L:
 756         case R_PARISC_PCREL17R:
 757         case R_PARISC_PCREL17C:
 758         case R_PARISC_PCREL14R:
 759         case R_PARISC_PCREL14F:
 760         case R_PARISC_PCREL22C:
 761         case R_PARISC_PCREL14WR:
 762         case R_PARISC_PCREL14DR:
 763         case R_PARISC_PCREL16F:
 764         case R_PARISC_PCREL16WF:
 765         case R_PARISC_PCREL16DF:
 766           need_entry = (NEED_PLT | NEED_STUB);
 767           break;
 768
 769         case R_PARISC_PLTOFF21L:
 770         case R_PARISC_PLTOFF14R:
 771         case R_PARISC_PLTOFF14F:
 772         case R_PARISC_PLTOFF14WR:
 773         case R_PARISC_PLTOFF14DR:
 774         case R_PARISC_PLTOFF16F:
 775         case R_PARISC_PLTOFF16WF:
 776         case R_PARISC_PLTOFF16DF:
 777           need_entry = (NEED_PLT);
 778           break;
 779
 780         case R_PARISC_DIR64:
 781           if (info->shared || maybe_dynamic)
 782             need_entry = (NEED_DYNREL);
 783           dynrel_type = R_PARISC_DIR64;
 784           break;
 785
 786         /* This is an indirect reference through the DLT to get the address
 787            of a OPD descriptor.  Thus we need to make a DLT entry that points
 788            to an OPD entry.  */
 789         case R_PARISC_LTOFF_FPTR21L:
 790         case R_PARISC_LTOFF_FPTR14R:
 791         case R_PARISC_LTOFF_FPTR14WR:
 792         case R_PARISC_LTOFF_FPTR14DR:
 793         case R_PARISC_LTOFF_FPTR32:
 794         case R_PARISC_LTOFF_FPTR64:
 795         case R_PARISC_LTOFF_FPTR16F:
 796         case R_PARISC_LTOFF_FPTR16WF:
 797         case R_PARISC_LTOFF_FPTR16DF:
 798           if (info->shared || maybe_dynamic)
 799             need_entry = (NEED_DLT | NEED_OPD);
 800           else
 801             need_entry = (NEED_DLT | NEED_OPD);
 802           dynrel_type = R_PARISC_FPTR64;
 803           break;
 804
 805         /* This is a simple OPD entry.  */
 806         case R_PARISC_FPTR64:
 807           if (info->shared || maybe_dynamic)
 808             need_entry = (NEED_OPD | NEED_DYNREL);
 809           else
 810             need_entry = (NEED_OPD);
 811           dynrel_type = R_PARISC_FPTR64;
 812           break;
 813
 814         /* Add more cases as needed.  */
 815         }
 816
 817       if (!need_entry)
 818         continue;
 819
 820       /* Collect a canonical name for this address.  */
 821       addr_name = get_dyn_name (abfd, h, rel, &buf, &buf_len);
 822
 823       /* Collect the canonical entry data for this address.  */
 824       dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
 825                                           addr_name, true, true);
 826       BFD_ASSERT (dyn_h);
 827
 828       /* Stash away enough information to be able to find this symbol
 829          regardless of whether or not it is local or global.  */
 830       dyn_h->h = h;
 831       dyn_h->owner = abfd;
 832       dyn_h->sym_indx = r_symndx;
 833
 834       /* ?!? We may need to do some error checking in here.  */
 835       /* Create what's needed.  */
 836       if (need_entry & NEED_DLT)
 837         {
 838           if (! hppa_info->dlt_sec
 839               && ! get_dlt (abfd, info, hppa_info))
 840             goto err_out;
 841           dyn_h->want_dlt = 1;
 842         }
 843
 844       if (need_entry & NEED_PLT)
 845         {
 846           if (! hppa_info->plt_sec
 847               && ! get_plt (abfd, info, hppa_info))
 848             goto err_out;
 849           dyn_h->want_plt = 1;
 850         }
 851
 852       if (need_entry & NEED_STUB)
 853         {
 854           if (! hppa_info->stub_sec
 855               && ! get_stub (abfd, info, hppa_info))
 856             goto err_out;
 857           dyn_h->want_stub = 1;
 858         }
 859
 860       if (need_entry & NEED_OPD)
 861         {
 862           if (! hppa_info->opd_sec
 863               && ! get_opd (abfd, info, hppa_info))
 864             goto err_out;
 865
 866           dyn_h->want_opd = 1;
 867
 868           /* FPTRs are not allocated by the dynamic linker for PA64, though
 869              it is possible that will change in the future.  */
 870
 871           /* This could be a local function that had its address taken, in
 872              which case H will be NULL.  */
 873           if (h)
 874             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 875         }
 876
 877       /* Add a new dynamic relocation to the chain of dynamic
 878          relocations for this symbol.  */
 879       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
 880         {
 881           if (! hppa_info->other_rel_sec
 882               && ! get_reloc_section (abfd, hppa_info, sec))
 883             goto err_out;
 884
 885           if (!count_dyn_reloc (abfd, dyn_h, dynrel_type, sec,
 886                                 sec_symndx, rel->r_offset, rel->r_addend))
 887             goto err_out;
 888
 889           /* If we are building a shared library and we just recorded
 890              a dynamic R_PARISC_FPTR64 relocation, then make sure the
 891              section symbol for this section ends up in the dynamic
 892              symbol table.  */
 893           if (info->shared && dynrel_type == R_PARISC_FPTR64
 894               && ! (_bfd_elf64_link_record_local_dynamic_symbol
 895                     (info, abfd, sec_symndx)))
 896             return false;
 897         }
 898     }
 899
 900   if (buf)
 901     free (buf);
 902   return true;
 903
 904  err_out:
 905   if (buf)
 906     free (buf);
 907   return false;
 908 }
 909
 910 struct elf64_hppa_allocate_data
 911 {
 912   struct bfd_link_info *info;
 913   bfd_size_type ofs;
 914 };
 915
 916 /* Should we do dynamic things to this symbol?  */
 917
 918 static boolean
 919 elf64_hppa_dynamic_symbol_p (h, info)
 920      struct elf_link_hash_entry *h;
 921      struct bfd_link_info *info;
 922 {
 923   if (h == NULL)
 924     return false;
 925
 926   while (h->root.type == bfd_link_hash_indirect
 927          || h->root.type == bfd_link_hash_warning)
 928     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 929
 930   if (h->dynindx == -1)
 931     return false;
 932
 933   if (h->root.type == bfd_link_hash_undefweak
 934       || h->root.type == bfd_link_hash_defweak)
 935     return true;
 936
 937   if (h->root.root.string[0] == '$' && h->root.root.string[1] == '$')
 938     return false;
 939
 940   if ((info->shared && !info->symbolic)
 941       || ((h->elf_link_hash_flags
 942            & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
 943           == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
 944     return true;
 945
 946   return false;
 947 }
 948
 949 /* Mark all funtions exported by this file so that we can later allocate
 950    entries in .opd for them.  */
 951
 952 static boolean
 953 elf64_hppa_mark_exported_functions (h, data)
 954      struct elf_link_hash_entry *h;
 955      PTR data;
 956 {
 957   struct bfd_link_info *info = (struct bfd_link_info *)data;
 958   struct elf64_hppa_link_hash_table *hppa_info;
 959
 960   hppa_info = elf64_hppa_hash_table (info);
 961
 962   if (h
 963       && (h->root.type == bfd_link_hash_defined
 964           || h->root.type == bfd_link_hash_defweak)
 965       && h->root.u.def.section->output_section != NULL
 966       && h->type == STT_FUNC)
 967     {
 968        struct elf64_hppa_dyn_hash_entry *dyn_h;
 969
 970       /* Add this symbol to the PA64 linker hash table.  */
 971       dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
 972                                           h->root.root.string, true, true);
 973       BFD_ASSERT (dyn_h);
 974       dyn_h->h = h;
 975
 976       if (! hppa_info->opd_sec
 977           && ! get_opd (hppa_info->root.dynobj, info, hppa_info))
 978         return false;
 979
 980       dyn_h->want_opd = 1;
 981       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 982     }
 983
 984   return true;
 985 }
 986
 987 /* Allocate space for a DLT entry.  */
 988
 989 static boolean
 990 allocate_global_data_dlt (dyn_h, data)
 991      struct elf64_hppa_dyn_hash_entry *dyn_h;
 992      PTR data;
 993 {
 994   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
 995
 996   if (dyn_h->want_dlt)
 997     {
 998       struct elf_link_hash_entry *h = dyn_h->h;
 999
1000       if (x->info->shared)
1001         {
1002           /* Possibly add the symbol to the local dynamic symbol
1003              table since we might need to create a dynamic relocation
1004              against it.  */
1005           if (! h
1006               || (h && h->dynindx == -1))
1007             {
1008               bfd *owner;
1009               owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1010
1011               if (!_bfd_elf64_link_record_local_dynamic_symbol
1012                     (x->info, owner, dyn_h->sym_indx))
1013                 return false;
1014             }
1015         }
1016
1017       dyn_h->dlt_offset = x->ofs;
1018       x->ofs += DLT_ENTRY_SIZE;
1019     }
1020   return true;
1021 }
1022
1023 /* Allocate space for a DLT.PLT entry.  */
1024
1025 static boolean
1026 allocate_global_data_plt (dyn_h, data)
1027      struct elf64_hppa_dyn_hash_entry *dyn_h;
1028      PTR data;
1029 {
1030   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1031
1032   if (dyn_h->want_plt
1033       && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1034       && !((dyn_h->h->root.type == bfd_link_hash_defined
1035             || dyn_h->h->root.type == bfd_link_hash_defweak)
1036            && dyn_h->h->root.u.def.section->output_section != NULL))
1037     {
1038       dyn_h->plt_offset = x->ofs;
1039       x->ofs += PLT_ENTRY_SIZE;
1040       if (dyn_h->plt_offset < 0x2000)
1041         elf64_hppa_hash_table (x->info)->gp_offset = dyn_h->plt_offset;
1042     }
1043   else
1044     dyn_h->want_plt = 0;
1045
1046   return true;
1047 }
1048
1049 /* Allocate space for a STUB entry.  */
1050
1051 static boolean
1052 allocate_global_data_stub (dyn_h, data)
1053      struct elf64_hppa_dyn_hash_entry *dyn_h;
1054      PTR data;
1055 {
1056   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1057
1058   if (dyn_h->want_stub
1059       && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1060       && !((dyn_h->h->root.type == bfd_link_hash_defined
1061             || dyn_h->h->root.type == bfd_link_hash_defweak)
1062            && dyn_h->h->root.u.def.section->output_section != NULL))
1063     {
1064       dyn_h->stub_offset = x->ofs;
1065       x->ofs += sizeof (plt_stub);
1066     }
1067   else
1068     dyn_h->want_stub = 0;
1069   return true;
1070 }
1071
1072 /* Allocate space for a FPTR entry.  */
1073
1074 static boolean
1075 allocate_global_data_opd (dyn_h, data)
1076      struct elf64_hppa_dyn_hash_entry *dyn_h;
1077      PTR data;
1078 {
1079   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1080
1081   if (dyn_h->want_opd)
1082     {
1083       struct elf_link_hash_entry *h = dyn_h->h;
1084
1085       if (h)
1086         while (h->root.type == bfd_link_hash_indirect
1087                || h->root.type == bfd_link_hash_warning)
1088           h = (struct elf_link_hash_entry *) h->root.u.i.link;
1089
1090       /* We never need an opd entry for a symbol which is not
1091          defined by this output file.  */
1092       if (h && h->root.type == bfd_link_hash_undefined)
1093         dyn_h->want_opd = 0;
1094
1095       /* If we are creating a shared library, took the address of a local
1096          function or might export this function from this object file, then
1097          we have to create an opd descriptor.  */
1098       else if (x->info->shared
1099                || h == NULL
1100                || h->dynindx == -1
1101                || ((h->root.type == bfd_link_hash_defined
1102                     || h->root.type == bfd_link_hash_defweak)
1103                    && h->root.u.def.section->output_section != NULL))
1104         {
1105           /* If we are creating a shared library, then we will have to
1106              create a runtime relocation for the symbol to properly
1107              initialize the .opd entry.  Make sure the symbol gets
1108              added to the dynamic symbol table.  */
1109           if (x->info->shared
1110               && (h == NULL || (h->dynindx == -1)))
1111             {
1112               bfd *owner;
1113               owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1114
1115               if (!_bfd_elf64_link_record_local_dynamic_symbol
1116                     (x->info, owner, dyn_h->sym_indx))
1117                 return false;
1118             }
1119
1120           /* This may not be necessary or desirable anymore now that
1121              we have some support for dealing with section symbols
1122              in dynamic relocs.  But name munging does make the result
1123              much easier to debug.  ie, the EPLT reloc will reference
1124              a symbol like .foobar, instead of .text + offset.  */
1125           if (x->info->shared && h)
1126             {
1127               char *new_name;
1128               struct elf_link_hash_entry *nh;
1129
1130               new_name = alloca (strlen (h->root.root.string) + 2);
1131               new_name[0] = '.';
1132               strcpy (new_name + 1, h->root.root.string);
1133
1134               nh = elf_link_hash_lookup (elf_hash_table (x->info),
1135                                          new_name, true, true, true);
1136
1137               nh->root.type = h->root.type;
1138               nh->root.u.def.value = h->root.u.def.value;
1139               nh->root.u.def.section = h->root.u.def.section;
1140
1141               if (! bfd_elf64_link_record_dynamic_symbol (x->info, nh))
1142                 return false;
1143
1144              }
1145           dyn_h->opd_offset = x->ofs;
1146           x->ofs += OPD_ENTRY_SIZE;
1147         }
1148
1149       /* Otherwise we do not need an opd entry.  */
1150       else
1151         dyn_h->want_opd = 0;
1152     }
1153   return true;
1154 }
1155
1156 /* HP requires the EI_OSABI field to be filled in.  The assignment to
1157    EI_ABIVERSION may not be strictly necessary.  */
1158
1159 static void
1160 elf64_hppa_post_process_headers (abfd, link_info)
1161      bfd * abfd;
1162      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1163 {
1164   Elf_Internal_Ehdr * i_ehdrp;
1165
1166   i_ehdrp = elf_elfheader (abfd);
1167
1168   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
1169   i_ehdrp->e_ident[EI_ABIVERSION] = 1;
1170 }
1171
1172 /* Create function descriptor section (.opd).  This section is called .opd
1173    because it contains "official prodecure descriptors".  The "official"
1174    refers to the fact that these descriptors are used when taking the address
1175    of a procedure, thus ensuring a unique address for each procedure.  */
1176
1177 static boolean
1178 get_opd (abfd, info, hppa_info)
1179      bfd *abfd;
1180      struct bfd_link_info *info;
1181      struct elf64_hppa_link_hash_table *hppa_info;
1182 {
1183   asection *opd;
1184   bfd *dynobj;
1185
1186   opd = hppa_info->opd_sec;
1187   if (!opd)
1188     {
1189       dynobj = hppa_info->root.dynobj;
1190       if (!dynobj)
1191         hppa_info->root.dynobj = dynobj = abfd;
1192
1193       opd = bfd_make_section (dynobj, ".opd");
1194       if (!opd
1195           || !bfd_set_section_flags (dynobj, opd,
1196                                      (SEC_ALLOC
1197                                       | SEC_LOAD
1198                                       | SEC_HAS_CONTENTS
1199                                       | SEC_IN_MEMORY
1200                                       | SEC_LINKER_CREATED))
1201           || !bfd_set_section_alignment (abfd, opd, 3))
1202         {
1203           BFD_ASSERT (0);
1204           return false;
1205         }
1206
1207       hppa_info->opd_sec = opd;
1208     }
1209
1210   return true;
1211 }
1212
1213 /* Create the PLT section.  */
1214
1215 static boolean
1216 get_plt (abfd, info, hppa_info)
1217      bfd *abfd;
1218      struct bfd_link_info *info;
1219      struct elf64_hppa_link_hash_table *hppa_info;
1220 {
1221   asection *plt;
1222   bfd *dynobj;
1223
1224   plt = hppa_info->plt_sec;
1225   if (!plt)
1226     {
1227       dynobj = hppa_info->root.dynobj;
1228       if (!dynobj)
1229         hppa_info->root.dynobj = dynobj = abfd;
1230
1231       plt = bfd_make_section (dynobj, ".plt");
1232       if (!plt
1233           || !bfd_set_section_flags (dynobj, plt,
1234                                      (SEC_ALLOC
1235                                       | SEC_LOAD
1236                                       | SEC_HAS_CONTENTS
1237                                       | SEC_IN_MEMORY
1238                                       | SEC_LINKER_CREATED))
1239           || !bfd_set_section_alignment (abfd, plt, 3))
1240         {
1241           BFD_ASSERT (0);
1242           return false;
1243         }
1244
1245       hppa_info->plt_sec = plt;
1246     }
1247
1248   return true;
1249 }
1250
1251 /* Create the DLT section.  */
1252
1253 static boolean
1254 get_dlt (abfd, info, hppa_info)
1255      bfd *abfd;
1256      struct bfd_link_info *info;
1257      struct elf64_hppa_link_hash_table *hppa_info;
1258 {
1259   asection *dlt;
1260   bfd *dynobj;
1261
1262   dlt = hppa_info->dlt_sec;
1263   if (!dlt)
1264     {
1265       dynobj = hppa_info->root.dynobj;
1266       if (!dynobj)
1267         hppa_info->root.dynobj = dynobj = abfd;
1268
1269       dlt = bfd_make_section (dynobj, ".dlt");
1270       if (!dlt
1271           || !bfd_set_section_flags (dynobj, dlt,
1272                                      (SEC_ALLOC
1273                                       | SEC_LOAD
1274                                       | SEC_HAS_CONTENTS
1275                                       | SEC_IN_MEMORY
1276                                       | SEC_LINKER_CREATED))
1277           || !bfd_set_section_alignment (abfd, dlt, 3))
1278         {
1279           BFD_ASSERT (0);
1280           return false;
1281         }
1282
1283       hppa_info->dlt_sec = dlt;
1284     }
1285
1286   return true;
1287 }
1288
1289 /* Create the stubs section.  */
1290
1291 static boolean
1292 get_stub (abfd, info, hppa_info)
1293      bfd *abfd;
1294      struct bfd_link_info *info;
1295      struct elf64_hppa_link_hash_table *hppa_info;
1296 {
1297   asection *stub;
1298   bfd *dynobj;
1299
1300   stub = hppa_info->stub_sec;
1301   if (!stub)
1302     {
1303       dynobj = hppa_info->root.dynobj;
1304       if (!dynobj)
1305         hppa_info->root.dynobj = dynobj = abfd;
1306
1307       stub = bfd_make_section (dynobj, ".stub");
1308       if (!stub
1309           || !bfd_set_section_flags (dynobj, stub,
1310                                      (SEC_ALLOC
1311                                       | SEC_LOAD
1312                                       | SEC_HAS_CONTENTS
1313                                       | SEC_IN_MEMORY
1314                                       | SEC_READONLY
1315                                       | SEC_LINKER_CREATED))
1316           || !bfd_set_section_alignment (abfd, stub, 3))
1317         {
1318           BFD_ASSERT (0);
1319           return false;
1320         }
1321
1322       hppa_info->stub_sec = stub;
1323     }
1324
1325   return true;
1326 }
1327
1328 /* Create sections necessary for dynamic linking.  This is only a rough
1329    cut and will likely change as we learn more about the somewhat
1330    unusual dynamic linking scheme HP uses.
1331
1332    .stub:
1333         Contains code to implement cross-space calls.  The first time one
1334         of the stubs is used it will call into the dynamic linker, later
1335         calls will go straight to the target.
1336
1337         The only stub we support right now looks like
1338
1339         ldd OFFSET(%dp),%r1
1340         bve %r0(%r1)
1341         ldd OFFSET+8(%dp),%dp
1342
1343         Other stubs may be needed in the future.  We may want the remove
1344         the break/nop instruction.  It is only used right now to keep the
1345         offset of a .plt entry and a .stub entry in sync.
1346
1347    .dlt:
1348         This is what most people call the .got.  HP used a different name.
1349         Losers.
1350
1351    .rela.dlt:
1352         Relocations for the DLT.
1353
1354    .plt:
1355         Function pointers as address,gp pairs.
1356
1357    .rela.plt:
1358         Should contain dynamic IPLT (and EPLT?) relocations.
1359
1360    .opd:
1361         FPTRS
1362
1363    .rela.opd:
1364         EPLT relocations for symbols exported from shared libraries.  */
1365
1366 static boolean
1367 elf64_hppa_create_dynamic_sections (abfd, info)
1368      bfd *abfd;
1369      struct bfd_link_info *info;
1370 {
1371   asection *s;
1372
1373   if (! get_stub (abfd, info, elf64_hppa_hash_table (info)))
1374     return false;
1375
1376   if (! get_dlt (abfd, info, elf64_hppa_hash_table (info)))
1377     return false;
1378
1379   if (! get_plt (abfd, info, elf64_hppa_hash_table (info)))
1380     return false;
1381
1382   if (! get_opd (abfd, info, elf64_hppa_hash_table (info)))
1383     return false;
1384
1385   s = bfd_make_section(abfd, ".rela.dlt");
1386   if (s == NULL
1387       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1388                                            | SEC_HAS_CONTENTS
1389                                            | SEC_IN_MEMORY
1390                                            | SEC_READONLY
1391                                            | SEC_LINKER_CREATED))
1392       || !bfd_set_section_alignment (abfd, s, 3))
1393     return false;
1394   elf64_hppa_hash_table (info)->dlt_rel_sec = s;
1395
1396   s = bfd_make_section(abfd, ".rela.plt");
1397   if (s == NULL
1398       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1399                                            | SEC_HAS_CONTENTS
1400                                            | SEC_IN_MEMORY
1401                                            | SEC_READONLY
1402                                            | SEC_LINKER_CREATED))
1403       || !bfd_set_section_alignment (abfd, s, 3))
1404     return false;
1405   elf64_hppa_hash_table (info)->plt_rel_sec = s;
1406
1407   s = bfd_make_section(abfd, ".rela.data");
1408   if (s == NULL
1409       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1410                                            | SEC_HAS_CONTENTS
1411                                            | SEC_IN_MEMORY
1412                                            | SEC_READONLY
1413                                            | SEC_LINKER_CREATED))
1414       || !bfd_set_section_alignment (abfd, s, 3))
1415     return false;
1416   elf64_hppa_hash_table (info)->other_rel_sec = s;
1417
1418   s = bfd_make_section(abfd, ".rela.opd");
1419   if (s == NULL
1420       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1421                                            | SEC_HAS_CONTENTS
1422                                            | SEC_IN_MEMORY
1423                                            | SEC_READONLY
1424                                            | SEC_LINKER_CREATED))
1425       || !bfd_set_section_alignment (abfd, s, 3))
1426     return false;
1427   elf64_hppa_hash_table (info)->opd_rel_sec = s;
1428
1429   return true;
1430 }
1431
1432 /* Allocate dynamic relocations for those symbols that turned out
1433    to be dynamic.  */
1434
1435 static boolean
1436 allocate_dynrel_entries (dyn_h, data)
1437      struct elf64_hppa_dyn_hash_entry *dyn_h;
1438      PTR data;
1439 {
1440   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1441   struct elf64_hppa_link_hash_table *hppa_info;
1442   struct elf64_hppa_dyn_reloc_entry *rent;
1443   boolean dynamic_symbol, shared;
1444
1445   hppa_info = elf64_hppa_hash_table (x->info);
1446   dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info);
1447   shared = x->info->shared;
1448
1449   /* We may need to allocate relocations for a non-dynamic symbol
1450      when creating a shared library.  */
1451   if (!dynamic_symbol && !shared)
1452     return true;
1453
1454   /* Take care of the normal data relocations.  */
1455
1456   for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
1457     {
1458       switch (rent->type)
1459         {
1460         case R_PARISC_FPTR64:
1461           /* Allocate one iff we are not building a shared library and
1462              !want_opd, which by this point will be true only if we're
1463              actually allocating one statically in the main executable.  */
1464           if (!x->info->shared && dyn_h->want_opd)
1465             continue;
1466           break;
1467         }
1468       hppa_info->other_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1469
1470       /* Make sure this symbol gets into the dynamic symbol table if it is
1471          not already recorded.  ?!? This should not be in the loop since
1472          the symbol need only be added once.  */
1473       if (dyn_h->h == 0 || dyn_h->h->dynindx == -1)
1474         if (!_bfd_elf64_link_record_local_dynamic_symbol
1475             (x->info, rent->sec->owner, dyn_h->sym_indx))
1476           return false;
1477     }
1478
1479   /* Take care of the GOT and PLT relocations.  */
1480
1481   if ((dynamic_symbol || shared) && dyn_h->want_dlt)
1482     hppa_info->dlt_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1483
1484   /* If we are building a shared library, then every symbol that has an
1485      opd entry will need an EPLT relocation to relocate the symbol's address
1486      and __gp value based on the runtime load address.  */
1487   if (shared && dyn_h->want_opd)
1488     hppa_info->opd_rel_sec->_raw_size += sizeof (Elf64_External_Rela);
1489
1490   if (dyn_h->want_plt && dynamic_symbol)
1491     {
1492       bfd_size_type t = 0;
1493
1494       /* Dynamic symbols get one IPLT relocation.  Local symbols in
1495          shared libraries get two REL relocations.  Local symbols in
1496          main applications get nothing.  */
1497       if (dynamic_symbol)
1498         t = sizeof (Elf64_External_Rela);
1499       else if (shared)
1500         t = 2 * sizeof (Elf64_External_Rela);
1501
1502       hppa_info->plt_rel_sec->_raw_size += t;
1503     }
1504
1505   return true;
1506 }
1507
1508 /* Adjust a symbol defined by a dynamic object and referenced by a
1509    regular object.  */
1510
1511 static boolean
1512 elf64_hppa_adjust_dynamic_symbol (info, h)
1513      struct bfd_link_info *info;
1514      struct elf_link_hash_entry *h;
1515 {
1516   /* ??? Undefined symbols with PLT entries should be re-defined
1517      to be the PLT entry.  */
1518
1519   /* If this is a weak symbol, and there is a real definition, the
1520      processor independent code will have arranged for us to see the
1521      real definition first, and we can just use the same value.  */
1522   if (h->weakdef != NULL)
1523     {
1524       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1525                   || h->weakdef->root.type == bfd_link_hash_defweak);
1526       h->root.u.def.section = h->weakdef->root.u.def.section;
1527       h->root.u.def.value = h->weakdef->root.u.def.value;
1528       return true;
1529     }
1530
1531   /* If this is a reference to a symbol defined by a dynamic object which
1532      is not a function, we might allocate the symbol in our .dynbss section
1533      and allocate a COPY dynamic relocation.
1534
1535      But PA64 code is canonically PIC, so as a rule we can avoid this sort
1536      of hackery.  */
1537
1538   return true;
1539 }
1540
1541 /* Set the final sizes of the dynamic sections and allocate memory for
1542    the contents of our special sections.  */
1543
1544 static boolean
1545 elf64_hppa_size_dynamic_sections (output_bfd, info)
1546      bfd *output_bfd;
1547      struct bfd_link_info *info;
1548 {
1549   bfd *dynobj;
1550   asection *s;
1551   boolean plt;
1552   boolean relocs;
1553   boolean reltext;
1554   boolean stubs;
1555   struct elf64_hppa_allocate_data data;
1556   struct elf64_hppa_link_hash_table *hppa_info;
1557
1558   hppa_info = elf64_hppa_hash_table (info);
1559
1560   dynobj = elf_hash_table (info)->dynobj;
1561   BFD_ASSERT (dynobj != NULL);
1562
1563   if (elf_hash_table (info)->dynamic_sections_created)
1564     {
1565       /* Set the contents of the .interp section to the interpreter.  */
1566       if (! info->shared)
1567         {
1568           s = bfd_get_section_by_name (dynobj, ".interp");
1569           BFD_ASSERT (s != NULL);
1570           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1571           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1572         }
1573     }
1574   else
1575     {
1576       /* We may have created entries in the .rela.got section.
1577          However, if we are not creating the dynamic sections, we will
1578          not actually use these entries.  Reset the size of .rela.dlt,
1579          which will cause it to get stripped from the output file
1580          below.  */
1581       s = bfd_get_section_by_name (dynobj, ".rela.dlt");
1582       if (s != NULL)
1583         s->_raw_size = 0;
1584     }
1585
1586   /* Allocate the GOT entries.  */
1587
1588   data.info = info;
1589   if (elf64_hppa_hash_table (info)->dlt_sec)
1590     {
1591       data.ofs = 0x0;
1592       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1593                                     allocate_global_data_dlt, &data);
1594       hppa_info->dlt_sec->_raw_size = data.ofs;
1595
1596       data.ofs = 0x0;
1597       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1598                                     allocate_global_data_plt, &data);
1599       hppa_info->plt_sec->_raw_size = data.ofs;
1600
1601       data.ofs = 0x0;
1602       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1603                                     allocate_global_data_stub, &data);
1604       hppa_info->stub_sec->_raw_size = data.ofs;
1605     }
1606
1607   /* Mark each function this program exports so that we will allocate
1608      space in the .opd section for each function's FPTR.
1609
1610      We have to traverse the main linker hash table since we have to
1611      find functions which may not have been mentioned in any relocs.  */
1612   elf_link_hash_traverse (elf_hash_table (info),
1613                           elf64_hppa_mark_exported_functions,
1614                           info);
1615
1616   /* Allocate space for entries in the .opd section.  */
1617   if (elf64_hppa_hash_table (info)->opd_sec)
1618     {
1619       data.ofs = 0;
1620       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1621                                     allocate_global_data_opd, &data);
1622       hppa_info->opd_sec->_raw_size = data.ofs;
1623     }
1624
1625   /* Now allocate space for dynamic relocations, if necessary.  */
1626   if (hppa_info->root.dynamic_sections_created)
1627     elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1628                                   allocate_dynrel_entries, &data);
1629
1630   /* The sizes of all the sections are set.  Allocate memory for them.  */
1631   plt = false;
1632   relocs = false;
1633   reltext = false;
1634   for (s = dynobj->sections; s != NULL; s = s->next)
1635     {
1636       const char *name;
1637       boolean strip;
1638
1639       if ((s->flags & SEC_LINKER_CREATED) == 0)
1640         continue;
1641
1642       /* It's OK to base decisions on the section name, because none
1643          of the dynobj section names depend upon the input files.  */
1644       name = bfd_get_section_name (dynobj, s);
1645
1646       strip = 0;
1647
1648       if (strcmp (name, ".plt") == 0)
1649         {
1650           if (s->_raw_size == 0)
1651             {
1652               /* Strip this section if we don't need it; see the
1653                  comment below.  */
1654               strip = true;
1655             }
1656           else
1657             {
1658               /* Remember whether there is a PLT.  */
1659               plt = true;
1660             }
1661         }
1662       else if (strcmp (name, ".dlt") == 0)
1663         {
1664           if (s->_raw_size == 0)
1665             {
1666               /* Strip this section if we don't need it; see the
1667                  comment below.  */
1668               strip = true;
1669             }
1670         }
1671       else if (strcmp (name, ".opd") == 0)
1672         {
1673           if (s->_raw_size == 0)
1674             {
1675               /* Strip this section if we don't need it; see the
1676                  comment below.  */
1677               strip = true;
1678             }
1679         }
1680       else if (strncmp (name, ".rela", 4) == 0)
1681         {
1682           if (s->_raw_size == 0)
1683             {
1684               /* If we don't need this section, strip it from the
1685                  output file.  This is mostly to handle .rela.bss and
1686                  .rela.plt.  We must create both sections in
1687                  create_dynamic_sections, because they must be created
1688                  before the linker maps input sections to output
1689                  sections.  The linker does that before
1690                  adjust_dynamic_symbol is called, and it is that
1691                  function which decides whether anything needs to go
1692                  into these sections.  */
1693               strip = true;
1694             }
1695           else
1696             {
1697               asection *target;
1698
1699               /* Remember whether there are any reloc sections other
1700                  than .rela.plt.  */
1701               if (strcmp (name, ".rela.plt") != 0)
1702                 {
1703                   const char *outname;
1704
1705                   relocs = true;
1706
1707                   /* If this relocation section applies to a read only
1708                      section, then we probably need a DT_TEXTREL
1709                      entry.  The entries in the .rela.plt section
1710                      really apply to the .got section, which we
1711                      created ourselves and so know is not readonly.  */
1712                   outname = bfd_get_section_name (output_bfd,
1713                                                   s->output_section);
1714                   target = bfd_get_section_by_name (output_bfd, outname + 4);
1715                   if (target != NULL
1716                       && (target->flags & SEC_READONLY) != 0
1717                       && (target->flags & SEC_ALLOC) != 0)
1718                     reltext = true;
1719                 }
1720
1721               /* We use the reloc_count field as a counter if we need
1722                  to copy relocs into the output file.  */
1723               s->reloc_count = 0;
1724             }
1725         }
1726       else if (strncmp (name, ".dlt", 4) != 0
1727                && strcmp (name, ".stub") != 0
1728                && strcmp (name, ".got") != 0)
1729         {
1730           /* It's not one of our sections, so don't allocate space.  */
1731           continue;
1732         }
1733
1734       if (strip)
1735         {
1736           _bfd_strip_section_from_output (info, s);
1737           continue;
1738         }
1739
1740       /* Allocate memory for the section contents if it has not
1741          been allocated already.  */
1742       if (s->contents == NULL)
1743         {
1744           s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1745           if (s->contents == NULL && s->_raw_size != 0)
1746             return false;
1747         }
1748     }
1749
1750   if (elf_hash_table (info)->dynamic_sections_created)
1751     {
1752       /* Always create a DT_PLTGOT.  It actually has nothing to do with
1753          the PLT, it is how we communicate the __gp value of a load
1754          module to the dynamic linker.  */
1755       if (! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_FLAGS, 0)
1756           || ! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
1757         return false;
1758
1759       /* Add some entries to the .dynamic section.  We fill in the
1760          values later, in elf64_hppa_finish_dynamic_sections, but we
1761          must add the entries now so that we get the correct size for
1762          the .dynamic section.  The DT_DEBUG entry is filled in by the
1763          dynamic linker and used by the debugger.  */
1764       if (! info->shared)
1765         {
1766           if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0)
1767               || ! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_HOOK, 0)
1768               || ! bfd_elf64_add_dynamic_entry (info, DT_HP_LOAD_MAP, 0))
1769             return false;
1770         }
1771
1772       if (plt)
1773         {
1774           if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1775               || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1776               || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1777             return false;
1778         }
1779
1780       if (relocs)
1781         {
1782           if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1783               || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1784               || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1785                                                 sizeof (Elf64_External_Rela)))
1786             return false;
1787         }
1788
1789       if (reltext)
1790         {
1791           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1792             return false;
1793         }
1794     }
1795
1796   return true;
1797 }
1798
1799 /* Called after we have output the symbol into the dynamic symbol
1800    table, but before we output the symbol into the normal symbol
1801    table.
1802
1803    For some symbols we had to change their address when outputting
1804    the dynamic symbol table.  We undo that change here so that
1805    the symbols have their expected value in the normal symbol
1806    table.  Ick.  */
1807
1808 static boolean
1809 elf64_hppa_link_output_symbol_hook (abfd, info, name, sym, input_sec)
1810      bfd *abfd;
1811      struct bfd_link_info *info;
1812      const char *name;
1813      Elf_Internal_Sym *sym;
1814      asection *input_sec;
1815 {
1816   struct elf64_hppa_link_hash_table *hppa_info;
1817   struct elf64_hppa_dyn_hash_entry *dyn_h;
1818
1819   /* We may be called with the file symbol or section symbols.
1820      They never need munging, so it is safe to ignore them.  */
1821   if (!name)
1822     return true;
1823
1824   /* Get the PA dyn_symbol (if any) associated with NAME.  */
1825   hppa_info = elf64_hppa_hash_table (info);
1826   dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1827                                       name, false, false);
1828
1829   /* Function symbols for which we created .opd entries were munged
1830      by finish_dynamic_symbol and have to be un-munged here.  */
1831   if (dyn_h && dyn_h->want_opd)
1832     {
1833       /* Restore the saved value and section index.  */
1834       sym->st_value = dyn_h->st_value;
1835       sym->st_shndx = dyn_h->st_shndx;
1836     }
1837
1838   return true;
1839 }
1840
1841 /* Finish up dynamic symbol handling.  We set the contents of various
1842    dynamic sections here.  */
1843
1844 static boolean
1845 elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
1846      bfd *output_bfd;
1847      struct bfd_link_info *info;
1848      struct elf_link_hash_entry *h;
1849      Elf_Internal_Sym *sym;
1850 {
1851   asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel;
1852   struct elf64_hppa_link_hash_table *hppa_info;
1853   struct elf64_hppa_dyn_hash_entry *dyn_h;
1854
1855   hppa_info = elf64_hppa_hash_table (info);
1856   dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1857                                       h->root.root.string, false, false);
1858
1859   stub = hppa_info->stub_sec;
1860   splt = hppa_info->plt_sec;
1861   sdlt = hppa_info->dlt_sec;
1862   sopd = hppa_info->opd_sec;
1863   spltrel = hppa_info->plt_rel_sec;
1864   sdltrel = hppa_info->dlt_rel_sec;
1865
1866   BFD_ASSERT (stub != NULL && splt != NULL
1867               && sopd != NULL && sdlt != NULL)
1868
1869   /* Incredible.  It is actually necessary to NOT use the symbol's real
1870      value when building the dynamic symbol table for a shared library.
1871      At least for symbols that refer to functions.
1872
1873      We will store a new value and section index into the symbol long
1874      enough to output it into the dynamic symbol table, then we restore
1875      the original values (in elf64_hppa_link_output_symbol_hook).  */
1876   if (dyn_h && dyn_h->want_opd)
1877     {
1878       /* Save away the original value and section index so that we
1879          can restore them later.  */
1880       dyn_h->st_value = sym->st_value;
1881       dyn_h->st_shndx = sym->st_shndx;
1882
1883       /* For the dynamic symbol table entry, we want the value to be
1884          address of this symbol's entry within the .opd section.  */
1885       sym->st_value = (dyn_h->opd_offset
1886                        + sopd->output_offset
1887                        + sopd->output_section->vma);
1888       sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1889                                                          sopd->output_section);
1890     }
1891
1892   /* Initialize a .plt entry if requested.  */
1893   if (dyn_h && dyn_h->want_plt
1894       && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1895     {
1896       bfd_vma value;
1897       Elf_Internal_Rela rel;
1898
1899       /* We do not actually care about the value in the PLT entry
1900          if we are creating a shared library and the symbol is
1901          still undefined, we create a dynamic relocation to fill
1902          in the correct value.  */
1903       if (info->shared && h->root.type == bfd_link_hash_undefined)
1904         value = 0;
1905       else
1906         value = (h->root.u.def.value + h->root.u.def.section->vma);
1907
1908       /* Fill in the entry in the procedure linkage table.
1909
1910          The format of a plt entry is
1911          <funcaddr> <__gp>.
1912
1913          plt_offset is the offset within the PLT section at which to
1914          install the PLT entry.
1915
1916          We are modifying the in-memory PLT contents here, so we do not add
1917          in the output_offset of the PLT section.  */
1918
1919       bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset);
1920       value = _bfd_get_gp_value (splt->output_section->owner);
1921       bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset + 0x8);
1922
1923       /* Create a dynamic IPLT relocation for this entry.
1924
1925          We are creating a relocation in the output file's PLT section,
1926          which is included within the DLT secton.  So we do need to include
1927          the PLT's output_offset in the computation of the relocation's
1928          address.  */
1929       rel.r_offset = (dyn_h->plt_offset + splt->output_offset
1930                       + splt->output_section->vma);
1931       rel.r_info = ELF64_R_INFO (h->dynindx, R_PARISC_IPLT);
1932       rel.r_addend = 0;
1933
1934       bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel,
1935                                  (((Elf64_External_Rela *)
1936                                    spltrel->contents)
1937                                   + spltrel->reloc_count));
1938       spltrel->reloc_count++;
1939     }
1940
1941   /* Initialize an external call stub entry if requested.  */
1942   if (dyn_h && dyn_h->want_stub
1943       && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1944     {
1945       bfd_vma value;
1946       int insn;
1947
1948       /* Install the generic stub template.
1949
1950          We are modifying the contents of the stub section, so we do not
1951          need to include the stub section's output_offset here.  */
1952       memcpy (stub->contents + dyn_h->stub_offset, plt_stub, sizeof (plt_stub));
1953
1954       /* Fix up the first ldd instruction.
1955
1956          We are modifying the contents of the STUB section in memory,
1957          so we do not need to include its output offset in this computation.
1958
1959          Note the plt_offset value is the value of the PLT entry relative to
1960          the start of the PLT section.  These instructions will reference
1961          data relative to the value of __gp, which may not necessarily have
1962          the same address as the start of the PLT section.
1963
1964          gp_offset contains the offset of __gp within the PLT section.  */
1965       value = dyn_h->plt_offset - hppa_info->gp_offset;
1966
1967       insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset);
1968       insn &= 0xffffc00e;
1969       insn |= ((value & 0x2000) >> 13);
1970       value &= 0x1ff8;
1971       value <<= 1;
1972       bfd_put_32 (stub->owner, (insn | value),
1973                   stub->contents + dyn_h->stub_offset);
1974
1975       /* Fix up the second ldd instruction.  */
1976       value = dyn_h->plt_offset - hppa_info->gp_offset + 8;
1977
1978       insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8);
1979       insn &= 0xffffc00e;
1980       insn |= ((value & 0x2000) >> 13);
1981       value &= 0x1ff8;
1982       value <<= 1;
1983       bfd_put_32 (stub->owner, (insn | value),
1984                   stub->contents + dyn_h->stub_offset + 8);
1985     }
1986
1987   /* Millicode symbols should not be put in the dynamic
1988      symbol table under any circumstances.  */
1989   if (ELF_ST_TYPE (sym->st_info) == STT_PARISC_MILLI)
1990     h->dynindx = -1;
1991
1992   return true;
1993 }
1994
1995 /* The .opd section contains FPTRs for each function this file
1996    exports.  Initialize the FPTR entries.  */
1997
1998 static boolean
1999 elf64_hppa_finalize_opd (dyn_h, data)
2000      struct elf64_hppa_dyn_hash_entry *dyn_h;
2001      PTR data;
2002 {
2003   struct bfd_link_info *info = (struct bfd_link_info *)data;
2004   struct elf64_hppa_link_hash_table *hppa_info;
2005   struct elf_link_hash_entry *h = dyn_h->h;
2006   asection *sopd;
2007   asection *sopdrel;
2008
2009   hppa_info = elf64_hppa_hash_table (info);
2010   sopd = hppa_info->opd_sec;
2011   sopdrel = hppa_info->opd_rel_sec;
2012
2013   if (h && dyn_h && dyn_h->want_opd)
2014     {
2015       bfd_vma value;
2016
2017       /* The first two words of an .opd entry are zero.
2018
2019          We are modifying the contents of the OPD section in memory, so we
2020          do not need to include its output offset in this computation.  */
2021       memset (sopd->contents + dyn_h->opd_offset, 0, 16);
2022
2023       value = (h->root.u.def.value
2024                + h->root.u.def.section->output_section->vma
2025                + h->root.u.def.section->output_offset);
2026
2027       /* The next word is the address of the function.  */
2028       bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 16);
2029
2030       /* The last word is our local __gp value.  */
2031       value = _bfd_get_gp_value (sopd->output_section->owner);
2032       bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 24);
2033     }
2034
2035   /* If we are generating a shared library, we must generate EPLT relocations
2036      for each entry in the .opd, even for static functions (they may have
2037      had their address taken).  */
2038   if (info->shared && dyn_h && dyn_h->want_opd)
2039     {
2040       Elf64_Internal_Rela rel;
2041       bfd_vma value;
2042       int dynindx;
2043
2044       /* We may need to do a relocation against a local symbol, in
2045          which case we have to look up it's dynamic symbol index off
2046          the local symbol hash table.  */
2047       if (h && h->dynindx != -1)
2048         dynindx = h->dynindx;
2049       else
2050         dynindx
2051           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2052                                                 dyn_h->sym_indx);
2053
2054       /* The offset of this relocation is the absolute address of the
2055          .opd entry for this symbol.  */
2056       rel.r_offset = (dyn_h->opd_offset + sopd->output_offset
2057                       + sopd->output_section->vma);
2058
2059       /* If H is non-null, then we have an external symbol.
2060
2061          It is imperative that we use a different dynamic symbol for the
2062          EPLT relocation if the symbol has global scope.
2063
2064          In the dynamic symbol table, the function symbol will have a value
2065          which is address of the function's .opd entry.
2066
2067          Thus, we can not use that dynamic symbol for the EPLT relocation
2068          (if we did, the data in the .opd would reference itself rather
2069          than the actual address of the function).  Instead we have to use
2070          a new dynamic symbol which has the same value as the original global
2071          function symbol.
2072
2073          We prefix the original symbol with a "." and use the new symbol in
2074          the EPLT relocation.  This new symbol has already been recorded in
2075          the symbol table, we just have to look it up and use it.
2076
2077          We do not have such problems with static functions because we do
2078          not make their addresses in the dynamic symbol table point to
2079          the .opd entry.  Ultimately this should be safe since a static
2080          function can not be directly referenced outside of its shared
2081          library.
2082
2083          We do have to play similar games for FPTR relocations in shared
2084          libraries, including those for static symbols.  See the FPTR
2085          handling in elf64_hppa_finalize_dynreloc.  */
2086       if (h)
2087         {
2088           char *new_name;
2089           struct elf_link_hash_entry *nh;
2090
2091           new_name = alloca (strlen (h->root.root.string) + 2);
2092           new_name[0] = '.';
2093           strcpy (new_name + 1, h->root.root.string);
2094
2095           nh = elf_link_hash_lookup (elf_hash_table (info),
2096                                      new_name, false, false, false);
2097
2098           /* All we really want from the new symbol is its dynamic
2099              symbol index.  */
2100           dynindx = nh->dynindx;
2101         }
2102
2103       rel.r_addend = 0;
2104       rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2105
2106       bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel,
2107                                  (((Elf64_External_Rela *)
2108                                    sopdrel->contents)
2109                                   + sopdrel->reloc_count));
2110       sopdrel->reloc_count++;
2111     }
2112   return true;
2113 }
2114
2115 /* The .dlt section contains addresses for items referenced through the
2116    dlt.  Note that we can have a DLTIND relocation for a local symbol, thus
2117    we can not depend on finish_dynamic_symbol to initialize the .dlt.  */
2118
2119 static boolean
2120 elf64_hppa_finalize_dlt (dyn_h, data)
2121      struct elf64_hppa_dyn_hash_entry *dyn_h;
2122      PTR data;
2123 {
2124   struct bfd_link_info *info = (struct bfd_link_info *)data;
2125   struct elf64_hppa_link_hash_table *hppa_info;
2126   asection *sdlt, *sdltrel;
2127   struct elf_link_hash_entry *h = dyn_h->h;
2128
2129   hppa_info = elf64_hppa_hash_table (info);
2130
2131   sdlt = hppa_info->dlt_sec;
2132   sdltrel = hppa_info->dlt_rel_sec;
2133
2134   /* H/DYN_H may refer to a local variable and we know it's
2135      address, so there is no need to create a relocation.  Just install
2136      the proper value into the DLT, note this shortcut can not be
2137      skipped when building a shared library.  */
2138   if (! info->shared && h && dyn_h && dyn_h->want_dlt)
2139     {
2140       bfd_vma value;
2141
2142       /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2143          to point to the FPTR entry in the .opd section.
2144
2145          We include the OPD's output offset in this computation as
2146          we are referring to an absolute address in the resulting
2147          object file.  */
2148       if (dyn_h->want_opd)
2149         {
2150           value = (dyn_h->opd_offset
2151                    + hppa_info->opd_sec->output_offset
2152                    + hppa_info->opd_sec->output_section->vma);
2153         }
2154       else
2155         {
2156           value = (h->root.u.def.value
2157                    + h->root.u.def.section->output_offset);
2158
2159           if (h->root.u.def.section->output_section)
2160             value += h->root.u.def.section->output_section->vma;
2161           else
2162             value += h->root.u.def.section->vma;
2163         }
2164
2165       /* We do not need to include the output offset of the DLT section
2166          here because we are modifying the in-memory contents.  */
2167       bfd_put_64 (sdlt->owner, value, sdlt->contents + dyn_h->dlt_offset);
2168     }
2169
2170   /* Create a relocation for the DLT entry assocated with this symbol.
2171      When building a shared library the symbol does not have to be dynamic.  */
2172   if (dyn_h->want_dlt
2173       && (elf64_hppa_dynamic_symbol_p (dyn_h->h, info) || info->shared))
2174     {
2175       Elf64_Internal_Rela rel;
2176       int dynindx;
2177
2178       /* We may need to do a relocation against a local symbol, in
2179          which case we have to look up it's dynamic symbol index off
2180          the local symbol hash table.  */
2181       if (h && h->dynindx != -1)
2182         dynindx = h->dynindx;
2183       else
2184         dynindx
2185           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2186                                                 dyn_h->sym_indx);
2187
2188
2189       /* Create a dynamic relocation for this entry.  Do include the output
2190          offset of the DLT entry since we need an absolute address in the
2191          resulting object file.  */
2192       rel.r_offset = (dyn_h->dlt_offset + sdlt->output_offset
2193                       + sdlt->output_section->vma);
2194       if (h && h->type == STT_FUNC)
2195           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2196       else
2197           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2198       rel.r_addend = 0;
2199
2200       bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel,
2201                                  (((Elf64_External_Rela *)
2202                                    sdltrel->contents)
2203                                   + sdltrel->reloc_count));
2204       sdltrel->reloc_count++;
2205     }
2206   return true;
2207 }
2208
2209 /* Finalize the dynamic relocations.  Specifically the FPTR relocations
2210    for dynamic functions used to initialize static data.  */
2211
2212 static boolean
2213 elf64_hppa_finalize_dynreloc (dyn_h, data)
2214      struct elf64_hppa_dyn_hash_entry *dyn_h;
2215      PTR data;
2216 {
2217   struct bfd_link_info *info = (struct bfd_link_info *)data;
2218   struct elf64_hppa_link_hash_table *hppa_info;
2219   struct elf_link_hash_entry *h;
2220   int dynamic_symbol;
2221
2222   dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, info);
2223
2224   if (!dynamic_symbol && !info->shared)
2225     return true;
2226
2227   if (dyn_h->reloc_entries)
2228     {
2229       struct elf64_hppa_dyn_reloc_entry *rent;
2230       int dynindx;
2231
2232       hppa_info = elf64_hppa_hash_table (info);
2233       h = dyn_h->h;
2234
2235       /* We may need to do a relocation against a local symbol, in
2236          which case we have to look up it's dynamic symbol index off
2237          the local symbol hash table.  */
2238       if (h && h->dynindx != -1)
2239         dynindx = h->dynindx;
2240       else
2241         dynindx
2242           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2243                                                 dyn_h->sym_indx);
2244
2245       for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
2246         {
2247           Elf64_Internal_Rela rel;
2248
2249           switch (rent->type)
2250             {
2251               case R_PARISC_FPTR64:
2252               /* Allocate one iff we are not building a shared library and
2253                  !want_opd, which by this point will be true only if we're
2254                  actually allocating one statically in the main executable.  */
2255               if (!info->shared && dyn_h->want_opd)
2256                 continue;
2257               break;
2258             }
2259
2260           /* Create a dynamic relocation for this entry.
2261
2262              We need the output offset for the reloc's section because
2263              we are creating an absolute address in the resulting object
2264              file.  */
2265           rel.r_offset = (rent->offset + rent->sec->output_offset
2266                           + rent->sec->output_section->vma);
2267
2268           /* An FPTR64 relocation implies that we took the address of
2269              a function and that the function has an entry in the .opd
2270              section.  We want the FPTR64 relocation to reference the
2271              entry in .opd.
2272
2273              We could munge the symbol value in the dynamic symbol table
2274              (in fact we already do for functions with global scope) to point
2275              to the .opd entry.  Then we could use that dynamic symbol in
2276              this relocation.
2277
2278              Or we could do something sensible, not munge the symbol's
2279              address and instead just use a different symbol to reference
2280              the .opd entry.  At least that seems sensible until you
2281              realize there's no local dynamic symbols we can use for that
2282              purpose.  Thus the hair in the check_relocs routine.
2283
2284              We use a section symbol recorded by check_relocs as the
2285              base symbol for the relocation.  The addend is the difference
2286              between the section symbol and the address of the .opd entry.  */
2287           if (info->shared && rent->type == R_PARISC_FPTR64)
2288             {
2289               bfd_vma value, value2;
2290               asymbol *sym;
2291               int elf_index;
2292
2293               /* First compute the address of the opd entry for this symbol.  */
2294               value = (dyn_h->opd_offset
2295                        + hppa_info->opd_sec->output_section->vma
2296                        + hppa_info->opd_sec->output_offset);
2297
2298               /* Compute the value of the start of the section with
2299                  the relocation.  */
2300               value2 = (rent->sec->output_section->vma
2301                         + rent->sec->output_offset);
2302
2303               /* Compute the difference between the start of the section
2304                  with the relocation and the opd entry.  */
2305               value -= value2;
2306
2307               /* The result becomes the addend of the relocation.  */
2308               rel.r_addend = value;
2309
2310               /* The section symbol becomes the symbol for the dynamic
2311                  relocation.  */
2312               dynindx
2313                 = _bfd_elf_link_lookup_local_dynindx (info,
2314                                                       rent->sec->owner,
2315                                                       rent->sec_symndx);
2316             }
2317           else
2318             rel.r_addend = rent->addend;
2319
2320           rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2321
2322           bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2323                                      &rel,
2324                                      (((Elf64_External_Rela *)
2325                                       hppa_info->other_rel_sec->contents)
2326                                       + hppa_info->other_rel_sec->reloc_count));
2327           hppa_info->other_rel_sec->reloc_count++;
2328         }
2329     }
2330
2331   return true;
2332 }
2333
2334 /* Finish up the dynamic sections.  */
2335
2336 static boolean
2337 elf64_hppa_finish_dynamic_sections (output_bfd, info)
2338      bfd *output_bfd;
2339      struct bfd_link_info *info;
2340 {
2341   bfd *dynobj;
2342   asection *sdyn;
2343   struct elf64_hppa_link_hash_table *hppa_info;
2344
2345   hppa_info = elf64_hppa_hash_table (info);
2346
2347   /* Finalize the contents of the .opd section.  */
2348   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2349                                 elf64_hppa_finalize_opd,
2350                                 info);
2351
2352   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2353                                 elf64_hppa_finalize_dynreloc,
2354                                 info);
2355
2356   /* Finalize the contents of the .dlt section.  */
2357   dynobj = elf_hash_table (info)->dynobj;
2358   /* Finalize the contents of the .dlt section.  */
2359   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2360                                 elf64_hppa_finalize_dlt,
2361                                 info);
2362
2363
2364   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2365
2366   if (elf_hash_table (info)->dynamic_sections_created)
2367     {
2368       Elf64_External_Dyn *dyncon, *dynconend;
2369       struct elf_link_hash_entry *h;
2370
2371       BFD_ASSERT (sdyn != NULL);
2372
2373       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2374       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2375       for (; dyncon < dynconend; dyncon++)
2376         {
2377           Elf_Internal_Dyn dyn;
2378           asection *s;
2379
2380           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2381
2382           switch (dyn.d_tag)
2383             {
2384             default:
2385               break;
2386
2387             case DT_HP_LOAD_MAP:
2388               /* Compute the absolute address of 16byte scratchpad area
2389                  for the dynamic linker.
2390
2391                  By convention the linker script will allocate the scratchpad
2392                  area at the start of the .data section.  So all we have to
2393                  to is find the start of the .data section.  */
2394               s = bfd_get_section_by_name (output_bfd, ".data");
2395               dyn.d_un.d_ptr = s->vma;
2396               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2397               break;
2398
2399             case DT_PLTGOT:
2400               /* HP's use PLTGOT to set the GOT register.  */
2401               dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2402               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2403               break;
2404
2405             case DT_JMPREL:
2406               s = hppa_info->plt_rel_sec;
2407               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2408               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2409               break;
2410
2411             case DT_PLTRELSZ:
2412               s = hppa_info->plt_rel_sec;
2413               dyn.d_un.d_val = s->_raw_size;
2414               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2415               break;
2416
2417             case DT_RELA:
2418               s = hppa_info->other_rel_sec;
2419               if (! s)
2420                 s = hppa_info->dlt_rel_sec;
2421               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2422               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2423               break;
2424
2425             case DT_RELASZ:
2426               s = hppa_info->other_rel_sec;
2427               dyn.d_un.d_val = s->_raw_size;
2428               s = hppa_info->dlt_rel_sec;
2429               dyn.d_un.d_val += s->_raw_size;
2430               s = hppa_info->opd_rel_sec;
2431               dyn.d_un.d_val += s->_raw_size;
2432               /* There is some question about whether or not the size of
2433                  the PLT relocs should be included here.  HP's tools do
2434                  it, so we'll emulate them.  */
2435               s = hppa_info->plt_rel_sec;
2436               dyn.d_un.d_val += s->_raw_size;
2437               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2438               break;
2439
2440             }
2441         }
2442     }
2443
2444   return true;
2445 }
2446
2447
2448 /* Return the number of additional phdrs we will need.
2449
2450    The generic ELF code only creates PT_PHDRs for executables.  The HP
2451    dynamic linker requires PT_PHDRs for dynamic libraries too.
2452
2453    This routine indicates that the backend needs one additional program
2454    header for that case.
2455
2456    Note we do not have access to the link info structure here, so we have
2457    to guess whether or not we are building a shared library based on the
2458    existence of a .interp section.  */
2459
2460 static int
2461 elf64_hppa_additional_program_headers (abfd)
2462      bfd *abfd;
2463 {
2464   asection *s;
2465
2466   /* If we are creating a shared library, then we have to create a
2467      PT_PHDR segment.  HP's dynamic linker chokes without it.  */
2468   s = bfd_get_section_by_name (abfd, ".interp");
2469   if (! s)
2470     return 1;
2471   return 0;
2472 }
2473
2474 /* Allocate and initialize any program headers required by this
2475    specific backend.
2476
2477    The generic ELF code only creates PT_PHDRs for executables.  The HP
2478    dynamic linker requires PT_PHDRs for dynamic libraries too.
2479
2480    This allocates the PT_PHDR and initializes it in a manner suitable
2481    for the HP linker.
2482
2483    Note we do not have access to the link info structure here, so we have
2484    to guess whether or not we are building a shared library based on the
2485    existence of a .interp section.  */
2486
2487 static boolean
2488 elf64_hppa_modify_segment_map (abfd)
2489      bfd *abfd;
2490 {
2491   struct elf_segment_map *m, **pm;
2492   asection *s;
2493
2494   s = bfd_get_section_by_name (abfd, ".interp");
2495   if (! s)
2496     {
2497       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2498         if (m->p_type == PT_PHDR)
2499           break;
2500       if (m == NULL)
2501         {
2502           m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
2503           if (m == NULL)
2504             return false;
2505
2506           m->p_type = PT_PHDR;
2507           m->p_flags = PF_R | PF_X;
2508           m->p_flags_valid = 1;
2509           m->p_paddr_valid = 1;
2510           m->includes_phdrs = 1;
2511
2512           m->next = elf_tdata (abfd)->segment_map;
2513           elf_tdata (abfd)->segment_map = m;
2514         }
2515     }
2516
2517   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2518     if (m->p_type == PT_LOAD)
2519       {
2520         int i;
2521
2522         for (i = 0; i < m->count; i++)
2523           {
2524             /* The code "hint" is not really a hint.  It is a requirement
2525                for certain versions of the HP dynamic linker.  Worse yet,
2526                it must be set even if the shared library does not have
2527                any code in its "text" segment (thus the check for .hash
2528                to catch this situation).  */
2529             if (m->sections[i]->flags & SEC_CODE
2530                 || (strcmp (m->sections[i]->name, ".hash") == 0))
2531               m->p_flags |= (PF_X | PF_HP_CODE);
2532           }
2533       }
2534
2535   return true;
2536 }
2537
2538 /* The hash bucket size is the standard one, namely 4.  */
2539
2540 const struct elf_size_info hppa64_elf_size_info =
2541 {
2542   sizeof (Elf64_External_Ehdr),
2543   sizeof (Elf64_External_Phdr),
2544   sizeof (Elf64_External_Shdr),
2545   sizeof (Elf64_External_Rel),
2546   sizeof (Elf64_External_Rela),
2547   sizeof (Elf64_External_Sym),
2548   sizeof (Elf64_External_Dyn),
2549   sizeof (Elf_External_Note),
2550   4,
2551   1,
2552   64, 8,
2553   ELFCLASS64, EV_CURRENT,
2554   bfd_elf64_write_out_phdrs,
2555   bfd_elf64_write_shdrs_and_ehdr,
2556   bfd_elf64_write_relocs,
2557   bfd_elf64_swap_symbol_out,
2558   bfd_elf64_slurp_reloc_table,
2559   bfd_elf64_slurp_symbol_table,
2560   bfd_elf64_swap_dyn_in,
2561   bfd_elf64_swap_dyn_out,
2562   NULL,
2563   NULL,
2564   NULL,
2565   NULL
2566 };
2567
2568 #define TARGET_BIG_SYM                  bfd_elf64_hppa_vec
2569 #define TARGET_BIG_NAME                 "elf64-hppa"
2570 #define ELF_ARCH                        bfd_arch_hppa
2571 #define ELF_MACHINE_CODE                EM_PARISC
2572 /* This is not strictly correct.  The maximum page size for PA2.0 is
2573    64M.  But everything still uses 4k.  */
2574 #define ELF_MAXPAGESIZE                 0x1000
2575 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2576 #define bfd_elf64_bfd_is_local_label_name       elf_hppa_is_local_label_name
2577 #define elf_info_to_howto               elf_hppa_info_to_howto
2578 #define elf_info_to_howto_rel           elf_hppa_info_to_howto_rel
2579
2580 #define elf_backend_section_from_shdr   elf64_hppa_section_from_shdr
2581 #define elf_backend_object_p            elf64_hppa_object_p
2582 #define elf_backend_final_write_processing \
2583                                         elf_hppa_final_write_processing
2584 #define elf_backend_fake_sections       elf_hppa_fake_sections
2585 #define elf_backend_add_symbol_hook     elf_hppa_add_symbol_hook
2586
2587 #define elf_backend_relocate_section        elf_hppa_relocate_section
2588
2589 #define bfd_elf64_bfd_final_link        elf_hppa_final_link
2590
2591 #define elf_backend_create_dynamic_sections \
2592                                         elf64_hppa_create_dynamic_sections
2593 #define elf_backend_post_process_headers        elf64_hppa_post_process_headers
2594
2595 #define elf_backend_adjust_dynamic_symbol \
2596                                         elf64_hppa_adjust_dynamic_symbol
2597
2598 #define elf_backend_size_dynamic_sections \
2599                                         elf64_hppa_size_dynamic_sections
2600
2601 #define elf_backend_finish_dynamic_symbol \
2602                                         elf64_hppa_finish_dynamic_symbol
2603 #define elf_backend_finish_dynamic_sections \
2604                                         elf64_hppa_finish_dynamic_sections
2605
2606 /* Stuff for the BFD linker: */
2607 #define bfd_elf64_bfd_link_hash_table_create \
2608         elf64_hppa_hash_table_create
2609
2610 #define elf_backend_check_relocs \
2611         elf64_hppa_check_relocs
2612
2613 #define elf_backend_size_info \
2614   hppa64_elf_size_info
2615
2616 #define elf_backend_additional_program_headers \
2617         elf64_hppa_additional_program_headers
2618
2619 #define elf_backend_modify_segment_map \
2620         elf64_hppa_modify_segment_map
2621
2622 #define elf_backend_link_output_symbol_hook \
2623         elf64_hppa_link_output_symbol_hook
2624
2625
2626 #define elf_backend_want_got_plt        0
2627 #define elf_backend_plt_readonly        0
2628 #define elf_backend_want_plt_sym        0
2629 #define elf_backend_got_header_size     0
2630 #define elf_backend_plt_header_size     0
2631 #define elf_backend_type_change_ok true
2632
2633 #include "elf64-target.h"