bfd/elf-hppa.h

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