bfd/elf-hppa.h

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