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 we are not creating a shared library, and this symbol is
1083      referenced by a shared library but is not defined anywhere, then
1084      the generic code will warn that it is undefined.
1085
1086      This behavior is undesirable on HPs since the standard shared
1087      libraries contain references to undefined symbols.
1088
1089      So we twiddle the flags associated with such symbols so that they
1090      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1091
1092      Ultimately we should have better controls over the generic ELF BFD
1093      linker code.  */
1094   if (! info->relocateable
1095       && ! (info->shared
1096             && !info->no_undefined)
1097       && h->root.type == bfd_link_hash_undefined
1098       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) != 0
1099       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
1100     {
1101       h->elf_link_hash_flags &= ~ELF_LINK_HASH_REF_DYNAMIC;
1102       h->elf_link_hash_flags |= 0x8000;
1103     }
1104
1105   return true;
1106 }
1107
1108 static boolean
1109 elf_hppa_remark_useless_dynamic_symbols (h, data)
1110      struct elf_link_hash_entry *h;
1111      PTR data;
1112 {
1113   struct bfd_link_info *info = (struct bfd_link_info *)data;
1114
1115   /* If we are not creating a shared library, and this symbol is
1116      referenced by a shared library but is not defined anywhere, then
1117      the generic code will warn that it is undefined.
1118
1119      This behavior is undesirable on HPs since the standard shared
1120      libraries contain reerences to undefined symbols.
1121
1122      So we twiddle the flags associated with such symbols so that they
1123      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1124
1125      Ultimately we should have better controls over the generic ELF BFD
1126      linker code.  */
1127   if (! info->relocateable
1128       && ! (info->shared
1129             && !info->no_undefined)
1130       && h->root.type == bfd_link_hash_undefined
1131       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1132       && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0
1133       && (h->elf_link_hash_flags & 0x8000) != 0)
1134     {
1135       h->elf_link_hash_flags |= ELF_LINK_HASH_REF_DYNAMIC;
1136       h->elf_link_hash_flags &= ~0x8000;
1137     }
1138
1139   return true;
1140 }
1141
1142 static boolean
1143 elf_hppa_is_dynamic_loader_symbol (name)
1144      const char * name;
1145 {
1146   return (! strcmp (name, "__CPU_REVISION")
1147           || ! strcmp (name, "__CPU_KEYBITS_1")
1148           || ! strcmp (name, "__SYSTEM_ID_D")
1149           || ! strcmp (name, "__FPU_MODEL")
1150           || ! strcmp (name, "__FPU_REVISION")
1151           || ! strcmp (name, "__ARGC")
1152           || ! strcmp (name, "__ARGV")
1153           || ! strcmp (name, "__ENVP")
1154           || ! strcmp (name, "__TLS_SIZE_D")
1155           || ! strcmp (name, "__LOAD_INFO")
1156           || ! strcmp (name, "__systab"));
1157 }
1158
1159 /* Record the lowest address for the data and text segments.  */
1160 static void
1161 elf_hppa_record_segment_addrs (abfd, section, data)
1162      bfd *abfd ATTRIBUTE_UNUSED;
1163      asection *section;
1164      PTR data;
1165 {
1166   struct elf64_hppa_link_hash_table *hppa_info;
1167   bfd_vma value;
1168
1169   hppa_info = (struct elf64_hppa_link_hash_table *)data;
1170
1171   value = section->vma - section->filepos;
1172
1173   if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1174        == (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1175       && value < hppa_info->text_segment_base)
1176     hppa_info->text_segment_base = value;
1177   else if (((section->flags & (SEC_ALLOC | SEC_LOAD | SEC_READONLY))
1178             == (SEC_ALLOC | SEC_LOAD))
1179            && value < hppa_info->data_segment_base)
1180     hppa_info->data_segment_base = value;
1181 }
1182
1183 /* Called after we have seen all the input files/sections, but before
1184    final symbol resolution and section placement has been determined.
1185
1186    We use this hook to (possibly) provide a value for __gp, then we
1187    fall back to the generic ELF final link routine.  */
1188
1189 static boolean
1190 elf_hppa_final_link (abfd, info)
1191      bfd *abfd;
1192      struct bfd_link_info *info;
1193 {
1194   boolean retval;
1195   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1196
1197   if (! info->relocateable)
1198     {
1199       struct elf_link_hash_entry *gp;
1200       bfd_vma gp_val;
1201
1202       /* The linker script defines a value for __gp iff it was referenced
1203          by one of the objects being linked.  First try to find the symbol
1204          in the hash table.  If that fails, just compute the value __gp
1205          should have had.  */
1206       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
1207                                  false, false);
1208
1209       if (gp)
1210         {
1211
1212           /* Adjust the value of __gp as we may want to slide it into the
1213              .plt section so that the stubs can access PLT entries without
1214              using an addil sequence.  */
1215           gp->root.u.def.value += hppa_info->gp_offset;
1216
1217           gp_val = (gp->root.u.def.section->output_section->vma
1218                     + gp->root.u.def.section->output_offset
1219                     + gp->root.u.def.value);
1220         }
1221       else
1222         {
1223           asection *sec;
1224
1225           /* First look for a .plt section.  If found, then __gp is the
1226              address of the .plt + gp_offset.
1227
1228              If no .plt is found, then look for .dlt, .opd and .data (in
1229              that order) and set __gp to the base address of whichever section
1230             is found first.  */
1231
1232           sec = hppa_info->plt_sec;
1233           if (sec)
1234             gp_val = (sec->output_offset
1235                       + sec->output_section->vma
1236                       + hppa_info->gp_offset);
1237           else
1238             {
1239               sec = hppa_info->dlt_sec;
1240               if (!sec)
1241                 sec = hppa_info->opd_sec;
1242               if (!sec)
1243                 sec = bfd_get_section_by_name (abfd, ".data");
1244               if (!sec)
1245                 return false;
1246
1247               gp_val = sec->output_offset + sec->output_section->vma;
1248             }
1249         }
1250
1251       /* Install whatever value we found/computed for __gp.  */
1252       _bfd_set_gp_value (abfd, gp_val);
1253     }
1254
1255   /* We need to know the base of the text and data segments so that we
1256      can perform SEGREL relocations.  We will record the base addresses
1257      when we encounter the first SEGREL relocation.  */
1258   hppa_info->text_segment_base = (bfd_vma)-1;
1259   hppa_info->data_segment_base = (bfd_vma)-1;
1260
1261   /* HP's shared libraries have references to symbols that are not
1262      defined anywhere.  The generic ELF BFD linker code will complaim
1263      about such symbols.
1264
1265      So we detect the losing case and arrange for the flags on the symbol
1266      to indicate that it was never referenced.  This keeps the generic
1267      ELF BFD link code happy and appears to not create any secondary
1268      problems.  Ultimately we need a way to control the behavior of the
1269      generic ELF BFD link code better.  */
1270   elf_link_hash_traverse (elf_hash_table (info),
1271                           elf_hppa_unmark_useless_dynamic_symbols,
1272                           info);
1273
1274   /* Invoke the regular ELF backend linker to do all the work.  */
1275   retval = bfd_elf_bfd_final_link (abfd, info);
1276
1277   elf_link_hash_traverse (elf_hash_table (info),
1278                           elf_hppa_remark_useless_dynamic_symbols,
1279                           info);
1280
1281   return retval;
1282 }
1283
1284 /* Relocate an HPPA ELF section.  */
1285
1286 static boolean
1287 elf_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
1288                            contents, relocs, local_syms, local_sections)
1289      bfd *output_bfd;
1290      struct bfd_link_info *info;
1291      bfd *input_bfd;
1292      asection *input_section;
1293      bfd_byte *contents;
1294      Elf_Internal_Rela *relocs;
1295      Elf_Internal_Sym *local_syms;
1296      asection **local_sections;
1297 {
1298   Elf_Internal_Shdr *symtab_hdr;
1299   Elf_Internal_Rela *rel;
1300   Elf_Internal_Rela *relend;
1301   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1302
1303   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1304
1305   rel = relocs;
1306   relend = relocs + input_section->reloc_count;
1307   for (; rel < relend; rel++)
1308     {
1309       int r_type;
1310       reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
1311       unsigned long r_symndx;
1312       struct elf_link_hash_entry *h;
1313       Elf_Internal_Sym *sym;
1314       asection *sym_sec;
1315       bfd_vma relocation;
1316       bfd_reloc_status_type r;
1317       const char *sym_name;
1318       const char *dyn_name;
1319       char *dynh_buf = NULL;
1320       size_t dynh_buflen = 0;
1321       struct elf64_hppa_dyn_hash_entry *dyn_h = NULL;
1322
1323       r_type = ELF_R_TYPE (rel->r_info);
1324       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
1325         {
1326           bfd_set_error (bfd_error_bad_value);
1327           return false;
1328         }
1329
1330       r_symndx = ELF_R_SYM (rel->r_info);
1331
1332       if (info->relocateable)
1333         {
1334           /* This is a relocateable link.  We don't have to change
1335              anything, unless the reloc is against a section symbol,
1336              in which case we have to adjust according to where the
1337              section symbol winds up in the output section.  */
1338           if (r_symndx < symtab_hdr->sh_info)
1339             {
1340               sym = local_syms + r_symndx;
1341               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1342                 {
1343                   sym_sec = local_sections[r_symndx];
1344                   rel->r_addend += sym_sec->output_offset;
1345                 }
1346             }
1347
1348           continue;
1349         }
1350
1351       /* This is a final link.  */
1352       h = NULL;
1353       sym = NULL;
1354       sym_sec = NULL;
1355       if (r_symndx < symtab_hdr->sh_info)
1356         {
1357           /* This is a local symbol.  */
1358           sym = local_syms + r_symndx;
1359           sym_sec = local_sections[r_symndx];
1360           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
1361
1362           /* If this symbol has an entry in the PA64 dynamic hash
1363              table, then get it.  */
1364           dyn_name = get_dyn_name (input_section, h, rel,
1365                                    &dynh_buf, &dynh_buflen);
1366           dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1367                                               dyn_name, false, false);
1368
1369         }
1370       else
1371         {
1372           /* This is not a local symbol.  */
1373           long indx;
1374
1375           indx = r_symndx - symtab_hdr->sh_info;
1376           h = elf_sym_hashes (input_bfd)[indx];
1377           while (h->root.type == bfd_link_hash_indirect
1378                  || h->root.type == bfd_link_hash_warning)
1379             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1380           if (h->root.type == bfd_link_hash_defined
1381               || h->root.type == bfd_link_hash_defweak)
1382             {
1383               sym_sec = h->root.u.def.section;
1384
1385               /* If this symbol has an entry in the PA64 dynamic hash
1386                  table, then get it.  */
1387               dyn_name = get_dyn_name (input_section, h, rel,
1388                                        &dynh_buf, &dynh_buflen);
1389               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1390                                                   dyn_name, false, false);
1391
1392               /* If we have a relocation against a symbol defined in a
1393                  shared library and we have not created an entry in the
1394                  PA64 dynamic symbol hash table for it, then we lose.  */
1395               if (sym_sec->output_section == NULL && dyn_h == NULL)
1396                 {
1397                   (*_bfd_error_handler)
1398                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1399                      bfd_archive_filename (input_bfd), h->root.root.string,
1400                      bfd_get_section_name (input_bfd, input_section));
1401                   relocation = 0;
1402                 }
1403               else if (sym_sec->output_section)
1404                 relocation = (h->root.u.def.value
1405                               + sym_sec->output_offset
1406                               + sym_sec->output_section->vma);
1407               /* Value will be provided via one of the offsets in the
1408                  dyn_h hash table entry.  */
1409               else
1410                 relocation = 0;
1411             }
1412           /* Allow undefined symbols in shared libraries.  */
1413           else if (info->shared && !info->no_undefined
1414                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1415             {
1416               if (info->symbolic)
1417                 (*info->callbacks->undefined_symbol)
1418                   (info, h->root.root.string, input_bfd,
1419                    input_section, rel->r_offset, false);
1420
1421               /* If this symbol has an entry in the PA64 dynamic hash
1422                  table, then get it.  */
1423               dyn_name = get_dyn_name (input_section, h, rel,
1424                                        &dynh_buf, &dynh_buflen);
1425               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1426                                                   dyn_name, false, false);
1427
1428               if (dyn_h == NULL)
1429                 {
1430                   (*_bfd_error_handler)
1431                     (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1432                      bfd_archive_filename (input_bfd), h->root.root.string,
1433                      bfd_get_section_name (input_bfd, input_section));
1434                   relocation = 0;
1435                 }
1436               relocation = 0;
1437             }
1438           else if (h->root.type == bfd_link_hash_undefweak)
1439             relocation = 0;
1440           else
1441             {
1442               /* Ignore dynamic loader defined symbols.  */
1443               if (elf_hppa_is_dynamic_loader_symbol (h->root.root.string))
1444                 relocation = 0;
1445               else
1446                 {
1447                   if (!((*info->callbacks->undefined_symbol)
1448                         (info, h->root.root.string, input_bfd,
1449                          input_section, rel->r_offset, true)))
1450                     return false;
1451                   break;
1452                 }
1453             }
1454         }
1455
1456       if (h != NULL)
1457         sym_name = h->root.root.string;
1458       else
1459         {
1460           sym_name = bfd_elf_string_from_elf_section (input_bfd,
1461                                                       symtab_hdr->sh_link,
1462                                                       sym->st_name);
1463           if (sym_name == NULL)
1464             return false;
1465           if (*sym_name == '\0')
1466             sym_name = bfd_section_name (input_bfd, sym_sec);
1467         }
1468
1469       r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
1470                                         input_section, contents,
1471                                         relocation, info, sym_sec,
1472                                         h, dyn_h);
1473
1474       if (r != bfd_reloc_ok)
1475         {
1476           switch (r)
1477             {
1478             default:
1479               abort ();
1480             case bfd_reloc_overflow:
1481               {
1482                 if (!((*info->callbacks->reloc_overflow)
1483                       (info, sym_name, howto->name, (bfd_vma) 0,
1484                         input_bfd, input_section, rel->r_offset)))
1485                   return false;
1486               }
1487               break;
1488             }
1489         }
1490     }
1491   return true;
1492 }
1493
1494 /* Compute the value for a relocation (REL) during a final link stage,
1495    then insert the value into the proper location in CONTENTS.
1496
1497    VALUE is a tentative value for the relocation and may be overridden
1498    and modified here based on the specific relocation to be performed.
1499
1500    For example we do conversions for PC-relative branches in this routine
1501    or redirection of calls to external routines to stubs.
1502
1503    The work of actually applying the relocation is left to a helper
1504    routine in an attempt to reduce the complexity and size of this
1505    function.  */
1506
1507 static bfd_reloc_status_type
1508 elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
1509                               input_section, contents, value,
1510                               info, sym_sec, h, dyn_h)
1511      Elf_Internal_Rela *rel;
1512      bfd *input_bfd;
1513      bfd *output_bfd;
1514      asection *input_section;
1515      bfd_byte *contents;
1516      bfd_vma value;
1517      struct bfd_link_info *info;
1518      asection *sym_sec;
1519      struct elf_link_hash_entry *h ATTRIBUTE_UNUSED;
1520      struct elf64_hppa_dyn_hash_entry *dyn_h;
1521 {
1522   int insn;
1523   bfd_vma offset = rel->r_offset;
1524   bfd_signed_vma addend = rel->r_addend;
1525   reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
1526   unsigned int r_type = howto->type;
1527   bfd_byte *hit_data = contents + offset;
1528   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1529
1530   insn = bfd_get_32 (input_bfd, hit_data);
1531
1532   switch (r_type)
1533     {
1534     case R_PARISC_NONE:
1535       break;
1536
1537     /* Basic function call support.  I'm not entirely sure if PCREL14F is
1538        actually needed or even handled correctly.
1539
1540        Note for a call to a function defined in another dynamic library
1541        we want to redirect the call to a stub.  */
1542
1543     /* Random PC relative relocs.  */
1544     case R_PARISC_PCREL21L:
1545     case R_PARISC_PCREL14R:
1546     case R_PARISC_PCREL14F:
1547     case R_PARISC_PCREL14WR:
1548     case R_PARISC_PCREL14DR:
1549     case R_PARISC_PCREL16F:
1550     case R_PARISC_PCREL16WF:
1551     case R_PARISC_PCREL16DF:
1552       {
1553         /* If this is a call to a function defined in another dynamic
1554            library, then redirect the call to the local stub for this
1555            function.  */
1556         if (sym_sec == NULL || sym_sec->output_section == NULL)
1557           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1558                    + hppa_info->stub_sec->output_section->vma);
1559
1560         /* Turn VALUE into a proper PC relative address.  */
1561         value -= (offset + input_section->output_offset
1562                   + input_section->output_section->vma);
1563
1564         /* Adjust for any field selectors.  */
1565         if (r_type == R_PARISC_PCREL21L)
1566           value = hppa_field_adjust (value, -8 + addend, e_lsel);
1567         else if (r_type == R_PARISC_PCREL14F
1568                  || r_type == R_PARISC_PCREL16F
1569                  || r_type == R_PARISC_PCREL16WF
1570                  || r_type == R_PARISC_PCREL16DF)
1571           value = hppa_field_adjust (value, -8 + addend, e_fsel);
1572         else
1573           value = hppa_field_adjust (value, -8 + addend, e_rsel);
1574
1575         /* Apply the relocation to the given instruction.  */
1576         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1577         break;
1578       }
1579
1580     case R_PARISC_PCREL12F:
1581     case R_PARISC_PCREL22F:
1582     case R_PARISC_PCREL17F:
1583     case R_PARISC_PCREL22C:
1584     case R_PARISC_PCREL17C:
1585     case R_PARISC_PCREL17R:
1586       {
1587         /* If this is a call to a function defined in another dynamic
1588            library, then redirect the call to the local stub for this
1589            function.  */
1590         if (sym_sec == NULL || sym_sec->output_section == NULL)
1591           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1592                    + hppa_info->stub_sec->output_section->vma);
1593
1594         /* Turn VALUE into a proper PC relative address.  */
1595         value -= (offset + input_section->output_offset
1596                   + input_section->output_section->vma);
1597
1598         /* Adjust for any field selectors.  */
1599         if (r_type == R_PARISC_PCREL17R)
1600           value = hppa_field_adjust (value, -8 + addend, e_rsel);
1601         else
1602           value = hppa_field_adjust (value, -8 + addend, e_fsel);
1603
1604         /* All branches are implicitly shifted by 2 places.  */
1605         value >>= 2;
1606
1607         /* Apply the relocation to the given instruction.  */
1608         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1609         break;
1610       }
1611
1612     /* Indirect references to data through the DLT.  */
1613     case R_PARISC_DLTIND14R:
1614     case R_PARISC_DLTIND14F:
1615     case R_PARISC_DLTIND14DR:
1616     case R_PARISC_DLTIND14WR:
1617     case R_PARISC_DLTIND21L:
1618     case R_PARISC_LTOFF_FPTR14R:
1619     case R_PARISC_LTOFF_FPTR14DR:
1620     case R_PARISC_LTOFF_FPTR14WR:
1621     case R_PARISC_LTOFF_FPTR21L:
1622     case R_PARISC_LTOFF_FPTR16F:
1623     case R_PARISC_LTOFF_FPTR16WF:
1624     case R_PARISC_LTOFF_FPTR16DF:
1625     case R_PARISC_LTOFF_TP21L:
1626     case R_PARISC_LTOFF_TP14R:
1627     case R_PARISC_LTOFF_TP14F:
1628     case R_PARISC_LTOFF_TP14WR:
1629     case R_PARISC_LTOFF_TP14DR:
1630     case R_PARISC_LTOFF_TP16F:
1631     case R_PARISC_LTOFF_TP16WF:
1632     case R_PARISC_LTOFF_TP16DF:
1633     case R_PARISC_LTOFF16F:
1634     case R_PARISC_LTOFF16WF:
1635     case R_PARISC_LTOFF16DF:
1636       {
1637         /* If this relocation was against a local symbol, then we still
1638            have not set up the DLT entry (it's not convenient to do so
1639            in the "finalize_dlt" routine because it is difficult to get
1640            to the local symbol's value).
1641
1642            So, if this is a local symbol (h == NULL), then we need to
1643            fill in its DLT entry.
1644
1645            Similarly we may still need to set up an entry in .opd for
1646            a local function which had its address taken.  */
1647         if (dyn_h->h == NULL)
1648           {
1649             /* Now do .opd creation if needed.  */
1650             if (r_type == R_PARISC_LTOFF_FPTR14R
1651                 || r_type == R_PARISC_LTOFF_FPTR14DR
1652                 || r_type == R_PARISC_LTOFF_FPTR14WR
1653                 || r_type == R_PARISC_LTOFF_FPTR21L
1654                 || r_type == R_PARISC_LTOFF_FPTR16F
1655                 || r_type == R_PARISC_LTOFF_FPTR16WF
1656                 || r_type == R_PARISC_LTOFF_FPTR16DF)
1657               {
1658                 /* The first two words of an .opd entry are zero.  */
1659                 memset (hppa_info->opd_sec->contents + dyn_h->opd_offset,
1660                         0, 16);
1661
1662                 /* The next word is the address of the function.  */
1663                 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1664                             (hppa_info->opd_sec->contents
1665                              + dyn_h->opd_offset + 16));
1666
1667                 /* The last word is our local __gp value.  */
1668                 value = _bfd_get_gp_value
1669                           (hppa_info->opd_sec->output_section->owner);
1670                 bfd_put_64 (hppa_info->opd_sec->owner, value,
1671                             (hppa_info->opd_sec->contents
1672                              + dyn_h->opd_offset + 24));
1673
1674                 /* The DLT value is the address of the .opd entry.  */
1675                 value = (dyn_h->opd_offset
1676                          + hppa_info->opd_sec->output_offset
1677                          + hppa_info->opd_sec->output_section->vma);
1678                 addend = 0;
1679               }
1680
1681             bfd_put_64 (hppa_info->dlt_sec->owner,
1682                         value + addend,
1683                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1684           }
1685
1686         /* We want the value of the DLT offset for this symbol, not
1687            the symbol's actual address.  Note that __gp may not point
1688            to the start of the DLT, so we have to compute the absolute
1689            address, then subtract out the value of __gp.  */
1690         value = (dyn_h->dlt_offset
1691                  + hppa_info->dlt_sec->output_offset
1692                  + hppa_info->dlt_sec->output_section->vma);
1693         value -= _bfd_get_gp_value (output_bfd);
1694
1695         /* All DLTIND relocations are basically the same at this point,
1696            except that we need different field selectors for the 21bit
1697            version vs the 14bit versions.  */
1698         if (r_type == R_PARISC_DLTIND21L
1699             || r_type == R_PARISC_LTOFF_FPTR21L
1700             || r_type == R_PARISC_LTOFF_TP21L)
1701           value = hppa_field_adjust (value, 0, e_lsel);
1702         else if (r_type == R_PARISC_DLTIND14F
1703                  || r_type == R_PARISC_LTOFF_FPTR16F
1704                  || r_type == R_PARISC_LTOFF_FPTR16WF
1705                  || r_type == R_PARISC_LTOFF_FPTR16DF
1706                  || r_type == R_PARISC_LTOFF16F
1707                  || r_type == R_PARISC_LTOFF16DF
1708                  || r_type == R_PARISC_LTOFF16WF
1709                  || r_type == R_PARISC_LTOFF_TP16F
1710                  || r_type == R_PARISC_LTOFF_TP16WF
1711                  || r_type == R_PARISC_LTOFF_TP16DF)
1712           value = hppa_field_adjust (value, 0, e_fsel);
1713         else
1714           value = hppa_field_adjust (value, 0, e_rsel);
1715
1716         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1717         break;
1718       }
1719
1720     case R_PARISC_DLTREL14R:
1721     case R_PARISC_DLTREL14F:
1722     case R_PARISC_DLTREL14DR:
1723     case R_PARISC_DLTREL14WR:
1724     case R_PARISC_DLTREL21L:
1725     case R_PARISC_DPREL21L:
1726     case R_PARISC_DPREL14WR:
1727     case R_PARISC_DPREL14DR:
1728     case R_PARISC_DPREL14R:
1729     case R_PARISC_DPREL14F:
1730     case R_PARISC_GPREL16F:
1731     case R_PARISC_GPREL16WF:
1732     case R_PARISC_GPREL16DF:
1733       {
1734         /* Subtract out the global pointer value to make value a DLT
1735            relative address.  */
1736         value -= _bfd_get_gp_value (output_bfd);
1737
1738         /* All DLTREL relocations are basically the same at this point,
1739            except that we need different field selectors for the 21bit
1740            version vs the 14bit versions.  */
1741         if (r_type == R_PARISC_DLTREL21L
1742             || r_type == R_PARISC_DPREL21L)
1743           value = hppa_field_adjust (value, addend, e_lrsel);
1744         else if (r_type == R_PARISC_DLTREL14F
1745                  || r_type == R_PARISC_DPREL14F
1746                  || r_type == R_PARISC_GPREL16F
1747                  || r_type == R_PARISC_GPREL16WF
1748                  || r_type == R_PARISC_GPREL16DF)
1749           value = hppa_field_adjust (value, addend, e_fsel);
1750         else
1751           value = hppa_field_adjust (value, addend, e_rrsel);
1752
1753         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1754         break;
1755       }
1756
1757     case R_PARISC_DIR21L:
1758     case R_PARISC_DIR17R:
1759     case R_PARISC_DIR17F:
1760     case R_PARISC_DIR14R:
1761     case R_PARISC_DIR14F:
1762     case R_PARISC_DIR14WR:
1763     case R_PARISC_DIR14DR:
1764     case R_PARISC_DIR16F:
1765     case R_PARISC_DIR16WF:
1766     case R_PARISC_DIR16DF:
1767       {
1768         /* All DIR relocations are basically the same at this point,
1769            except that branch offsets need to be divided by four, and
1770            we need different field selectors.  Note that we don't
1771            redirect absolute calls to local stubs.  */
1772
1773         if (r_type == R_PARISC_DIR21L)
1774           value = hppa_field_adjust (value, addend, e_lrsel);
1775         else if (r_type == R_PARISC_DIR17F
1776                  || r_type == R_PARISC_DIR16F
1777                  || r_type == R_PARISC_DIR16WF
1778                  || r_type == R_PARISC_DIR16DF
1779                  || r_type == R_PARISC_DIR14F)
1780           value = hppa_field_adjust (value, addend, e_fsel);
1781         else
1782           value = hppa_field_adjust (value, addend, e_rrsel);
1783
1784         if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
1785           {
1786             /* All branches are implicitly shifted by 2 places.  */
1787             value >>= 2;
1788           }
1789
1790         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1791         break;
1792       }
1793
1794     case R_PARISC_PLTOFF21L:
1795     case R_PARISC_PLTOFF14R:
1796     case R_PARISC_PLTOFF14F:
1797     case R_PARISC_PLTOFF14WR:
1798     case R_PARISC_PLTOFF14DR:
1799     case R_PARISC_PLTOFF16F:
1800     case R_PARISC_PLTOFF16WF:
1801     case R_PARISC_PLTOFF16DF:
1802       {
1803         /* We want the value of the PLT offset for this symbol, not
1804            the symbol's actual address.  Note that __gp may not point
1805            to the start of the DLT, so we have to compute the absolute
1806            address, then subtract out the value of __gp.  */
1807         value = (dyn_h->plt_offset
1808                  + hppa_info->plt_sec->output_offset
1809                  + hppa_info->plt_sec->output_section->vma);
1810         value -= _bfd_get_gp_value (output_bfd);
1811
1812         /* All PLTOFF relocations are basically the same at this point,
1813            except that we need different field selectors for the 21bit
1814            version vs the 14bit versions.  */
1815         if (r_type == R_PARISC_PLTOFF21L)
1816           value = hppa_field_adjust (value, addend, e_lrsel);
1817         else if (r_type == R_PARISC_PLTOFF14F
1818                  || r_type == R_PARISC_PLTOFF16F
1819                  || r_type == R_PARISC_PLTOFF16WF
1820                  || r_type == R_PARISC_PLTOFF16DF)
1821           value = hppa_field_adjust (value, addend, e_fsel);
1822         else
1823           value = hppa_field_adjust (value, addend, e_rrsel);
1824
1825         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1826         break;
1827       }
1828
1829     case R_PARISC_LTOFF_FPTR32:
1830       {
1831         /* We may still need to create the FPTR itself if it was for
1832            a local symbol.  */
1833         if (dyn_h->h == NULL)
1834           {
1835             /* The first two words of an .opd entry are zero.  */
1836             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1837
1838             /* The next word is the address of the function.  */
1839             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1840                         (hppa_info->opd_sec->contents
1841                          + dyn_h->opd_offset + 16));
1842
1843             /* The last word is our local __gp value.  */
1844             value = _bfd_get_gp_value
1845                       (hppa_info->opd_sec->output_section->owner);
1846             bfd_put_64 (hppa_info->opd_sec->owner, value,
1847                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
1848
1849             /* The DLT value is the address of the .opd entry.  */
1850             value = (dyn_h->opd_offset
1851                      + hppa_info->opd_sec->output_offset
1852                      + hppa_info->opd_sec->output_section->vma);
1853
1854             bfd_put_64 (hppa_info->dlt_sec->owner,
1855                         value,
1856                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1857           }
1858
1859         /* We want the value of the DLT offset for this symbol, not
1860            the symbol's actual address.  Note that __gp may not point
1861            to the start of the DLT, so we have to compute the absolute
1862            address, then subtract out the value of __gp.  */
1863         value = (dyn_h->dlt_offset
1864                  + hppa_info->dlt_sec->output_offset
1865                  + hppa_info->dlt_sec->output_section->vma);
1866         value -= _bfd_get_gp_value (output_bfd);
1867         bfd_put_32 (input_bfd, value, hit_data);
1868         return bfd_reloc_ok;
1869       }
1870
1871     case R_PARISC_LTOFF_FPTR64:
1872     case R_PARISC_LTOFF_TP64:
1873       {
1874         /* We may still need to create the FPTR itself if it was for
1875            a local symbol.  */
1876         if (dyn_h->h == NULL && r_type == R_PARISC_LTOFF_FPTR64)
1877           {
1878             /* The first two words of an .opd entry are zero.  */
1879             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1880
1881             /* The next word is the address of the function.  */
1882             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1883                         (hppa_info->opd_sec->contents
1884                          + dyn_h->opd_offset + 16));
1885
1886             /* The last word is our local __gp value.  */
1887             value = _bfd_get_gp_value
1888                       (hppa_info->opd_sec->output_section->owner);
1889             bfd_put_64 (hppa_info->opd_sec->owner, value,
1890                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
1891
1892             /* The DLT value is the address of the .opd entry.  */
1893             value = (dyn_h->opd_offset
1894                      + hppa_info->opd_sec->output_offset
1895                      + hppa_info->opd_sec->output_section->vma);
1896
1897             bfd_put_64 (hppa_info->dlt_sec->owner,
1898                         value,
1899                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1900           }
1901
1902         /* We want the value of the DLT offset for this symbol, not
1903            the symbol's actual address.  Note that __gp may not point
1904            to the start of the DLT, so we have to compute the absolute
1905            address, then subtract out the value of __gp.  */
1906         value = (dyn_h->dlt_offset
1907                  + hppa_info->dlt_sec->output_offset
1908                  + hppa_info->dlt_sec->output_section->vma);
1909         value -= _bfd_get_gp_value (output_bfd);
1910         bfd_put_64 (input_bfd, value, hit_data);
1911         return bfd_reloc_ok;
1912       }
1913
1914     case R_PARISC_DIR32:
1915       bfd_put_32 (input_bfd, value + addend, hit_data);
1916       return bfd_reloc_ok;
1917
1918     case R_PARISC_DIR64:
1919       bfd_put_64 (input_bfd, value + addend, hit_data);
1920       return bfd_reloc_ok;
1921
1922     case R_PARISC_GPREL64:
1923       /* Subtract out the global pointer value to make value a DLT
1924          relative address.  */
1925       value -= _bfd_get_gp_value (output_bfd);
1926
1927       bfd_put_64 (input_bfd, value + addend, hit_data);
1928       return bfd_reloc_ok;
1929
1930     case R_PARISC_LTOFF64:
1931         /* We want the value of the DLT offset for this symbol, not
1932            the symbol's actual address.  Note that __gp may not point
1933            to the start of the DLT, so we have to compute the absolute
1934            address, then subtract out the value of __gp.  */
1935       value = (dyn_h->dlt_offset
1936                + hppa_info->dlt_sec->output_offset
1937                + hppa_info->dlt_sec->output_section->vma);
1938       value -= _bfd_get_gp_value (output_bfd);
1939
1940       bfd_put_64 (input_bfd, value + addend, hit_data);
1941       return bfd_reloc_ok;
1942
1943     case R_PARISC_PCREL32:
1944       {
1945         /* If this is a call to a function defined in another dynamic
1946            library, then redirect the call to the local stub for this
1947            function.  */
1948         if (sym_sec == NULL || sym_sec->output_section == NULL)
1949           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1950                    + hppa_info->stub_sec->output_section->vma);
1951
1952         /* Turn VALUE into a proper PC relative address.  */
1953         value -= (offset + input_section->output_offset
1954                   + input_section->output_section->vma);
1955
1956         value += addend;
1957         value -= 8;
1958         bfd_put_32 (input_bfd, value, hit_data);
1959         return bfd_reloc_ok;
1960       }
1961
1962     case R_PARISC_PCREL64:
1963       {
1964         /* If this is a call to a function defined in another dynamic
1965            library, then redirect the call to the local stub for this
1966            function.  */
1967         if (sym_sec == NULL || sym_sec->output_section == NULL)
1968           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1969                    + hppa_info->stub_sec->output_section->vma);
1970
1971         /* Turn VALUE into a proper PC relative address.  */
1972         value -= (offset + input_section->output_offset
1973                   + input_section->output_section->vma);
1974
1975         value += addend;
1976         value -= 8;
1977         bfd_put_64 (input_bfd, value, hit_data);
1978         return bfd_reloc_ok;
1979       }
1980
1981     case R_PARISC_FPTR64:
1982       {
1983         /* We may still need to create the FPTR itself if it was for
1984            a local symbol.  */
1985         if (dyn_h->h == NULL)
1986           {
1987             /* The first two words of an .opd entry are zero.  */
1988             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1989
1990             /* The next word is the address of the function.  */
1991             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1992                         (hppa_info->opd_sec->contents
1993                          + dyn_h->opd_offset + 16));
1994
1995             /* The last word is our local __gp value.  */
1996             value = _bfd_get_gp_value
1997                       (hppa_info->opd_sec->output_section->owner);
1998             bfd_put_64 (hppa_info->opd_sec->owner, value,
1999                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
2000           }
2001
2002         /* We want the value of the OPD offset for this symbol, not
2003            the symbol's actual address.  */
2004         value = (dyn_h->opd_offset
2005                  + hppa_info->opd_sec->output_offset
2006                  + hppa_info->opd_sec->output_section->vma);
2007
2008         bfd_put_64 (input_bfd, value, hit_data);
2009         return bfd_reloc_ok;
2010       }
2011
2012     case R_PARISC_SECREL32:
2013       bfd_put_32 (input_bfd,
2014                   value + addend - sym_sec->output_section->vma,
2015                   hit_data);
2016       return bfd_reloc_ok;
2017
2018     case R_PARISC_SEGREL32:
2019     case R_PARISC_SEGREL64:
2020       {
2021         /* If this is the first SEGREL relocation, then initialize
2022            the segment base values.  */
2023         if (hppa_info->text_segment_base == (bfd_vma) -1)
2024           bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
2025                                  hppa_info);
2026
2027         /* VALUE holds the absolute address.  We want to include the
2028            addend, then turn it into a segment relative address.
2029
2030            The segment is derived from SYM_SEC.  We assume that there are
2031            only two segments of note in the resulting executable/shlib.
2032            A readonly segment (.text) and a readwrite segment (.data).  */
2033         value += addend;
2034
2035         if (sym_sec->flags & SEC_CODE)
2036           value -= hppa_info->text_segment_base;
2037         else
2038           value -= hppa_info->data_segment_base;
2039
2040         if (r_type == R_PARISC_SEGREL32)
2041           bfd_put_32 (input_bfd, value, hit_data);
2042         else
2043           bfd_put_64 (input_bfd, value, hit_data);
2044         return bfd_reloc_ok;
2045       }
2046
2047     /* Something we don't know how to handle.  */
2048     default:
2049       return bfd_reloc_notsupported;
2050     }
2051
2052   /* Update the instruction word.  */
2053   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
2054   return bfd_reloc_ok;
2055 }
2056
2057 /* Relocate the given INSN.  VALUE should be the actual value we want
2058    to insert into the instruction, ie by this point we should not be
2059    concerned with computing an offset relative to the DLT, PC, etc.
2060    Instead this routine is meant to handle the bit manipulations needed
2061    to insert the relocation into the given instruction.  */
2062
2063 static int
2064 elf_hppa_relocate_insn (insn, sym_value, r_type)
2065      int insn;
2066      int sym_value;
2067      unsigned int r_type;
2068 {
2069   switch (r_type)
2070     {
2071     /* This is any 22 bit branch.  In PA2.0 syntax it corresponds to
2072        the "B" instruction.  */
2073     case R_PARISC_PCREL22F:
2074     case R_PARISC_PCREL22C:
2075       return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
2076
2077       /* This is any 12 bit branch.  */
2078     case R_PARISC_PCREL12F:
2079       return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
2080
2081     /* This is any 17 bit branch.  In PA2.0 syntax it also corresponds
2082        to the "B" instruction as well as BE.  */
2083     case R_PARISC_PCREL17F:
2084     case R_PARISC_DIR17F:
2085     case R_PARISC_DIR17R:
2086     case R_PARISC_PCREL17C:
2087     case R_PARISC_PCREL17R:
2088       return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
2089
2090     /* ADDIL or LDIL instructions.  */
2091     case R_PARISC_DLTREL21L:
2092     case R_PARISC_DLTIND21L:
2093     case R_PARISC_LTOFF_FPTR21L:
2094     case R_PARISC_PCREL21L:
2095     case R_PARISC_LTOFF_TP21L:
2096     case R_PARISC_DPREL21L:
2097     case R_PARISC_PLTOFF21L:
2098     case R_PARISC_DIR21L:
2099       return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
2100
2101     /* LDO and integer loads/stores with 14 bit displacements.  */
2102     case R_PARISC_DLTREL14R:
2103     case R_PARISC_DLTREL14F:
2104     case R_PARISC_DLTIND14R:
2105     case R_PARISC_DLTIND14F:
2106     case R_PARISC_LTOFF_FPTR14R:
2107     case R_PARISC_LTOFF_FPTR16F:
2108     case R_PARISC_PCREL14R:
2109     case R_PARISC_PCREL14F:
2110     case R_PARISC_PCREL16F:
2111     case R_PARISC_LTOFF_TP14R:
2112     case R_PARISC_LTOFF_TP14F:
2113     case R_PARISC_LTOFF_TP16F:
2114     case R_PARISC_DPREL14R:
2115     case R_PARISC_DPREL14F:
2116     case R_PARISC_GPREL16F:
2117     case R_PARISC_PLTOFF14R:
2118     case R_PARISC_PLTOFF14F:
2119     case R_PARISC_PLTOFF16F:
2120     case R_PARISC_DIR14R:
2121     case R_PARISC_DIR14F:
2122     case R_PARISC_DIR16F:
2123     case R_PARISC_LTOFF16F:
2124       return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
2125
2126     /* Doubleword loads and stores with a 14 bit displacement.  */
2127     case R_PARISC_DLTREL14DR:
2128     case R_PARISC_DLTIND14DR:
2129     case R_PARISC_LTOFF_FPTR14DR:
2130     case R_PARISC_LTOFF_FPTR16DF:
2131     case R_PARISC_PCREL14DR:
2132     case R_PARISC_PCREL16DF:
2133     case R_PARISC_LTOFF_TP14DR:
2134     case R_PARISC_LTOFF_TP16DF:
2135     case R_PARISC_DPREL14DR:
2136     case R_PARISC_GPREL16DF:
2137     case R_PARISC_PLTOFF14DR:
2138     case R_PARISC_PLTOFF16DF:
2139     case R_PARISC_DIR14DR:
2140     case R_PARISC_DIR16DF:
2141     case R_PARISC_LTOFF16DF:
2142       return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
2143                                  | ((sym_value & 0x1ff8) << 1));
2144
2145     /* Floating point single word load/store instructions.  */
2146     case R_PARISC_DLTREL14WR:
2147     case R_PARISC_DLTIND14WR:
2148     case R_PARISC_LTOFF_FPTR14WR:
2149     case R_PARISC_LTOFF_FPTR16WF:
2150     case R_PARISC_PCREL14WR:
2151     case R_PARISC_PCREL16WF:
2152     case R_PARISC_LTOFF_TP14WR:
2153     case R_PARISC_LTOFF_TP16WF:
2154     case R_PARISC_DPREL14WR:
2155     case R_PARISC_GPREL16WF:
2156     case R_PARISC_PLTOFF14WR:
2157     case R_PARISC_PLTOFF16WF:
2158     case R_PARISC_DIR16WF:
2159     case R_PARISC_DIR14WR:
2160     case R_PARISC_LTOFF16WF:
2161       return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
2162                                  | ((sym_value & 0x1ffc) << 1));
2163
2164     default:
2165       return insn;
2166     }
2167 }
2168 #endif