bfd/elf-hppa.h

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