bfd/elf-hppa.h

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