bfd/elf-hppa.h

   1 /* Common code for PA ELF implementations.
   2    Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #define ELF_HOWTO_TABLE_SIZE       R_PARISC_UNIMPLEMENTED + 1
  21
  22 /* This file is included by multiple PA ELF BFD backends with different
  23    sizes.
  24
  25    Most of the routines are written to be size independent, but sometimes
  26    external constraints require 32 or 64 bit specific code.  We remap
  27    the definitions/functions as necessary here.  */
  28 #if ARCH_SIZE == 64
  29 #define ELF_R_TYPE(X)   ELF64_R_TYPE(X)
  30 #define ELF_R_SYM(X)   ELF64_R_SYM(X)
  31 #define elf_hppa_internal_shdr Elf64_Internal_Shdr
  32 #define elf_hppa_reloc_final_type elf64_hppa_reloc_final_type
  33 #define _bfd_elf_hppa_gen_reloc_type _bfd_elf64_hppa_gen_reloc_type
  34 #define elf_hppa_relocate_section elf64_hppa_relocate_section
  35 #define bfd_elf_bfd_final_link bfd_elf64_bfd_final_link
  36 #define elf_hppa_final_link elf64_hppa_final_link
  37 #endif
  38 #if ARCH_SIZE == 32
  39 #define ELF_R_TYPE(X)   ELF32_R_TYPE(X)
  40 #define ELF_R_SYM(X)   ELF32_R_SYM(X)
  41 #define elf_hppa_internal_shdr Elf32_Internal_Shdr
  42 #define elf_hppa_reloc_final_type elf32_hppa_reloc_final_type
  43 #define _bfd_elf_hppa_gen_reloc_type _bfd_elf32_hppa_gen_reloc_type
  44 #define elf_hppa_relocate_section elf32_hppa_relocate_section
  45 #define bfd_elf_bfd_final_link bfd_elf32_bfd_final_link
  46 #define elf_hppa_final_link elf32_hppa_final_link
  47 #endif
  48
  49 static void elf_hppa_info_to_howto
  50   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  51
  52 static void elf_hppa_info_to_howto_rel
  53   PARAMS ((bfd *, arelent *, Elf_Internal_Rel *));
  54
  55 static reloc_howto_type * elf_hppa_reloc_type_lookup
  56   PARAMS ((bfd *, bfd_reloc_code_real_type));
  57
  58 static boolean elf_hppa_is_local_label_name
  59   PARAMS ((bfd *, const char *));
  60
  61 static boolean elf_hppa_fake_sections
  62   PARAMS ((bfd *abfd, elf_hppa_internal_shdr *, asection *));
  63
  64 static void elf_hppa_final_write_processing
  65   PARAMS ((bfd *, boolean));
  66
  67 #if ARCH_SIZE == 64
  68 static boolean elf_hppa_add_symbol_hook
  69   PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
  70            const char **, flagword *, asection **, bfd_vma *));
  71
  72 static boolean elf_hppa_unmark_useless_dynamic_symbols
  73   PARAMS ((struct elf_link_hash_entry *, PTR));
  74
  75 static boolean elf_hppa_remark_useless_dynamic_symbols
  76   PARAMS ((struct elf_link_hash_entry *, PTR));
  77
  78 static boolean elf_hppa_is_dynamic_loader_symbol
  79   PARAMS ((const char *));
  80
  81 static void elf_hppa_record_segment_addrs
  82   PARAMS ((bfd *, asection *, PTR));
  83
  84 static boolean elf_hppa_final_link
  85   PARAMS ((bfd *, struct bfd_link_info *));
  86
  87 static boolean elf_hppa_relocate_section
  88   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
  89            bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  90
  91 static bfd_reloc_status_type elf_hppa_final_link_relocate
  92   PARAMS ((Elf_Internal_Rela *, bfd *, bfd *, asection *,
  93            bfd_byte *, bfd_vma, struct bfd_link_info *,
  94            asection *, struct elf_link_hash_entry *,
  95            struct elf64_hppa_dyn_hash_entry *));
  96
  97 static int elf_hppa_relocate_insn
  98   PARAMS ((int, int, unsigned int));
  99 #endif
 100
 101 /* ELF/PA relocation howto entries.  */
 102
 103 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
 104 {
 105   { R_PARISC_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield,
 106     bfd_elf_generic_reloc, "R_PARISC_NONE", false, 0, 0, false },
 107
 108   /* The values in DIR32 are to placate the check in
 109      _bfd_stab_section_find_nearest_line.  */
 110   { R_PARISC_DIR32, 0, 2, 32, false, 0, complain_overflow_bitfield,
 111     bfd_elf_generic_reloc, "R_PARISC_DIR32", false, 0, 0xffffffff, false },
 112   { R_PARISC_DIR21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 113     bfd_elf_generic_reloc, "R_PARISC_DIR21L", false, 0, 0, false },
 114   { R_PARISC_DIR17R, 0, 0, 17, false, 0, complain_overflow_bitfield,
 115     bfd_elf_generic_reloc, "R_PARISC_DIR17R", false, 0, 0, false },
 116   { R_PARISC_DIR17F, 0, 0, 17, false, 0, complain_overflow_bitfield,
 117     bfd_elf_generic_reloc, "R_PARISC_DIR17F", false, 0, 0, false },
 118   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 119     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 120   { R_PARISC_DIR14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 121     bfd_elf_generic_reloc, "R_PARISC_DIR14R", false, 0, 0, false },
 122   { R_PARISC_DIR14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 123     bfd_elf_generic_reloc, "R_PARISC_DIR14F", false, 0, 0, false },
 124   /* 8 */
 125   { R_PARISC_PCREL12F, 0, 0, 12, true, 0, complain_overflow_bitfield,
 126     bfd_elf_generic_reloc, "R_PARISC_PCREL12F", false, 0, 0, false },
 127   { R_PARISC_PCREL32, 0, 0, 32, true, 0, complain_overflow_bitfield,
 128     bfd_elf_generic_reloc, "R_PARISC_PCREL32", false, 0, 0, false },
 129   { R_PARISC_PCREL21L, 0, 0, 21, true, 0, complain_overflow_bitfield,
 130     bfd_elf_generic_reloc, "R_PARISC_PCREL21L", false, 0, 0, false },
 131   { R_PARISC_PCREL17R, 0, 0, 17, true, 0, complain_overflow_bitfield,
 132     bfd_elf_generic_reloc, "R_PARISC_PCREL17R", false, 0, 0, false },
 133   { R_PARISC_PCREL17F, 0, 0, 17, true, 0, complain_overflow_bitfield,
 134     bfd_elf_generic_reloc, "R_PARISC_PCREL17F", false, 0, 0, false },
 135   { R_PARISC_PCREL17C, 0, 0, 17, true, 0, complain_overflow_bitfield,
 136     bfd_elf_generic_reloc, "R_PARISC_PCREL17C", false, 0, 0, false },
 137   { R_PARISC_PCREL14R, 0, 0, 14, true, 0, complain_overflow_bitfield,
 138     bfd_elf_generic_reloc, "R_PARISC_PCREL14R", false, 0, 0, false },
 139   { R_PARISC_PCREL14F, 0, 0, 14, true, 0, complain_overflow_bitfield,
 140     bfd_elf_generic_reloc, "R_PARISC_PCREL14F", false, 0, 0, false },
 141   /* 16 */
 142   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 143     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 144   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 145     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 146   { R_PARISC_DPREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 147     bfd_elf_generic_reloc, "R_PARISC_DPREL21L", false, 0, 0, false },
 148   { R_PARISC_DPREL14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 149     bfd_elf_generic_reloc, "R_PARISC_DPREL14WR", false, 0, 0, false },
 150   { R_PARISC_DPREL14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 151     bfd_elf_generic_reloc, "R_PARISC_DPREL14DR", false, 0, 0, false },
 152   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 153     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 154   { R_PARISC_DPREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 155     bfd_elf_generic_reloc, "R_PARISC_DPREL14R", false, 0, 0, false },
 156   { R_PARISC_DPREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 157     bfd_elf_generic_reloc, "R_PARISC_DPREL14F", false, 0, 0, false },
 158   /* 24 */
 159   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 160     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 161   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 162     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 163   { R_PARISC_DLTREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 164     bfd_elf_generic_reloc, "R_PARISC_DLTREL21L", false, 0, 0, false },
 165   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 166     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 167   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 168     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 169   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 170     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 171   { R_PARISC_DLTREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 172     bfd_elf_generic_reloc, "R_PARISC_DLTREL14R", false, 0, 0, false },
 173   { R_PARISC_DLTREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 174     bfd_elf_generic_reloc, "R_PARISC_DLTREL14F", false, 0, 0, false },
 175   /* 32 */
 176   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 177     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 178   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 179     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 180   { R_PARISC_DLTIND21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 181     bfd_elf_generic_reloc, "R_PARISC_DLTIND21L", false, 0, 0, false },
 182   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 183     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 184   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 185     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 186   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 187     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 188   { R_PARISC_DLTIND14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 189     bfd_elf_generic_reloc, "R_PARISC_DLTIND14R", false, 0, 0, false },
 190   { R_PARISC_DLTIND14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 191     bfd_elf_generic_reloc, "R_PARISC_DLTIND14F", false, 0, 0, false },
 192   /* 40 */
 193   { R_PARISC_SETBASE, 0, 0, 0, false, 0, complain_overflow_bitfield,
 194     bfd_elf_generic_reloc, "R_PARISC_SETBASE", false, 0, 0, false },
 195   { R_PARISC_SECREL32, 0, 0, 32, false, 0, complain_overflow_bitfield,
 196     bfd_elf_generic_reloc, "R_PARISC_SECREL32", false, 0, 0, false },
 197   { R_PARISC_BASEREL21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 198     bfd_elf_generic_reloc, "R_PARISC_BASEREL21L", false, 0, 0, false },
 199   { R_PARISC_BASEREL17R, 0, 0, 17, false, 0, complain_overflow_bitfield,
 200     bfd_elf_generic_reloc, "R_PARISC_BASEREL17R", false, 0, 0, false },
 201   { R_PARISC_BASEREL17F, 0, 0, 17, false, 0, complain_overflow_bitfield,
 202     bfd_elf_generic_reloc, "R_PARISC_BASEREL17F", false, 0, 0, false },
 203   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 204     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 205   { R_PARISC_BASEREL14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 206     bfd_elf_generic_reloc, "R_PARISC_BASEREL14R", false, 0, 0, false },
 207   { R_PARISC_BASEREL14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 208     bfd_elf_generic_reloc, "R_PARISC_BASEREL14F", false, 0, 0, false },
 209   /* 48 */
 210   { R_PARISC_SEGBASE, 0, 0, 0, false, 0, complain_overflow_bitfield,
 211     bfd_elf_generic_reloc, "R_PARISC_SEGBASE", false, 0, 0, false },
 212   { R_PARISC_SEGREL32, 0, 0, 32, false, 0, complain_overflow_bitfield,
 213     bfd_elf_generic_reloc, "R_PARISC_SEGREL32", false, 0, 0, false },
 214   { R_PARISC_PLTOFF21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 215     bfd_elf_generic_reloc, "R_PARISC_PLTOFF21L", false, 0, 0, false },
 216   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 217     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 218   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 219     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 220   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 221     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 222   { R_PARISC_PLTOFF14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 223     bfd_elf_generic_reloc, "R_PARISC_PLTOFF14R", false, 0, 0, false },
 224   { R_PARISC_PLTOFF14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 225     bfd_elf_generic_reloc, "R_PARISC_PLTOFF14F", false, 0, 0, false },
 226   /* 56 */
 227   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 228     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 229   { R_PARISC_LTOFF_FPTR32, 0, 0, 32, false, 0, complain_overflow_bitfield,
 230     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR32", false, 0, 0, false },
 231   { R_PARISC_LTOFF_FPTR21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 232     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR21L", false, 0, 0, false },
 233   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 234     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 235   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 236     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 237   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 238     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 239   { R_PARISC_LTOFF_FPTR14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 240     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR14R", false, 0, 0, false },
 241   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 242     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 243   /* 64 */
 244   { R_PARISC_FPTR64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 245     bfd_elf_generic_reloc, "R_PARISC_FPTR64", false, 0, 0, false },
 246   { R_PARISC_PLABEL32, 0, 0, 32, false, 0, complain_overflow_bitfield,
 247     bfd_elf_generic_reloc, "R_PARISC_PLABEL32", false, 0, 0, false },
 248   { R_PARISC_PLABEL21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 249     bfd_elf_generic_reloc, "R_PARISC_PLABEL21L", false, 0, 0, false },
 250   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 251     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 252   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 253     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 254   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 255     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 256   { R_PARISC_PLABEL14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 257     bfd_elf_generic_reloc, "R_PARISC_PLABEL14R", false, 0, 0, false },
 258   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 259     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 260   /* 72 */
 261   { R_PARISC_PCREL64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 262     bfd_elf_generic_reloc, "R_PARISC_PCREL64", false, 0, 0, false },
 263   { R_PARISC_PCREL22C, 0, 0, 22, false, 0, complain_overflow_bitfield,
 264     bfd_elf_generic_reloc, "R_PARISC_PCREL22C", false, 0, 0, false },
 265   { R_PARISC_PCREL22F, 0, 0, 22, false, 0, complain_overflow_bitfield,
 266     bfd_elf_generic_reloc, "R_PARISC_PCREL22F", false, 0, 0, false },
 267   { R_PARISC_PCREL14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 268     bfd_elf_generic_reloc, "R_PARISC_PCREL14WR", false, 0, 0, false },
 269   { R_PARISC_PCREL14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 270     bfd_elf_generic_reloc, "R_PARISC_PCREL14DR", false, 0, 0, false },
 271   { R_PARISC_PCREL16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 272     bfd_elf_generic_reloc, "R_PARISC_PCREL16F", false, 0, 0, false },
 273   { R_PARISC_PCREL16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 274     bfd_elf_generic_reloc, "R_PARISC_PCREL16WF", false, 0, 0, false },
 275   { R_PARISC_PCREL16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 276     bfd_elf_generic_reloc, "R_PARISC_PCREL16DF", false, 0, 0, false },
 277   /* 80 */
 278   { R_PARISC_DIR64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 279     bfd_elf_generic_reloc, "R_PARISC_DIR64", false, 0, 0, false },
 280   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 281     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 282   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 283     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 284   { R_PARISC_DIR14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 285     bfd_elf_generic_reloc, "R_PARISC_DIR14WR", false, 0, 0, false },
 286   { R_PARISC_DIR14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 287     bfd_elf_generic_reloc, "R_PARISC_DIR14DR", false, 0, 0, false },
 288   { R_PARISC_DIR16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 289     bfd_elf_generic_reloc, "R_PARISC_DIR16F", false, 0, 0, false },
 290   { R_PARISC_DIR16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 291     bfd_elf_generic_reloc, "R_PARISC_DIR16WF", false, 0, 0, false },
 292   { R_PARISC_DIR16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 293     bfd_elf_generic_reloc, "R_PARISC_DIR16DF", false, 0, 0, false },
 294   /* 88 */
 295   { R_PARISC_GPREL64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 296     bfd_elf_generic_reloc, "R_PARISC_GPREL64", false, 0, 0, false },
 297   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 298     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 299   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 300     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 301   { R_PARISC_DLTREL14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 302     bfd_elf_generic_reloc, "R_PARISC_DLTREL14WR", false, 0, 0, false },
 303   { R_PARISC_DLTREL14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 304     bfd_elf_generic_reloc, "R_PARISC_DLTREL14DR", false, 0, 0, false },
 305   { R_PARISC_GPREL16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 306     bfd_elf_generic_reloc, "R_PARISC_GPREL16F", false, 0, 0, false },
 307   { R_PARISC_GPREL16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 308     bfd_elf_generic_reloc, "R_PARISC_GPREL16WF", false, 0, 0, false },
 309   { R_PARISC_GPREL16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 310     bfd_elf_generic_reloc, "R_PARISC_GPREL16DF", false, 0, 0, false },
 311   /* 96 */
 312   { R_PARISC_LTOFF64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 313     bfd_elf_generic_reloc, "R_PARISC_LTOFF64", false, 0, 0, false },
 314   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 315     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 316   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 317     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 318   { R_PARISC_DLTIND14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 319     bfd_elf_generic_reloc, "R_PARISC_DLTIND14WR", false, 0, 0, false },
 320   { R_PARISC_DLTIND14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 321     bfd_elf_generic_reloc, "R_PARISC_DLTIND14DR", false, 0, 0, false },
 322   { R_PARISC_LTOFF16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 323     bfd_elf_generic_reloc, "R_PARISC_LTOFF16F", false, 0, 0, false },
 324   { R_PARISC_LTOFF16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 325     bfd_elf_generic_reloc, "R_PARISC_LTOFF16DF", false, 0, 0, false },
 326   { R_PARISC_LTOFF16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 327     bfd_elf_generic_reloc, "R_PARISC_LTOFF16DF", false, 0, 0, false },
 328   /* 104 */
 329   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 330     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 331   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 332     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 333   { R_PARISC_BASEREL14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 334     bfd_elf_generic_reloc, "R_PARISC_BASEREL14WR", false, 0, 0, false },
 335   { R_PARISC_BASEREL14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 336     bfd_elf_generic_reloc, "R_PARISC_BASEREL14DR", false, 0, 0, false },
 337   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 338     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 339   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 340     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 341   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 342     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 343   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 344     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 345   /* 112 */
 346   { R_PARISC_SEGREL64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 347     bfd_elf_generic_reloc, "R_PARISC_SEGREL64", false, 0, 0, false },
 348   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 349     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 350   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 351     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 352   { R_PARISC_PLTOFF14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 353     bfd_elf_generic_reloc, "R_PARISC_PLTOFF14WR", false, 0, 0, false },
 354   { R_PARISC_PLTOFF14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 355     bfd_elf_generic_reloc, "R_PARISC_PLTOFF14DR", false, 0, 0, false },
 356   { R_PARISC_PLTOFF16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 357     bfd_elf_generic_reloc, "R_PARISC_PLTOFF16F", false, 0, 0, false },
 358   { R_PARISC_PLTOFF16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 359     bfd_elf_generic_reloc, "R_PARISC_PLTOFF16WF", false, 0, 0, false },
 360   { R_PARISC_PLTOFF16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 361     bfd_elf_generic_reloc, "R_PARISC_PLTOFF16DF", false, 0, 0, false },
 362   /* 120 */
 363   { R_PARISC_LTOFF_FPTR64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 364     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 365   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 366     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 367   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 368     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 369   { R_PARISC_LTOFF_FPTR14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 370     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR14WR", false, 0, 0, false },
 371   { R_PARISC_LTOFF_FPTR14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 372     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR14DR", false, 0, 0, false },
 373   { R_PARISC_LTOFF_FPTR16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 374     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR16F", false, 0, 0, false },
 375   { R_PARISC_LTOFF_FPTR16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 376     bfd_elf_generic_reloc, "R_PARISC_LTOFF_FPTR16WF", false, 0, 0, false },
 377   { R_PARISC_LTOFF_FPTR16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 378     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 379   /* 128 */
 380   { R_PARISC_COPY, 0, 0, 0, false, 0, complain_overflow_bitfield,
 381     bfd_elf_generic_reloc, "R_PARISC_COPY", false, 0, 0, false },
 382   { R_PARISC_IPLT, 0, 0, 0, false, 0, complain_overflow_bitfield,
 383     bfd_elf_generic_reloc, "R_PARISC_IPLT", false, 0, 0, false },
 384   { R_PARISC_EPLT, 0, 0, 0, false, 0, complain_overflow_bitfield,
 385     bfd_elf_generic_reloc, "R_PARISC_EPLT", false, 0, 0, false },
 386   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 387     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 388   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 389     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 390   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 391     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 392   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 393     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 394   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 395     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 396   /* 136 */
 397   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 398     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 399   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 400     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 401   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 402     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 403   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 404     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 405   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 406     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 407   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 408     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 409   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 410     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 411   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 412     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 413   /* 144 */
 414   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 415     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 416   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 417     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 418   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 419     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 420   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 421     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 422   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 423     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 424   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 425     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 426   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 427     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 428   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 429     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 430   /* 152 */
 431   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 432     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 433   { R_PARISC_TPREL32, 0, 0, 32, false, 0, complain_overflow_dont,
 434     bfd_elf_generic_reloc, "R_PARISC_TPREL32", false, 0, 0, false },
 435   { R_PARISC_TPREL21L, 0, 0, 21, false, 0, complain_overflow_dont,
 436     bfd_elf_generic_reloc, "R_PARISC_TPREL21L", false, 0, 0, false },
 437   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 438     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 439   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 440     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 441   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 442     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 443   { R_PARISC_TPREL14R, 0, 0, 14, false, 0, complain_overflow_dont,
 444     bfd_elf_generic_reloc, "R_PARISC_TPREL14R", false, 0, 0, false },
 445   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 446     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 447   /* 160 */
 448   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 449     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 450   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 451     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 452   { R_PARISC_LTOFF_TP21L, 0, 0, 21, false, 0, complain_overflow_bitfield,
 453     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP21L", false, 0, 0, false },
 454   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 455     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 456   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 457     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 458   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 459     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 460   { R_PARISC_LTOFF_TP14R, 0, 0, 14, false, 0, complain_overflow_bitfield,
 461     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 462   { R_PARISC_LTOFF_TP14F, 0, 0, 14, false, 0, complain_overflow_bitfield,
 463     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP14F", false, 0, 0, false },
 464   /* 168 */
 465   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 466     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 467   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 468     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 469   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 470     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 471   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 472     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 473   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 474     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 475   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 476     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 477   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 478     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 479   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 480     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 481   /* 176 */
 482   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 483     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 484   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 485     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 486   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 487     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 488   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 489     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 490   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 491     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 492   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 493     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 494   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 495     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 496   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 497     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 498   /* 184 */
 499   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 500     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 501   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 502     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 503   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 504     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 505   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 506     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 507   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 508     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 509   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 510     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 511   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 512     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 513   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 514     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 515   /* 192 */
 516   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 517     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 518   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 519     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 520   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 521     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 522   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 523     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 524   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 525     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 526   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 527     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 528   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 529     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 530   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 531     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 532   /* 200 */
 533   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 534     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 535   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 536     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 537   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 538     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 539   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 540     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 541   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 542     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 543   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 544     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 545   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 546     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 547   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 548     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 549   /* 208 */
 550   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 551     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 552   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 553     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 554   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 555     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 556   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 557     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 558   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_dont,
 559     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 560   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 561     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 562   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 563     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 564   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 565     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 566   /* 216 */
 567   { R_PARISC_TPREL64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 568     bfd_elf_generic_reloc, "R_PARISC_TPREL64", false, 0, 0, false },
 569   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 570     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 571   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 572     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 573   { R_PARISC_TPREL14WR, 0, 0, 14, false, 0, complain_overflow_dont,
 574     bfd_elf_generic_reloc, "R_PARISC_TPREL14WR", false, 0, 0, false },
 575   { R_PARISC_TPREL14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 576     bfd_elf_generic_reloc, "R_PARISC_TPREL14DR", false, 0, 0, false },
 577   { R_PARISC_TPREL16F, 0, 0, 16, false, 0, complain_overflow_bitfield,
 578     bfd_elf_generic_reloc, "R_PARISC_TPREL16F", false, 0, 0, false },
 579   { R_PARISC_TPREL16WF, 0, 0, 16, false, 0, complain_overflow_dont,
 580     bfd_elf_generic_reloc, "R_PARISC_TPREL16WF", false, 0, 0, false },
 581   { R_PARISC_TPREL16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 582     bfd_elf_generic_reloc, "R_PARISC_TPREL16DF", false, 0, 0, false },
 583   /* 224 */
 584   { R_PARISC_LTOFF_TP64, 0, 0, 64, false, 0, complain_overflow_bitfield,
 585     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP64", false, 0, 0, false },
 586   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 587     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 588   { R_PARISC_UNIMPLEMENTED, 0, 0, 0, false, 0, complain_overflow_bitfield,
 589     bfd_elf_generic_reloc, "R_PARISC_UNIMPLEMENTED", false, 0, 0, false },
 590   { R_PARISC_LTOFF_TP14WR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 591     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP14WR", false, 0, 0, false },
 592   { R_PARISC_LTOFF_TP14DR, 0, 0, 14, false, 0, complain_overflow_bitfield,
 593     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP14DR", false, 0, 0, false },
 594   { R_PARISC_LTOFF_TP16F, 0, 0, 16, false, 0, complain_overflow_dont,
 595     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP16F", false, 0, 0, false },
 596   { R_PARISC_LTOFF_TP16WF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 597     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP16WF", false, 0, 0, false },
 598   { R_PARISC_LTOFF_TP16DF, 0, 0, 16, false, 0, complain_overflow_bitfield,
 599     bfd_elf_generic_reloc, "R_PARISC_LTOFF_TP16DF", false, 0, 0, false },
 600   /* 232 */
 601   { R_PARISC_GNU_VTENTRY, 0, 0, 0, false, 0, complain_overflow_dont,
 602     bfd_elf_generic_reloc, "R_PARISC_GNU_VTENTRY", false, 0, 0, false },
 603   { R_PARISC_GNU_VTINHERIT, 0, 0, 0, false, 0, complain_overflow_dont,
 604     bfd_elf_generic_reloc, "R_PARISC_GNU_VTINHERIT", false, 0, 0, false },
 605 };
 606
 607 #define OFFSET_14R_FROM_21L 4
 608 #define OFFSET_14F_FROM_21L 5
 609
 610 /* Return the final relocation type for the given base type, instruction
 611    format, and field selector.  */
 612
 613 elf_hppa_reloc_type
 614 elf_hppa_reloc_final_type (abfd, base_type, format, field)
 615      bfd *abfd;
 616      elf_hppa_reloc_type base_type;
 617      int format;
 618      unsigned int field;
 619 {
 620   elf_hppa_reloc_type final_type = base_type;
 621
 622   /* Just a tangle of nested switch statements to deal with the braindamage
 623      that a different field selector means a completely different relocation
 624      for PA ELF.  */
 625   switch (base_type)
 626     {
 627     /* We have been using generic relocation types.  However, that may not
 628        really make sense.  Anyway, we need to support both R_PARISC_DIR64
 629        and R_PARISC_DIR32 here.  */
 630     case R_PARISC_DIR32:
 631     case R_PARISC_DIR64:
 632     case R_HPPA_ABS_CALL:
 633       switch (format)
 634         {
 635         case 14:
 636           switch (field)
 637             {
 638             case e_fsel:
 639               final_type = R_PARISC_DIR14F;
 640               break;
 641             case e_rsel:
 642             case e_rrsel:
 643             case e_rdsel:
 644               final_type = R_PARISC_DIR14R;
 645               break;
 646             case e_rtsel:
 647               final_type = R_PARISC_DLTIND14R;
 648               break;
 649             case e_rtpsel:
 650               final_type = R_PARISC_LTOFF_FPTR14DR;
 651               break;
 652             case e_tsel:
 653               final_type = R_PARISC_DLTIND14F;
 654               break;
 655             case e_rpsel:
 656               final_type = R_PARISC_PLABEL14R;
 657               break;
 658             default:
 659               return R_PARISC_NONE;
 660             }
 661           break;
 662
 663         case 17:
 664           switch (field)
 665             {
 666             case e_fsel:
 667               final_type = R_PARISC_DIR17F;
 668               break;
 669             case e_rsel:
 670             case e_rrsel:
 671             case e_rdsel:
 672               final_type = R_PARISC_DIR17R;
 673               break;
 674             default:
 675               return R_PARISC_NONE;
 676             }
 677           break;
 678
 679         case 21:
 680           switch (field)
 681             {
 682             case e_lsel:
 683             case e_lrsel:
 684             case e_ldsel:
 685             case e_nlsel:
 686             case e_nlrsel:
 687               final_type = R_PARISC_DIR21L;
 688               break;
 689             case e_ltsel:
 690               final_type = R_PARISC_DLTIND21L;
 691               break;
 692             case e_ltpsel:
 693               final_type = R_PARISC_LTOFF_FPTR21L;
 694               break;
 695             case e_lpsel:
 696               final_type = R_PARISC_PLABEL21L;
 697               break;
 698             default:
 699               return R_PARISC_NONE;
 700             }
 701           break;
 702
 703         case 32:
 704           switch (field)
 705             {
 706             case e_fsel:
 707               final_type = R_PARISC_DIR32;
 708               /* When in 64bit mode, a 32bit relocation is supposed to
 709                  be a section relative relocation.  Dwarf2 (for example)
 710                  uses 32bit section relative relocations.  */
 711               if (bfd_get_arch_info (abfd)->bits_per_address != 32)
 712                 final_type = R_PARISC_SECREL32;
 713               break;
 714             case e_psel:
 715               final_type = R_PARISC_PLABEL32;
 716               break;
 717             default:
 718               return R_PARISC_NONE;
 719             }
 720           break;
 721
 722         case 64:
 723           switch (field)
 724             {
 725             case e_fsel:
 726               final_type = R_PARISC_DIR64;
 727               break;
 728             case e_psel:
 729               final_type = R_PARISC_FPTR64;
 730               break;
 731             default:
 732               return R_PARISC_NONE;
 733             }
 734           break;
 735
 736         default:
 737           return R_PARISC_NONE;
 738         }
 739       break;
 740
 741     case R_HPPA_GOTOFF:
 742       switch (format)
 743         {
 744         case 14:
 745           switch (field)
 746             {
 747             case e_rsel:
 748             case e_rrsel:
 749             case e_rdsel:
 750               /* R_PARISC_DLTREL14R for elf64, R_PARISC_DPREL14R for elf32  */
 751               final_type = base_type + OFFSET_14R_FROM_21L;
 752               break;
 753             case e_fsel:
 754               /* R_PARISC_DLTREL14F for elf64, R_PARISC_DPREL14F for elf32  */
 755               final_type = base_type + OFFSET_14F_FROM_21L;
 756               break;
 757             default:
 758               return R_PARISC_NONE;
 759             }
 760           break;
 761
 762         case 21:
 763           switch (field)
 764             {
 765             case e_lsel:
 766             case e_lrsel:
 767             case e_ldsel:
 768             case e_nlsel:
 769             case e_nlrsel:
 770               /* R_PARISC_DLTREL21L for elf64, R_PARISC_DPREL21L for elf32  */
 771               final_type = base_type;
 772               break;
 773             default:
 774               return R_PARISC_NONE;
 775             }
 776           break;
 777
 778         default:
 779           return R_PARISC_NONE;
 780         }
 781       break;
 782
 783     case R_HPPA_PCREL_CALL:
 784       switch (format)
 785         {
 786         case 12:
 787           switch (field)
 788             {
 789             case e_fsel:
 790               final_type = R_PARISC_PCREL12F;
 791               break;
 792             default:
 793               return R_PARISC_NONE;
 794             }
 795           break;
 796
 797         case 14:
 798           /* Contrary to appearances, these are not calls of any sort.
 799              Rather, they are loads/stores with a pcrel reloc.  */
 800           switch (field)
 801             {
 802             case e_rsel:
 803             case e_rrsel:
 804             case e_rdsel:
 805               final_type = R_PARISC_PCREL14R;
 806               break;
 807             case e_fsel:
 808               final_type = R_PARISC_PCREL14F;
 809               break;
 810             default:
 811               return R_PARISC_NONE;
 812             }
 813           break;
 814
 815         case 17:
 816           switch (field)
 817             {
 818             case e_rsel:
 819             case e_rrsel:
 820             case e_rdsel:
 821               final_type = R_PARISC_PCREL17R;
 822               break;
 823             case e_fsel:
 824               final_type = R_PARISC_PCREL17F;
 825               break;
 826             default:
 827               return R_PARISC_NONE;
 828             }
 829           break;
 830
 831         case 21:
 832           switch (field)
 833             {
 834             case e_lsel:
 835             case e_lrsel:
 836             case e_ldsel:
 837             case e_nlsel:
 838             case e_nlrsel:
 839               final_type = R_PARISC_PCREL21L;
 840               break;
 841             default:
 842               return R_PARISC_NONE;
 843             }
 844           break;
 845
 846         case 22:
 847           switch (field)
 848             {
 849             case e_fsel:
 850               final_type = R_PARISC_PCREL22F;
 851               break;
 852             default:
 853               return R_PARISC_NONE;
 854             }
 855           break;
 856
 857         default:
 858           return R_PARISC_NONE;
 859         }
 860       break;
 861
 862     case R_PARISC_GNU_VTENTRY:
 863     case R_PARISC_GNU_VTINHERIT:
 864     case R_PARISC_SEGREL32:
 865     case R_PARISC_SEGBASE:
 866       /* The defaults are fine for these cases.  */
 867       break;
 868
 869     default:
 870       return R_PARISC_NONE;
 871     }
 872
 873   return final_type;
 874 }
 875
 876 /* Return one (or more) BFD relocations which implement the base
 877    relocation with modifications based on format and field.  */
 878
 879 elf_hppa_reloc_type **
 880 _bfd_elf_hppa_gen_reloc_type (abfd, base_type, format, field, ignore, sym)
 881      bfd *abfd;
 882      elf_hppa_reloc_type base_type;
 883      int format;
 884      unsigned int field;
 885      int ignore ATTRIBUTE_UNUSED;
 886      asymbol *sym ATTRIBUTE_UNUSED;
 887 {
 888   elf_hppa_reloc_type *finaltype;
 889   elf_hppa_reloc_type **final_types;
 890   bfd_size_type amt = sizeof (elf_hppa_reloc_type *) * 2;
 891
 892   /* Allocate slots for the BFD relocation.  */
 893   final_types = (elf_hppa_reloc_type **) bfd_alloc (abfd, amt);
 894   if (final_types == NULL)
 895     return NULL;
 896
 897   /* Allocate space for the relocation itself.  */
 898   amt = sizeof (elf_hppa_reloc_type);
 899   finaltype = (elf_hppa_reloc_type *) bfd_alloc (abfd, amt);
 900   if (finaltype == NULL)
 901     return NULL;
 902
 903   /* Some reasonable defaults.  */
 904   final_types[0] = finaltype;
 905   final_types[1] = NULL;
 906
 907   *finaltype = elf_hppa_reloc_final_type (abfd, base_type, format, field);
 908
 909   return final_types;
 910 }
 911
 912 /* Translate from an elf into field into a howto relocation pointer.  */
 913
 914 static void
 915 elf_hppa_info_to_howto (abfd, bfd_reloc, elf_reloc)
 916      bfd *abfd ATTRIBUTE_UNUSED;
 917      arelent *bfd_reloc;
 918      Elf_Internal_Rela *elf_reloc;
 919 {
 920   BFD_ASSERT (ELF_R_TYPE(elf_reloc->r_info)
 921               < (unsigned int) R_PARISC_UNIMPLEMENTED);
 922   bfd_reloc->howto = &elf_hppa_howto_table[ELF_R_TYPE (elf_reloc->r_info)];
 923 }
 924
 925 /* Translate from an elf into field into a howto relocation pointer.  */
 926
 927 static void
 928 elf_hppa_info_to_howto_rel (abfd, bfd_reloc, elf_reloc)
 929      bfd *abfd ATTRIBUTE_UNUSED;
 930      arelent *bfd_reloc;
 931      Elf_Internal_Rel *elf_reloc;
 932 {
 933   BFD_ASSERT (ELF_R_TYPE(elf_reloc->r_info)
 934               < (unsigned int) R_PARISC_UNIMPLEMENTED);
 935   bfd_reloc->howto = &elf_hppa_howto_table[ELF_R_TYPE (elf_reloc->r_info)];
 936 }
 937
 938 /* Return the address of the howto table entry to perform the CODE
 939    relocation for an ARCH machine.  */
 940
 941 static reloc_howto_type *
 942 elf_hppa_reloc_type_lookup (abfd, code)
 943      bfd *abfd ATTRIBUTE_UNUSED;
 944      bfd_reloc_code_real_type code;
 945 {
 946   if ((int) code < (int) R_PARISC_UNIMPLEMENTED)
 947     {
 948       BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
 949       return &elf_hppa_howto_table[(int) code];
 950     }
 951   return NULL;
 952 }
 953
 954 /* Return true if SYM represents a local label symbol.  */
 955
 956 static boolean
 957 elf_hppa_is_local_label_name (abfd, name)
 958      bfd *abfd ATTRIBUTE_UNUSED;
 959      const char *name;
 960 {
 961   if (name[0] == 'L' && name[1] == '$')
 962     return 1;
 963   return _bfd_elf_is_local_label_name (abfd, name);
 964 }
 965
 966 /* Set the correct type for an ELF section.  We do this by the
 967    section name, which is a hack, but ought to work.  */
 968
 969 static boolean
 970 elf_hppa_fake_sections (abfd, hdr, sec)
 971      bfd *abfd;
 972      elf_hppa_internal_shdr *hdr;
 973      asection *sec;
 974 {
 975   register const char *name;
 976
 977   name = bfd_get_section_name (abfd, sec);
 978
 979   if (strcmp (name, ".PARISC.unwind") == 0)
 980     {
 981       int indx;
 982       asection *asec;
 983 #if ARCH_SIZE == 64
 984       hdr->sh_type = SHT_LOPROC + 1;
 985 #else
 986       hdr->sh_type = 1;
 987 #endif
 988       /* ?!? How are unwinds supposed to work for symbols in arbitrary
 989          sections?  Or what if we have multiple .text sections in a single
 990          .o file?  HP really messed up on this one.
 991
 992          Ugh.  We can not use elf_section_data (sec)->this_idx at this
 993          point because it is not initialized yet.
 994
 995          So we (gasp) recompute it here.  Hopefully nobody ever changes the
 996          way sections are numbered in elf.c!  */
 997       for (asec = abfd->sections, indx = 1; asec; asec = asec->next, indx++)
 998         {
 999           if (asec->name && strcmp (asec->name, ".text") == 0)
1000             {
1001               hdr->sh_info = indx;
1002               break;
1003             }
1004         }
1005
1006       /* I have no idea if this is really necessary or what it means.  */
1007       hdr->sh_entsize = 4;
1008     }
1009   return true;
1010 }
1011
1012 static void
1013 elf_hppa_final_write_processing (abfd, linker)
1014      bfd *abfd;
1015      boolean linker ATTRIBUTE_UNUSED;
1016 {
1017   int mach = bfd_get_mach (abfd);
1018
1019   elf_elfheader (abfd)->e_flags &= ~(EF_PARISC_ARCH | EF_PARISC_TRAPNIL
1020                                      | EF_PARISC_EXT | EF_PARISC_LSB
1021                                      | EF_PARISC_WIDE | EF_PARISC_NO_KABP
1022                                      | EF_PARISC_LAZYSWAP);
1023
1024   if (mach == 10)
1025     elf_elfheader (abfd)->e_flags |= EFA_PARISC_1_0;
1026   else if (mach == 11)
1027     elf_elfheader (abfd)->e_flags |= EFA_PARISC_1_1;
1028   else if (mach == 20)
1029     elf_elfheader (abfd)->e_flags |= EFA_PARISC_2_0;
1030   else if (mach == 25)
1031     elf_elfheader (abfd)->e_flags |= (EF_PARISC_WIDE
1032                                       | EFA_PARISC_2_0
1033                                       /* The GNU tools have trapped without
1034                                          option since 1993, so need to take
1035                                          a step backwards with the ELF
1036                                          based toolchains.  */
1037                                       | EF_PARISC_TRAPNIL);
1038 }
1039
1040 #if ARCH_SIZE == 64
1041 /* Hook called by the linker routine which adds symbols from an object
1042    file.  HP's libraries define symbols with HP specific section
1043    indices, which we have to handle.  */
1044
1045 static boolean
1046 elf_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1047      bfd *abfd;
1048      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1049      const Elf_Internal_Sym *sym;
1050      const char **namep ATTRIBUTE_UNUSED;
1051      flagword *flagsp ATTRIBUTE_UNUSED;
1052      asection **secp;
1053      bfd_vma *valp;
1054 {
1055   int index = sym->st_shndx;
1056
1057   switch (index)
1058     {
1059     case SHN_PARISC_ANSI_COMMON:
1060       *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
1061       (*secp)->flags |= SEC_IS_COMMON;
1062       *valp = sym->st_size;
1063       break;
1064
1065     case SHN_PARISC_HUGE_COMMON:
1066       *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");
1067       (*secp)->flags |= SEC_IS_COMMON;
1068       *valp = sym->st_size;
1069       break;
1070     }
1071
1072   return true;
1073 }
1074
1075 static boolean
1076 elf_hppa_unmark_useless_dynamic_symbols (h, data)
1077      struct elf_link_hash_entry *h;
1078      PTR data;
1079 {
1080   struct bfd_link_info *info = (struct bfd_link_info *)data;
1081
1082   if (h->root.type == bfd_link_hash_warning)
1083     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1084
1085   /* If we are not creating a shared library, and this symbol is
1086      referenced by a shared library but is not defined anywhere, then
1087      the generic code will warn that it is undefined.
1088
1089      This behavior is undesirable on HPs since the standard shared
1090      libraries contain references to undefined symbols.
1091
1092      So we twiddle the flags associated with such symbols so that they
1093      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1094
1095      Ultimately we should have better controls over the generic ELF BFD
1096      linker code.  */
1097   if (! info->relocateable
1098       && ! (info->shared
1099             && !info->no_undefined)
1100       && h->root.type == bfd_link_hash_undefined
1101       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
1102       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
1103     {
1104       h->elf_link_hash_flags &= ~ELF_LINK_HASH_REF_DYNAMIC;
1105       h->elf_link_hash_flags |= 0x8000;
1106     }
1107
1108   return true;
1109 }
1110
1111 static boolean
1112 elf_hppa_remark_useless_dynamic_symbols (h, data)
1113      struct elf_link_hash_entry *h;
1114      PTR data;
1115 {
1116   struct bfd_link_info *info = (struct bfd_link_info *)data;
1117
1118   if (h->root.type == bfd_link_hash_warning)
1119     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1120
1121   /* If we are not creating a shared library, and this symbol is
1122      referenced by a shared library but is not defined anywhere, then
1123      the generic code will warn that it is undefined.
1124
1125      This behavior is undesirable on HPs since the standard shared
1126      libraries contain reerences to undefined symbols.
1127
1128      So we twiddle the flags associated with such symbols so that they
1129      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1130
1131      Ultimately we should have better controls over the generic ELF BFD
1132      linker code.  */
1133   if (! info->relocateable
1134       && ! (info->shared
1135             && !info->no_undefined)
1136       && h->root.type == bfd_link_hash_undefined
1137       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1138       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1139       && (h->elf_link_hash_flags & 0x8000) != 0)
1140     {
1141       h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1142       h->elf_link_hash_flags &= ~0x8000;
1143     }
1144
1145   return true;
1146 }
1147
1148 static boolean
1149 elf_hppa_is_dynamic_loader_symbol (name)
1150      const char * name;
1151 {
1152   return (! strcmp (name, "__CPU_REVISION")
1153           || ! strcmp (name, "__CPU_KEYBITS_1")
1154           || ! strcmp (name, "__SYSTEM_ID_D")
1155           || ! strcmp (name, "__FPU_MODEL")
1156           || ! strcmp (name, "__FPU_REVISION")
1157           || ! strcmp (name, "__ARGC")
1158           || ! strcmp (name, "__ARGV")
1159           || ! strcmp (name, "__ENVP")
1160           || ! strcmp (name, "__TLS_SIZE_D")
1161           || ! strcmp (name, "__LOAD_INFO")
1162           || ! strcmp (name, "__systab"));
1163 }
1164
1165 /* Record the lowest address for the data and text segments.  */
1166 static void
1167 elf_hppa_record_segment_addrs (abfd, section, data)
1168      bfd *abfd ATTRIBUTE_UNUSED;
1169      asection *section;
1170      PTR data;
1171 {
1172   struct elf64_hppa_link_hash_table *hppa_info;
1173   bfd_vma value;
1174
1175   hppa_info = (struct elf64_hppa_link_hash_table *)data;
1176
1177   value = section->vma - section->filepos;
1178
1179   if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1180        == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1181       && value < hppa_info->text_segment_base)
1182     hppa_info->text_segment_base = value;
1183   else if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1184             == (SEC_ALLOC | SEC_LOAD))
1185            && value < hppa_info->data_segment_base)
1186     hppa_info->data_segment_base = value;
1187 }
1188
1189 /* Called after we have seen all the input files/sections, but before
1190    final symbol resolution and section placement has been determined.
1191
1192    We use this hook to (possibly) provide a value for __gp, then we
1193    fall back to the generic ELF final link routine.  */
1194
1195 static boolean
1196 elf_hppa_final_link (abfd, info)
1197      bfd *abfd;
1198      struct bfd_link_info *info;
1199 {
1200   boolean retval;
1201   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1202
1203   if (! info->relocateable)
1204     {
1205       struct elf_link_hash_entry *gp;
1206       bfd_vma gp_val;
1207
1208       /* The linker script defines a value for __gp iff it was referenced
1209          by one of the objects being linked.  First try to find the symbol
1210          in the hash table.  If that fails, just compute the value __gp
1211          should have had.  */
1212       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
1213                                  false, false);
1214
1215       if (gp)
1216         {
1217
1218           /* Adjust the value of __gp as we may want to slide it into the
1219              .plt section so that the stubs can access PLT entries without
1220              using an addil sequence.  */
1221           gp->root.u.def.value += hppa_info->gp_offset;
1222
1223           gp_val = (gp->root.u.def.section->output_section->vma
1224                     + gp->root.u.def.section->output_offset
1225                     + gp->root.u.def.value);
1226         }
1227       else
1228         {
1229           asection *sec;
1230
1231           /* First look for a .plt section.  If found, then __gp is the
1232              address of the .plt + gp_offset.
1233
1234              If no .plt is found, then look for .dlt, .opd and .data (in
1235              that order) and set __gp to the base address of whichever section
1236             is found first.  */
1237
1238           sec = hppa_info->plt_sec;
1239           if (sec)
1240             gp_val = (sec->output_offset
1241                       + sec->output_section->vma
1242                       + hppa_info->gp_offset);
1243           else
1244             {
1245               sec = hppa_info->dlt_sec;
1246               if (!sec)
1247                 sec = hppa_info->opd_sec;
1248               if (!sec)
1249                 sec = bfd_get_section_by_name (abfd, ".data");
1250               if (!sec)
1251                 return false;
1252
1253               gp_val = sec->output_offset + sec->output_section->vma;
1254             }
1255         }
1256
1257       /* Install whatever value we found/computed for __gp.  */
1258       _bfd_set_gp_value (abfd, gp_val);
1259     }
1260
1261   /* We need to know the base of the text and data segments so that we
1262      can perform SEGREL relocations.  We will record the base addresses
1263      when we encounter the first SEGREL relocation.  */
1264   hppa_info->text_segment_base = (bfd_vma)-1;
1265   hppa_info->data_segment_base = (bfd_vma)-1;
1266
1267   /* HP's shared libraries have references to symbols that are not
1268      defined anywhere.  The generic ELF BFD linker code will complaim
1269      about such symbols.
1270
1271      So we detect the losing case and arrange for the flags on the symbol
1272      to indicate that it was never referenced.  This keeps the generic
1273      ELF BFD link code happy and appears to not create any secondary
1274      problems.  Ultimately we need a way to control the behavior of the
1275      generic ELF BFD link code better.  */
1276   elf_link_hash_traverse (elf_hash_table (info),
1277                           elf_hppa_unmark_useless_dynamic_symbols,
1278                           info);
1279
1280   /* Invoke the regular ELF backend linker to do all the work.  */
1281   retval = bfd_elf_bfd_final_link (abfd, info);
1282
1283   elf_link_hash_traverse (elf_hash_table (info),
1284                           elf_hppa_remark_useless_dynamic_symbols,
1285                           info);
1286
1287   return retval;
1288 }
1289
1290 /* Relocate an HPPA ELF section.  */
1291
1292 static boolean
1293 elf_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
1294                            contents, relocs, local_syms, local_sections)
1295      bfd *output_bfd;
1296      struct bfd_link_info *info;
1297      bfd *input_bfd;
1298      asection *input_section;
1299      bfd_byte *contents;
1300      Elf_Internal_Rela *relocs;
1301      Elf_Internal_Sym *local_syms;
1302      asection **local_sections;
1303 {
1304   Elf_Internal_Shdr *symtab_hdr;
1305   Elf_Internal_Rela *rel;
1306   Elf_Internal_Rela *relend;
1307   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1308
1309   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1310
1311   rel = relocs;
1312   relend = relocs + input_section->reloc_count;
1313   for (; rel < relend; rel++)
1314     {
1315       int r_type;
1316       reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
1317       unsigned long r_symndx;
1318       struct elf_link_hash_entry *h;
1319       Elf_Internal_Sym *sym;
1320       asection *sym_sec;
1321       bfd_vma relocation;
1322       bfd_reloc_status_type r;
1323       const char *sym_name;
1324       const char *dyn_name;
1325       char *dynh_buf = NULL;
1326       size_t dynh_buflen = 0;
1327       struct elf64_hppa_dyn_hash_entry *dyn_h = NULL;
1328
1329       r_type = ELF_R_TYPE (rel->r_info);
1330       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
1331         {
1332           bfd_set_error (bfd_error_bad_value);
1333           return false;
1334         }
1335
1336       r_symndx = ELF_R_SYM (rel->r_info);
1337
1338       if (info->relocateable)
1339         {
1340           /* This is a relocateable link.  We don't have to change
1341              anything, unless the reloc is against a section symbol,
1342              in which case we have to adjust according to where the
1343              section symbol winds up in the output section.  */
1344           if (r_symndx < symtab_hdr->sh_info)
1345             {
1346               sym = local_syms + r_symndx;
1347               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1348                 {
1349                   sym_sec = local_sections[r_symndx];
1350                   rel->r_addend += sym_sec->output_offset;
1351                 }
1352             }
1353
1354           continue;
1355         }
1356
1357       /* This is a final link.  */
1358       h = NULL;
1359       sym = NULL;
1360       sym_sec = NULL;
1361       if (r_symndx < symtab_hdr->sh_info)
1362         {
1363           /* This is a local symbol.  */
1364           sym = local_syms + r_symndx;
1365           sym_sec = local_sections[r_symndx];
1366           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
1367
1368           /* If this symbol has an entry in the PA64 dynamic hash
1369              table, then get it.  */
1370           dyn_name = get_dyn_name (input_section, h, rel,
1371                                    &dynh_buf, &dynh_buflen);
1372           dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1373                                               dyn_name, false, false);
1374
1375         }
1376       else
1377         {
1378           /* This is not a local symbol.  */
1379           long indx;
1380
1381           indx = r_symndx - symtab_hdr->sh_info;
1382           h = elf_sym_hashes (input_bfd)[indx];
1383           while (h->root.type == bfd_link_hash_indirect
1384                  || h->root.type == bfd_link_hash_warning)
1385             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1386           if (h->root.type == bfd_link_hash_defined
1387               || h->root.type == bfd_link_hash_defweak)
1388             {
1389               sym_sec = h->root.u.def.section;
1390
1391               /* If this symbol has an entry in the PA64 dynamic hash
1392                  table, then get it.  */
1393               dyn_name = get_dyn_name (input_section, h, rel,
1394                                        &dynh_buf, &dynh_buflen);
1395               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1396                                                   dyn_name, false, false);
1397
1398               /* If we have a relocation against a symbol defined in a
1399                  shared library and we have not created an entry in the
1400                  PA64 dynamic symbol hash table for it, then we lose.  */
1401               if (sym_sec->output_section == NULL && dyn_h == NULL)
1402                 {
1403                   (*_bfd_error_handler)
1404                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1405                      bfd_archive_filename (input_bfd), h->root.root.string,
1406                      bfd_get_section_name (input_bfd, input_section));
1407                   relocation = 0;
1408                 }
1409               else if (sym_sec->output_section)
1410                 relocation = (h->root.u.def.value
1411                               + sym_sec->output_offset
1412                               + sym_sec->output_section->vma);
1413               /* Value will be provided via one of the offsets in the
1414                  dyn_h hash table entry.  */
1415               else
1416                 relocation = 0;
1417             }
1418           /* Allow undefined symbols in shared libraries.  */
1419           else if (info->shared && !info->no_undefined
1420                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1421             {
1422               if (info->symbolic)
1423                 (*info->callbacks->undefined_symbol)
1424                   (info, h->root.root.string, input_bfd,
1425                    input_section, rel->r_offset, false);
1426
1427               /* If this symbol has an entry in the PA64 dynamic hash
1428                  table, then get it.  */
1429               dyn_name = get_dyn_name (input_section, h, rel,
1430                                        &dynh_buf, &dynh_buflen);
1431               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1432                                                   dyn_name, false, false);
1433
1434               if (dyn_h == NULL)
1435                 {
1436                   (*_bfd_error_handler)
1437                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1438                      bfd_archive_filename (input_bfd), h->root.root.string,
1439                      bfd_get_section_name (input_bfd, input_section));
1440                   relocation = 0;
1441                 }
1442               relocation = 0;
1443             }
1444           else if (h->root.type == bfd_link_hash_undefweak)
1445             relocation = 0;
1446           else
1447             {
1448               /* Ignore dynamic loader defined symbols.  */
1449               if (elf_hppa_is_dynamic_loader_symbol (h->root.root.string))
1450                 relocation = 0;
1451               else
1452                 {
1453                   if (!((*info->callbacks->undefined_symbol)
1454                         (info, h->root.root.string, input_bfd,
1455                          input_section, rel->r_offset, true)))
1456                     return false;
1457                   break;
1458                 }
1459             }
1460         }
1461
1462       if (h != NULL)
1463         sym_name = h->root.root.string;
1464       else
1465         {
1466           sym_name = bfd_elf_string_from_elf_section (input_bfd,
1467                                                       symtab_hdr->sh_link,
1468                                                       sym->st_name);
1469           if (sym_name == NULL)
1470             return false;
1471           if (*sym_name == '\0')
1472             sym_name = bfd_section_name (input_bfd, sym_sec);
1473         }
1474
1475       r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
1476                                         input_section, contents,
1477                                         relocation, info, sym_sec,
1478                                         h, dyn_h);
1479
1480       if (r != bfd_reloc_ok)
1481         {
1482           switch (r)
1483             {
1484             default:
1485               abort ();
1486             case bfd_reloc_overflow:
1487               {
1488                 if (!((*info->callbacks->reloc_overflow)
1489                       (info, sym_name, howto->name, (bfd_vma) 0,
1490                         input_bfd, input_section, rel->r_offset)))
1491                   return false;
1492               }
1493               break;
1494             }
1495         }
1496     }
1497   return true;
1498 }
1499
1500 /* Compute the value for a relocation (REL) during a final link stage,
1501    then insert the value into the proper location in CONTENTS.
1502
1503    VALUE is a tentative value for the relocation and may be overridden
1504    and modified here based on the specific relocation to be performed.
1505
1506    For example we do conversions for PC-relative branches in this routine
1507    or redirection of calls to external routines to stubs.
1508
1509    The work of actually applying the relocation is left to a helper
1510    routine in an attempt to reduce the complexity and size of this
1511    function.  */
1512
1513 static bfd_reloc_status_type
1514 elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
1515                               input_section, contents, value,
1516                               info, sym_sec, h, dyn_h)
1517      Elf_Internal_Rela *rel;
1518      bfd *input_bfd;
1519      bfd *output_bfd;
1520      asection *input_section;
1521      bfd_byte *contents;
1522      bfd_vma value;
1523      struct bfd_link_info *info;
1524      asection *sym_sec;
1525      struct elf_link_hash_entry *h ATTRIBUTE_UNUSED;
1526      struct elf64_hppa_dyn_hash_entry *dyn_h;
1527 {
1528   int insn;
1529   bfd_vma offset = rel->r_offset;
1530   bfd_signed_vma addend = rel->r_addend;
1531   reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
1532   unsigned int r_type = howto->type;
1533   bfd_byte *hit_data = contents + offset;
1534   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1535
1536   insn = bfd_get_32 (input_bfd, hit_data);
1537
1538   switch (r_type)
1539     {
1540     case R_PARISC_NONE:
1541       break;
1542
1543     /* Basic function call support.  I'm not entirely sure if PCREL14F is
1544        actually needed or even handled correctly.
1545
1546        Note for a call to a function defined in another dynamic library
1547        we want to redirect the call to a stub.  */
1548
1549     /* Random PC relative relocs.  */
1550     case R_PARISC_PCREL21L:
1551     case R_PARISC_PCREL14R:
1552     case R_PARISC_PCREL14F:
1553     case R_PARISC_PCREL14WR:
1554     case R_PARISC_PCREL14DR:
1555     case R_PARISC_PCREL16F:
1556     case R_PARISC_PCREL16WF:
1557     case R_PARISC_PCREL16DF:
1558       {
1559         /* If this is a call to a function defined in another dynamic
1560            library, then redirect the call to the local stub for this
1561            function.  */
1562         if (sym_sec == NULL || sym_sec->output_section == NULL)
1563           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1564                    + hppa_info->stub_sec->output_section->vma);
1565
1566         /* Turn VALUE into a proper PC relative address.  */
1567         value -= (offset + input_section->output_offset
1568                   + input_section->output_section->vma);
1569
1570         /* Adjust for any field selectors.  */
1571         if (r_type == R_PARISC_PCREL21L)
1572           value = hppa_field_adjust (value, -8 + addend, e_lsel);
1573         else if (r_type == R_PARISC_PCREL14F
1574                  || r_type == R_PARISC_PCREL16F
1575                  || r_type == R_PARISC_PCREL16WF
1576                  || r_type == R_PARISC_PCREL16DF)
1577           value = hppa_field_adjust (value, -8 + addend, e_fsel);
1578         else
1579           value = hppa_field_adjust (value, -8 + addend, e_rsel);
1580
1581         /* Apply the relocation to the given instruction.  */
1582         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1583         break;
1584       }
1585
1586     case R_PARISC_PCREL12F:
1587     case R_PARISC_PCREL22F:
1588     case R_PARISC_PCREL17F:
1589     case R_PARISC_PCREL22C:
1590     case R_PARISC_PCREL17C:
1591     case R_PARISC_PCREL17R:
1592       {
1593         /* If this is a call to a function defined in another dynamic
1594            library, then redirect the call to the local stub for this
1595            function.  */
1596         if (sym_sec == NULL || sym_sec->output_section == NULL)
1597           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1598                    + hppa_info->stub_sec->output_section->vma);
1599
1600         /* Turn VALUE into a proper PC relative address.  */
1601         value -= (offset + input_section->output_offset
1602                   + input_section->output_section->vma);
1603
1604         /* Adjust for any field selectors.  */
1605         if (r_type == R_PARISC_PCREL17R)
1606           value = hppa_field_adjust (value, -8 + addend, e_rsel);
1607         else
1608           value = hppa_field_adjust (value, -8 + addend, e_fsel);
1609
1610         /* All branches are implicitly shifted by 2 places.  */
1611         value >>= 2;
1612
1613         /* Apply the relocation to the given instruction.  */
1614         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1615         break;
1616       }
1617
1618     /* Indirect references to data through the DLT.  */
1619     case R_PARISC_DLTIND14R:
1620     case R_PARISC_DLTIND14F:
1621     case R_PARISC_DLTIND14DR:
1622     case R_PARISC_DLTIND14WR:
1623     case R_PARISC_DLTIND21L:
1624     case R_PARISC_LTOFF_FPTR14R:
1625     case R_PARISC_LTOFF_FPTR14DR:
1626     case R_PARISC_LTOFF_FPTR14WR:
1627     case R_PARISC_LTOFF_FPTR21L:
1628     case R_PARISC_LTOFF_FPTR16F:
1629     case R_PARISC_LTOFF_FPTR16WF:
1630     case R_PARISC_LTOFF_FPTR16DF:
1631     case R_PARISC_LTOFF_TP21L:
1632     case R_PARISC_LTOFF_TP14R:
1633     case R_PARISC_LTOFF_TP14F:
1634     case R_PARISC_LTOFF_TP14WR:
1635     case R_PARISC_LTOFF_TP14DR:
1636     case R_PARISC_LTOFF_TP16F:
1637     case R_PARISC_LTOFF_TP16WF:
1638     case R_PARISC_LTOFF_TP16DF:
1639     case R_PARISC_LTOFF16F:
1640     case R_PARISC_LTOFF16WF:
1641     case R_PARISC_LTOFF16DF:
1642       {
1643         /* If this relocation was against a local symbol, then we still
1644            have not set up the DLT entry (it's not convenient to do so
1645            in the "finalize_dlt" routine because it is difficult to get
1646            to the local symbol's value).
1647
1648            So, if this is a local symbol (h == NULL), then we need to
1649            fill in its DLT entry.
1650
1651            Similarly we may still need to set up an entry in .opd for
1652            a local function which had its address taken.  */
1653         if (dyn_h->h == NULL)
1654           {
1655             /* Now do .opd creation if needed.  */
1656             if (r_type == R_PARISC_LTOFF_FPTR14R
1657                 || r_type == R_PARISC_LTOFF_FPTR14DR
1658                 || r_type == R_PARISC_LTOFF_FPTR14WR
1659                 || r_type == R_PARISC_LTOFF_FPTR21L
1660                 || r_type == R_PARISC_LTOFF_FPTR16F
1661                 || r_type == R_PARISC_LTOFF_FPTR16WF
1662                 || r_type == R_PARISC_LTOFF_FPTR16DF)
1663               {
1664                 /* The first two words of an .opd entry are zero.  */
1665                 memset (hppa_info->opd_sec->contents + dyn_h->opd_offset,
1666                         0, 16);
1667
1668                 /* The next word is the address of the function.  */
1669                 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1670                             (hppa_info->opd_sec->contents
1671                              + dyn_h->opd_offset + 16));
1672
1673                 /* The last word is our local __gp value.  */
1674                 value = _bfd_get_gp_value
1675                           (hppa_info->opd_sec->output_section->owner);
1676                 bfd_put_64 (hppa_info->opd_sec->owner, value,
1677                             (hppa_info->opd_sec->contents
1678                              + dyn_h->opd_offset + 24));
1679
1680                 /* The DLT value is the address of the .opd entry.  */
1681                 value = (dyn_h->opd_offset
1682                          + hppa_info->opd_sec->output_offset
1683                          + hppa_info->opd_sec->output_section->vma);
1684                 addend = 0;
1685               }
1686
1687             bfd_put_64 (hppa_info->dlt_sec->owner,
1688                         value + addend,
1689                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1690           }
1691
1692         /* We want the value of the DLT offset for this symbol, not
1693            the symbol's actual address.  Note that __gp may not point
1694            to the start of the DLT, so we have to compute the absolute
1695            address, then subtract out the value of __gp.  */
1696         value = (dyn_h->dlt_offset
1697                  + hppa_info->dlt_sec->output_offset
1698                  + hppa_info->dlt_sec->output_section->vma);
1699         value -= _bfd_get_gp_value (output_bfd);
1700
1701         /* All DLTIND relocations are basically the same at this point,
1702            except that we need different field selectors for the 21bit
1703            version vs the 14bit versions.  */
1704         if (r_type == R_PARISC_DLTIND21L
1705             || r_type == R_PARISC_LTOFF_FPTR21L
1706             || r_type == R_PARISC_LTOFF_TP21L)
1707           value = hppa_field_adjust (value, 0, e_lsel);
1708         else if (r_type == R_PARISC_DLTIND14F
1709                  || r_type == R_PARISC_LTOFF_FPTR16F
1710                  || r_type == R_PARISC_LTOFF_FPTR16WF
1711                  || r_type == R_PARISC_LTOFF_FPTR16DF
1712                  || r_type == R_PARISC_LTOFF16F
1713                  || r_type == R_PARISC_LTOFF16DF
1714                  || r_type == R_PARISC_LTOFF16WF
1715                  || r_type == R_PARISC_LTOFF_TP16F
1716                  || r_type == R_PARISC_LTOFF_TP16WF
1717                  || r_type == R_PARISC_LTOFF_TP16DF)
1718           value = hppa_field_adjust (value, 0, e_fsel);
1719         else
1720           value = hppa_field_adjust (value, 0, e_rsel);
1721
1722         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1723         break;
1724       }
1725
1726     case R_PARISC_DLTREL14R:
1727     case R_PARISC_DLTREL14F:
1728     case R_PARISC_DLTREL14DR:
1729     case R_PARISC_DLTREL14WR:
1730     case R_PARISC_DLTREL21L:
1731     case R_PARISC_DPREL21L:
1732     case R_PARISC_DPREL14WR:
1733     case R_PARISC_DPREL14DR:
1734     case R_PARISC_DPREL14R:
1735     case R_PARISC_DPREL14F:
1736     case R_PARISC_GPREL16F:
1737     case R_PARISC_GPREL16WF:
1738     case R_PARISC_GPREL16DF:
1739       {
1740         /* Subtract out the global pointer value to make value a DLT
1741            relative address.  */
1742         value -= _bfd_get_gp_value (output_bfd);
1743
1744         /* All DLTREL relocations are basically the same at this point,
1745            except that we need different field selectors for the 21bit
1746            version vs the 14bit versions.  */
1747         if (r_type == R_PARISC_DLTREL21L
1748             || r_type == R_PARISC_DPREL21L)
1749           value = hppa_field_adjust (value, addend, e_lrsel);
1750         else if (r_type == R_PARISC_DLTREL14F
1751                  || r_type == R_PARISC_DPREL14F
1752                  || r_type == R_PARISC_GPREL16F
1753                  || r_type == R_PARISC_GPREL16WF
1754                  || r_type == R_PARISC_GPREL16DF)
1755           value = hppa_field_adjust (value, addend, e_fsel);
1756         else
1757           value = hppa_field_adjust (value, addend, e_rrsel);
1758
1759         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1760         break;
1761       }
1762
1763     case R_PARISC_DIR21L:
1764     case R_PARISC_DIR17R:
1765     case R_PARISC_DIR17F:
1766     case R_PARISC_DIR14R:
1767     case R_PARISC_DIR14F:
1768     case R_PARISC_DIR14WR:
1769     case R_PARISC_DIR14DR:
1770     case R_PARISC_DIR16F:
1771     case R_PARISC_DIR16WF:
1772     case R_PARISC_DIR16DF:
1773       {
1774         /* All DIR relocations are basically the same at this point,
1775            except that branch offsets need to be divided by four, and
1776            we need different field selectors.  Note that we don't
1777            redirect absolute calls to local stubs.  */
1778
1779         if (r_type == R_PARISC_DIR21L)
1780           value = hppa_field_adjust (value, addend, e_lrsel);
1781         else if (r_type == R_PARISC_DIR17F
1782                  || r_type == R_PARISC_DIR16F
1783                  || r_type == R_PARISC_DIR16WF
1784                  || r_type == R_PARISC_DIR16DF
1785                  || r_type == R_PARISC_DIR14F)
1786           value = hppa_field_adjust (value, addend, e_fsel);
1787         else
1788           value = hppa_field_adjust (value, addend, e_rrsel);
1789
1790         if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
1791           {
1792             /* All branches are implicitly shifted by 2 places.  */
1793             value >>= 2;
1794           }
1795
1796         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1797         break;
1798       }
1799
1800     case R_PARISC_PLTOFF21L:
1801     case R_PARISC_PLTOFF14R:
1802     case R_PARISC_PLTOFF14F:
1803     case R_PARISC_PLTOFF14WR:
1804     case R_PARISC_PLTOFF14DR:
1805     case R_PARISC_PLTOFF16F:
1806     case R_PARISC_PLTOFF16WF:
1807     case R_PARISC_PLTOFF16DF:
1808       {
1809         /* We want the value of the PLT offset for this symbol, not
1810            the symbol's actual address.  Note that __gp may not point
1811            to the start of the DLT, so we have to compute the absolute
1812            address, then subtract out the value of __gp.  */
1813         value = (dyn_h->plt_offset
1814                  + hppa_info->plt_sec->output_offset
1815                  + hppa_info->plt_sec->output_section->vma);
1816         value -= _bfd_get_gp_value (output_bfd);
1817
1818         /* All PLTOFF relocations are basically the same at this point,
1819            except that we need different field selectors for the 21bit
1820            version vs the 14bit versions.  */
1821         if (r_type == R_PARISC_PLTOFF21L)
1822           value = hppa_field_adjust (value, addend, e_lrsel);
1823         else if (r_type == R_PARISC_PLTOFF14F
1824                  || r_type == R_PARISC_PLTOFF16F
1825                  || r_type == R_PARISC_PLTOFF16WF
1826                  || r_type == R_PARISC_PLTOFF16DF)
1827           value = hppa_field_adjust (value, addend, e_fsel);
1828         else
1829           value = hppa_field_adjust (value, addend, e_rrsel);
1830
1831         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1832         break;
1833       }
1834
1835     case R_PARISC_LTOFF_FPTR32:
1836       {
1837         /* We may still need to create the FPTR itself if it was for
1838            a local symbol.  */
1839         if (dyn_h->h == NULL)
1840           {
1841             /* The first two words of an .opd entry are zero.  */
1842             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1843
1844             /* The next word is the address of the function.  */
1845             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1846                         (hppa_info->opd_sec->contents
1847                          + dyn_h->opd_offset + 16));
1848
1849             /* The last word is our local __gp value.  */
1850             value = _bfd_get_gp_value
1851                       (hppa_info->opd_sec->output_section->owner);
1852             bfd_put_64 (hppa_info->opd_sec->owner, value,
1853                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
1854
1855             /* The DLT value is the address of the .opd entry.  */
1856             value = (dyn_h->opd_offset
1857                      + hppa_info->opd_sec->output_offset
1858                      + hppa_info->opd_sec->output_section->vma);
1859
1860             bfd_put_64 (hppa_info->dlt_sec->owner,
1861                         value,
1862                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1863           }
1864
1865         /* We want the value of the DLT offset for this symbol, not
1866            the symbol's actual address.  Note that __gp may not point
1867            to the start of the DLT, so we have to compute the absolute
1868            address, then subtract out the value of __gp.  */
1869         value = (dyn_h->dlt_offset
1870                  + hppa_info->dlt_sec->output_offset
1871                  + hppa_info->dlt_sec->output_section->vma);
1872         value -= _bfd_get_gp_value (output_bfd);
1873         bfd_put_32 (input_bfd, value, hit_data);
1874         return bfd_reloc_ok;
1875       }
1876
1877     case R_PARISC_LTOFF_FPTR64:
1878     case R_PARISC_LTOFF_TP64:
1879       {
1880         /* We may still need to create the FPTR itself if it was for
1881            a local symbol.  */
1882         if (dyn_h->h == NULL && r_type == R_PARISC_LTOFF_FPTR64)
1883           {
1884             /* The first two words of an .opd entry are zero.  */
1885             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1886
1887             /* The next word is the address of the function.  */
1888             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1889                         (hppa_info->opd_sec->contents
1890                          + dyn_h->opd_offset + 16));
1891
1892             /* The last word is our local __gp value.  */
1893             value = _bfd_get_gp_value
1894                       (hppa_info->opd_sec->output_section->owner);
1895             bfd_put_64 (hppa_info->opd_sec->owner, value,
1896                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
1897
1898             /* The DLT value is the address of the .opd entry.  */
1899             value = (dyn_h->opd_offset
1900                      + hppa_info->opd_sec->output_offset
1901                      + hppa_info->opd_sec->output_section->vma);
1902
1903             bfd_put_64 (hppa_info->dlt_sec->owner,
1904                         value,
1905                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1906           }
1907
1908         /* We want the value of the DLT offset for this symbol, not
1909            the symbol's actual address.  Note that __gp may not point
1910            to the start of the DLT, so we have to compute the absolute
1911            address, then subtract out the value of __gp.  */
1912         value = (dyn_h->dlt_offset
1913                  + hppa_info->dlt_sec->output_offset
1914                  + hppa_info->dlt_sec->output_section->vma);
1915         value -= _bfd_get_gp_value (output_bfd);
1916         bfd_put_64 (input_bfd, value, hit_data);
1917         return bfd_reloc_ok;
1918       }
1919
1920     case R_PARISC_DIR32:
1921       bfd_put_32 (input_bfd, value + addend, hit_data);
1922       return bfd_reloc_ok;
1923
1924     case R_PARISC_DIR64:
1925       bfd_put_64 (input_bfd, value + addend, hit_data);
1926       return bfd_reloc_ok;
1927
1928     case R_PARISC_GPREL64:
1929       /* Subtract out the global pointer value to make value a DLT
1930          relative address.  */
1931       value -= _bfd_get_gp_value (output_bfd);
1932
1933       bfd_put_64 (input_bfd, value + addend, hit_data);
1934       return bfd_reloc_ok;
1935
1936     case R_PARISC_LTOFF64:
1937         /* We want the value of the DLT offset for this symbol, not
1938            the symbol's actual address.  Note that __gp may not point
1939            to the start of the DLT, so we have to compute the absolute
1940            address, then subtract out the value of __gp.  */
1941       value = (dyn_h->dlt_offset
1942                + hppa_info->dlt_sec->output_offset
1943                + hppa_info->dlt_sec->output_section->vma);
1944       value -= _bfd_get_gp_value (output_bfd);
1945
1946       bfd_put_64 (input_bfd, value + addend, hit_data);
1947       return bfd_reloc_ok;
1948
1949     case R_PARISC_PCREL32:
1950       {
1951         /* If this is a call to a function defined in another dynamic
1952            library, then redirect the call to the local stub for this
1953            function.  */
1954         if (sym_sec == NULL || sym_sec->output_section == NULL)
1955           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1956                    + hppa_info->stub_sec->output_section->vma);
1957
1958         /* Turn VALUE into a proper PC relative address.  */
1959         value -= (offset + input_section->output_offset
1960                   + input_section->output_section->vma);
1961
1962         value += addend;
1963         value -= 8;
1964         bfd_put_32 (input_bfd, value, hit_data);
1965         return bfd_reloc_ok;
1966       }
1967
1968     case R_PARISC_PCREL64:
1969       {
1970         /* If this is a call to a function defined in another dynamic
1971            library, then redirect the call to the local stub for this
1972            function.  */
1973         if (sym_sec == NULL || sym_sec->output_section == NULL)
1974           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1975                    + hppa_info->stub_sec->output_section->vma);
1976
1977         /* Turn VALUE into a proper PC relative address.  */
1978         value -= (offset + input_section->output_offset
1979                   + input_section->output_section->vma);
1980
1981         value += addend;
1982         value -= 8;
1983         bfd_put_64 (input_bfd, value, hit_data);
1984         return bfd_reloc_ok;
1985       }
1986
1987     case R_PARISC_FPTR64:
1988       {
1989         /* We may still need to create the FPTR itself if it was for
1990            a local symbol.  */
1991         if (dyn_h->h == NULL)
1992           {
1993             /* The first two words of an .opd entry are zero.  */
1994             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1995
1996             /* The next word is the address of the function.  */
1997             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1998                         (hppa_info->opd_sec->contents
1999                          + dyn_h->opd_offset + 16));
2000
2001             /* The last word is our local __gp value.  */
2002             value = _bfd_get_gp_value
2003                       (hppa_info->opd_sec->output_section->owner);
2004             bfd_put_64 (hppa_info->opd_sec->owner, value,
2005                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
2006           }
2007
2008         /* We want the value of the OPD offset for this symbol, not
2009            the symbol's actual address.  */
2010         value = (dyn_h->opd_offset
2011                  + hppa_info->opd_sec->output_offset
2012                  + hppa_info->opd_sec->output_section->vma);
2013
2014         bfd_put_64 (input_bfd, value, hit_data);
2015         return bfd_reloc_ok;
2016       }
2017
2018     case R_PARISC_SECREL32:
2019       bfd_put_32 (input_bfd,
2020                   value + addend - sym_sec->output_section->vma,
2021                   hit_data);
2022       return bfd_reloc_ok;
2023
2024     case R_PARISC_SEGREL32:
2025     case R_PARISC_SEGREL64:
2026       {
2027         /* If this is the first SEGREL relocation, then initialize
2028            the segment base values.  */
2029         if (hppa_info->text_segment_base == (bfd_vma) -1)
2030           bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
2031                                  hppa_info);
2032
2033         /* VALUE holds the absolute address.  We want to include the
2034            addend, then turn it into a segment relative address.
2035
2036            The segment is derived from SYM_SEC.  We assume that there are
2037            only two segments of note in the resulting executable/shlib.
2038            A readonly segment (.text) and a readwrite segment (.data).  */
2039         value += addend;
2040
2041         if (sym_sec->flags & SEC_CODE)
2042           value -= hppa_info->text_segment_base;
2043         else
2044           value -= hppa_info->data_segment_base;
2045
2046         if (r_type == R_PARISC_SEGREL32)
2047           bfd_put_32 (input_bfd, value, hit_data);
2048         else
2049           bfd_put_64 (input_bfd, value, hit_data);
2050         return bfd_reloc_ok;
2051       }
2052
2053     /* Something we don't know how to handle.  */
2054     default:
2055       return bfd_reloc_notsupported;
2056     }
2057
2058   /* Update the instruction word.  */
2059   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
2060   return bfd_reloc_ok;
2061 }
2062
2063 /* Relocate the given INSN.  VALUE should be the actual value we want
2064    to insert into the instruction, ie by this point we should not be
2065    concerned with computing an offset relative to the DLT, PC, etc.
2066    Instead this routine is meant to handle the bit manipulations needed
2067    to insert the relocation into the given instruction.  */
2068
2069 static int
2070 elf_hppa_relocate_insn (insn, sym_value, r_type)
2071      int insn;
2072      int sym_value;
2073      unsigned int r_type;
2074 {
2075   switch (r_type)
2076     {
2077     /* This is any 22 bit branch.  In PA2.0 syntax it corresponds to
2078        the "B" instruction.  */
2079     case R_PARISC_PCREL22F:
2080     case R_PARISC_PCREL22C:
2081       return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
2082
2083       /* This is any 12 bit branch.  */
2084     case R_PARISC_PCREL12F:
2085       return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
2086
2087     /* This is any 17 bit branch.  In PA2.0 syntax it also corresponds
2088        to the "B" instruction as well as BE.  */
2089     case R_PARISC_PCREL17F:
2090     case R_PARISC_DIR17F:
2091     case R_PARISC_DIR17R:
2092     case R_PARISC_PCREL17C:
2093     case R_PARISC_PCREL17R:
2094       return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
2095
2096     /* ADDIL or LDIL instructions.  */
2097     case R_PARISC_DLTREL21L:
2098     case R_PARISC_DLTIND21L:
2099     case R_PARISC_LTOFF_FPTR21L:
2100     case R_PARISC_PCREL21L:
2101     case R_PARISC_LTOFF_TP21L:
2102     case R_PARISC_DPREL21L:
2103     case R_PARISC_PLTOFF21L:
2104     case R_PARISC_DIR21L:
2105       return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
2106
2107     /* LDO and integer loads/stores with 14 bit displacements.  */
2108     case R_PARISC_DLTREL14R:
2109     case R_PARISC_DLTREL14F:
2110     case R_PARISC_DLTIND14R:
2111     case R_PARISC_DLTIND14F:
2112     case R_PARISC_LTOFF_FPTR14R:
2113     case R_PARISC_LTOFF_FPTR16F:
2114     case R_PARISC_PCREL14R:
2115     case R_PARISC_PCREL14F:
2116     case R_PARISC_PCREL16F:
2117     case R_PARISC_LTOFF_TP14R:
2118     case R_PARISC_LTOFF_TP14F:
2119     case R_PARISC_LTOFF_TP16F:
2120     case R_PARISC_DPREL14R:
2121     case R_PARISC_DPREL14F:
2122     case R_PARISC_GPREL16F:
2123     case R_PARISC_PLTOFF14R:
2124     case R_PARISC_PLTOFF14F:
2125     case R_PARISC_PLTOFF16F:
2126     case R_PARISC_DIR14R:
2127     case R_PARISC_DIR14F:
2128     case R_PARISC_DIR16F:
2129     case R_PARISC_LTOFF16F:
2130       return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
2131
2132     /* Doubleword loads and stores with a 14 bit displacement.  */
2133     case R_PARISC_DLTREL14DR:
2134     case R_PARISC_DLTIND14DR:
2135     case R_PARISC_LTOFF_FPTR14DR:
2136     case R_PARISC_LTOFF_FPTR16DF:
2137     case R_PARISC_PCREL14DR:
2138     case R_PARISC_PCREL16DF:
2139     case R_PARISC_LTOFF_TP14DR:
2140     case R_PARISC_LTOFF_TP16DF:
2141     case R_PARISC_DPREL14DR:
2142     case R_PARISC_GPREL16DF:
2143     case R_PARISC_PLTOFF14DR:
2144     case R_PARISC_PLTOFF16DF:
2145     case R_PARISC_DIR14DR:
2146     case R_PARISC_DIR16DF:
2147     case R_PARISC_LTOFF16DF:
2148       return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
2149                                  | ((sym_value & 0x1ff8) << 1));
2150
2151     /* Floating point single word load/store instructions.  */
2152     case R_PARISC_DLTREL14WR:
2153     case R_PARISC_DLTIND14WR:
2154     case R_PARISC_LTOFF_FPTR14WR:
2155     case R_PARISC_LTOFF_FPTR16WF:
2156     case R_PARISC_PCREL14WR:
2157     case R_PARISC_PCREL16WF:
2158     case R_PARISC_LTOFF_TP14WR:
2159     case R_PARISC_LTOFF_TP16WF:
2160     case R_PARISC_DPREL14WR:
2161     case R_PARISC_GPREL16WF:
2162     case R_PARISC_PLTOFF14WR:
2163     case R_PARISC_PLTOFF16WF:
2164     case R_PARISC_DIR16WF:
2165     case R_PARISC_DIR14WR:
2166     case R_PARISC_LTOFF16WF:
2167       return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
2168                                  | ((sym_value & 0x1ffc) << 1));
2169
2170     default:
2171       return insn;
2172     }
2173 }
2174 #endif