bfd/elf32-hppa.c

   1 /* BFD back-end for HP PA-RISC ELF files.
   2    Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
   3
   4    Written by
   5
   6         Center for Software Science
   7         Department of Computer Science
   8         University of Utah
   9
  10 This file is part of BFD, the Binary File Descriptor library.
  11
  12 This program is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 This program is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with this program; if not, write to the Free Software
  24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  25
  26 #include "bfd.h"
  27 #include "sysdep.h"
  28 #include "bfdlink.h"
  29 #include "libbfd.h"
  30 #include "obstack.h"
  31 #include "libelf.h"
  32
  33 /* The internal type of a symbol table extension entry.  */
  34 typedef unsigned long symext_entryS;
  35
  36 /* The external type of a symbol table extension entry.  */
  37 #define ELF32_PARISC_SX_SIZE (4)
  38 #define ELF32_PARISC_SX_GET(bfd, addr) bfd_h_get_32 ((bfd), (addr))
  39 #define ELF32_PARISC_SX_PUT(bfd, val, addr) \
  40   bfd_h_put_32 ((bfd), (val), (addr))
  41
  42 /* HPPA symbol table extension entry types */
  43 enum elf32_hppa_symextn_types
  44 {
  45   PARISC_SXT_NULL,
  46   PARISC_SXT_SYMNDX,
  47   PARISC_SXT_ARG_RELOC,
  48 };
  49
  50 /* These macros compose and decompose the value of a symextn entry:
  51
  52    entry_type = ELF32_PARISC_SX_TYPE(word);
  53    entry_value = ELF32_PARISC_SX_VAL(word);
  54    word = ELF32_PARISC_SX_WORD(type,val);  */
  55
  56 #define ELF32_PARISC_SX_TYPE(p)         ((p) >> 24)
  57 #define ELF32_PARISC_SX_VAL(p)          ((p) & 0xFFFFFF)
  58 #define ELF32_PARISC_SX_WORD(type,val)  (((type) << 24) + (val & 0xFFFFFF))
  59
  60 /* The following was added facilitate implementation of the .hppa_symextn
  61    section.  This section is built after the symbol table is built in the
  62    elf_write_object_contents routine (called from bfd_close).  It is built
  63    so late because it requires information that is not known until
  64    the symbol and string table sections have been allocated, and
  65    the symbol table has been built. */
  66
  67 #define SYMEXTN_SECTION_NAME ".PARISC.symext"
  68
  69 struct symext_chain
  70   {
  71     symext_entryS entry;
  72     struct symext_chain *next;
  73   };
  74
  75 typedef struct symext_chain symext_chainS;
  76
  77 /* We use three different hash tables to hold information for
  78    linking PA ELF objects.
  79
  80    The first is the elf32_hppa_link_hash_table which is derived
  81    from the standard ELF linker hash table.  We use this as a place to
  82    attach other hash tables and static information.
  83
  84    The second is the stub hash table which is derived from the
  85    base BFD hash table.  The stub hash table holds the information
  86    necessary to build the linker stubs during a link.
  87
  88    The last hash table keeps track of argument location information needed
  89    to build hash tables.  Each function with nonzero argument location
  90    bits will have an entry in this table.  */
  91
  92 /* Hash table for linker stubs.  */
  93
  94 struct elf32_hppa_stub_hash_entry
  95 {
  96   /* Base hash table entry structure, we can get the name of the stub
  97      (and thus know exactly what actions it performs) from the base
  98      hash table entry.  */
  99   struct bfd_hash_entry root;
 100
 101   /* Offset of the beginning of this stub.  */
 102   bfd_vma offset;
 103
 104   /* Given the symbol's value and its section we can determine its final
 105      value when building the stubs (so the stub knows where to jump.  */
 106   symvalue target_value;
 107   asection *target_section;
 108 };
 109
 110 struct elf32_hppa_stub_hash_table
 111 {
 112   /* The hash table itself.  */
 113   struct bfd_hash_table root;
 114
 115   /* The stub BFD.  */
 116   bfd *stub_bfd;
 117
 118   /* Where to place the next stub.  */
 119   bfd_byte *location;
 120
 121   /* Current offset in the stub section.  */
 122   unsigned int offset;
 123
 124 };
 125
 126 /* Hash table for argument location information.  */
 127
 128 struct elf32_hppa_args_hash_entry
 129 {
 130   /* Base hash table entry structure.  */
 131   struct bfd_hash_entry root;
 132
 133   /* The argument location bits for this entry.  */
 134   int arg_bits;
 135 };
 136
 137 struct elf32_hppa_args_hash_table
 138 {
 139   /* The hash table itself.  */
 140   struct bfd_hash_table root;
 141 };
 142
 143 struct elf32_hppa_link_hash_entry
 144 {
 145   struct elf_link_hash_entry root;
 146 };
 147
 148 struct elf32_hppa_link_hash_table
 149 {
 150   /* The main hash table.  */
 151   struct elf_link_hash_table root;
 152
 153   /* The stub hash table.  */
 154   struct elf32_hppa_stub_hash_table *stub_hash_table;
 155
 156   /* The argument relocation bits hash table.  */
 157   struct elf32_hppa_args_hash_table *args_hash_table;
 158
 159   /* A count of the number of output symbols.  */
 160   unsigned int output_symbol_count;
 161
 162   /* Stuff so we can handle DP relative relocations.  */
 163   long global_value;
 164   int global_sym_defined;
 165 };
 166
 167 /* FIXME.  */
 168 #define ARGUMENTS       0
 169 #define RETURN_VALUE    1
 170
 171 /* The various argument relocations that may be performed.  */
 172 typedef enum
 173 {
 174   /* No relocation.  */
 175   NO,
 176   /* Relocate 32 bits from GR to FP register.  */
 177   GF,
 178   /* Relocate 64 bits from a GR pair to FP pair.  */
 179   GD,
 180   /* Relocate 32 bits from FP to GR.  */
 181   FG,
 182   /* Relocate 64 bits from FP pair to GR pair.  */
 183   DG,
 184 } arg_reloc_type;
 185
 186 /* What is being relocated (eg which argument or the return value).  */
 187 typedef enum
 188 {
 189   ARG0, ARG1, ARG2, ARG3, RET,
 190 } arg_reloc_location;
 191
 192
 193 /* ELF32/HPPA relocation support
 194
 195         This file contains ELF32/HPPA relocation support as specified
 196         in the Stratus FTX/Golf Object File Format (SED-1762) dated
 197         February 1994.  */
 198
 199 #include "elf32-hppa.h"
 200 #include "hppa_stubs.h"
 201
 202 static bfd_reloc_status_type hppa_elf_reloc
 203   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 204
 205 static unsigned long hppa_elf_relocate_insn
 206   PARAMS ((bfd *, asection *, unsigned long, unsigned long, long,
 207            long, unsigned long, unsigned long, unsigned long));
 208
 209 static bfd_reloc_status_type hppa_elf_reloc
 210   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd*, char **));
 211
 212 static reloc_howto_type * elf_hppa_reloc_type_lookup
 213   PARAMS ((bfd *, bfd_reloc_code_real_type));
 214
 215 static boolean elf32_hppa_set_section_contents
 216   PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
 217
 218 static void elf_info_to_howto
 219   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
 220
 221 static boolean elf32_hppa_backend_symbol_table_processing
 222   PARAMS ((bfd *, elf_symbol_type *, int));
 223
 224 static void elf32_hppa_backend_begin_write_processing
 225   PARAMS ((bfd *, struct bfd_link_info *));
 226
 227 static void elf32_hppa_backend_final_write_processing
 228   PARAMS ((bfd *, boolean));
 229
 230 static void add_entry_to_symext_chain
 231   PARAMS ((bfd *, unsigned int, unsigned int, symext_chainS **,
 232            symext_chainS **));
 233
 234 static void
 235 elf_hppa_tc_make_sections PARAMS ((bfd *, symext_chainS *));
 236
 237 static boolean hppa_elf_is_local_label PARAMS ((bfd *, asymbol *));
 238
 239 static boolean elf32_hppa_add_symbol_hook
 240   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
 241            const char **, flagword *, asection **, bfd_vma *));
 242
 243 static bfd_reloc_status_type elf32_hppa_bfd_final_link_relocate
 244   PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
 245            bfd_byte *, bfd_vma, bfd_vma, bfd_vma, struct bfd_link_info *,
 246            asection *, const char *, int));
 247
 248 static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
 249   PARAMS ((bfd *));
 250
 251 static struct bfd_hash_entry *
 252 elf32_hppa_stub_hash_newfunc
 253   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 254
 255 static struct bfd_hash_entry *
 256 elf32_hppa_args_hash_newfunc
 257   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
 258
 259 static boolean
 260 elf32_hppa_relocate_section
 261   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
 262            bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
 263
 264 static boolean
 265 elf32_hppa_stub_hash_table_init
 266   PARAMS ((struct elf32_hppa_stub_hash_table *, bfd *,
 267            struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *,
 268                                                struct bfd_hash_table *,
 269                                                const char *))));
 270
 271 static boolean
 272 elf32_hppa_build_one_stub PARAMS ((struct bfd_hash_entry *, PTR));
 273
 274 static boolean
 275 elf32_hppa_read_symext_info
 276   PARAMS ((bfd *, Elf_Internal_Shdr *, struct elf32_hppa_args_hash_table *,
 277            Elf_Internal_Sym *));
 278
 279 static unsigned int elf32_hppa_size_of_stub
 280   PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, const char *));
 281
 282 static boolean elf32_hppa_arg_reloc_needed
 283   PARAMS ((unsigned int, unsigned int, arg_reloc_type []));
 284
 285 static void elf32_hppa_name_of_stub
 286   PARAMS ((unsigned int, unsigned int, bfd_vma, bfd_vma, char *));
 287
 288 static boolean elf32_hppa_size_symext PARAMS ((struct bfd_hash_entry *, PTR));
 289
 290 static boolean elf32_hppa_link_output_symbol_hook
 291   PARAMS ((bfd *, struct bfd_link_info *, const char *,
 292            Elf_Internal_Sym *, asection *));
 293
 294 /* ELF/PA relocation howto entries.  */
 295
 296 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
 297 {
 298   {R_PARISC_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_NONE"},
 299   {R_PARISC_DIR32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR32"},
 300   {R_PARISC_DIR21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR21L"},
 301   {R_PARISC_DIR17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17R"},
 302   {R_PARISC_DIR17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR17F"},
 303   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 304   {R_PARISC_DIR14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DIR14R"},
 305   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 306
 307   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 308   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 309   {R_PARISC_PCREL21L, 0, 0, 21, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL21L"},
 310   {R_PARISC_PCREL17R, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17R"},
 311   {R_PARISC_PCREL17F, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17F"},
 312   {R_PARISC_PCREL17C, 0, 0, 17, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL17C"},
 313   {R_PARISC_PCREL14R, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14R"},
 314   {R_PARISC_PCREL14F, 0, 0, 14, true, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PCREL14F"},
 315
 316   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 317   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 318   {R_PARISC_DPREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL21L"},
 319   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 320   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 321   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 322   {R_PARISC_DPREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14R"},
 323   {R_PARISC_DPREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DPREL14F"},
 324
 325   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 326   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 327   {R_PARISC_DLTREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL21L"},
 328   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 329   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 330   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 331   {R_PARISC_DLTREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14R"},
 332   {R_PARISC_DLTREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTREL14F"},
 333
 334   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 335   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 336   {R_PARISC_DLTIND21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND21L"},
 337   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 338   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 339   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 340   {R_PARISC_DLTIND14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14R"},
 341   {R_PARISC_DLTIND14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_DLTIND14F"},
 342
 343   {R_PARISC_SETBASE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_SETBASE"},
 344   {R_PARISC_BASEREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL32"},
 345   {R_PARISC_BASEREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL21L"},
 346   {R_PARISC_BASEREL17R, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17R"},
 347   {R_PARISC_BASEREL17F, 0, 0, 17, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL17F"},
 348   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 349   {R_PARISC_BASEREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14R"},
 350   {R_PARISC_BASEREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_BASEREL14F"},
 351
 352   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 353   {R_PARISC_TEXTREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_TEXTREL32"},
 354   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 355   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 356   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 357   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 358   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 359   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 360
 361   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 362   {R_PARISC_DATAREL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 363   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 364   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 365   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 366   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 367   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 368   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 369
 370
 371   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 372   {R_PARISC_PLABEL32, 0, 0, 32, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL32"},
 373   {R_PARISC_PLABEL21L, 0, 0, 21, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL21L"},
 374   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 375   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 376   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 377   {R_PARISC_PLABEL14R, 0, 0, 14, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLABEL14R"},
 378   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 379
 380   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 381   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 382   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 383   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 384   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 385   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 386   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 387   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 388
 389   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 390   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 391   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 392   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 393   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 394   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 395   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 396   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 397   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 398   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 399   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 400   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 401   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 402   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 403   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 404   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 405
 406   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 407   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 408   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 409   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 410   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 411   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 412   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 413   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 414   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 415   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 416   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 417   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 418   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 419   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 420   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 421   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 422
 423   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 424   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 425   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 426   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 427   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 428   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 429   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 430   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 431   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 432   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 433   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 434   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 435   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 436   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 437   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 438   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 439
 440
 441   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 442   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 443   {R_PARISC_PLTIND21L, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND21L"},
 444   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 445   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 446   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_UNIMPLEMENTED"},
 447   {R_PARISC_PLTIND14R, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14R"},
 448   {R_PARISC_PLTIND14F, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_PLTIND14F"},
 449
 450
 451   {R_PARISC_COPY, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_COPY"},
 452   {R_PARISC_GLOB_DAT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_GLOB_DAT"},
 453   {R_PARISC_JMP_SLOT, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_JMP_SLOT"},
 454   {R_PARISC_RELATIVE, 0, 0, 0, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_PARISC_RELATIVE"},
 455
 456   {R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont, NULL, "R_PARISC_UNIMPLEMENTED"},
 457 };
 458
 459 /* Where (what register type) is an argument comming from?  */
 460 typedef enum
 461 {
 462   AR_NO,
 463   AR_GR,
 464   AR_FR,
 465   AR_FU,
 466   AR_FPDBL1,
 467   AR_FPDBL2,
 468 } arg_location;
 469
 470 /* Horizontal represents the callee's argument location information,
 471    vertical represents caller's argument location information.  Value at a
 472    particular X,Y location represents what (if any) argument relocation
 473    needs to be performed to make caller and callee agree.  */
 474
 475 static CONST arg_reloc_type arg_mismatches[6][6] =
 476 {
 477   {NO, NO, NO, NO, NO, NO},
 478   {NO, NO, GF, NO, GD, NO},
 479   {NO, FG, NO, NO, NO, NO},
 480   {NO, NO, NO, NO, NO, NO},
 481   {NO, DG, NO, NO, NO, NO},
 482   {NO, DG, NO, NO, NO, NO},
 483 };
 484
 485 /* Likewise, but reversed for the return value.  */
 486 static CONST arg_reloc_type ret_mismatches[6][6] =
 487 {
 488   {NO, NO, NO, NO, NO, NO},
 489   {NO, NO, FG, NO, DG, NO},
 490   {NO, GF, NO, NO, NO, NO},
 491   {NO, NO, NO, NO, NO, NO},
 492   {NO, GD, NO, NO, NO, NO},
 493   {NO, GD, NO, NO, NO, NO},
 494 };
 495
 496 /* Misc static crud for symbol extension records.  */
 497 static symext_chainS *symext_rootP;
 498 static symext_chainS *symext_lastP;
 499 static bfd_size_type symext_chain_size;
 500
 501 /* FIXME: We should be able to try this static variable!  */
 502 static bfd_byte *symextn_contents;
 503
 504
 505 /* For linker stub hash tables.  */
 506 #define elf32_hppa_stub_hash_lookup(table, string, create, copy) \
 507   ((struct elf32_hppa_stub_hash_entry *) \
 508    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
 509
 510 #define elf32_hppa_stub_hash_traverse(table, func, info) \
 511   (bfd_hash_traverse \
 512    (&(table)->root, \
 513     (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
 514     (info)))
 515
 516 /* For linker args hash tables.  */
 517 #define elf32_hppa_args_hash_lookup(table, string, create, copy) \
 518   ((struct elf32_hppa_args_hash_entry *) \
 519    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
 520
 521 #define elf32_hppa_args_hash_traverse(table, func, info) \
 522   (bfd_hash_traverse \
 523    (&(table)->root, \
 524     (boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) (func), \
 525     (info)))
 526
 527 #define elf32_hppa_args_hash_table_init(table, newfunc) \
 528   (bfd_hash_table_init \
 529    (&(table)->root, \
 530     (struct bfd_hash_entry *(*) PARAMS ((struct bfd_hash_entry *, \
 531                                          struct bfd_hash_table *, \
 532                                          const char *))) (newfunc)))
 533
 534 /* For HPPA linker hash table.  */
 535
 536 #define elf32_hppa_link_hash_lookup(table, string, create, copy, follow)\
 537   ((struct elf32_hppa_link_hash_entry *)                                \
 538    elf_link_hash_lookup (&(table)->root, (string), (create),            \
 539                          (copy), (follow)))
 540
 541 #define elf32_hppa_link_hash_traverse(table, func, info)                \
 542   (elf_link_hash_traverse                                               \
 543    (&(table)->root,                                                     \
 544     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
 545     (info)))
 546
 547 /* Get the PA ELF linker hash table from a link_info structure.  */
 548
 549 #define elf32_hppa_hash_table(p) \
 550   ((struct elf32_hppa_link_hash_table *) ((p)->hash))
 551
 552
 553 /* Extract specific argument location bits for WHICH from
 554    the full argument location in AR.  */
 555 #define EXTRACT_ARBITS(ar, which) ((ar) >> (8 - ((which) * 2))) & 3
 556
 557 /* Assorted hash table functions.  */
 558
 559 /* Initialize an entry in the stub hash table.  */
 560
 561 static struct bfd_hash_entry *
 562 elf32_hppa_stub_hash_newfunc (entry, table, string)
 563      struct bfd_hash_entry *entry;
 564      struct bfd_hash_table *table;
 565      const char *string;
 566 {
 567   struct elf32_hppa_stub_hash_entry *ret;
 568
 569   ret = (struct elf32_hppa_stub_hash_entry *) entry;
 570
 571   /* Allocate the structure if it has not already been allocated by a
 572      subclass.  */
 573   if (ret == NULL)
 574     ret = ((struct elf32_hppa_stub_hash_entry *)
 575            bfd_hash_allocate (table,
 576                               sizeof (struct elf32_hppa_stub_hash_entry)));
 577   if (ret == NULL)
 578     {
 579       bfd_set_error (bfd_error_no_memory);
 580       return NULL;
 581     }
 582
 583   /* Call the allocation method of the superclass.  */
 584   ret = ((struct elf32_hppa_stub_hash_entry *)
 585          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 586
 587   if (ret)
 588     {
 589       /* Initialize the local fields.  */
 590       ret->offset = 0;
 591       ret->target_value = 0;
 592       ret->target_section = NULL;
 593     }
 594
 595   return (struct bfd_hash_entry *) ret;
 596 }
 597
 598 /* Initialize a stub hash table.  */
 599
 600 static boolean
 601 elf32_hppa_stub_hash_table_init (table, stub_bfd, newfunc)
 602      struct elf32_hppa_stub_hash_table *table;
 603      bfd *stub_bfd;
 604      struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
 605                                                 struct bfd_hash_table *,
 606                                                 const char *));
 607 {
 608   table->offset = 0;
 609   table->location = 0;
 610   table->stub_bfd = stub_bfd;
 611   return (bfd_hash_table_init (&table->root, newfunc));
 612 }
 613
 614 /* Initialize an entry in the argument location hash table.  */
 615
 616 static struct bfd_hash_entry *
 617 elf32_hppa_args_hash_newfunc (entry, table, string)
 618      struct bfd_hash_entry *entry;
 619      struct bfd_hash_table *table;
 620      const char *string;
 621 {
 622   struct elf32_hppa_args_hash_entry *ret;
 623
 624   ret = (struct elf32_hppa_args_hash_entry *) entry;
 625
 626   /* Allocate the structure if it has not already been allocated by a
 627      subclass.  */
 628   if (ret == NULL)
 629     ret = ((struct elf32_hppa_args_hash_entry *)
 630            bfd_hash_allocate (table,
 631                               sizeof (struct elf32_hppa_args_hash_entry)));
 632   if (ret == NULL)
 633     {
 634       bfd_set_error (bfd_error_no_memory);
 635       return NULL;
 636     }
 637
 638   /* Call the allocation method of the superclass.  */
 639   ret = ((struct elf32_hppa_args_hash_entry *)
 640          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
 641
 642   /* Initialize the local fields.  */
 643   if (ret)
 644     ret->arg_bits = 0;
 645
 646   return (struct bfd_hash_entry *) ret;
 647 }
 648
 649 /* Create the derived linker hash table.  The PA ELF port uses the derived
 650    hash table to keep information specific to the PA ELF linker (without
 651    using static variables).  */
 652
 653 static struct bfd_link_hash_table *
 654 elf32_hppa_link_hash_table_create (abfd)
 655      bfd *abfd;
 656 {
 657   struct elf32_hppa_link_hash_table *ret;
 658
 659   ret = ((struct elf32_hppa_link_hash_table *)
 660          bfd_alloc (abfd, sizeof (struct elf32_hppa_link_hash_table)));
 661   if (ret == NULL)
 662     {
 663       bfd_set_error (bfd_error_no_memory);
 664       return NULL;
 665     }
 666   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 667                                       _bfd_elf_link_hash_newfunc))
 668     {
 669       bfd_release (abfd, ret);
 670       return NULL;
 671     }
 672   ret->stub_hash_table = NULL;
 673   ret->args_hash_table = NULL;
 674   ret->output_symbol_count = 0;
 675   ret->global_value = 0;
 676   ret->global_sym_defined = 0;
 677
 678   return &ret->root.root;
 679 }
 680
 681 /* Relocate the given INSN given the various input parameters.
 682
 683    FIXME: endianness and sizeof (long) issues abound here.  */
 684
 685 static unsigned long
 686 hppa_elf_relocate_insn (abfd, input_sect, insn, address, sym_value,
 687                         r_addend, r_format, r_field, pcrel)
 688      bfd *abfd;
 689      asection *input_sect;
 690      unsigned long insn;
 691      unsigned long address;
 692      long sym_value;
 693      long r_addend;
 694      unsigned long r_format;
 695      unsigned long r_field;
 696      unsigned long pcrel;
 697 {
 698   unsigned char opcode = get_opcode (insn);
 699   long constant_value;
 700
 701   switch (opcode)
 702     {
 703     case LDO:
 704     case LDB:
 705     case LDH:
 706     case LDW:
 707     case LDWM:
 708     case STB:
 709     case STH:
 710     case STW:
 711     case STWM:
 712     case COMICLR:
 713     case SUBI:
 714     case ADDIT:
 715     case ADDI:
 716     case LDIL:
 717     case ADDIL:
 718       constant_value = HPPA_R_CONSTANT (r_addend);
 719
 720       if (pcrel)
 721         sym_value -= address;
 722
 723       sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
 724       return hppa_rebuild_insn (abfd, insn, sym_value, r_format);
 725
 726     case BL:
 727     case BE:
 728     case BLE:
 729       /* XXX computing constant_value is not needed??? */
 730       constant_value = assemble_17 ((insn & 0x001f0000) >> 16,
 731                                     (insn & 0x00001ffc) >> 2,
 732                                     insn & 1);
 733
 734       constant_value = (constant_value << 15) >> 15;
 735       if (pcrel)
 736         {
 737           sym_value -=
 738             address + input_sect->output_offset
 739             + input_sect->output_section->vma;
 740           sym_value = hppa_field_adjust (sym_value, -8, r_field);
 741         }
 742       else
 743         sym_value = hppa_field_adjust (sym_value, constant_value, r_field);
 744
 745       return hppa_rebuild_insn (abfd, insn, sym_value >> 2, r_format);
 746
 747     default:
 748       if (opcode == 0)
 749         {
 750           constant_value = HPPA_R_CONSTANT (r_addend);
 751
 752           if (pcrel)
 753             sym_value -= address;
 754
 755           return hppa_field_adjust (sym_value, constant_value, r_field);
 756         }
 757       else
 758         abort ();
 759     }
 760 }
 761
 762 /* Relocate an HPPA ELF section.  */
 763
 764 static boolean
 765 elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
 766                              contents, relocs, local_syms, local_sections)
 767      bfd *output_bfd;
 768      struct bfd_link_info *info;
 769      bfd *input_bfd;
 770      asection *input_section;
 771      bfd_byte *contents;
 772      Elf_Internal_Rela *relocs;
 773      Elf_Internal_Sym *local_syms;
 774      asection **local_sections;
 775 {
 776   Elf_Internal_Shdr *symtab_hdr;
 777   Elf_Internal_Rela *rel;
 778   Elf_Internal_Rela *relend;
 779
 780   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 781
 782   rel = relocs;
 783   relend = relocs + input_section->reloc_count;
 784   for (; rel < relend; rel++)
 785     {
 786       int r_type;
 787       reloc_howto_type *howto;
 788       long r_symndx;
 789       struct elf_link_hash_entry *h;
 790       Elf_Internal_Sym *sym;
 791       asection *sym_sec;
 792       bfd_vma relocation;
 793       bfd_reloc_status_type r;
 794       const char *sym_name;
 795
 796       r_type = ELF32_R_TYPE (rel->r_info);
 797       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
 798         {
 799           bfd_set_error (bfd_error_bad_value);
 800           return false;
 801         }
 802       howto = elf_hppa_howto_table + r_type;
 803
 804       r_symndx = ELF32_R_SYM (rel->r_info);
 805
 806       if (info->relocateable)
 807         {
 808           /* This is a relocateable link.  We don't have to change
 809              anything, unless the reloc is against a section symbol,
 810              in which case we have to adjust according to where the
 811              section symbol winds up in the output section.  */
 812           if (r_symndx < symtab_hdr->sh_info)
 813             {
 814               sym = local_syms + r_symndx;
 815               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 816                 {
 817                   sym_sec = local_sections[r_symndx];
 818                   rel->r_addend += sym_sec->output_offset;
 819                 }
 820             }
 821
 822           continue;
 823         }
 824
 825       /* This is a final link.  */
 826       h = NULL;
 827       sym = NULL;
 828       sym_sec = NULL;
 829       if (r_symndx < symtab_hdr->sh_info)
 830         {
 831           sym = local_syms + r_symndx;
 832           sym_sec = local_sections[r_symndx];
 833           relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION
 834                            ? 0 : sym->st_value)
 835                          + sym_sec->output_offset
 836                          + sym_sec->output_section->vma);
 837         }
 838       else
 839         {
 840           long indx;
 841
 842           indx = r_symndx - symtab_hdr->sh_info;
 843           h = elf_sym_hashes (input_bfd)[indx];
 844           if (h->root.type == bfd_link_hash_defined
 845               || h->root.type == bfd_link_hash_defweak)
 846             {
 847               sym_sec = h->root.u.def.section;
 848               relocation = (h->root.u.def.value
 849                             + sym_sec->output_offset
 850                             + sym_sec->output_section->vma);
 851             }
 852           else if (h->root.type == bfd_link_hash_undefweak)
 853             relocation = 0;
 854           else
 855             {
 856               if (!((*info->callbacks->undefined_symbol)
 857                     (info, h->root.root.string, input_bfd,
 858                      input_section, rel->r_offset)))
 859                 return false;
 860               break;
 861             }
 862         }
 863
 864       if (h != NULL)
 865         sym_name = h->root.root.string;
 866       else
 867         {
 868           sym_name = bfd_elf_string_from_elf_section (input_bfd,
 869                                                       symtab_hdr->sh_link,
 870                                                       sym->st_name);
 871           if (sym_name == NULL)
 872             return false;
 873           if (*sym_name == '\0')
 874             sym_name = bfd_section_name (input_bfd, sym_sec);
 875         }
 876
 877       /* If args_hash_table is NULL, then we have encountered some
 878          kind of link error (ex. undefined symbols).  Do not try to
 879          apply any relocations, continue the loop so we can notify
 880          the user of several errors in a single attempted link.  */
 881       if (elf32_hppa_hash_table (info)->args_hash_table == NULL)
 882         continue;
 883
 884       r = elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
 885                                               input_section, contents,
 886                                               rel->r_offset, relocation,
 887                                               rel->r_addend, info, sym_sec,
 888                                               sym_name, h == NULL);
 889
 890       if (r != bfd_reloc_ok)
 891         {
 892           switch (r)
 893             {
 894             /* This can happen for DP relative relocs if $global$ is
 895                undefined.  This is a panic situation so we don't try
 896                to continue.  */
 897             case bfd_reloc_undefined:
 898             case bfd_reloc_notsupported:
 899               if (!((*info->callbacks->undefined_symbol)
 900                     (info, "$global$", input_bfd,
 901                      input_section, rel->r_offset)))
 902                 return false;
 903               return false;
 904             case bfd_reloc_dangerous:
 905               {
 906                 /* We use this return value to indicate that we performed
 907                    a "dangerous" relocation.  This doesn't mean we did
 908                    the wrong thing, it just means there may be some cleanup
 909                    that needs to be done here.
 910
 911                    In particular we had to swap the last call insn and its
 912                    delay slot.  If the delay slot insn needed a relocation,
 913                    then we'll need to adjust the next relocation entry's
 914                    offset to account for the fact that the insn moved.
 915
 916                    This hair wouldn't be necessary if we inserted stubs
 917                    between procedures and used a "bl" to get to the stub.  */
 918                 if (rel != relend)
 919                   {
 920                     Elf_Internal_Rela *next_rel = rel + 1;
 921
 922                     if (rel->r_offset + 4 == next_rel->r_offset)
 923                       next_rel->r_offset -= 4;
 924                   }
 925                 break;
 926               }
 927             default:
 928             case bfd_reloc_outofrange:
 929             case bfd_reloc_overflow:
 930               {
 931                 if (!((*info->callbacks->reloc_overflow)
 932                       (info, sym_name, howto->name, (bfd_vma) 0,
 933                         input_bfd, input_section, rel->r_offset)))
 934                   return false;
 935               }
 936               break;
 937             }
 938         }
 939     }
 940
 941   return true;
 942 }
 943
 944 /* Return one (or more) BFD relocations which implement the base
 945    relocation with modifications based on format and field.  */
 946
 947 elf32_hppa_reloc_type **
 948 hppa_elf_gen_reloc_type (abfd, base_type, format, field)
 949      bfd *abfd;
 950      elf32_hppa_reloc_type base_type;
 951      int format;
 952      int field;
 953 {
 954   elf32_hppa_reloc_type *finaltype;
 955   elf32_hppa_reloc_type **final_types;
 956
 957   /* Allocate slots for the BFD relocation.  */
 958   final_types = (elf32_hppa_reloc_type **)
 959     bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type *) * 2);
 960   if (final_types == NULL)
 961     return NULL;
 962
 963   /* Allocate space for the relocation itself.  */
 964   finaltype = (elf32_hppa_reloc_type *)
 965     bfd_alloc_by_size_t (abfd, sizeof (elf32_hppa_reloc_type));
 966   if (finaltype == NULL)
 967     return NULL;
 968
 969   /* Some reasonable defaults.  */
 970   final_types[0] = finaltype;
 971   final_types[1] = NULL;
 972
 973 #define final_type finaltype[0]
 974
 975   final_type = base_type;
 976
 977   /* Just a tangle of nested switch statements to deal with the braindamage
 978      that a different field selector means a completely different relocation
 979      for PA ELF.  */
 980   switch (base_type)
 981     {
 982     case R_HPPA:
 983     case R_HPPA_ABS_CALL:
 984       switch (format)
 985         {
 986         case 14:
 987           switch (field)
 988             {
 989             case e_rsel:
 990             case e_rrsel:
 991               final_type = R_PARISC_DIR14R;
 992               break;
 993             case e_rtsel:
 994               final_type = R_PARISC_DLTREL14R;
 995               break;
 996             case e_tsel:
 997               final_type = R_PARISC_DLTREL14F;
 998               break;
 999             case e_rpsel:
1000               final_type = R_PARISC_PLABEL14R;
1001               break;
1002             default:
1003               return NULL;
1004             }
1005           break;
1006
1007         case 17:
1008           switch (field)
1009             {
1010             case e_fsel:
1011               final_type = R_PARISC_DIR17F;
1012               break;
1013             case e_rsel:
1014             case e_rrsel:
1015               final_type = R_PARISC_DIR17R;
1016               break;
1017             default:
1018               return NULL;
1019             }
1020           break;
1021
1022         case 21:
1023           switch (field)
1024             {
1025             case e_lsel:
1026             case e_lrsel:
1027               final_type = R_PARISC_DIR21L;
1028               break;
1029             case e_ltsel:
1030               final_type = R_PARISC_DLTREL21L;
1031               break;
1032             case e_lpsel:
1033               final_type = R_PARISC_PLABEL21L;
1034               break;
1035             default:
1036               return NULL;
1037             }
1038           break;
1039
1040         case 32:
1041           switch (field)
1042             {
1043             case e_fsel:
1044               final_type = R_PARISC_DIR32;
1045               break;
1046             case e_psel:
1047               final_type = R_PARISC_PLABEL32;
1048               break;
1049             default:
1050               return NULL;
1051             }
1052           break;
1053
1054         default:
1055           return NULL;
1056         }
1057       break;
1058
1059
1060     case R_HPPA_GOTOFF:
1061       switch (format)
1062         {
1063         case 14:
1064           switch (field)
1065             {
1066             case e_rsel:
1067             case e_rrsel:
1068               final_type = R_PARISC_DPREL14R;
1069               break;
1070             case e_fsel:
1071               final_type = R_PARISC_DPREL14F;
1072               break;
1073             default:
1074               return NULL;
1075             }
1076           break;
1077
1078         case 21:
1079           switch (field)
1080             {
1081             case e_lrsel:
1082             case e_lsel:
1083               final_type = R_PARISC_DPREL21L;
1084               break;
1085             default:
1086               return NULL;
1087             }
1088           break;
1089
1090         default:
1091           return NULL;
1092         }
1093       break;
1094
1095
1096     case R_HPPA_PCREL_CALL:
1097       switch (format)
1098         {
1099         case 14:
1100           switch (field)
1101             {
1102             case e_rsel:
1103             case e_rrsel:
1104               final_type = R_PARISC_PCREL14R;
1105               break;
1106             case e_fsel:
1107               final_type = R_PARISC_PCREL14F;
1108               break;
1109             default:
1110               return NULL;
1111             }
1112           break;
1113
1114         case 17:
1115           switch (field)
1116             {
1117             case e_rsel:
1118             case e_rrsel:
1119               final_type = R_PARISC_PCREL17R;
1120               break;
1121             case e_fsel:
1122               final_type = R_PARISC_PCREL17F;
1123               break;
1124             default:
1125               return NULL;
1126             }
1127           break;
1128
1129         case 21:
1130           switch (field)
1131             {
1132             case e_lsel:
1133             case e_lrsel:
1134               final_type = R_PARISC_PCREL21L;
1135               break;
1136             default:
1137               return NULL;
1138             }
1139           break;
1140
1141         default:
1142           return NULL;
1143         }
1144       break;
1145
1146     default:
1147       return NULL;
1148     }
1149
1150   return final_types;
1151 }
1152
1153 #undef final_type
1154
1155 /* Set the contents of a particular section at a particular location.  */
1156
1157 static boolean
1158 elf32_hppa_set_section_contents (abfd, section, location, offset, count)
1159      bfd *abfd;
1160      sec_ptr section;
1161      PTR location;
1162      file_ptr offset;
1163      bfd_size_type count;
1164 {
1165   /* Ignore write requests for the symbol extension section until we've
1166      had the chance to rebuild it ourselves.  */
1167   if (!strcmp (section->name, ".PARISC.symextn") && !symext_chain_size)
1168     return true;
1169   else
1170     return _bfd_elf_set_section_contents (abfd, section, location,
1171                                           offset, count);
1172 }
1173
1174 /* Translate from an elf into field into a howto relocation pointer.  */
1175
1176 static void
1177 elf_info_to_howto (abfd, cache_ptr, dst)
1178      bfd *abfd;
1179      arelent *cache_ptr;
1180      Elf32_Internal_Rela *dst;
1181 {
1182   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_PARISC_UNIMPLEMENTED);
1183   cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE (dst->r_info)];
1184 }
1185
1186
1187 /* Actually perform a relocation.  NOTE this is (mostly) superceeded
1188    by elf32_hppa_bfd_final_link_relocate which is called by the new
1189    fast linker.  */
1190
1191 static bfd_reloc_status_type
1192 hppa_elf_reloc (abfd, reloc_entry, symbol_in, data, input_section, output_bfd,
1193                 error_message)
1194      bfd *abfd;
1195      arelent *reloc_entry;
1196      asymbol *symbol_in;
1197      PTR data;
1198      asection *input_section;
1199      bfd *output_bfd;
1200      char **error_message;
1201 {
1202   /* It is no longer valid to call hppa_elf_reloc when creating
1203      a final executable.  */
1204   if (output_bfd)
1205     {
1206       reloc_entry->address += input_section->output_offset;
1207
1208       /* Work around lossage in generic elf code to write relocations.
1209          (maps different section symbols into the same symbol index).  */
1210       if ((symbol_in->flags & BSF_SECTION_SYM)
1211           && symbol_in->section)
1212         reloc_entry->addend += symbol_in->section->output_offset;
1213       return bfd_reloc_ok;
1214     }
1215   else
1216     {
1217       *error_message = (char *) "Unsupported call to hppa_elf_reloc";
1218       return bfd_reloc_notsupported;
1219     }
1220 }
1221
1222 /* Actually perform a relocation as part of a final link.  This can get
1223    rather hairy when linker stubs are needed.  */
1224
1225 static bfd_reloc_status_type
1226 elf32_hppa_bfd_final_link_relocate (howto, input_bfd, output_bfd,
1227                                     input_section, contents, offset, value,
1228                                     addend, info, sym_sec, sym_name, is_local)
1229      reloc_howto_type *howto;
1230      bfd *input_bfd;
1231      bfd *output_bfd;
1232      asection *input_section;
1233      bfd_byte *contents;
1234      bfd_vma offset;
1235      bfd_vma value;
1236      bfd_vma addend;
1237      struct bfd_link_info *info;
1238      asection *sym_sec;
1239      const char *sym_name;
1240      int is_local;
1241 {
1242   unsigned long insn;
1243   unsigned long r_type = howto->type;
1244   unsigned long r_format = howto->bitsize;
1245   unsigned long r_field = e_fsel;
1246   bfd_byte *hit_data = contents + offset;
1247   boolean r_pcrel = howto->pc_relative;
1248
1249   insn = bfd_get_32 (input_bfd, hit_data);
1250
1251   /* Make sure we have a value for $global$.  FIXME isn't this effectively
1252      just like the gp pointer on MIPS?  Can we use those routines for this
1253      purpose?  */
1254   if (!elf32_hppa_hash_table (info)->global_sym_defined)
1255     {
1256       struct elf_link_hash_entry *h;
1257       asection *sec;
1258
1259       h = elf_link_hash_lookup (elf_hash_table (info), "$global$", false,
1260                                  false, false);
1261
1262       /* If there isn't a $global$, then we're in deep trouble.  */
1263       if (h == NULL)
1264         return bfd_reloc_notsupported;
1265
1266       /* If $global$ isn't a defined symbol, then we're still in deep
1267          trouble.  */
1268       if (h->root.type != bfd_link_hash_defined)
1269         return bfd_reloc_undefined;
1270
1271       sec = h->root.u.def.section;
1272       elf32_hppa_hash_table (info)->global_value = (h->root.u.def.value
1273                                                     + sec->output_section->vma
1274                                                     + sec->output_offset);
1275       elf32_hppa_hash_table (info)->global_sym_defined = 1;
1276     }
1277
1278   switch (r_type)
1279     {
1280     case R_PARISC_NONE:
1281       break;
1282
1283     case R_PARISC_DIR32:
1284     case R_PARISC_DIR17F:
1285     case R_PARISC_PCREL17C:
1286       r_field = e_fsel;
1287       goto do_basic_type_1;
1288     case R_PARISC_DIR21L:
1289     case R_PARISC_PCREL21L:
1290       r_field = e_lrsel;
1291       goto do_basic_type_1;
1292     case R_PARISC_DIR17R:
1293     case R_PARISC_PCREL17R:
1294     case R_PARISC_DIR14R:
1295     case R_PARISC_PCREL14R:
1296       r_field = e_rrsel;
1297       goto do_basic_type_1;
1298
1299     /* For all the DP relative relocations, we need to examine the symbol's
1300        section.  If it's a code section, then "data pointer relative" makes
1301        no sense.  In that case we don't adjust the "value", and for 21 bit
1302        addil instructions, we change the source addend register from %dp to
1303        %r0.  */
1304     case R_PARISC_DPREL21L:
1305       r_field = e_lrsel;
1306       if (sym_sec->flags & SEC_CODE)
1307         {
1308           if ((insn & 0xfc000000) >> 26 == 0xa
1309                && (insn & 0x03e00000) >> 21 == 0x1b)
1310             insn &= ~0x03e00000;
1311         }
1312       else
1313         value -= elf32_hppa_hash_table (info)->global_value;
1314       goto do_basic_type_1;
1315     case R_PARISC_DPREL14R:
1316       r_field = e_rrsel;
1317       if ((sym_sec->flags & SEC_CODE) == 0)
1318         value -= elf32_hppa_hash_table (info)->global_value;
1319       goto do_basic_type_1;
1320     case R_PARISC_DPREL14F:
1321       r_field = e_fsel;
1322       if ((sym_sec->flags & SEC_CODE) == 0)
1323         value -= elf32_hppa_hash_table (info)->global_value;
1324       goto do_basic_type_1;
1325
1326     /* These cases are separate as they may involve a lot more work
1327        to deal with linker stubs.  */
1328     case R_PARISC_PLABEL32:
1329     case R_PARISC_PLABEL21L:
1330     case R_PARISC_PLABEL14R:
1331     case R_PARISC_PCREL17F:
1332       {
1333         bfd_vma location;
1334         unsigned int len, caller_args, callee_args;
1335         arg_reloc_type arg_reloc_types[5];
1336         struct elf32_hppa_args_hash_table *args_hash_table;
1337         struct elf32_hppa_args_hash_entry *args_hash;
1338         char *new_name, *stub_name;
1339
1340         /* Get the field selector right.  We'll need it in a minute.  */
1341         if (r_type == R_PARISC_PCREL17F
1342             || r_type == R_PARISC_PLABEL32)
1343           r_field = e_fsel;
1344         else if (r_type == R_PARISC_PLABEL21L)
1345           r_field = e_lrsel;
1346         else if (r_type == R_PARISC_PLABEL14R)
1347           r_field = e_rrsel;
1348
1349         /* Find out where we are and where we're going.  */
1350         location = (offset +
1351                     input_section->output_offset +
1352                     input_section->output_section->vma);
1353
1354         /* Now look for the argument relocation bits associated with the
1355            target.  */
1356         len = strlen (sym_name) + 1;
1357         if (is_local)
1358           len += 9;
1359         new_name = malloc (len);
1360         if (!new_name)
1361           {
1362             bfd_set_error (bfd_error_no_memory);
1363             return bfd_reloc_notsupported;
1364           }
1365         strcpy (new_name, sym_name);
1366
1367         /* Local symbols have unique IDs.  */
1368         if (is_local)
1369           sprintf (new_name + len - 10, "_%08x", (int)sym_sec);
1370
1371         args_hash_table = elf32_hppa_hash_table (info)->args_hash_table;
1372
1373         args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
1374                                                  new_name, false, false);
1375         if (args_hash == NULL)
1376           callee_args = 0;
1377         else
1378           callee_args = args_hash->arg_bits;
1379
1380         /* If this is a CALL relocation, then get the caller's bits
1381            from the addend.  Else use the magic 0x155 value for PLABELS.
1382
1383            Also we don't care about the destination (value) for PLABELS.  */
1384         if (r_type == R_PARISC_PCREL17F)
1385           caller_args = HPPA_R_ARG_RELOC (addend);
1386         else
1387           {
1388             caller_args = 0x155;
1389             location = value;
1390           }
1391
1392         /* Any kind of linker stub needed?  */
1393         if (((int)(value - location) > 0x3ffff)
1394             || ((int)(value - location) < (int)0xfffc0000)
1395             || elf32_hppa_arg_reloc_needed (caller_args, callee_args,
1396                                             arg_reloc_types))
1397           {
1398             struct elf32_hppa_stub_hash_table *stub_hash_table;
1399             struct elf32_hppa_stub_hash_entry *stub_hash;
1400             asection *stub_section;
1401
1402             /* Build a name for the stub.  */
1403
1404             len = strlen (new_name);
1405             len += 23;
1406             stub_name = malloc (len);
1407             if (!stub_name)
1408               {
1409                 bfd_set_error (bfd_error_no_memory);
1410                 return bfd_reloc_notsupported;
1411               }
1412             elf32_hppa_name_of_stub (caller_args, callee_args,
1413                                      location, value, stub_name);
1414             strcat (stub_name, new_name);
1415             free (new_name);
1416
1417             stub_hash_table = elf32_hppa_hash_table (info)->stub_hash_table;
1418
1419             stub_hash
1420               = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
1421                                              false, false);
1422
1423             /* We're done with that name.  */
1424             free (stub_name);
1425
1426             /* The stub BFD only has one section.  */
1427             stub_section = stub_hash_table->stub_bfd->sections;
1428
1429             if (stub_hash != NULL)
1430               {
1431
1432                 if (r_type == R_PARISC_PCREL17F)
1433                   {
1434                     unsigned long delay_insn;
1435                     unsigned int opcode, rtn_reg, ldo_target_reg, ldo_src_reg;
1436
1437                     /* We'll need to peek at the next insn.  */
1438                     delay_insn = bfd_get_32 (input_bfd, hit_data + 4);
1439                     opcode = get_opcode (delay_insn);
1440
1441                     /* We also need to know the return register for this
1442                        call.  */
1443                     rtn_reg = (insn & 0x03e00000) >> 21;
1444
1445                     ldo_src_reg = (delay_insn & 0x03e00000) >> 21;
1446                     ldo_target_reg = (delay_insn & 0x001f0000) >> 16;
1447
1448                     /* Munge up the value and other parameters for
1449                        hppa_elf_relocate_insn.  */
1450
1451                     value = (stub_hash->offset
1452                              + stub_section->output_offset
1453                              + stub_section->output_section->vma);
1454
1455                     r_format = 17;
1456                     r_field = e_fsel;
1457                     r_pcrel = 0;
1458                     addend = 0;
1459
1460                     /* We need to peek at the delay insn and determine if
1461                        we'll need to swap the branch and its delay insn.  */
1462                     if ((insn & 2)
1463                         || (opcode == LDO
1464                             && ldo_target_reg == rtn_reg)
1465                         || (delay_insn == 0x08000240))
1466                       {
1467                         /* No need to swap the branch and its delay slot, but
1468                            we do need to make sure to jump past the return
1469                            pointer update in the stub.  */
1470                         value += 4;
1471
1472                         /* If the delay insn does a return pointer adjustment,
1473                            then we have to make sure it stays valid.  */
1474                         if (opcode == LDO
1475                             && ldo_target_reg == rtn_reg)
1476                           {
1477                             delay_insn &= 0xfc00ffff;
1478                             delay_insn |= ((31 << 21) | (31 << 16));
1479                             bfd_put_32 (input_bfd, delay_insn, hit_data + 4);
1480                           }
1481                         /* Use a BLE to reach the stub.  */
1482                         insn = BLE_SR4_R0;
1483                       }
1484                     else
1485                       {
1486                         /* Wonderful, we have to swap the call insn and its
1487                            delay slot.  */
1488                         bfd_put_32 (input_bfd, delay_insn, hit_data);
1489                         /* Use a BLE,n to reach the stub.  */
1490                         insn = (BLE_SR4_R0 | 0x2);
1491                         bfd_put_32 (input_bfd, insn, hit_data + 4);
1492                         insn = hppa_elf_relocate_insn (input_bfd,
1493                                                        input_section,
1494                                                        insn, offset + 4,
1495                                                        value, addend,
1496                                                        r_format, r_field,
1497                                                        r_pcrel);
1498                         /* Update the instruction word.  */
1499                         bfd_put_32 (input_bfd, insn, hit_data + 4);
1500                         return bfd_reloc_dangerous;
1501                       }
1502                   }
1503                 else
1504                   {
1505                     /* PLABEL stuff is easy.  */
1506
1507                     value = (stub_hash->offset
1508                              + stub_section->output_offset
1509                              + stub_section->output_section->vma);
1510                     /* We don't need the RP adjustment for PLABELs.  */
1511                     value += 4;
1512                     if (r_type == R_PARISC_PLABEL32)
1513                       r_format = 32;
1514                     else if (r_type == R_PARISC_PLABEL21L)
1515                       r_format = 21;
1516                     else if (r_type == R_PARISC_PLABEL14R)
1517                       r_format = 14;
1518
1519                     r_pcrel = 0;
1520                     addend = 0;
1521                   }
1522                 }
1523               else
1524                 return bfd_reloc_notsupported;
1525           }
1526         goto do_basic_type_1;
1527       }
1528
1529 do_basic_type_1:
1530       insn = hppa_elf_relocate_insn (input_bfd, input_section, insn,
1531                                      offset, value, addend, r_format,
1532                                      r_field, r_pcrel);
1533       break;
1534
1535     /* Something we don't know how to handle.  */
1536     default:
1537       return bfd_reloc_notsupported;
1538     }
1539
1540   /* Update the instruction word.  */
1541   bfd_put_32 (input_bfd, insn, hit_data);
1542   return (bfd_reloc_ok);
1543 }
1544
1545 /* Return the address of the howto table entry to perform the CODE
1546    relocation for an ARCH machine.  */
1547
1548 static reloc_howto_type *
1549 elf_hppa_reloc_type_lookup (abfd, code)
1550      bfd *abfd;
1551      bfd_reloc_code_real_type code;
1552 {
1553   if ((int) code < (int) R_PARISC_UNIMPLEMENTED)
1554     {
1555       BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
1556       return &elf_hppa_howto_table[(int) code];
1557     }
1558   return NULL;
1559 }
1560
1561 /* Return true if SYM represents a local label symbol.  */
1562
1563 static boolean
1564 hppa_elf_is_local_label (abfd, sym)
1565      bfd *abfd;
1566      asymbol *sym;
1567 {
1568   return (sym->name[0] == 'L' && sym->name[1] == '$');
1569 }
1570
1571 /* Do any backend specific processing when beginning to write an object
1572    file.  For PA ELF we need to determine the size of the symbol extension
1573    section *before* any other output processing happens.  */
1574
1575 static void
1576 elf32_hppa_backend_begin_write_processing (abfd, info)
1577      bfd *abfd;
1578      struct bfd_link_info *info;
1579 {
1580   unsigned int i;
1581   asection *symextn_sec;
1582
1583   /* Size up the symbol extension section.  */
1584   if ((abfd->outsymbols == NULL
1585        && info == NULL)
1586       || symext_chain_size != 0)
1587     return;
1588
1589   if (info == NULL)
1590     {
1591       /* We were not called from the BFD ELF linker code, so we need
1592          to examine the output BFD's outsymbols.
1593
1594          Note we can not build the symbol extensions now as the symbol
1595          map hasn't been set up.  */
1596       for (i = 0; i < abfd->symcount; i++)
1597         {
1598           elf_symbol_type *symbol = (elf_symbol_type *)abfd->outsymbols[i];
1599
1600           /* Only functions ever need an entry in the symbol extension
1601              section.  */
1602           if (!(symbol->symbol.flags & BSF_FUNCTION))
1603             continue;
1604
1605           /* And only if they specify the locations of their arguments.  */
1606           if (symbol->tc_data.hppa_arg_reloc == 0)
1607             continue;
1608
1609           /* Yup.  This function symbol needs an entry.  */
1610           symext_chain_size += 2 * ELF32_PARISC_SX_SIZE;
1611         }
1612     }
1613   else if (info->relocateable == true)
1614     {
1615       struct elf32_hppa_args_hash_table *table;
1616       table = elf32_hppa_hash_table (info)->args_hash_table;
1617
1618       /* Determine the size of the symbol extension section.  */
1619       elf32_hppa_args_hash_traverse (table,
1620                                      elf32_hppa_size_symext,
1621                                      &symext_chain_size);
1622     }
1623
1624   /* Now create the section and set its size.  We'll fill in the
1625      contents later.  */
1626   symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1627   if (symextn_sec == NULL)
1628     symextn_sec = bfd_make_section (abfd, SYMEXTN_SECTION_NAME);
1629
1630   bfd_set_section_flags (abfd, symextn_sec,
1631                          SEC_LOAD | SEC_HAS_CONTENTS | SEC_DATA);
1632   symextn_sec->output_section = symextn_sec;
1633   symextn_sec->output_offset = 0;
1634   bfd_set_section_alignment (abfd, symextn_sec, 2);
1635   bfd_set_section_size (abfd, symextn_sec, symext_chain_size);
1636 }
1637
1638 /* Called for each entry in the args location hash table.  For each
1639    entry we bump the size pointer by 2 records (16 bytes).  */
1640
1641 static boolean
1642 elf32_hppa_size_symext (gen_entry, in_args)
1643      struct bfd_hash_entry *gen_entry;
1644      PTR in_args;
1645 {
1646   bfd_size_type *sizep = (bfd_size_type *)in_args;
1647
1648   *sizep += 2 * ELF32_PARISC_SX_SIZE;
1649   return true;
1650 }
1651
1652 /* Backend routine called by the linker for each output symbol.
1653
1654    For PA ELF we use this opportunity to add an appropriate entry
1655    to the symbol extension chain for function symbols.  */
1656
1657 static boolean
1658 elf32_hppa_link_output_symbol_hook (abfd, info, name, sym, section)
1659      bfd *abfd;
1660      struct bfd_link_info *info;
1661      const char *name;
1662      Elf_Internal_Sym *sym;
1663      asection *section;
1664 {
1665   char *new_name;
1666   unsigned int len, index;
1667   struct elf32_hppa_args_hash_table *args_hash_table;
1668   struct elf32_hppa_args_hash_entry *args_hash;
1669
1670   /* If the args hash table is NULL, then we've encountered an error
1671      of some sorts (for example, an undefined symbol).  In that case
1672      we've got nothing else to do.
1673
1674      NOTE: elf_link_output_symbol will abort if we return false here!  */
1675   if (elf32_hppa_hash_table (info)->args_hash_table == NULL)
1676     return true;
1677
1678   index = elf32_hppa_hash_table (info)->output_symbol_count++;
1679
1680   /* We need to look up this symbol in the args hash table to see if
1681      it has argument relocation bits.  */
1682   if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
1683     return true;
1684
1685   /* We know it's a function symbol of some kind.  */
1686   len = strlen (name) + 1;
1687   if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
1688     len += 9;
1689
1690   new_name = malloc (len);
1691   if (new_name == NULL)
1692     {
1693       bfd_set_error (bfd_error_no_memory);
1694       return false;
1695     }
1696
1697   strcpy (new_name, name);
1698   if (ELF_ST_BIND (sym->st_info) == STB_LOCAL)
1699     sprintf (new_name + len - 10, "_%08x", (int)section);
1700
1701   /* Now that we have the unique name, we can look it up in the
1702      args hash table.  */
1703   args_hash_table = elf32_hppa_hash_table (info)->args_hash_table;
1704   args_hash = elf32_hppa_args_hash_lookup (args_hash_table, new_name,
1705                                            false, false);
1706   free (new_name);
1707   if (args_hash == NULL)
1708     return true;
1709
1710   /* We know this symbol has arg reloc bits.  */
1711   add_entry_to_symext_chain (abfd, args_hash->arg_bits,
1712                              index, &symext_rootP, &symext_lastP);
1713   return true;
1714 }
1715
1716 /* Perform any processing needed late in the object file writing process.
1717    For PA ELF we build and set the contents of the symbol extension
1718    section.  */
1719
1720 static void
1721 elf32_hppa_backend_final_write_processing (abfd, linker)
1722      bfd *abfd;
1723      boolean linker;
1724 {
1725   asection *symextn_sec;
1726   unsigned int i;
1727
1728   /* Now build the symbol extension section.  */
1729   if (symext_chain_size == 0)
1730     return;
1731
1732   if (! linker)
1733     {
1734       /* We were not called from the backend linker, so we still need
1735          to build the symbol extension chain.
1736
1737          Look at each symbol, adding the appropriate information to the
1738          symbol extension section list as necessary.  */
1739       for (i = 0; i < abfd->symcount; i++)
1740         {
1741           elf_symbol_type *symbol = (elf_symbol_type *) abfd->outsymbols[i];
1742
1743           /* Only functions ever need an entry in the symbol extension
1744              section.  */
1745           if (!(symbol->symbol.flags & BSF_FUNCTION))
1746             continue;
1747
1748           /* And only if they specify the locations of their arguments.  */
1749           if (symbol->tc_data.hppa_arg_reloc == 0)
1750             continue;
1751
1752           /* Add this symbol's information to the chain.  */
1753           add_entry_to_symext_chain (abfd, symbol->tc_data.hppa_arg_reloc,
1754                                      symbol->symbol.udata.i, &symext_rootP,
1755                                      &symext_lastP);
1756         }
1757     }
1758
1759   /* Now fill in the contents of the symbol extension section.  */
1760   elf_hppa_tc_make_sections (abfd, symext_rootP);
1761
1762   /* And attach that as the section's contents.  */
1763   symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1764   if (symextn_sec == (asection *) 0)
1765     abort();
1766
1767   symextn_sec->contents = (void *)symextn_contents;
1768
1769   bfd_set_section_contents (abfd, symextn_sec, symextn_sec->contents,
1770                             symextn_sec->output_offset, symextn_sec->_raw_size);
1771 }
1772
1773 /* Update the symbol extention chain to include the symbol pointed to
1774    by SYMBOLP if SYMBOLP is a function symbol.  Used internally and by GAS.  */
1775
1776 static void
1777 add_entry_to_symext_chain (abfd, arg_reloc, sym_idx, symext_root, symext_last)
1778      bfd *abfd;
1779      unsigned int arg_reloc;
1780      unsigned int sym_idx;
1781      symext_chainS **symext_root;
1782      symext_chainS **symext_last;
1783 {
1784   symext_chainS *symextP;
1785
1786   /* Allocate memory and initialize this entry.  */
1787   symextP = (symext_chainS *) bfd_alloc (abfd, sizeof (symext_chainS) * 2);
1788   if (!symextP)
1789     {
1790       bfd_set_error (bfd_error_no_memory);
1791       abort();                  /* FIXME */
1792     }
1793
1794   symextP[0].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_SYMNDX, sym_idx);
1795   symextP[0].next = &symextP[1];
1796
1797   symextP[1].entry = ELF32_PARISC_SX_WORD (PARISC_SXT_ARG_RELOC, arg_reloc);
1798   symextP[1].next = NULL;
1799
1800   /* Now update the chain itself so it can be walked later to build
1801      the symbol extension section.  */
1802   if (*symext_root == NULL)
1803     {
1804       *symext_root = &symextP[0];
1805       *symext_last = &symextP[1];
1806     }
1807   else
1808     {
1809       (*symext_last)->next = &symextP[0];
1810       *symext_last = &symextP[1];
1811     }
1812 }
1813
1814 /* Build the symbol extension section.  */
1815
1816 static void
1817 elf_hppa_tc_make_sections (abfd, symext_root)
1818      bfd *abfd;
1819      symext_chainS *symext_root;
1820 {
1821   symext_chainS *symextP;
1822   unsigned int i;
1823   asection *symextn_sec;
1824
1825   symextn_sec = bfd_get_section_by_name (abfd, SYMEXTN_SECTION_NAME);
1826
1827   /* Grab some memory for the contents of the symbol extension section
1828      itself.  */
1829   symextn_contents = (bfd_byte *) bfd_zalloc (abfd,
1830                                               symextn_sec->_raw_size);
1831   if (!symextn_contents)
1832     {
1833       bfd_set_error (bfd_error_no_memory);
1834       abort();                  /* FIXME */
1835     }
1836
1837   /* Fill in the contents of the symbol extension chain.  */
1838   for (i = 0, symextP = symext_root; symextP; symextP = symextP->next, ++i)
1839     ELF32_PARISC_SX_PUT (abfd, (bfd_vma) symextP->entry,
1840                          symextn_contents + i * ELF32_PARISC_SX_SIZE);
1841
1842   return;
1843 }
1844
1845 /* Do some PA ELF specific work after reading in the symbol table.
1846    In particular attach the argument relocation from the
1847    symbol extension section to the appropriate symbols.  */
1848
1849 static boolean
1850 elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
1851      bfd *abfd;
1852      elf_symbol_type *esyms;
1853      int symcnt;
1854 {
1855   Elf32_Internal_Shdr *symextn_hdr =
1856     bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
1857   unsigned int i, current_sym_idx = 0;
1858
1859   /* If no symbol extension existed, then all symbol extension information
1860      is assumed to be zero.  */
1861   if (symextn_hdr == NULL)
1862     {
1863       for (i = 0; i < symcnt; i++)
1864         esyms[i].tc_data.hppa_arg_reloc = 0;
1865       return (true);
1866     }
1867
1868   /* FIXME:  Why not use bfd_get_section_contents here?  Also should give
1869      memory back when we're done.  */
1870   /* Allocate a buffer of the appropriate size for the symextn section.  */
1871   symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
1872   if (!symextn_hdr->contents)
1873     {
1874       bfd_set_error (bfd_error_no_memory);
1875       return false;
1876     }
1877
1878   /* Read in the symextn section.  */
1879   if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
1880     return false;
1881   if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->sh_size, abfd)
1882       != symextn_hdr->sh_size)
1883     return false;
1884
1885   /* Parse entries in the symbol extension section, updating the symtab
1886      entries as we go */
1887   for (i = 0; i < symextn_hdr->sh_size / ELF32_PARISC_SX_SIZE; i++)
1888     {
1889       symext_entryS se =
1890         ELF32_PARISC_SX_GET (abfd,
1891                              (symextn_hdr->contents
1892                               + i * ELF32_PARISC_SX_SIZE));
1893       unsigned int se_value = ELF32_PARISC_SX_VAL (se);
1894       unsigned int se_type = ELF32_PARISC_SX_TYPE (se);
1895
1896       switch (se_type)
1897         {
1898         case PARISC_SXT_NULL:
1899           break;
1900
1901         case PARISC_SXT_SYMNDX:
1902           if (se_value >= symcnt)
1903             {
1904               bfd_set_error (bfd_error_bad_value);
1905               return (false);
1906             }
1907           current_sym_idx = se_value - 1;
1908           break;
1909
1910         case PARISC_SXT_ARG_RELOC:
1911           esyms[current_sym_idx].tc_data.hppa_arg_reloc = se_value;
1912           break;
1913
1914         default:
1915           bfd_set_error (bfd_error_bad_value);
1916           return (false);
1917         }
1918     }
1919   return (true);
1920 }
1921
1922 /* Read and attach the symbol extension information for the symbols
1923    in INPUT_BFD to the argument location hash table.  Handle locals
1924    if DO_LOCALS is true; likewise for globals when DO_GLOBALS is true.  */
1925
1926 static boolean
1927 elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table, local_syms)
1928      bfd *input_bfd;
1929      Elf_Internal_Shdr *symtab_hdr;
1930      struct elf32_hppa_args_hash_table *args_hash_table;
1931      Elf_Internal_Sym *local_syms;
1932 {
1933   asection *symextn_sec;
1934   bfd_byte *contents;
1935   unsigned int i, n_entries, current_index = 0;
1936
1937   /* Get the symbol extension section for this BFD.  If no section exists
1938      then there's nothing to do.  Likewise if the section exists, but
1939      has no contents.  */
1940   symextn_sec = bfd_get_section_by_name (input_bfd, SYMEXTN_SECTION_NAME);
1941   if (symextn_sec == NULL)
1942     return true;
1943
1944   /* Done separately so we can turn off SEC_HAS_CONTENTS (see below).  */
1945   if (symextn_sec->_raw_size == 0)
1946     {
1947       symextn_sec->flags &= ~SEC_HAS_CONTENTS;
1948       return true;
1949     }
1950
1951   contents = (bfd_byte *) malloc (symextn_sec->_raw_size);
1952   if (contents == NULL)
1953     {
1954       bfd_set_error (bfd_error_no_memory);
1955       return false;
1956     }
1957
1958   /* How gross.  We turn off SEC_HAS_CONTENTS for the input symbol extension
1959      sections to keep the generic ELF/BFD code from trying to do anything
1960      with them.  We have to undo that hack temporarily so that we can read
1961      in the contents with the generic code.  */
1962   symextn_sec->flags |= SEC_HAS_CONTENTS;
1963   if (bfd_get_section_contents (input_bfd, symextn_sec, contents,
1964                                 0, symextn_sec->_raw_size) == false)
1965     {
1966       symextn_sec->flags &= ~SEC_HAS_CONTENTS;
1967       free (contents);
1968       return false;
1969     }
1970
1971   /* Gross.  Turn off SEC_HAS_CONTENTS for the input symbol extension
1972      sections (see above).  */
1973   symextn_sec->flags &= ~SEC_HAS_CONTENTS;
1974
1975   n_entries = symextn_sec->_raw_size / ELF32_PARISC_SX_SIZE;
1976   for (i = 0; i < n_entries; i++)
1977     {
1978       symext_entryS entry =
1979         ELF32_PARISC_SX_GET (input_bfd, contents + i * ELF32_PARISC_SX_SIZE);
1980       unsigned int value = ELF32_PARISC_SX_VAL (entry);
1981       unsigned int type = ELF32_PARISC_SX_TYPE (entry);
1982       struct elf32_hppa_args_hash_entry *args_hash;
1983
1984       switch (type)
1985         {
1986         case PARISC_SXT_NULL:
1987           break;
1988
1989         case PARISC_SXT_SYMNDX:
1990           if (value >= symtab_hdr->sh_size / sizeof (Elf32_External_Sym))
1991             {
1992               bfd_set_error (bfd_error_bad_value);
1993               free (contents);
1994               return false;
1995             }
1996           current_index = value;
1997           break;
1998
1999         case PARISC_SXT_ARG_RELOC:
2000           if (current_index < symtab_hdr->sh_info)
2001             {
2002               Elf_Internal_Shdr *hdr;
2003               char *new_name;
2004               const char *sym_name;
2005               asection *sym_sec;
2006               unsigned int len;
2007
2008               hdr = elf_elfsections (input_bfd)[local_syms[current_index].st_shndx];
2009               sym_sec = hdr->bfd_section;
2010               sym_name = bfd_elf_string_from_elf_section (input_bfd,
2011                                                       symtab_hdr->sh_link,
2012                                         local_syms[current_index].st_name);
2013               len = strlen (sym_name) + 10;
2014               new_name = malloc (len);
2015               if (new_name == NULL)
2016                 {
2017                   bfd_set_error (bfd_error_no_memory);
2018                   free (contents);
2019                   return false;
2020                 }
2021               strcpy (new_name, sym_name);
2022               sprintf (new_name + len - 10, "_%08x", (int)sym_sec);
2023
2024               /* This is a global symbol with argument location info.
2025                  We need to enter it into the hash table.  */
2026               args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2027                                                        new_name, true,
2028                                                        true);
2029               free (new_name);
2030               if (args_hash == NULL)
2031                 {
2032                   free (contents);
2033                   return false;
2034                 }
2035               args_hash->arg_bits = value;
2036               break;
2037             }
2038           else if (current_index >= symtab_hdr->sh_info)
2039             {
2040               struct elf_link_hash_entry *h;
2041
2042               current_index -= symtab_hdr->sh_info;
2043               h = elf_sym_hashes(input_bfd)[current_index];
2044               /* This is a global symbol with argument location
2045                  information.  We need to enter it into the hash table.  */
2046               args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2047                                                        h->root.root.string,
2048                                                        true, true);
2049               if (args_hash == NULL)
2050                 {
2051                   bfd_set_error (bfd_error_bad_value);
2052                   free (contents);
2053                   return false;
2054                 }
2055               args_hash->arg_bits = value;
2056               break;
2057             }
2058           else
2059             break;
2060
2061         default:
2062           bfd_set_error (bfd_error_bad_value);
2063           free (contents);
2064           return false;
2065         }
2066     }
2067   free (contents);
2068   return true;
2069 }
2070
2071 /* Undo the generic ELF code's subtraction of section->vma from the
2072    value of each external symbol.  */
2073
2074 static boolean
2075 elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2076      bfd *abfd;
2077      struct bfd_link_info *info;
2078      const Elf_Internal_Sym *sym;
2079      const char **namep;
2080      flagword *flagsp;
2081      asection **secp;
2082      bfd_vma *valp;
2083 {
2084   *valp += (*secp)->vma;
2085   return true;
2086 }
2087
2088 /* Determine the name of the stub needed to perform a call assuming the
2089    argument relocation bits for caller and callee are in CALLER and CALLEE
2090    for a call from LOCATION to DESTINATION.  Copy the name into STUB_NAME.  */
2091
2092 static void
2093 elf32_hppa_name_of_stub (caller, callee, location, destination, stub_name)
2094      unsigned int caller, callee;
2095      bfd_vma location, destination;
2096      char *stub_name;
2097 {
2098   arg_reloc_type arg_reloc_types[5];
2099
2100   if (elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types))
2101     {
2102       arg_reloc_location i;
2103       /* Fill in the basic template.  */
2104       strcpy (stub_name, "__XX_XX_XX_XX_XX_stub_");
2105
2106       /* Now fix the specifics.  */
2107       for (i = ARG0; i <= RET; i++)
2108         switch (arg_reloc_types[i])
2109           {
2110             case NO:
2111               stub_name[3 * i + 2] = 'N';
2112               stub_name[3 * i + 3] = 'O';
2113               break;
2114             case GF:
2115               stub_name[3 * i + 2] = 'G';
2116               stub_name[3 * i + 3] = 'F';
2117               break;
2118             case FG:
2119               stub_name[3 * i + 2] = 'F';
2120               stub_name[3 * i + 3] = 'G';
2121               break;
2122             case GD:
2123               stub_name[3 * i + 2] = 'G';
2124               stub_name[3 * i + 3] = 'D';
2125               break;
2126             case DG:
2127               stub_name[3 * i + 2] = 'D';
2128               stub_name[3 * i + 3] = 'G';
2129               break;
2130           }
2131     }
2132   else
2133     strcpy (stub_name, "_____long_branch_stub_");
2134 }
2135
2136 /* Determine if an argument relocation stub is needed to perform a
2137    call assuming the argument relocation bits for caller and callee
2138    are in CALLER and CALLEE.  Place the type of relocations (if any)
2139    into stub_types_p.  */
2140
2141 static boolean
2142 elf32_hppa_arg_reloc_needed (caller, callee, stub_types)
2143      unsigned int caller, callee;
2144      arg_reloc_type stub_types[5];
2145 {
2146   /* Special case for no relocations.  */
2147   if (caller == 0 || callee == 0)
2148     return 0;
2149   else
2150     {
2151       arg_location caller_loc[5];
2152       arg_location callee_loc[5];
2153
2154       /* Extract the location information for the argument and return
2155          value on both the caller and callee sides.  */
2156       caller_loc[ARG0] = EXTRACT_ARBITS (caller, ARG0);
2157       callee_loc[ARG0] = EXTRACT_ARBITS (callee, ARG0);
2158       caller_loc[ARG1] = EXTRACT_ARBITS (caller, ARG1);
2159       callee_loc[ARG1] = EXTRACT_ARBITS (callee, ARG1);
2160       caller_loc[ARG2] = EXTRACT_ARBITS (caller, ARG2);
2161       callee_loc[ARG2] = EXTRACT_ARBITS (callee, ARG2);
2162       caller_loc[ARG3] = EXTRACT_ARBITS (caller, ARG3);
2163       callee_loc[ARG3] = EXTRACT_ARBITS (callee, ARG3);
2164       caller_loc[RET] = EXTRACT_ARBITS (caller, RET);
2165       callee_loc[RET] = EXTRACT_ARBITS (callee, RET);
2166
2167       /* Check some special combinations.  This is necessary to
2168          deal with double precision FP arguments.  */
2169       if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
2170         {
2171           caller_loc[ARG0] = AR_FPDBL1;
2172           caller_loc[ARG1] = AR_NO;
2173         }
2174       if (caller_loc[ARG2] == AR_FU || caller_loc[ARG3] == AR_FU)
2175         {
2176           caller_loc[ARG2] = AR_FPDBL2;
2177           caller_loc[ARG3] = AR_NO;
2178         }
2179       if (callee_loc[ARG0] == AR_FU || callee_loc[ARG1] == AR_FU)
2180         {
2181           callee_loc[ARG0] = AR_FPDBL1;
2182           callee_loc[ARG1] = AR_NO;
2183         }
2184       if (callee_loc[ARG2] == AR_FU || callee_loc[ARG3] == AR_FU)
2185         {
2186           callee_loc[ARG2] = AR_FPDBL2;
2187           callee_loc[ARG3] = AR_NO;
2188         }
2189
2190       /* Now look up any relocation needed for each argument and the
2191          return value.  */
2192       stub_types[ARG0] = arg_mismatches[caller_loc[ARG0]][callee_loc[ARG0]];
2193       stub_types[ARG1] = arg_mismatches[caller_loc[ARG1]][callee_loc[ARG1]];
2194       stub_types[ARG2] = arg_mismatches[caller_loc[ARG2]][callee_loc[ARG2]];
2195       stub_types[ARG3] = arg_mismatches[caller_loc[ARG3]][callee_loc[ARG3]];
2196       stub_types[RET] = ret_mismatches[caller_loc[RET]][callee_loc[RET]];
2197
2198       return (stub_types[ARG0] != NO
2199               || stub_types[ARG1] != NO
2200               || stub_types[ARG2] != NO
2201               || stub_types[ARG3] != NO
2202               || stub_types[RET] != NO);
2203     }
2204 }
2205
2206 /* Compute the size of the stub needed to call from LOCATION to DESTINATION
2207    (a function named SYM_NAME), with argument relocation bits CALLER and
2208    CALLEE.  Return zero if no stub is needed to perform such a call.  */
2209
2210 static unsigned int
2211 elf32_hppa_size_of_stub (callee, caller, location, destination, sym_name)
2212      unsigned int callee, caller;
2213      bfd_vma location, destination;
2214      const char *sym_name;
2215 {
2216   arg_reloc_type arg_reloc_types[5];
2217
2218   /* Determine if a long branch or argument relocation stub is needed.
2219      If an argument relocation stub is needed, the relocation will be
2220      stored into arg_reloc_types.  */
2221   if (!(((int)(location - destination) > 0x3ffff)
2222         || ((int)(location - destination) < (int)0xfffc0000)
2223         || elf32_hppa_arg_reloc_needed (caller, callee, arg_reloc_types)))
2224     return 0;
2225
2226   /* Some kind of stub is needed.  Determine how big it needs to be.
2227      First check for argument relocation stubs as they also handle
2228      long calls.  Then check for long calls to millicode and finally
2229      the normal long calls.  */
2230   if (arg_reloc_types[ARG0] != NO
2231       || arg_reloc_types[ARG1] != NO
2232       || arg_reloc_types[ARG2] != NO
2233       || arg_reloc_types[ARG3] != NO
2234       || arg_reloc_types[RET] != NO)
2235     {
2236       /* Some kind of argument relocation stub is needed.  */
2237       unsigned int len = 16;
2238       arg_reloc_location i;
2239
2240       /* Each GR or FG relocation takes 2 insns, each GD or DG
2241          relocation takes 3 insns.  Plus 4 more insns for the
2242          RP adjustment, ldil & (be | ble) and copy.  */
2243       for (i = ARG0; i <= RET; i++)
2244         switch (arg_reloc_types[i])
2245           {
2246             case GF:
2247             case FG:
2248               len += 8;
2249               break;
2250
2251             case GD:
2252             case DG:
2253               len += 12;
2254               break;
2255
2256             default:
2257               break;
2258           }
2259
2260       /* Extra instructions are needed if we're relocating a return value.  */
2261       if (arg_reloc_types[RET] != NO)
2262         len += 12;
2263
2264       return len;
2265     }
2266   else if (!strncmp ("$$", sym_name, 2)
2267       && strcmp ("$$dyncall", sym_name))
2268     return 12;
2269   else
2270     return 16;
2271 }
2272
2273 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
2274    IN_ARGS contains the stub BFD and link info pointers.  */
2275
2276 static boolean
2277 elf32_hppa_build_one_stub (gen_entry, in_args)
2278      struct bfd_hash_entry *gen_entry;
2279      PTR in_args;
2280 {
2281   void **args = (void **)in_args;
2282   bfd *stub_bfd = (bfd *)args[0];
2283   struct bfd_link_info *info = (struct bfd_link_info *)args[1];
2284   struct elf32_hppa_stub_hash_entry *entry;
2285   struct elf32_hppa_stub_hash_table *stub_hash_table;
2286   bfd_byte *loc;
2287   symvalue sym_value;
2288   const char *sym_name;
2289
2290   /* Initialize pointers to the stub hash table, the particular entry we
2291      are building a stub for, and where (in memory) we should place the stub
2292      instructions.  */
2293   entry = (struct elf32_hppa_stub_hash_entry *)gen_entry;
2294   stub_hash_table = elf32_hppa_hash_table(info)->stub_hash_table;
2295   loc = stub_hash_table->location;
2296
2297   /* Make a note of the offset within the stubs for this entry.  */
2298   entry->offset = stub_hash_table->offset;
2299
2300   /* The symbol's name starts at offset 22.  */
2301   sym_name = entry->root.string + 22;
2302
2303   sym_value = (entry->target_value
2304                + entry->target_section->output_offset
2305                + entry->target_section->output_section->vma);
2306
2307   if (strncmp ("_____long_branch_stub_", entry->root.string, 22))
2308     {
2309       /* This must be an argument or return value relocation stub.  */
2310       unsigned long insn;
2311       arg_reloc_location i;
2312       bfd_byte *begin_loc = loc;
2313
2314       /* First the return pointer adjustment.  Depending on exact calling
2315          sequence this instruction may be skipped.  */
2316       bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc);
2317       loc += 4;
2318
2319       /* If we are relocating a return value, then we're going to have
2320          to return into the stub.  So we have to save off the user's
2321          return pointer into the stack at RP'.  */
2322       if (strncmp (entry->root.string + 14, "NO", 2))
2323         {
2324           bfd_put_32 (stub_bfd, STW_R31_M8R30, loc);
2325           loc += 4;
2326         }
2327
2328       /* Iterate over the argument relocations, emitting instructions
2329          to move them around as necessary.  */
2330       for (i = ARG0; i <= ARG3; i++)
2331         {
2332           if (!strncmp (entry->root.string + 3 * i + 2, "GF", 2))
2333             {
2334               bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((26 - i) << 16), loc);
2335               bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | (4 + i), loc + 4);
2336               loc += 8;
2337             }
2338           else if (!strncmp (entry->root.string + 3 * i + 2, "FG", 2))
2339             {
2340               bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | (4 + i), loc);
2341               bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((26 - i) << 16), loc + 4);
2342               loc += 8;
2343             }
2344           else if (!strncmp (entry->root.string + 3 * i + 2, "GD", 2))
2345             {
2346               bfd_put_32 (stub_bfd, STW_ARG_M12R30 | ((26 - i) << 16), loc);
2347               bfd_put_32 (stub_bfd, STW_ARG_M16R30 | ((25 - i) << 16), loc + 4);
2348               bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | (5 + i), loc + 8);
2349               loc += 12;
2350             }
2351           else if (!strncmp (entry->root.string + 3 * i + 2, "DG", 2))
2352             {
2353               bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | (5 + i), loc);
2354               bfd_put_32 (stub_bfd, LDW_M12R30_ARG | ((26 - i) << 16), loc + 4);
2355               bfd_put_32 (stub_bfd, LDW_M16R30_ARG | ((25 - i) << 16), loc + 8);
2356               loc += 12;
2357             }
2358         }
2359
2360       /* Load the high bits of the target address into %r1.  */
2361       insn = hppa_rebuild_insn (stub_bfd, LDIL_R1,
2362                                 hppa_field_adjust (sym_value, 0, e_lrsel), 21);
2363       bfd_put_32 (stub_bfd, insn, loc);
2364       loc += 4;
2365
2366       /* If we are relocating a return value, then we're going to have
2367          to return into the stub, then perform the return value relocation.  */
2368       if (strncmp (entry->root.string + 14, "NO", 2))
2369         {
2370           /* To return to the stub we "ble" to the target and copy the return
2371              pointer from %r31 into %r2.  */
2372           insn = hppa_rebuild_insn (stub_bfd,
2373                                     BLE_SR4_R1,
2374                                     hppa_field_adjust (sym_value, 0,
2375                                                        e_rrsel) >> 2,
2376                                     17);
2377           bfd_put_32 (stub_bfd, insn, loc);
2378           bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4);
2379
2380           /* Reload the return pointer for our caller from the stack.  */
2381           bfd_put_32 (stub_bfd, LDW_M8R30_R31, loc + 8);
2382           loc += 12;
2383
2384           /* Perform the return value relocation.  */
2385           if (!strncmp (entry->root.string + 14, "GF", 2))
2386             {
2387               bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (28 << 16), loc);
2388               bfd_put_32 (stub_bfd, FLDW_M16R30_FARG | 4, loc + 4);
2389               loc += 8;
2390             }
2391           else if (!strncmp (entry->root.string + 14, "FG", 2))
2392             {
2393               bfd_put_32 (stub_bfd, FSTW_FARG_M16R30 | 4, loc);
2394               bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (28 << 16), loc + 4);
2395               loc += 8;
2396             }
2397           else if (!strncmp (entry->root.string + 2, "GD", 2))
2398             {
2399               bfd_put_32 (stub_bfd, STW_ARG_M12R30 | (28 << 16), loc);
2400               bfd_put_32 (stub_bfd, STW_ARG_M16R30 | (29 << 16), loc + 4);
2401               bfd_put_32 (stub_bfd, FLDD_M16R30_FARG | 4, loc + 8);
2402               loc += 12;
2403             }
2404           else if (!strncmp (entry->root.string + 2, "DG", 2))
2405             {
2406               bfd_put_32 (stub_bfd, FSTD_FARG_M16R30 | 4, loc);
2407               bfd_put_32 (stub_bfd, LDW_M12R30_ARG | (28 << 16), loc + 4);
2408               bfd_put_32 (stub_bfd, LDW_M16R30_ARG | (29 << 16), loc + 8);
2409               loc += 12;
2410             }
2411           /* Branch back to the user's code now.  */
2412           bfd_put_32 (stub_bfd, BV_N_0_R31, loc);
2413           loc += 4;
2414         }
2415       else
2416         {
2417           /* No return value relocation, so we can simply "be" to the
2418              target and copy out return pointer into %r2.  */
2419           insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1,
2420                                     hppa_field_adjust (sym_value, 0,
2421                                                        e_rrsel) >> 2, 17);
2422           bfd_put_32 (stub_bfd, insn, loc);
2423           bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 4);
2424           loc += 8;
2425         }
2426
2427       /* Update the location and offsets.  */
2428       stub_hash_table->location += (loc - begin_loc);
2429       stub_hash_table->offset += (loc - begin_loc);
2430     }
2431   else
2432     {
2433       /* Create one of two variant long branch stubs.  One for $$dyncall and
2434          normal calls, the other for calls to millicode.  */
2435       unsigned long insn;
2436       int millicode_call = 0;
2437
2438       if (!strncmp ("$$", sym_name, 2) && strcmp ("$$dyncall", sym_name))
2439         millicode_call = 1;
2440
2441       /* First the return pointer adjustment.  Depending on exact calling
2442          sequence this instruction may be skipped.  */
2443       bfd_put_32 (stub_bfd, LDO_M4_R31_R31, loc);
2444
2445       /* The next two instructions are the long branch itself.  A long branch
2446          is formed with "ldil" loading the upper bits of the target address
2447          into a register, then branching with "be" which adds in the lower bits.
2448          Long branches to millicode nullify the delay slot of the "be".  */
2449       insn = hppa_rebuild_insn (stub_bfd, LDIL_R1,
2450                                 hppa_field_adjust (sym_value, 0, e_lrsel), 21);
2451       bfd_put_32 (stub_bfd, insn, loc + 4);
2452       insn = hppa_rebuild_insn (stub_bfd, BE_SR4_R1 | (millicode_call ? 2 : 0),
2453                                 hppa_field_adjust (sym_value, 0, e_rrsel) >> 2,
2454                                 17);
2455       bfd_put_32 (stub_bfd, insn, loc + 8);
2456
2457       if (!millicode_call)
2458         {
2459           /* The sequence to call this stub places the return pointer into %r31,
2460              the final target expects the return pointer in %r2, so copy the
2461               return pointer into the proper register.  */
2462           bfd_put_32 (stub_bfd, COPY_R31_R2, loc + 12);
2463
2464           /* Update the location and offsets.  */
2465           stub_hash_table->location += 16;
2466           stub_hash_table->offset += 16;
2467         }
2468       else
2469         {
2470           /* Update the location and offsets.  */
2471           stub_hash_table->location += 12;
2472           stub_hash_table->offset += 12;
2473         }
2474
2475     }
2476   return true;
2477 }
2478
2479 /* External entry points for sizing and building linker stubs.  */
2480
2481 /* Build all the stubs associated with the current output file.  The
2482    stubs are kept in a hash table attached to the main linker hash
2483    table.  This is called via hppaelf_finish in the linker.  */
2484
2485 boolean
2486 elf32_hppa_build_stubs (stub_bfd, info)
2487      bfd *stub_bfd;
2488      struct bfd_link_info *info;
2489 {
2490   /* The stub BFD only has one section.  */
2491   asection *stub_sec = stub_bfd->sections;
2492   struct elf32_hppa_stub_hash_table *table;
2493   unsigned int size;
2494   void *args[2];
2495
2496   /* So we can pass both the BFD for the stubs and the link info
2497      structure to the routine which actually builds stubs.  */
2498   args[0] = stub_bfd;
2499   args[1] = info;
2500
2501   /* Allocate memory to hold the linker stubs.  */
2502   size = bfd_section_size (stub_bfd, stub_sec);
2503   stub_sec->contents = (unsigned char *) bfd_zalloc (stub_bfd, size);
2504   if (stub_sec->contents == NULL)
2505     {
2506       bfd_set_error (bfd_error_no_memory);
2507       return false;
2508     }
2509   table = elf32_hppa_hash_table(info)->stub_hash_table;
2510   table->location = stub_sec->contents;
2511
2512   /* Build the stubs as directed by the stub hash table.  */
2513   elf32_hppa_stub_hash_traverse (table, elf32_hppa_build_one_stub, args);
2514
2515   return true;
2516 }
2517
2518 /* Determine and set the size of the stub section for a final link.
2519
2520    The basic idea here is to examine all the relocations looking for
2521    PC-relative calls to a target that is unreachable with a "bl"
2522    instruction or calls where the caller and callee disagree on the
2523    location of their arguments or return value.  */
2524
2525 boolean
2526 elf32_hppa_size_stubs (stub_bfd, output_bfd, link_info)
2527      bfd *stub_bfd;
2528      bfd *output_bfd;
2529      struct bfd_link_info *link_info;
2530 {
2531   bfd *input_bfd;
2532   asection *section, *stub_sec = 0;
2533   Elf_Internal_Shdr *symtab_hdr;
2534   Elf_Internal_Sym *local_syms, *isym, **all_local_syms;
2535   Elf32_External_Sym *ext_syms, *esym;
2536   unsigned int i, index, bfd_count = 0;
2537   struct elf32_hppa_stub_hash_table *stub_hash_table = 0;
2538   struct elf32_hppa_args_hash_table *args_hash_table = 0;
2539
2540   /* Create and initialize the stub hash table.  */
2541   stub_hash_table = ((struct elf32_hppa_stub_hash_table *)
2542                      malloc (sizeof (struct elf32_hppa_stub_hash_table)));
2543   if (!stub_hash_table)
2544     {
2545       bfd_set_error (bfd_error_no_memory);
2546       goto error_return;
2547     }
2548
2549   if (!elf32_hppa_stub_hash_table_init (stub_hash_table, stub_bfd,
2550                                         elf32_hppa_stub_hash_newfunc))
2551     goto error_return;
2552
2553   /* Likewise for the argument location hash table.  */
2554   args_hash_table = ((struct elf32_hppa_args_hash_table *)
2555                      malloc (sizeof (struct elf32_hppa_args_hash_table)));
2556   if (!args_hash_table)
2557     {
2558       bfd_set_error (bfd_error_no_memory);
2559       goto error_return;
2560     }
2561
2562   if (!elf32_hppa_args_hash_table_init (args_hash_table,
2563                                         elf32_hppa_args_hash_newfunc))
2564     goto error_return;
2565
2566   /* Attach the hash tables to the main hash table.  */
2567   elf32_hppa_hash_table(link_info)->stub_hash_table = stub_hash_table;
2568   elf32_hppa_hash_table(link_info)->args_hash_table = args_hash_table;
2569
2570   /* Count the number of input BFDs.  */
2571   for (input_bfd = link_info->input_bfds;
2572        input_bfd != NULL;
2573        input_bfd = input_bfd->link_next)
2574      bfd_count++;
2575
2576   /* We want to read in symbol extension records only once.  To do this
2577      we need to read in the local symbols in parallel and save them for
2578      later use; so hold pointers to the local symbols in an array.  */
2579   all_local_syms
2580     = (Elf_Internal_Sym **) malloc (sizeof (Elf_Internal_Sym *) * bfd_count);
2581   if (all_local_syms == NULL)
2582     {
2583       bfd_set_error (bfd_error_no_memory);
2584       goto error_return;
2585     }
2586   memset (all_local_syms, 0, sizeof (Elf_Internal_Sym *) * bfd_count);
2587
2588   /* Walk over all the input BFDs adding entries to the args hash table
2589      for all the external functions.  */
2590   for (input_bfd = link_info->input_bfds, index = 0;
2591        input_bfd != NULL;
2592        input_bfd = input_bfd->link_next, index++)
2593     {
2594       /* We'll need the symbol table in a second.  */
2595       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2596       if (symtab_hdr->sh_info == 0)
2597         continue;
2598
2599       /* We need an array of the local symbols attached to the input bfd.
2600          Unfortunately, we're going to have to read & swap them in.  */
2601       local_syms
2602         = (Elf_Internal_Sym *)malloc (symtab_hdr->sh_info
2603                                       * sizeof (Elf_Internal_Sym));
2604       if (local_syms == NULL)
2605         {
2606           bfd_set_error (bfd_error_no_memory);
2607           for (i = 0; i < bfd_count; i++)
2608             if (all_local_syms[i])
2609               free (all_local_syms[i]);
2610           free (all_local_syms);
2611           goto error_return;
2612         }
2613       all_local_syms[index] = local_syms;
2614
2615       ext_syms
2616         = (Elf32_External_Sym *)malloc (symtab_hdr->sh_info
2617                                         * sizeof (Elf32_External_Sym));
2618       if (ext_syms == NULL)
2619         {
2620           bfd_set_error (bfd_error_no_memory);
2621           for (i = 0; i < bfd_count; i++)
2622             if (all_local_syms[i])
2623               free (all_local_syms[i]);
2624           free (all_local_syms);
2625           goto error_return;
2626         }
2627
2628       if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2629           || bfd_read (ext_syms, 1,
2630                        (symtab_hdr->sh_info
2631                         * sizeof (Elf32_External_Sym)), input_bfd)
2632           != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym)))
2633         {
2634           for (i = 0; i < bfd_count; i++)
2635             if (all_local_syms[i])
2636               free (all_local_syms[i]);
2637           free (all_local_syms);
2638           free (ext_syms);
2639           goto error_return;
2640         }
2641
2642       /* Swap the local symbols in.  */
2643       isym = local_syms;
2644       esym = ext_syms;
2645       for (i = 0; i < symtab_hdr->sh_info; i++, esym++, isym++)
2646          bfd_elf32_swap_symbol_in (input_bfd, esym, isym);
2647
2648       /* Now we can free the external symbols.  */
2649       free (ext_syms);
2650
2651       if (elf32_hppa_read_symext_info (input_bfd, symtab_hdr, args_hash_table,
2652                                        local_syms) == false)
2653         {
2654           for (i = 0; i < bfd_count; i++)
2655             if (all_local_syms[i])
2656               free (all_local_syms[i]);
2657           free (all_local_syms);
2658           goto error_return;
2659         }
2660     }
2661
2662   /* Magic as we know the stub bfd only has one section.  */
2663   stub_sec = stub_bfd->sections;
2664
2665   /* If generating a relocateable output file, then we don't
2666      have to examine the relocs.  */
2667   if (link_info->relocateable)
2668     {
2669       for (i = 0; i < bfd_count; i++)
2670         if (all_local_syms[i])
2671           free (all_local_syms[i]);
2672       free (all_local_syms);
2673       return true;
2674     }
2675
2676   /* Now that we have argument location information for all the global
2677      functions we can start looking for stubs.  */
2678   for (input_bfd = link_info->input_bfds, index = 0;
2679        input_bfd != NULL;
2680        input_bfd = input_bfd->link_next, index++)
2681     {
2682       /* We'll need the symbol table in a second.  */
2683       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2684       if (symtab_hdr->sh_info == 0)
2685         continue;
2686
2687       local_syms = all_local_syms[index];
2688
2689       /* Walk over each section attached to the input bfd.  */
2690       for (section = input_bfd->sections;
2691            section != NULL;
2692            section = section->next)
2693         {
2694           Elf_Internal_Shdr *input_rel_hdr;
2695           Elf32_External_Rela *external_relocs, *erelaend, *erela;
2696           Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2697
2698           /* If there aren't any relocs, then there's nothing to do.  */
2699           if ((section->flags & SEC_RELOC) == 0
2700               || section->reloc_count == 0)
2701             continue;
2702
2703           /* Allocate space for the external relocations.  */
2704           external_relocs
2705             = (Elf32_External_Rela *) malloc (section->reloc_count * sizeof (Elf32_External_Rela));
2706           if (external_relocs == NULL)
2707             {
2708               bfd_set_error (bfd_error_no_memory);
2709               for (i = 0; i < bfd_count; i++)
2710                 if (all_local_syms[i])
2711                   free (all_local_syms[i]);
2712               free (all_local_syms);
2713               goto error_return;
2714             }
2715
2716           /* Likewise for the internal relocations.  */
2717           internal_relocs
2718             = (Elf_Internal_Rela *) malloc (section->reloc_count * sizeof (Elf_Internal_Rela));
2719           if (internal_relocs == NULL)
2720             {
2721               bfd_set_error (bfd_error_no_memory);
2722               free (external_relocs);
2723               for (i = 0; i < bfd_count; i++)
2724                 if (all_local_syms[i])
2725                   free (all_local_syms[i]);
2726               free (all_local_syms);
2727               goto error_return;
2728             }
2729
2730           /* Read in the external relocs.  */
2731           input_rel_hdr = &elf_section_data (section)->rel_hdr;
2732           if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
2733               || bfd_read (external_relocs, 1, input_rel_hdr->sh_size,
2734                            input_bfd) != input_rel_hdr->sh_size)
2735             {
2736               free (external_relocs);
2737               free (internal_relocs);
2738               for (i = 0; i < bfd_count; i++)
2739                 if (all_local_syms[i])
2740                   free (all_local_syms[i]);
2741               free (all_local_syms);
2742               goto error_return;
2743             }
2744
2745           /* Swap in the relocs.  */
2746           erela = external_relocs;
2747           erelaend = erela + section->reloc_count;
2748           irela = internal_relocs;
2749           for (; erela < erelaend; erela++, irela++)
2750             bfd_elf32_swap_reloca_in (input_bfd, erela, irela);
2751
2752           /* We're done with the external relocs, free them.  */
2753           free (external_relocs);
2754
2755           /* Now examine each relocation.  */
2756           irela = internal_relocs;
2757           irelaend = irela + section->reloc_count;
2758           for (; irela < irelaend; irela++)
2759             {
2760               long r_type, callee_args, caller_args, r_index, size_of_stub;
2761               struct elf_link_hash_entry *hash;
2762               struct elf32_hppa_stub_hash_entry *stub_hash;
2763               struct elf32_hppa_args_hash_entry *args_hash;
2764               Elf_Internal_Sym *sym;
2765               asection *sym_sec;
2766               const char *sym_name;
2767               symvalue sym_value;
2768               bfd_vma location, destination;
2769               char *new_name = NULL;
2770
2771               r_type = ELF32_R_TYPE (irela->r_info);
2772               r_index = ELF32_R_SYM (irela->r_info);
2773
2774               if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
2775                 {
2776                   bfd_set_error (bfd_error_bad_value);
2777                   free (internal_relocs);
2778                   for (i = 0; i < bfd_count; i++)
2779                     if (all_local_syms[i])
2780                       free (all_local_syms[i]);
2781                   free (all_local_syms);
2782                   goto error_return;
2783                 }
2784
2785               /* Only look for stubs on call instructions or plabel
2786                  references.  */
2787               if (r_type != R_PARISC_PCREL17F
2788                   && r_type != R_PARISC_PLABEL32
2789                   && r_type != R_PARISC_PLABEL21L
2790                   && r_type != R_PARISC_PLABEL14R)
2791                 continue;
2792
2793               /* Now determine the call target, its name, value, section
2794                  and argument relocation bits.  */
2795               hash = NULL;
2796               sym = NULL;
2797               sym_sec = NULL;
2798               if (r_index < symtab_hdr->sh_info)
2799                 {
2800                   /* It's a local symbol.  */
2801                   Elf_Internal_Shdr *hdr;
2802
2803                   sym = local_syms + r_index;
2804                   hdr = elf_elfsections (input_bfd)[sym->st_shndx];
2805                   sym_sec = hdr->bfd_section;
2806                   sym_name = bfd_elf_string_from_elf_section (input_bfd,
2807                                                               symtab_hdr->sh_link,
2808                                                               sym->st_name);
2809                   sym_value = (ELF_ST_TYPE (sym->st_info) == STT_SECTION
2810                                ? 0 : sym->st_value);
2811                   destination = (sym_value
2812                                  + sym_sec->output_offset
2813                                  + sym_sec->output_section->vma);
2814
2815                   /* Tack on an ID so we can uniquely identify this local
2816                      symbol in the stub or arg info hash tables.  */
2817                   new_name = malloc (strlen (sym_name) + 10);
2818                   if (new_name == 0)
2819                     {
2820                       bfd_set_error (bfd_error_bad_value);
2821                       free (internal_relocs);
2822                       for (i = 0; i < bfd_count; i++)
2823                         if (all_local_syms[i])
2824                           free (all_local_syms[i]);
2825                       free (all_local_syms);
2826                       goto error_return;
2827                     }
2828                   sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
2829                   sym_name = new_name;
2830                 }
2831               else
2832                 {
2833                   /* It's an external symbol.  */
2834                   long index;
2835
2836                   index = r_index - symtab_hdr->sh_info;
2837                   hash = elf_sym_hashes (input_bfd)[index];
2838                   if (hash->root.type == bfd_link_hash_defined
2839                       || hash->root.type == bfd_link_hash_defweak)
2840                     {
2841                       sym_sec = hash->root.u.def.section;
2842                       sym_name = hash->root.root.string;
2843                       sym_value = hash->root.u.def.value;
2844                       destination = (sym_value
2845                                      + sym_sec->output_offset
2846                                      + sym_sec->output_section->vma);
2847                     }
2848                   else
2849                     {
2850                       bfd_set_error (bfd_error_bad_value);
2851                       free (internal_relocs);
2852                       for (i = 0; i < bfd_count; i++)
2853                         if (all_local_syms[i])
2854                           free (all_local_syms[i]);
2855                       free (all_local_syms);
2856                       goto error_return;
2857                     }
2858                 }
2859
2860               args_hash = elf32_hppa_args_hash_lookup (args_hash_table,
2861                                                        sym_name, false, false);
2862
2863               /* Get both caller and callee argument information.  */
2864               if (args_hash == NULL)
2865                 callee_args = 0;
2866               else
2867                 callee_args = args_hash->arg_bits;
2868
2869               /* For calls get the caller's bits from the addend of
2870                  the call relocation.  For PLABELS the caller's bits
2871                  are assumed to have all args & return values in general
2872                  registers (0x155).  */
2873               if (r_type == R_PARISC_PCREL17F)
2874                 caller_args = HPPA_R_ARG_RELOC (irela->r_addend);
2875               else
2876                 caller_args = 0x155;
2877
2878               /* Now determine where the call point is.  */
2879               location = (section->output_offset
2880                           + section->output_section->vma
2881                           + irela->r_offset);
2882
2883               /* We only care about the destination for PCREL function
2884                  calls (eg. we don't care for PLABELS).  */
2885               if (r_type != R_PARISC_PCREL17F)
2886                 location = destination;
2887
2888               /* Determine what (if any) linker stub is needed and its
2889                  size (in bytes).  */
2890               size_of_stub = elf32_hppa_size_of_stub (callee_args,
2891                                                       caller_args,
2892                                                       location,
2893                                                       destination,
2894                                                       sym_name);
2895               if (size_of_stub != 0)
2896                 {
2897                   char *stub_name;
2898                   unsigned int len;
2899
2900                   /* Get the name of this stub.  */
2901                   len = strlen (sym_name);
2902                   len += 23;
2903
2904                   stub_name = malloc (len);
2905                   if (!stub_name)
2906                     {
2907                       bfd_set_error (bfd_error_no_memory);
2908
2909                       /* Because sym_name was mallocd above for local
2910                          symbols.  */
2911                       if (r_index < symtab_hdr->sh_info)
2912                         free (new_name);
2913
2914                       free (internal_relocs);
2915                       for (i = 0; i < bfd_count; i++)
2916                         if (all_local_syms[i])
2917                           free (all_local_syms[i]);
2918                       free (all_local_syms);
2919                       goto error_return;
2920                     }
2921                   elf32_hppa_name_of_stub (caller_args, callee_args,
2922                                            location, destination, stub_name);
2923                   strcat (stub_name + 22, sym_name);
2924
2925                   /* Because sym_name was malloced above for local symbols.  */
2926                   if (r_index < symtab_hdr->sh_info)
2927                     free (new_name);
2928
2929                   stub_hash
2930                     = elf32_hppa_stub_hash_lookup (stub_hash_table, stub_name,
2931                                                    false, false);
2932                   if (stub_hash != NULL)
2933                     {
2934                       /* The proper stub has already been created, nothing
2935                          else to do.  */
2936                       free (stub_name);
2937                     }
2938                   else
2939                     {
2940                       bfd_set_section_size (stub_bfd, stub_sec,
2941                                             (bfd_section_size (stub_bfd,
2942                                                                stub_sec)
2943                                              + size_of_stub));
2944
2945                       /* Enter this entry into the linker stub hash table.  */
2946                       stub_hash
2947                         = elf32_hppa_stub_hash_lookup (stub_hash_table,
2948                                                        stub_name, true, true);
2949                       if (stub_hash == NULL)
2950                         {
2951                           bfd_set_error (bfd_error_no_memory);
2952                           free (stub_name);
2953                           free (internal_relocs);
2954                           for (i = 0; i < bfd_count; i++)
2955                             if (all_local_syms[i])
2956                               free (all_local_syms[i]);
2957                           free (all_local_syms);
2958                           goto error_return;
2959                         }
2960
2961                       /* We'll need these to determine the address that the
2962                          stub will branch to.  */
2963                       stub_hash->target_value = sym_value;
2964                       stub_hash->target_section = sym_sec;
2965                     }
2966                   free (stub_name);
2967                 }
2968             }
2969           /* We're done with the internal relocs, free them.  */
2970           free (internal_relocs);
2971         }
2972     }
2973   /* We're done with the local symbols, free them.  */
2974   for (i = 0; i < bfd_count; i++)
2975     if (all_local_syms[i])
2976       free (all_local_syms[i]);
2977   free (all_local_syms);
2978   return true;
2979
2980 error_return:
2981   /* Return gracefully, avoiding dangling references to the hash tables.  */
2982   if (stub_hash_table)
2983     {
2984       elf32_hppa_hash_table(link_info)->stub_hash_table = NULL;
2985       free (stub_hash_table);
2986     }
2987   if (args_hash_table)
2988     {
2989       elf32_hppa_hash_table(link_info)->args_hash_table = NULL;
2990       free (args_hash_table);
2991     }
2992   /* Set the size of the stub section to zero since we're never going
2993      to create them.   Avoids losing when we try to get its contents
2994      too.  */
2995   bfd_set_section_size (stub_bfd, stub_sec, 0);
2996   return false;
2997 }
2998
2999 /* Misc BFD support code.  */
3000 #define bfd_elf32_bfd_reloc_type_lookup         elf_hppa_reloc_type_lookup
3001 #define bfd_elf32_bfd_is_local_label            hppa_elf_is_local_label
3002
3003 /* Symbol extension stuff.  */
3004 #define bfd_elf32_set_section_contents          elf32_hppa_set_section_contents
3005 #define elf_backend_symbol_table_processing \
3006   elf32_hppa_backend_symbol_table_processing
3007 #define elf_backend_begin_write_processing \
3008   elf32_hppa_backend_begin_write_processing
3009 #define elf_backend_final_write_processing \
3010   elf32_hppa_backend_final_write_processing
3011
3012 /* Stuff for the BFD linker.  */
3013 #define elf_backend_relocate_section            elf32_hppa_relocate_section
3014 #define elf_backend_add_symbol_hook             elf32_hppa_add_symbol_hook
3015 #define elf_backend_link_output_symbol_hook \
3016   elf32_hppa_link_output_symbol_hook
3017 #define bfd_elf32_bfd_link_hash_table_create \
3018   elf32_hppa_link_hash_table_create
3019
3020 #define TARGET_BIG_SYM          bfd_elf32_hppa_vec
3021 #define TARGET_BIG_NAME         "elf32-hppa"
3022 #define ELF_ARCH                bfd_arch_hppa
3023 #define ELF_MACHINE_CODE        EM_PARISC
3024 #define ELF_MAXPAGESIZE         0x1000
3025
3026 #include "elf32-target.h"