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 derived 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 ((asection *, struct elf_link_hash_entry *,
 176            const Elf_Internal_Rela *, char **, size_t *));
 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 ATTRIBUTE_UNUSED;
 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 (sec, h, rel, pbuf, plen)
 403      asection *sec;
 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     nlen = 8 + 1 + sizeof (rel->r_info) * 2 - 8;
 420   tlen = nlen + 1 + sizeof (rel->r_addend) * 2 + 1;
 421
 422   len = *plen;
 423   buf = *pbuf;
 424   if (len < tlen)
 425     {
 426       if (buf)
 427         free (buf);
 428       *pbuf = buf = malloc (tlen);
 429       *plen = len = tlen;
 430       if (!buf)
 431         return NULL;
 432     }
 433
 434   if (h)
 435     {
 436       memcpy (buf, h->root.root.string, nlen);
 437       buf[nlen++] = '+';
 438       sprintf_vma (buf + nlen, rel->r_addend);
 439     }
 440   else
 441     {
 442       nlen = sprintf (buf, "%x:%lx",
 443                       sec->id & 0xffffffff,
 444                       (long) 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       unsigned int i;
 578       int highest_shndx;
 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 (sec, 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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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 ATTRIBUTE_UNUSED;
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   struct elf64_hppa_allocate_data data;
1555   struct elf64_hppa_link_hash_table *hppa_info;
1556
1557   hppa_info = elf64_hppa_hash_table (info);
1558
1559   dynobj = elf_hash_table (info)->dynobj;
1560   BFD_ASSERT (dynobj != NULL);
1561
1562   if (elf_hash_table (info)->dynamic_sections_created)
1563     {
1564       /* Set the contents of the .interp section to the interpreter.  */
1565       if (! info->shared)
1566         {
1567           s = bfd_get_section_by_name (dynobj, ".interp");
1568           BFD_ASSERT (s != NULL);
1569           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1570           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1571         }
1572     }
1573   else
1574     {
1575       /* We may have created entries in the .rela.got section.
1576          However, if we are not creating the dynamic sections, we will
1577          not actually use these entries.  Reset the size of .rela.dlt,
1578          which will cause it to get stripped from the output file
1579          below.  */
1580       s = bfd_get_section_by_name (dynobj, ".rela.dlt");
1581       if (s != NULL)
1582         s->_raw_size = 0;
1583     }
1584
1585   /* Allocate the GOT entries.  */
1586
1587   data.info = info;
1588   if (elf64_hppa_hash_table (info)->dlt_sec)
1589     {
1590       data.ofs = 0x0;
1591       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1592                                     allocate_global_data_dlt, &data);
1593       hppa_info->dlt_sec->_raw_size = data.ofs;
1594
1595       data.ofs = 0x0;
1596       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1597                                     allocate_global_data_plt, &data);
1598       hppa_info->plt_sec->_raw_size = data.ofs;
1599
1600       data.ofs = 0x0;
1601       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1602                                     allocate_global_data_stub, &data);
1603       hppa_info->stub_sec->_raw_size = data.ofs;
1604     }
1605
1606   /* Mark each function this program exports so that we will allocate
1607      space in the .opd section for each function's FPTR.
1608
1609      We have to traverse the main linker hash table since we have to
1610      find functions which may not have been mentioned in any relocs.  */
1611   elf_link_hash_traverse (elf_hash_table (info),
1612                           elf64_hppa_mark_exported_functions,
1613                           info);
1614
1615   /* Allocate space for entries in the .opd section.  */
1616   if (elf64_hppa_hash_table (info)->opd_sec)
1617     {
1618       data.ofs = 0;
1619       elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1620                                     allocate_global_data_opd, &data);
1621       hppa_info->opd_sec->_raw_size = data.ofs;
1622     }
1623
1624   /* Now allocate space for dynamic relocations, if necessary.  */
1625   if (hppa_info->root.dynamic_sections_created)
1626     elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1627                                   allocate_dynrel_entries, &data);
1628
1629   /* The sizes of all the sections are set.  Allocate memory for them.  */
1630   plt = false;
1631   relocs = false;
1632   reltext = false;
1633   for (s = dynobj->sections; s != NULL; s = s->next)
1634     {
1635       const char *name;
1636       boolean strip;
1637
1638       if ((s->flags & SEC_LINKER_CREATED) == 0)
1639         continue;
1640
1641       /* It's OK to base decisions on the section name, because none
1642          of the dynobj section names depend upon the input files.  */
1643       name = bfd_get_section_name (dynobj, s);
1644
1645       strip = 0;
1646
1647       if (strcmp (name, ".plt") == 0)
1648         {
1649           if (s->_raw_size == 0)
1650             {
1651               /* Strip this section if we don't need it; see the
1652                  comment below.  */
1653               strip = true;
1654             }
1655           else
1656             {
1657               /* Remember whether there is a PLT.  */
1658               plt = true;
1659             }
1660         }
1661       else if (strcmp (name, ".dlt") == 0)
1662         {
1663           if (s->_raw_size == 0)
1664             {
1665               /* Strip this section if we don't need it; see the
1666                  comment below.  */
1667               strip = true;
1668             }
1669         }
1670       else if (strcmp (name, ".opd") == 0)
1671         {
1672           if (s->_raw_size == 0)
1673             {
1674               /* Strip this section if we don't need it; see the
1675                  comment below.  */
1676               strip = true;
1677             }
1678         }
1679       else if (strncmp (name, ".rela", 4) == 0)
1680         {
1681           if (s->_raw_size == 0)
1682             {
1683               /* If we don't need this section, strip it from the
1684                  output file.  This is mostly to handle .rela.bss and
1685                  .rela.plt.  We must create both sections in
1686                  create_dynamic_sections, because they must be created
1687                  before the linker maps input sections to output
1688                  sections.  The linker does that before
1689                  adjust_dynamic_symbol is called, and it is that
1690                  function which decides whether anything needs to go
1691                  into these sections.  */
1692               strip = true;
1693             }
1694           else
1695             {
1696               asection *target;
1697
1698               /* Remember whether there are any reloc sections other
1699                  than .rela.plt.  */
1700               if (strcmp (name, ".rela.plt") != 0)
1701                 {
1702                   const char *outname;
1703
1704                   relocs = true;
1705
1706                   /* If this relocation section applies to a read only
1707                      section, then we probably need a DT_TEXTREL
1708                      entry.  The entries in the .rela.plt section
1709                      really apply to the .got section, which we
1710                      created ourselves and so know is not readonly.  */
1711                   outname = bfd_get_section_name (output_bfd,
1712                                                   s->output_section);
1713                   target = bfd_get_section_by_name (output_bfd, outname + 4);
1714                   if (target != NULL
1715                       && (target->flags & SEC_READONLY) != 0
1716                       && (target->flags & SEC_ALLOC) != 0)
1717                     reltext = true;
1718                 }
1719
1720               /* We use the reloc_count field as a counter if we need
1721                  to copy relocs into the output file.  */
1722               s->reloc_count = 0;
1723             }
1724         }
1725       else if (strncmp (name, ".dlt", 4) != 0
1726                && strcmp (name, ".stub") != 0
1727                && strcmp (name, ".got") != 0)
1728         {
1729           /* It's not one of our sections, so don't allocate space.  */
1730           continue;
1731         }
1732
1733       if (strip)
1734         {
1735           _bfd_strip_section_from_output (info, s);
1736           continue;
1737         }
1738
1739       /* Allocate memory for the section contents if it has not
1740          been allocated already.  */
1741       if (s->contents == NULL)
1742         {
1743           /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
1744              Unused entries should be reclaimed before the section's contents
1745              are written out, but at the moment this does not happen.  Thus in
1746              order to prevent writing out garbage, we initialise the section's
1747              contents to zero.  */
1748           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1749           if (s->contents == NULL && s->_raw_size != 0)
1750             return false;
1751         }
1752     }
1753
1754   if (elf_hash_table (info)->dynamic_sections_created)
1755     {
1756       /* Always create a DT_PLTGOT.  It actually has nothing to do with
1757          the PLT, it is how we communicate the __gp value of a load
1758          module to the dynamic linker.  */
1759       if (! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_FLAGS, 0)
1760           || ! bfd_elf64_add_dynamic_entry (info, DT_PLTGOT, 0))
1761         return false;
1762
1763       /* Add some entries to the .dynamic section.  We fill in the
1764          values later, in elf64_hppa_finish_dynamic_sections, but we
1765          must add the entries now so that we get the correct size for
1766          the .dynamic section.  The DT_DEBUG entry is filled in by the
1767          dynamic linker and used by the debugger.  */
1768       if (! info->shared)
1769         {
1770           if (! bfd_elf64_add_dynamic_entry (info, DT_DEBUG, 0)
1771               || ! bfd_elf64_add_dynamic_entry (info, DT_HP_DLD_HOOK, 0)
1772               || ! bfd_elf64_add_dynamic_entry (info, DT_HP_LOAD_MAP, 0))
1773             return false;
1774         }
1775
1776       if (plt)
1777         {
1778           if (! bfd_elf64_add_dynamic_entry (info, DT_PLTRELSZ, 0)
1779               || ! bfd_elf64_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
1780               || ! bfd_elf64_add_dynamic_entry (info, DT_JMPREL, 0))
1781             return false;
1782         }
1783
1784       if (relocs)
1785         {
1786           if (! bfd_elf64_add_dynamic_entry (info, DT_RELA, 0)
1787               || ! bfd_elf64_add_dynamic_entry (info, DT_RELASZ, 0)
1788               || ! bfd_elf64_add_dynamic_entry (info, DT_RELAENT,
1789                                                 sizeof (Elf64_External_Rela)))
1790             return false;
1791         }
1792
1793       if (reltext)
1794         {
1795           if (! bfd_elf64_add_dynamic_entry (info, DT_TEXTREL, 0))
1796             return false;
1797           info->flags |= DF_TEXTREL;
1798         }
1799     }
1800
1801   return true;
1802 }
1803
1804 /* Called after we have output the symbol into the dynamic symbol
1805    table, but before we output the symbol into the normal symbol
1806    table.
1807
1808    For some symbols we had to change their address when outputting
1809    the dynamic symbol table.  We undo that change here so that
1810    the symbols have their expected value in the normal symbol
1811    table.  Ick.  */
1812
1813 static boolean
1814 elf64_hppa_link_output_symbol_hook (abfd, info, name, sym, input_sec)
1815      bfd *abfd ATTRIBUTE_UNUSED;
1816      struct bfd_link_info *info;
1817      const char *name;
1818      Elf_Internal_Sym *sym;
1819      asection *input_sec ATTRIBUTE_UNUSED;
1820 {
1821   struct elf64_hppa_link_hash_table *hppa_info;
1822   struct elf64_hppa_dyn_hash_entry *dyn_h;
1823
1824   /* We may be called with the file symbol or section symbols.
1825      They never need munging, so it is safe to ignore them.  */
1826   if (!name)
1827     return true;
1828
1829   /* Get the PA dyn_symbol (if any) associated with NAME.  */
1830   hppa_info = elf64_hppa_hash_table (info);
1831   dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1832                                       name, false, false);
1833
1834   /* Function symbols for which we created .opd entries were munged
1835      by finish_dynamic_symbol and have to be un-munged here.  */
1836   if (dyn_h && dyn_h->want_opd)
1837     {
1838       /* Restore the saved value and section index.  */
1839       sym->st_value = dyn_h->st_value;
1840       sym->st_shndx = dyn_h->st_shndx;
1841     }
1842
1843   return true;
1844 }
1845
1846 /* Finish up dynamic symbol handling.  We set the contents of various
1847    dynamic sections here.  */
1848
1849 static boolean
1850 elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
1851      bfd *output_bfd;
1852      struct bfd_link_info *info;
1853      struct elf_link_hash_entry *h;
1854      Elf_Internal_Sym *sym;
1855 {
1856   asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel;
1857   struct elf64_hppa_link_hash_table *hppa_info;
1858   struct elf64_hppa_dyn_hash_entry *dyn_h;
1859
1860   hppa_info = elf64_hppa_hash_table (info);
1861   dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1862                                       h->root.root.string, false, false);
1863
1864   stub = hppa_info->stub_sec;
1865   splt = hppa_info->plt_sec;
1866   sdlt = hppa_info->dlt_sec;
1867   sopd = hppa_info->opd_sec;
1868   spltrel = hppa_info->plt_rel_sec;
1869   sdltrel = hppa_info->dlt_rel_sec;
1870
1871   BFD_ASSERT (stub != NULL && splt != NULL
1872               && sopd != NULL && sdlt != NULL)
1873
1874   /* Incredible.  It is actually necessary to NOT use the symbol's real
1875      value when building the dynamic symbol table for a shared library.
1876      At least for symbols that refer to functions.
1877
1878      We will store a new value and section index into the symbol long
1879      enough to output it into the dynamic symbol table, then we restore
1880      the original values (in elf64_hppa_link_output_symbol_hook).  */
1881   if (dyn_h && dyn_h->want_opd)
1882     {
1883       /* Save away the original value and section index so that we
1884          can restore them later.  */
1885       dyn_h->st_value = sym->st_value;
1886       dyn_h->st_shndx = sym->st_shndx;
1887
1888       /* For the dynamic symbol table entry, we want the value to be
1889          address of this symbol's entry within the .opd section.  */
1890       sym->st_value = (dyn_h->opd_offset
1891                        + sopd->output_offset
1892                        + sopd->output_section->vma);
1893       sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1894                                                          sopd->output_section);
1895     }
1896
1897   /* Initialize a .plt entry if requested.  */
1898   if (dyn_h && dyn_h->want_plt
1899       && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1900     {
1901       bfd_vma value;
1902       Elf_Internal_Rela rel;
1903
1904       /* We do not actually care about the value in the PLT entry
1905          if we are creating a shared library and the symbol is
1906          still undefined, we create a dynamic relocation to fill
1907          in the correct value.  */
1908       if (info->shared && h->root.type == bfd_link_hash_undefined)
1909         value = 0;
1910       else
1911         value = (h->root.u.def.value + h->root.u.def.section->vma);
1912
1913       /* Fill in the entry in the procedure linkage table.
1914
1915          The format of a plt entry is
1916          <funcaddr> <__gp>.
1917
1918          plt_offset is the offset within the PLT section at which to
1919          install the PLT entry.
1920
1921          We are modifying the in-memory PLT contents here, so we do not add
1922          in the output_offset of the PLT section.  */
1923
1924       bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset);
1925       value = _bfd_get_gp_value (splt->output_section->owner);
1926       bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset + 0x8);
1927
1928       /* Create a dynamic IPLT relocation for this entry.
1929
1930          We are creating a relocation in the output file's PLT section,
1931          which is included within the DLT secton.  So we do need to include
1932          the PLT's output_offset in the computation of the relocation's
1933          address.  */
1934       rel.r_offset = (dyn_h->plt_offset + splt->output_offset
1935                       + splt->output_section->vma);
1936       rel.r_info = ELF64_R_INFO (h->dynindx, R_PARISC_IPLT);
1937       rel.r_addend = 0;
1938
1939       bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel,
1940                                  (((Elf64_External_Rela *)
1941                                    spltrel->contents)
1942                                   + spltrel->reloc_count));
1943       spltrel->reloc_count++;
1944     }
1945
1946   /* Initialize an external call stub entry if requested.  */
1947   if (dyn_h && dyn_h->want_stub
1948       && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1949     {
1950       bfd_vma value;
1951       int insn;
1952
1953       /* Install the generic stub template.
1954
1955          We are modifying the contents of the stub section, so we do not
1956          need to include the stub section's output_offset here.  */
1957       memcpy (stub->contents + dyn_h->stub_offset, plt_stub, sizeof (plt_stub));
1958
1959       /* Fix up the first ldd instruction.
1960
1961          We are modifying the contents of the STUB section in memory,
1962          so we do not need to include its output offset in this computation.
1963
1964          Note the plt_offset value is the value of the PLT entry relative to
1965          the start of the PLT section.  These instructions will reference
1966          data relative to the value of __gp, which may not necessarily have
1967          the same address as the start of the PLT section.
1968
1969          gp_offset contains the offset of __gp within the PLT section.  */
1970       value = dyn_h->plt_offset - hppa_info->gp_offset;
1971
1972       insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset);
1973       insn &= 0xffffc00e;
1974       insn |= ((value & 0x2000) >> 13);
1975       value &= 0x1ff8;
1976       value <<= 1;
1977       bfd_put_32 (stub->owner, (insn | value),
1978                   stub->contents + dyn_h->stub_offset);
1979
1980       /* Fix up the second ldd instruction.  */
1981       value = dyn_h->plt_offset - hppa_info->gp_offset + 8;
1982
1983       insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8);
1984       insn &= 0xffffc00e;
1985       insn |= ((value & 0x2000) >> 13);
1986       value &= 0x1ff8;
1987       value <<= 1;
1988       bfd_put_32 (stub->owner, (insn | value),
1989                   stub->contents + dyn_h->stub_offset + 8);
1990     }
1991
1992   /* Millicode symbols should not be put in the dynamic
1993      symbol table under any circumstances.  */
1994   if (ELF_ST_TYPE (sym->st_info) == STT_PARISC_MILLI)
1995     h->dynindx = -1;
1996
1997   return true;
1998 }
1999
2000 /* The .opd section contains FPTRs for each function this file
2001    exports.  Initialize the FPTR entries.  */
2002
2003 static boolean
2004 elf64_hppa_finalize_opd (dyn_h, data)
2005      struct elf64_hppa_dyn_hash_entry *dyn_h;
2006      PTR data;
2007 {
2008   struct bfd_link_info *info = (struct bfd_link_info *)data;
2009   struct elf64_hppa_link_hash_table *hppa_info;
2010   struct elf_link_hash_entry *h = dyn_h->h;
2011   asection *sopd;
2012   asection *sopdrel;
2013
2014   hppa_info = elf64_hppa_hash_table (info);
2015   sopd = hppa_info->opd_sec;
2016   sopdrel = hppa_info->opd_rel_sec;
2017
2018   if (h && dyn_h && dyn_h->want_opd)
2019     {
2020       bfd_vma value;
2021
2022       /* The first two words of an .opd entry are zero.
2023
2024          We are modifying the contents of the OPD section in memory, so we
2025          do not need to include its output offset in this computation.  */
2026       memset (sopd->contents + dyn_h->opd_offset, 0, 16);
2027
2028       value = (h->root.u.def.value
2029                + h->root.u.def.section->output_section->vma
2030                + h->root.u.def.section->output_offset);
2031
2032       /* The next word is the address of the function.  */
2033       bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 16);
2034
2035       /* The last word is our local __gp value.  */
2036       value = _bfd_get_gp_value (sopd->output_section->owner);
2037       bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 24);
2038     }
2039
2040   /* If we are generating a shared library, we must generate EPLT relocations
2041      for each entry in the .opd, even for static functions (they may have
2042      had their address taken).  */
2043   if (info->shared && dyn_h && dyn_h->want_opd)
2044     {
2045       Elf64_Internal_Rela rel;
2046       int dynindx;
2047
2048       /* We may need to do a relocation against a local symbol, in
2049          which case we have to look up it's dynamic symbol index off
2050          the local symbol hash table.  */
2051       if (h && h->dynindx != -1)
2052         dynindx = h->dynindx;
2053       else
2054         dynindx
2055           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2056                                                 dyn_h->sym_indx);
2057
2058       /* The offset of this relocation is the absolute address of the
2059          .opd entry for this symbol.  */
2060       rel.r_offset = (dyn_h->opd_offset + sopd->output_offset
2061                       + sopd->output_section->vma);
2062
2063       /* If H is non-null, then we have an external symbol.
2064
2065          It is imperative that we use a different dynamic symbol for the
2066          EPLT relocation if the symbol has global scope.
2067
2068          In the dynamic symbol table, the function symbol will have a value
2069          which is address of the function's .opd entry.
2070
2071          Thus, we can not use that dynamic symbol for the EPLT relocation
2072          (if we did, the data in the .opd would reference itself rather
2073          than the actual address of the function).  Instead we have to use
2074          a new dynamic symbol which has the same value as the original global
2075          function symbol.
2076
2077          We prefix the original symbol with a "." and use the new symbol in
2078          the EPLT relocation.  This new symbol has already been recorded in
2079          the symbol table, we just have to look it up and use it.
2080
2081          We do not have such problems with static functions because we do
2082          not make their addresses in the dynamic symbol table point to
2083          the .opd entry.  Ultimately this should be safe since a static
2084          function can not be directly referenced outside of its shared
2085          library.
2086
2087          We do have to play similar games for FPTR relocations in shared
2088          libraries, including those for static symbols.  See the FPTR
2089          handling in elf64_hppa_finalize_dynreloc.  */
2090       if (h)
2091         {
2092           char *new_name;
2093           struct elf_link_hash_entry *nh;
2094
2095           new_name = alloca (strlen (h->root.root.string) + 2);
2096           new_name[0] = '.';
2097           strcpy (new_name + 1, h->root.root.string);
2098
2099           nh = elf_link_hash_lookup (elf_hash_table (info),
2100                                      new_name, false, false, false);
2101
2102           /* All we really want from the new symbol is its dynamic
2103              symbol index.  */
2104           dynindx = nh->dynindx;
2105         }
2106
2107       rel.r_addend = 0;
2108       rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2109
2110       bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel,
2111                                  (((Elf64_External_Rela *)
2112                                    sopdrel->contents)
2113                                   + sopdrel->reloc_count));
2114       sopdrel->reloc_count++;
2115     }
2116   return true;
2117 }
2118
2119 /* The .dlt section contains addresses for items referenced through the
2120    dlt.  Note that we can have a DLTIND relocation for a local symbol, thus
2121    we can not depend on finish_dynamic_symbol to initialize the .dlt.  */
2122
2123 static boolean
2124 elf64_hppa_finalize_dlt (dyn_h, data)
2125      struct elf64_hppa_dyn_hash_entry *dyn_h;
2126      PTR data;
2127 {
2128   struct bfd_link_info *info = (struct bfd_link_info *)data;
2129   struct elf64_hppa_link_hash_table *hppa_info;
2130   asection *sdlt, *sdltrel;
2131   struct elf_link_hash_entry *h = dyn_h->h;
2132
2133   hppa_info = elf64_hppa_hash_table (info);
2134
2135   sdlt = hppa_info->dlt_sec;
2136   sdltrel = hppa_info->dlt_rel_sec;
2137
2138   /* H/DYN_H may refer to a local variable and we know it's
2139      address, so there is no need to create a relocation.  Just install
2140      the proper value into the DLT, note this shortcut can not be
2141      skipped when building a shared library.  */
2142   if (! info->shared && h && dyn_h && dyn_h->want_dlt)
2143     {
2144       bfd_vma value;
2145
2146       /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2147          to point to the FPTR entry in the .opd section.
2148
2149          We include the OPD's output offset in this computation as
2150          we are referring to an absolute address in the resulting
2151          object file.  */
2152       if (dyn_h->want_opd)
2153         {
2154           value = (dyn_h->opd_offset
2155                    + hppa_info->opd_sec->output_offset
2156                    + hppa_info->opd_sec->output_section->vma);
2157         }
2158       else
2159         {
2160           value = (h->root.u.def.value
2161                    + h->root.u.def.section->output_offset);
2162
2163           if (h->root.u.def.section->output_section)
2164             value += h->root.u.def.section->output_section->vma;
2165           else
2166             value += h->root.u.def.section->vma;
2167         }
2168
2169       /* We do not need to include the output offset of the DLT section
2170          here because we are modifying the in-memory contents.  */
2171       bfd_put_64 (sdlt->owner, value, sdlt->contents + dyn_h->dlt_offset);
2172     }
2173
2174   /* Create a relocation for the DLT entry assocated with this symbol.
2175      When building a shared library the symbol does not have to be dynamic.  */
2176   if (dyn_h->want_dlt
2177       && (elf64_hppa_dynamic_symbol_p (dyn_h->h, info) || info->shared))
2178     {
2179       Elf64_Internal_Rela rel;
2180       int dynindx;
2181
2182       /* We may need to do a relocation against a local symbol, in
2183          which case we have to look up it's dynamic symbol index off
2184          the local symbol hash table.  */
2185       if (h && h->dynindx != -1)
2186         dynindx = h->dynindx;
2187       else
2188         dynindx
2189           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2190                                                 dyn_h->sym_indx);
2191
2192
2193       /* Create a dynamic relocation for this entry.  Do include the output
2194          offset of the DLT entry since we need an absolute address in the
2195          resulting object file.  */
2196       rel.r_offset = (dyn_h->dlt_offset + sdlt->output_offset
2197                       + sdlt->output_section->vma);
2198       if (h && h->type == STT_FUNC)
2199           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2200       else
2201           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2202       rel.r_addend = 0;
2203
2204       bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel,
2205                                  (((Elf64_External_Rela *)
2206                                    sdltrel->contents)
2207                                   + sdltrel->reloc_count));
2208       sdltrel->reloc_count++;
2209     }
2210   return true;
2211 }
2212
2213 /* Finalize the dynamic relocations.  Specifically the FPTR relocations
2214    for dynamic functions used to initialize static data.  */
2215
2216 static boolean
2217 elf64_hppa_finalize_dynreloc (dyn_h, data)
2218      struct elf64_hppa_dyn_hash_entry *dyn_h;
2219      PTR data;
2220 {
2221   struct bfd_link_info *info = (struct bfd_link_info *)data;
2222   struct elf64_hppa_link_hash_table *hppa_info;
2223   struct elf_link_hash_entry *h;
2224   int dynamic_symbol;
2225
2226   dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, info);
2227
2228   if (!dynamic_symbol && !info->shared)
2229     return true;
2230
2231   if (dyn_h->reloc_entries)
2232     {
2233       struct elf64_hppa_dyn_reloc_entry *rent;
2234       int dynindx;
2235
2236       hppa_info = elf64_hppa_hash_table (info);
2237       h = dyn_h->h;
2238
2239       /* We may need to do a relocation against a local symbol, in
2240          which case we have to look up it's dynamic symbol index off
2241          the local symbol hash table.  */
2242       if (h && h->dynindx != -1)
2243         dynindx = h->dynindx;
2244       else
2245         dynindx
2246           = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2247                                                 dyn_h->sym_indx);
2248
2249       for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
2250         {
2251           Elf64_Internal_Rela rel;
2252
2253           switch (rent->type)
2254             {
2255               case R_PARISC_FPTR64:
2256               /* Allocate one iff we are not building a shared library and
2257                  !want_opd, which by this point will be true only if we're
2258                  actually allocating one statically in the main executable.  */
2259               if (!info->shared && dyn_h->want_opd)
2260                 continue;
2261               break;
2262             }
2263
2264           /* Create a dynamic relocation for this entry.
2265
2266              We need the output offset for the reloc's section because
2267              we are creating an absolute address in the resulting object
2268              file.  */
2269           rel.r_offset = (rent->offset + rent->sec->output_offset
2270                           + rent->sec->output_section->vma);
2271
2272           /* An FPTR64 relocation implies that we took the address of
2273              a function and that the function has an entry in the .opd
2274              section.  We want the FPTR64 relocation to reference the
2275              entry in .opd.
2276
2277              We could munge the symbol value in the dynamic symbol table
2278              (in fact we already do for functions with global scope) to point
2279              to the .opd entry.  Then we could use that dynamic symbol in
2280              this relocation.
2281
2282              Or we could do something sensible, not munge the symbol's
2283              address and instead just use a different symbol to reference
2284              the .opd entry.  At least that seems sensible until you
2285              realize there's no local dynamic symbols we can use for that
2286              purpose.  Thus the hair in the check_relocs routine.
2287
2288              We use a section symbol recorded by check_relocs as the
2289              base symbol for the relocation.  The addend is the difference
2290              between the section symbol and the address of the .opd entry.  */
2291           if (info->shared && rent->type == R_PARISC_FPTR64)
2292             {
2293               bfd_vma value, value2;
2294
2295               /* First compute the address of the opd entry for this symbol.  */
2296               value = (dyn_h->opd_offset
2297                        + hppa_info->opd_sec->output_section->vma
2298                        + hppa_info->opd_sec->output_offset);
2299
2300               /* Compute the value of the start of the section with
2301                  the relocation.  */
2302               value2 = (rent->sec->output_section->vma
2303                         + rent->sec->output_offset);
2304
2305               /* Compute the difference between the start of the section
2306                  with the relocation and the opd entry.  */
2307               value -= value2;
2308
2309               /* The result becomes the addend of the relocation.  */
2310               rel.r_addend = value;
2311
2312               /* The section symbol becomes the symbol for the dynamic
2313                  relocation.  */
2314               dynindx
2315                 = _bfd_elf_link_lookup_local_dynindx (info,
2316                                                       rent->sec->owner,
2317                                                       rent->sec_symndx);
2318             }
2319           else
2320             rel.r_addend = rent->addend;
2321
2322           rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2323
2324           bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2325                                      &rel,
2326                                      (((Elf64_External_Rela *)
2327                                       hppa_info->other_rel_sec->contents)
2328                                       + hppa_info->other_rel_sec->reloc_count));
2329           hppa_info->other_rel_sec->reloc_count++;
2330         }
2331     }
2332
2333   return true;
2334 }
2335
2336 /* Finish up the dynamic sections.  */
2337
2338 static boolean
2339 elf64_hppa_finish_dynamic_sections (output_bfd, info)
2340      bfd *output_bfd;
2341      struct bfd_link_info *info;
2342 {
2343   bfd *dynobj;
2344   asection *sdyn;
2345   struct elf64_hppa_link_hash_table *hppa_info;
2346
2347   hppa_info = elf64_hppa_hash_table (info);
2348
2349   /* Finalize the contents of the .opd section.  */
2350   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2351                                 elf64_hppa_finalize_opd,
2352                                 info);
2353
2354   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2355                                 elf64_hppa_finalize_dynreloc,
2356                                 info);
2357
2358   /* Finalize the contents of the .dlt section.  */
2359   dynobj = elf_hash_table (info)->dynobj;
2360   /* Finalize the contents of the .dlt section.  */
2361   elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2362                                 elf64_hppa_finalize_dlt,
2363                                 info);
2364
2365
2366   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2367
2368   if (elf_hash_table (info)->dynamic_sections_created)
2369     {
2370       Elf64_External_Dyn *dyncon, *dynconend;
2371
2372       BFD_ASSERT (sdyn != NULL);
2373
2374       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2375       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2376       for (; dyncon < dynconend; dyncon++)
2377         {
2378           Elf_Internal_Dyn dyn;
2379           asection *s;
2380
2381           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2382
2383           switch (dyn.d_tag)
2384             {
2385             default:
2386               break;
2387
2388             case DT_HP_LOAD_MAP:
2389               /* Compute the absolute address of 16byte scratchpad area
2390                  for the dynamic linker.
2391
2392                  By convention the linker script will allocate the scratchpad
2393                  area at the start of the .data section.  So all we have to
2394                  to is find the start of the .data section.  */
2395               s = bfd_get_section_by_name (output_bfd, ".data");
2396               dyn.d_un.d_ptr = s->vma;
2397               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2398               break;
2399
2400             case DT_PLTGOT:
2401               /* HP's use PLTGOT to set the GOT register.  */
2402               dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2403               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2404               break;
2405
2406             case DT_JMPREL:
2407               s = hppa_info->plt_rel_sec;
2408               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2409               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2410               break;
2411
2412             case DT_PLTRELSZ:
2413               s = hppa_info->plt_rel_sec;
2414               dyn.d_un.d_val = s->_raw_size;
2415               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2416               break;
2417
2418             case DT_RELA:
2419               s = hppa_info->other_rel_sec;
2420               if (! s)
2421                 s = hppa_info->dlt_rel_sec;
2422               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2423               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2424               break;
2425
2426             case DT_RELASZ:
2427               s = hppa_info->other_rel_sec;
2428               dyn.d_un.d_val = s->_raw_size;
2429               s = hppa_info->dlt_rel_sec;
2430               dyn.d_un.d_val += s->_raw_size;
2431               s = hppa_info->opd_rel_sec;
2432               dyn.d_un.d_val += s->_raw_size;
2433               /* There is some question about whether or not the size of
2434                  the PLT relocs should be included here.  HP's tools do
2435                  it, so we'll emulate them.  */
2436               s = hppa_info->plt_rel_sec;
2437               dyn.d_un.d_val += s->_raw_size;
2438               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2439               break;
2440
2441             }
2442         }
2443     }
2444
2445   return true;
2446 }
2447
2448
2449 /* Return the number of additional phdrs we will need.
2450
2451    The generic ELF code only creates PT_PHDRs for executables.  The HP
2452    dynamic linker requires PT_PHDRs for dynamic libraries too.
2453
2454    This routine indicates that the backend needs one additional program
2455    header for that case.
2456
2457    Note we do not have access to the link info structure here, so we have
2458    to guess whether or not we are building a shared library based on the
2459    existence of a .interp section.  */
2460
2461 static int
2462 elf64_hppa_additional_program_headers (abfd)
2463      bfd *abfd;
2464 {
2465   asection *s;
2466
2467   /* If we are creating a shared library, then we have to create a
2468      PT_PHDR segment.  HP's dynamic linker chokes without it.  */
2469   s = bfd_get_section_by_name (abfd, ".interp");
2470   if (! s)
2471     return 1;
2472   return 0;
2473 }
2474
2475 /* Allocate and initialize any program headers required by this
2476    specific backend.
2477
2478    The generic ELF code only creates PT_PHDRs for executables.  The HP
2479    dynamic linker requires PT_PHDRs for dynamic libraries too.
2480
2481    This allocates the PT_PHDR and initializes it in a manner suitable
2482    for the HP linker.
2483
2484    Note we do not have access to the link info structure here, so we have
2485    to guess whether or not we are building a shared library based on the
2486    existence of a .interp section.  */
2487
2488 static boolean
2489 elf64_hppa_modify_segment_map (abfd)
2490      bfd *abfd;
2491 {
2492   struct elf_segment_map *m;
2493   asection *s;
2494
2495   s = bfd_get_section_by_name (abfd, ".interp");
2496   if (! s)
2497     {
2498       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2499         if (m->p_type == PT_PHDR)
2500           break;
2501       if (m == NULL)
2502         {
2503           m = (struct elf_segment_map *) bfd_zalloc (abfd, sizeof *m);
2504           if (m == NULL)
2505             return false;
2506
2507           m->p_type = PT_PHDR;
2508           m->p_flags = PF_R | PF_X;
2509           m->p_flags_valid = 1;
2510           m->p_paddr_valid = 1;
2511           m->includes_phdrs = 1;
2512
2513           m->next = elf_tdata (abfd)->segment_map;
2514           elf_tdata (abfd)->segment_map = m;
2515         }
2516     }
2517
2518   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2519     if (m->p_type == PT_LOAD)
2520       {
2521         unsigned int i;
2522
2523         for (i = 0; i < m->count; i++)
2524           {
2525             /* The code "hint" is not really a hint.  It is a requirement
2526                for certain versions of the HP dynamic linker.  Worse yet,
2527                it must be set even if the shared library does not have
2528                any code in its "text" segment (thus the check for .hash
2529                to catch this situation).  */
2530             if (m->sections[i]->flags & SEC_CODE
2531                 || (strcmp (m->sections[i]->name, ".hash") == 0))
2532               m->p_flags |= (PF_X | PF_HP_CODE);
2533           }
2534       }
2535
2536   return true;
2537 }
2538
2539 /* The hash bucket size is the standard one, namely 4.  */
2540
2541 const struct elf_size_info hppa64_elf_size_info =
2542 {
2543   sizeof (Elf64_External_Ehdr),
2544   sizeof (Elf64_External_Phdr),
2545   sizeof (Elf64_External_Shdr),
2546   sizeof (Elf64_External_Rel),
2547   sizeof (Elf64_External_Rela),
2548   sizeof (Elf64_External_Sym),
2549   sizeof (Elf64_External_Dyn),
2550   sizeof (Elf_External_Note),
2551   4,
2552   1,
2553   64, 8,
2554   ELFCLASS64, EV_CURRENT,
2555   bfd_elf64_write_out_phdrs,
2556   bfd_elf64_write_shdrs_and_ehdr,
2557   bfd_elf64_write_relocs,
2558   bfd_elf64_swap_symbol_out,
2559   bfd_elf64_slurp_reloc_table,
2560   bfd_elf64_slurp_symbol_table,
2561   bfd_elf64_swap_dyn_in,
2562   bfd_elf64_swap_dyn_out,
2563   NULL,
2564   NULL,
2565   NULL,
2566   NULL
2567 };
2568
2569 #define TARGET_BIG_SYM                  bfd_elf64_hppa_vec
2570 #define TARGET_BIG_NAME                 "elf64-hppa"
2571 #define ELF_ARCH                        bfd_arch_hppa
2572 #define ELF_MACHINE_CODE                EM_PARISC
2573 /* This is not strictly correct.  The maximum page size for PA2.0 is
2574    64M.  But everything still uses 4k.  */
2575 #define ELF_MAXPAGESIZE                 0x1000
2576 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2577 #define bfd_elf64_bfd_is_local_label_name       elf_hppa_is_local_label_name
2578 #define elf_info_to_howto               elf_hppa_info_to_howto
2579 #define elf_info_to_howto_rel           elf_hppa_info_to_howto_rel
2580
2581 #define elf_backend_section_from_shdr   elf64_hppa_section_from_shdr
2582 #define elf_backend_object_p            elf64_hppa_object_p
2583 #define elf_backend_final_write_processing \
2584                                         elf_hppa_final_write_processing
2585 #define elf_backend_fake_sections       elf_hppa_fake_sections
2586 #define elf_backend_add_symbol_hook     elf_hppa_add_symbol_hook
2587
2588 #define elf_backend_relocate_section        elf_hppa_relocate_section
2589
2590 #define bfd_elf64_bfd_final_link        elf_hppa_final_link
2591
2592 #define elf_backend_create_dynamic_sections \
2593                                         elf64_hppa_create_dynamic_sections
2594 #define elf_backend_post_process_headers        elf64_hppa_post_process_headers
2595
2596 #define elf_backend_adjust_dynamic_symbol \
2597                                         elf64_hppa_adjust_dynamic_symbol
2598
2599 #define elf_backend_size_dynamic_sections \
2600                                         elf64_hppa_size_dynamic_sections
2601
2602 #define elf_backend_finish_dynamic_symbol \
2603                                         elf64_hppa_finish_dynamic_symbol
2604 #define elf_backend_finish_dynamic_sections \
2605                                         elf64_hppa_finish_dynamic_sections
2606
2607 /* Stuff for the BFD linker: */
2608 #define bfd_elf64_bfd_link_hash_table_create \
2609         elf64_hppa_hash_table_create
2610
2611 #define elf_backend_check_relocs \
2612         elf64_hppa_check_relocs
2613
2614 #define elf_backend_size_info \
2615   hppa64_elf_size_info
2616
2617 #define elf_backend_additional_program_headers \
2618         elf64_hppa_additional_program_headers
2619
2620 #define elf_backend_modify_segment_map \
2621         elf64_hppa_modify_segment_map
2622
2623 #define elf_backend_link_output_symbol_hook \
2624         elf64_hppa_link_output_symbol_hook
2625
2626
2627 #define elf_backend_want_got_plt        0
2628 #define elf_backend_plt_readonly        0
2629 #define elf_backend_want_plt_sym        0
2630 #define elf_backend_got_header_size     0
2631 #define elf_backend_plt_header_size     0
2632 #define elf_backend_type_change_ok true
2633
2634 #include "elf64-target.h"