bfd/elf-hppa.h

   1 /* Common code for PA ELF implementations.
   2    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   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         case 64:
 749           switch (field)
 750             {
 751             case e_fsel:
 752               final_type = R_PARISC_GPREL64;
 753               break;
 754             default:
 755               return R_PARISC_NONE;
 756             }
 757           break;
 758
 759         default:
 760           return R_PARISC_NONE;
 761         }
 762       break;
 763
 764     case R_HPPA_PCREL_CALL:
 765       switch (format)
 766         {
 767         case 12:
 768           switch (field)
 769             {
 770             case e_fsel:
 771               final_type = R_PARISC_PCREL12F;
 772               break;
 773             default:
 774               return R_PARISC_NONE;
 775             }
 776           break;
 777
 778         case 14:
 779           /* Contrary to appearances, these are not calls of any sort.
 780              Rather, they are loads/stores with a pcrel reloc.  */
 781           switch (field)
 782             {
 783             case e_rsel:
 784             case e_rrsel:
 785             case e_rdsel:
 786               final_type = R_PARISC_PCREL14R;
 787               break;
 788             case e_fsel:
 789               if (bfd_get_mach (abfd) < 25)
 790                 final_type = R_PARISC_PCREL14F;
 791               else
 792                 final_type = R_PARISC_PCREL16F;
 793               break;
 794             default:
 795               return R_PARISC_NONE;
 796             }
 797           break;
 798
 799         case 17:
 800           switch (field)
 801             {
 802             case e_rsel:
 803             case e_rrsel:
 804             case e_rdsel:
 805               final_type = R_PARISC_PCREL17R;
 806               break;
 807             case e_fsel:
 808               final_type = R_PARISC_PCREL17F;
 809               break;
 810             default:
 811               return R_PARISC_NONE;
 812             }
 813           break;
 814
 815         case 21:
 816           switch (field)
 817             {
 818             case e_lsel:
 819             case e_lrsel:
 820             case e_ldsel:
 821             case e_nlsel:
 822             case e_nlrsel:
 823               final_type = R_PARISC_PCREL21L;
 824               break;
 825             default:
 826               return R_PARISC_NONE;
 827             }
 828           break;
 829
 830         case 22:
 831           switch (field)
 832             {
 833             case e_fsel:
 834               final_type = R_PARISC_PCREL22F;
 835               break;
 836             default:
 837               return R_PARISC_NONE;
 838             }
 839           break;
 840
 841         case 32:
 842           switch (field)
 843             {
 844             case e_fsel:
 845               final_type = R_PARISC_PCREL32;
 846               break;
 847             default:
 848               return R_PARISC_NONE;
 849             }
 850           break;
 851
 852         case 64:
 853           switch (field)
 854             {
 855             case e_fsel:
 856               final_type = R_PARISC_PCREL64;
 857               break;
 858             default:
 859               return R_PARISC_NONE;
 860             }
 861           break;
 862
 863         default:
 864           return R_PARISC_NONE;
 865         }
 866       break;
 867
 868     case R_PARISC_TLS_GD21L:
 869       switch (field)
 870         {
 871           case e_ltsel:
 872           case e_lrsel:
 873             final_type = R_PARISC_TLS_GD21L;
 874             break;
 875           case e_rtsel:
 876           case e_rrsel:
 877             final_type = R_PARISC_TLS_GD14R;
 878             break;
 879           default:
 880             return R_PARISC_NONE;
 881         }
 882       break;
 883
 884     case R_PARISC_TLS_LDM21L:
 885       switch (field)
 886         {
 887           case e_ltsel:
 888           case e_lrsel:
 889             final_type = R_PARISC_TLS_LDM21L;
 890             break;
 891           case e_rtsel:
 892           case e_rrsel:
 893             final_type = R_PARISC_TLS_LDM14R;
 894             break;
 895           default:
 896             return R_PARISC_NONE;
 897         }
 898       break;
 899
 900     case R_PARISC_TLS_LDO21L:
 901       switch (field)
 902         {
 903           case e_lrsel:
 904             final_type = R_PARISC_TLS_LDO21L;
 905             break;
 906           case e_rrsel:
 907             final_type = R_PARISC_TLS_LDO14R;
 908             break;
 909           default:
 910             return R_PARISC_NONE;
 911         }
 912       break;
 913
 914     case R_PARISC_TLS_IE21L:
 915       switch (field)
 916         {
 917           case e_ltsel:
 918           case e_lrsel:
 919             final_type = R_PARISC_TLS_IE21L;
 920             break;
 921           case e_rtsel:
 922           case e_rrsel:
 923             final_type = R_PARISC_TLS_IE14R;
 924             break;
 925           default:
 926             return R_PARISC_NONE;
 927         }
 928       break;
 929
 930     case R_PARISC_TLS_LE21L:
 931       switch (field)
 932         {
 933           case e_lrsel:
 934             final_type = R_PARISC_TLS_LE21L;
 935             break;
 936           case e_rrsel:
 937             final_type = R_PARISC_TLS_LE14R;
 938             break;
 939           default:
 940             return R_PARISC_NONE;
 941         }
 942       break;
 943
 944     case R_PARISC_SEGREL32:
 945       switch (format)
 946         {
 947         case 32:
 948           switch (field)
 949             {
 950             case e_fsel:
 951               final_type = R_PARISC_SEGREL32;
 952               break;
 953             default:
 954               return R_PARISC_NONE;
 955             }
 956           break;
 957
 958         case 64:
 959           switch (field)
 960             {
 961             case e_fsel:
 962               final_type = R_PARISC_SEGREL64;
 963               break;
 964             default:
 965               return R_PARISC_NONE;
 966             }
 967           break;
 968
 969         default:
 970           return R_PARISC_NONE;
 971         }
 972       break;
 973
 974     case R_PARISC_GNU_VTENTRY:
 975     case R_PARISC_GNU_VTINHERIT:
 976     case R_PARISC_SEGBASE:
 977       /* The defaults are fine for these cases.  */
 978       break;
 979
 980     default:
 981       return R_PARISC_NONE;
 982     }
 983
 984   return final_type;
 985 }
 986
 987 /* Return one (or more) BFD relocations which implement the base
 988    relocation with modifications based on format and field.  */
 989
 990 elf_hppa_reloc_type **
 991 _bfd_elf_hppa_gen_reloc_type (bfd *abfd,
 992                               elf_hppa_reloc_type base_type,
 993                               int format,
 994                               unsigned int field,
 995                               int ignore ATTRIBUTE_UNUSED,
 996                               asymbol *sym ATTRIBUTE_UNUSED)
 997 {
 998   elf_hppa_reloc_type *finaltype;
 999   elf_hppa_reloc_type **final_types;
1000   bfd_size_type amt = sizeof (elf_hppa_reloc_type *) * 2;
1001
1002   /* Allocate slots for the BFD relocation.  */
1003   final_types = bfd_alloc (abfd, amt);
1004   if (final_types == NULL)
1005     return NULL;
1006
1007   /* Allocate space for the relocation itself.  */
1008   amt = sizeof (elf_hppa_reloc_type);
1009   finaltype = bfd_alloc (abfd, amt);
1010   if (finaltype == NULL)
1011     return NULL;
1012
1013   /* Some reasonable defaults.  */
1014   final_types[0] = finaltype;
1015   final_types[1] = NULL;
1016
1017   *finaltype = elf_hppa_reloc_final_type (abfd, base_type, format, field);
1018
1019   return final_types;
1020 }
1021
1022 /* Translate from an elf into field into a howto relocation pointer.  */
1023
1024 static void
1025 elf_hppa_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1026                         arelent *bfd_reloc,
1027                         Elf_Internal_Rela *elf_reloc)
1028 {
1029   BFD_ASSERT (ELF_R_TYPE (elf_reloc->r_info)
1030               < (unsigned int) R_PARISC_UNIMPLEMENTED);
1031   bfd_reloc->howto = &elf_hppa_howto_table[ELF_R_TYPE (elf_reloc->r_info)];
1032 }
1033
1034 /* Translate from an elf into field into a howto relocation pointer.  */
1035
1036 static void
1037 elf_hppa_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1038                             arelent *bfd_reloc,
1039                             Elf_Internal_Rela *elf_reloc)
1040 {
1041   BFD_ASSERT (ELF_R_TYPE (elf_reloc->r_info)
1042               < (unsigned int) R_PARISC_UNIMPLEMENTED);
1043   bfd_reloc->howto = &elf_hppa_howto_table[ELF_R_TYPE (elf_reloc->r_info)];
1044 }
1045
1046 /* Return the address of the howto table entry to perform the CODE
1047    relocation for an ARCH machine.  */
1048
1049 static reloc_howto_type *
1050 elf_hppa_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1051                             bfd_reloc_code_real_type code)
1052 {
1053   if ((int) code < (int) R_PARISC_UNIMPLEMENTED)
1054     {
1055       BFD_ASSERT ((int) elf_hppa_howto_table[(int) code].type == (int) code);
1056       return &elf_hppa_howto_table[(int) code];
1057     }
1058   return NULL;
1059 }
1060
1061 static reloc_howto_type *
1062 elf_hppa_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1063                             const char *r_name)
1064 {
1065   unsigned int i;
1066
1067   for (i = 0;
1068        i < sizeof (elf_hppa_howto_table) / sizeof (elf_hppa_howto_table[0]);
1069        i++)
1070     if (elf_hppa_howto_table[i].name != NULL
1071         && strcasecmp (elf_hppa_howto_table[i].name, r_name) == 0)
1072       return &elf_hppa_howto_table[i];
1073
1074   return NULL;
1075 }
1076
1077 /* Return TRUE if SYM represents a local label symbol.  */
1078
1079 static bfd_boolean
1080 elf_hppa_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1081 {
1082   if (name[0] == 'L' && name[1] == '$')
1083     return TRUE;
1084   return _bfd_elf_is_local_label_name (abfd, name);
1085 }
1086
1087 /* Set the correct type for an ELF section.  We do this by the
1088    section name, which is a hack, but ought to work.  */
1089
1090 static bfd_boolean
1091 elf_hppa_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1092 {
1093   const char *name;
1094
1095   name = bfd_get_section_name (abfd, sec);
1096
1097   if (strcmp (name, ".PARISC.unwind") == 0)
1098     {
1099       int indx;
1100       asection *asec;
1101
1102 #if ARCH_SIZE == 64
1103       hdr->sh_type = SHT_LOPROC + 1;
1104 #else
1105       hdr->sh_type = 1;
1106 #endif
1107       /* ?!? How are unwinds supposed to work for symbols in arbitrary
1108          sections?  Or what if we have multiple .text sections in a single
1109          .o file?  HP really messed up on this one.
1110
1111          Ugh.  We can not use elf_section_data (sec)->this_idx at this
1112          point because it is not initialized yet.
1113
1114          So we (gasp) recompute it here.  Hopefully nobody ever changes the
1115          way sections are numbered in elf.c!  */
1116       for (asec = abfd->sections, indx = 1; asec; asec = asec->next, indx++)
1117         {
1118           if (asec->name && strcmp (asec->name, ".text") == 0)
1119             {
1120               hdr->sh_info = indx;
1121               break;
1122             }
1123         }
1124
1125       /* I have no idea if this is really necessary or what it means.  */
1126       hdr->sh_entsize = 4;
1127     }
1128   return TRUE;
1129 }
1130
1131 static void
1132 elf_hppa_final_write_processing (bfd *abfd,
1133                                  bfd_boolean linker ATTRIBUTE_UNUSED)
1134 {
1135   int mach = bfd_get_mach (abfd);
1136
1137   elf_elfheader (abfd)->e_flags &= ~(EF_PARISC_ARCH | EF_PARISC_TRAPNIL
1138                                      | EF_PARISC_EXT | EF_PARISC_LSB
1139                                      | EF_PARISC_WIDE | EF_PARISC_NO_KABP
1140                                      | EF_PARISC_LAZYSWAP);
1141
1142   if (mach == 10)
1143     elf_elfheader (abfd)->e_flags |= EFA_PARISC_1_0;
1144   else if (mach == 11)
1145     elf_elfheader (abfd)->e_flags |= EFA_PARISC_1_1;
1146   else if (mach == 20)
1147     elf_elfheader (abfd)->e_flags |= EFA_PARISC_2_0;
1148   else if (mach == 25)
1149     elf_elfheader (abfd)->e_flags |= (EF_PARISC_WIDE
1150                                       | EFA_PARISC_2_0
1151                                       /* The GNU tools have trapped without
1152                                          option since 1993, so need to take
1153                                          a step backwards with the ELF
1154                                          based toolchains.  */
1155                                       | EF_PARISC_TRAPNIL);
1156 }
1157
1158 /* Comparison function for qsort to sort unwind section during a
1159    final link.  */
1160
1161 static int
1162 hppa_unwind_entry_compare (const void *a, const void *b)
1163 {
1164   const bfd_byte *ap, *bp;
1165   unsigned long av, bv;
1166
1167   ap = a;
1168   av = (unsigned long) ap[0] << 24;
1169   av |= (unsigned long) ap[1] << 16;
1170   av |= (unsigned long) ap[2] << 8;
1171   av |= (unsigned long) ap[3];
1172
1173   bp = b;
1174   bv = (unsigned long) bp[0] << 24;
1175   bv |= (unsigned long) bp[1] << 16;
1176   bv |= (unsigned long) bp[2] << 8;
1177   bv |= (unsigned long) bp[3];
1178
1179   return av < bv ? -1 : av > bv ? 1 : 0;
1180 }
1181
1182 static bfd_boolean
1183 elf_hppa_sort_unwind (bfd *abfd)
1184 {
1185   asection *s;
1186
1187   /* Magic section names, but this is much safer than having
1188      relocate_section remember where SEGREL32 relocs occurred.
1189      Consider what happens if someone inept creates a linker script
1190      that puts unwind information in .text.  */
1191   s = bfd_get_section_by_name (abfd, ".PARISC.unwind");
1192   if (s != NULL)
1193     {
1194       bfd_size_type size;
1195       bfd_byte *contents;
1196
1197       if (!bfd_malloc_and_get_section (abfd, s, &contents))
1198         return FALSE;
1199
1200       size = s->size;
1201       qsort (contents, (size_t) (size / 16), 16, hppa_unwind_entry_compare);
1202
1203       if (! bfd_set_section_contents (abfd, s, contents, (file_ptr) 0, size))
1204         return FALSE;
1205     }
1206
1207   return TRUE;
1208 }
1209
1210 /* What to do when ld finds relocations against symbols defined in
1211    discarded sections.  */
1212
1213 static unsigned int
1214 elf_hppa_action_discarded (asection *sec)
1215 {
1216   if (strcmp (".PARISC.unwind", sec->name) == 0)
1217     return 0;
1218
1219   return _bfd_elf_default_action_discarded (sec);
1220 }
1221
1222 #if ARCH_SIZE == 64
1223 /* Hook called by the linker routine which adds symbols from an object
1224    file.  HP's libraries define symbols with HP specific section
1225    indices, which we have to handle.  */
1226
1227 static bfd_boolean
1228 elf_hppa_add_symbol_hook (bfd *abfd,
1229                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
1230                           Elf_Internal_Sym *sym,
1231                           const char **namep ATTRIBUTE_UNUSED,
1232                           flagword *flagsp ATTRIBUTE_UNUSED,
1233                           asection **secp,
1234                           bfd_vma *valp)
1235 {
1236   unsigned int index = sym->st_shndx;
1237
1238   switch (index)
1239     {
1240     case SHN_PARISC_ANSI_COMMON:
1241       *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
1242       (*secp)->flags |= SEC_IS_COMMON;
1243       *valp = sym->st_size;
1244       break;
1245
1246     case SHN_PARISC_HUGE_COMMON:
1247       *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");
1248       (*secp)->flags |= SEC_IS_COMMON;
1249       *valp = sym->st_size;
1250       break;
1251     }
1252
1253   return TRUE;
1254 }
1255
1256 static bfd_boolean
1257 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
1258                                          void *data)
1259 {
1260   struct bfd_link_info *info = data;
1261
1262   if (h->root.type == bfd_link_hash_warning)
1263     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1264
1265   /* If we are not creating a shared library, and this symbol is
1266      referenced by a shared library but is not defined anywhere, then
1267      the generic code will warn that it is undefined.
1268
1269      This behavior is undesirable on HPs since the standard shared
1270      libraries contain references to undefined symbols.
1271
1272      So we twiddle the flags associated with such symbols so that they
1273      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1274
1275      Ultimately we should have better controls over the generic ELF BFD
1276      linker code.  */
1277   if (! info->relocatable
1278       && info->unresolved_syms_in_shared_libs != RM_IGNORE
1279       && h->root.type == bfd_link_hash_undefined
1280       && h->ref_dynamic
1281       && !h->ref_regular)
1282     {
1283       h->ref_dynamic = 0;
1284       h->pointer_equality_needed = 1;
1285     }
1286
1287   return TRUE;
1288 }
1289
1290 static bfd_boolean
1291 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
1292                                          void *data)
1293 {
1294   struct bfd_link_info *info = data;
1295
1296   if (h->root.type == bfd_link_hash_warning)
1297     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1298
1299   /* If we are not creating a shared library, and this symbol is
1300      referenced by a shared library but is not defined anywhere, then
1301      the generic code will warn that it is undefined.
1302
1303      This behavior is undesirable on HPs since the standard shared
1304      libraries contain references to undefined symbols.
1305
1306      So we twiddle the flags associated with such symbols so that they
1307      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
1308
1309      Ultimately we should have better controls over the generic ELF BFD
1310      linker code.  */
1311   if (! info->relocatable
1312       && info->unresolved_syms_in_shared_libs != RM_IGNORE
1313       && h->root.type == bfd_link_hash_undefined
1314       && !h->ref_dynamic
1315       && !h->ref_regular
1316       && h->pointer_equality_needed)
1317     {
1318       h->ref_dynamic = 1;
1319       h->pointer_equality_needed = 0;
1320     }
1321
1322   return TRUE;
1323 }
1324
1325 static bfd_boolean
1326 elf_hppa_is_dynamic_loader_symbol (const char *name)
1327 {
1328   return (! strcmp (name, "__CPU_REVISION")
1329           || ! strcmp (name, "__CPU_KEYBITS_1")
1330           || ! strcmp (name, "__SYSTEM_ID_D")
1331           || ! strcmp (name, "__FPU_MODEL")
1332           || ! strcmp (name, "__FPU_REVISION")
1333           || ! strcmp (name, "__ARGC")
1334           || ! strcmp (name, "__ARGV")
1335           || ! strcmp (name, "__ENVP")
1336           || ! strcmp (name, "__TLS_SIZE_D")
1337           || ! strcmp (name, "__LOAD_INFO")
1338           || ! strcmp (name, "__systab"));
1339 }
1340
1341 /* Record the lowest address for the data and text segments.  */
1342 static void
1343 elf_hppa_record_segment_addrs (bfd *abfd,
1344                                asection *section,
1345                                void *data)
1346 {
1347   struct elf64_hppa_link_hash_table *hppa_info = data;
1348
1349   if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1350     {
1351       bfd_vma value;
1352       Elf_Internal_Phdr *p;
1353
1354       p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
1355       BFD_ASSERT (p != NULL);
1356       value = p->p_vaddr;
1357
1358       if (section->flags & SEC_READONLY)
1359         {
1360           if (value < hppa_info->text_segment_base)
1361             hppa_info->text_segment_base = value;
1362         }
1363       else
1364         {
1365           if (value < hppa_info->data_segment_base)
1366             hppa_info->data_segment_base = value;
1367         }
1368     }
1369 }
1370
1371 /* Called after we have seen all the input files/sections, but before
1372    final symbol resolution and section placement has been determined.
1373
1374    We use this hook to (possibly) provide a value for __gp, then we
1375    fall back to the generic ELF final link routine.  */
1376
1377 static bfd_boolean
1378 elf_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
1379 {
1380   bfd_boolean retval;
1381   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1382
1383   if (! info->relocatable)
1384     {
1385       struct elf_link_hash_entry *gp;
1386       bfd_vma gp_val;
1387
1388       /* The linker script defines a value for __gp iff it was referenced
1389          by one of the objects being linked.  First try to find the symbol
1390          in the hash table.  If that fails, just compute the value __gp
1391          should have had.  */
1392       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
1393                                  FALSE, FALSE);
1394
1395       if (gp)
1396         {
1397
1398           /* Adjust the value of __gp as we may want to slide it into the
1399              .plt section so that the stubs can access PLT entries without
1400              using an addil sequence.  */
1401           gp->root.u.def.value += hppa_info->gp_offset;
1402
1403           gp_val = (gp->root.u.def.section->output_section->vma
1404                     + gp->root.u.def.section->output_offset
1405                     + gp->root.u.def.value);
1406         }
1407       else
1408         {
1409           asection *sec;
1410
1411           /* First look for a .plt section.  If found, then __gp is the
1412              address of the .plt + gp_offset.
1413
1414              If no .plt is found, then look for .dlt, .opd and .data (in
1415              that order) and set __gp to the base address of whichever
1416              section is found first.  */
1417
1418           sec = hppa_info->plt_sec;
1419           if (sec && ! (sec->flags & SEC_EXCLUDE))
1420             gp_val = (sec->output_offset
1421                       + sec->output_section->vma
1422                       + hppa_info->gp_offset);
1423           else
1424             {
1425               sec = hppa_info->dlt_sec;
1426               if (!sec || (sec->flags & SEC_EXCLUDE))
1427                 sec = hppa_info->opd_sec;
1428               if (!sec || (sec->flags & SEC_EXCLUDE))
1429                 sec = bfd_get_section_by_name (abfd, ".data");
1430               if (!sec || (sec->flags & SEC_EXCLUDE))
1431                 gp_val = 0;
1432               else
1433                 gp_val = sec->output_offset + sec->output_section->vma;
1434             }
1435         }
1436
1437       /* Install whatever value we found/computed for __gp.  */
1438       _bfd_set_gp_value (abfd, gp_val);
1439     }
1440
1441   /* We need to know the base of the text and data segments so that we
1442      can perform SEGREL relocations.  We will record the base addresses
1443      when we encounter the first SEGREL relocation.  */
1444   hppa_info->text_segment_base = (bfd_vma)-1;
1445   hppa_info->data_segment_base = (bfd_vma)-1;
1446
1447   /* HP's shared libraries have references to symbols that are not
1448      defined anywhere.  The generic ELF BFD linker code will complain
1449      about such symbols.
1450
1451      So we detect the losing case and arrange for the flags on the symbol
1452      to indicate that it was never referenced.  This keeps the generic
1453      ELF BFD link code happy and appears to not create any secondary
1454      problems.  Ultimately we need a way to control the behavior of the
1455      generic ELF BFD link code better.  */
1456   elf_link_hash_traverse (elf_hash_table (info),
1457                           elf_hppa_unmark_useless_dynamic_symbols,
1458                           info);
1459
1460   /* Invoke the regular ELF backend linker to do all the work.  */
1461   retval = bfd_elf_final_link (abfd, info);
1462
1463   elf_link_hash_traverse (elf_hash_table (info),
1464                           elf_hppa_remark_useless_dynamic_symbols,
1465                           info);
1466
1467   /* If we're producing a final executable, sort the contents of the
1468      unwind section. */
1469   if (retval)
1470     retval = elf_hppa_sort_unwind (abfd);
1471
1472   return retval;
1473 }
1474
1475 /* Relocate the given INSN.  VALUE should be the actual value we want
1476    to insert into the instruction, ie by this point we should not be
1477    concerned with computing an offset relative to the DLT, PC, etc.
1478    Instead this routine is meant to handle the bit manipulations needed
1479    to insert the relocation into the given instruction.  */
1480
1481 static int
1482 elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)
1483 {
1484   switch (r_type)
1485     {
1486     /* This is any 22 bit branch.  In PA2.0 syntax it corresponds to
1487        the "B" instruction.  */
1488     case R_PARISC_PCREL22F:
1489     case R_PARISC_PCREL22C:
1490       return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
1491
1492       /* This is any 12 bit branch.  */
1493     case R_PARISC_PCREL12F:
1494       return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
1495
1496     /* This is any 17 bit branch.  In PA2.0 syntax it also corresponds
1497        to the "B" instruction as well as BE.  */
1498     case R_PARISC_PCREL17F:
1499     case R_PARISC_DIR17F:
1500     case R_PARISC_DIR17R:
1501     case R_PARISC_PCREL17C:
1502     case R_PARISC_PCREL17R:
1503       return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
1504
1505     /* ADDIL or LDIL instructions.  */
1506     case R_PARISC_DLTREL21L:
1507     case R_PARISC_DLTIND21L:
1508     case R_PARISC_LTOFF_FPTR21L:
1509     case R_PARISC_PCREL21L:
1510     case R_PARISC_LTOFF_TP21L:
1511     case R_PARISC_DPREL21L:
1512     case R_PARISC_PLTOFF21L:
1513     case R_PARISC_DIR21L:
1514       return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
1515
1516     /* LDO and integer loads/stores with 14 bit displacements.  */
1517     case R_PARISC_DLTREL14R:
1518     case R_PARISC_DLTREL14F:
1519     case R_PARISC_DLTIND14R:
1520     case R_PARISC_DLTIND14F:
1521     case R_PARISC_LTOFF_FPTR14R:
1522     case R_PARISC_PCREL14R:
1523     case R_PARISC_PCREL14F:
1524     case R_PARISC_LTOFF_TP14R:
1525     case R_PARISC_LTOFF_TP14F:
1526     case R_PARISC_DPREL14R:
1527     case R_PARISC_DPREL14F:
1528     case R_PARISC_PLTOFF14R:
1529     case R_PARISC_PLTOFF14F:
1530     case R_PARISC_DIR14R:
1531     case R_PARISC_DIR14F:
1532       return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
1533
1534     /* PA2.0W LDO and integer loads/stores with 16 bit displacements.  */
1535     case R_PARISC_LTOFF_FPTR16F:
1536     case R_PARISC_PCREL16F:
1537     case R_PARISC_LTOFF_TP16F:
1538     case R_PARISC_GPREL16F:
1539     case R_PARISC_PLTOFF16F:
1540     case R_PARISC_DIR16F:
1541     case R_PARISC_LTOFF16F:
1542       return (insn & ~0xffff) | re_assemble_16 (sym_value);
1543
1544     /* Doubleword loads and stores with a 14 bit displacement.  */
1545     case R_PARISC_DLTREL14DR:
1546     case R_PARISC_DLTIND14DR:
1547     case R_PARISC_LTOFF_FPTR14DR:
1548     case R_PARISC_LTOFF_FPTR16DF:
1549     case R_PARISC_PCREL14DR:
1550     case R_PARISC_PCREL16DF:
1551     case R_PARISC_LTOFF_TP14DR:
1552     case R_PARISC_LTOFF_TP16DF:
1553     case R_PARISC_DPREL14DR:
1554     case R_PARISC_GPREL16DF:
1555     case R_PARISC_PLTOFF14DR:
1556     case R_PARISC_PLTOFF16DF:
1557     case R_PARISC_DIR14DR:
1558     case R_PARISC_DIR16DF:
1559     case R_PARISC_LTOFF16DF:
1560       return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
1561                                  | ((sym_value & 0x1ff8) << 1));
1562
1563     /* Floating point single word load/store instructions.  */
1564     case R_PARISC_DLTREL14WR:
1565     case R_PARISC_DLTIND14WR:
1566     case R_PARISC_LTOFF_FPTR14WR:
1567     case R_PARISC_LTOFF_FPTR16WF:
1568     case R_PARISC_PCREL14WR:
1569     case R_PARISC_PCREL16WF:
1570     case R_PARISC_LTOFF_TP14WR:
1571     case R_PARISC_LTOFF_TP16WF:
1572     case R_PARISC_DPREL14WR:
1573     case R_PARISC_GPREL16WF:
1574     case R_PARISC_PLTOFF14WR:
1575     case R_PARISC_PLTOFF16WF:
1576     case R_PARISC_DIR16WF:
1577     case R_PARISC_DIR14WR:
1578     case R_PARISC_LTOFF16WF:
1579       return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
1580                                  | ((sym_value & 0x1ffc) << 1));
1581
1582     default:
1583       return insn;
1584     }
1585 }
1586
1587 /* Compute the value for a relocation (REL) during a final link stage,
1588    then insert the value into the proper location in CONTENTS.
1589
1590    VALUE is a tentative value for the relocation and may be overridden
1591    and modified here based on the specific relocation to be performed.
1592
1593    For example we do conversions for PC-relative branches in this routine
1594    or redirection of calls to external routines to stubs.
1595
1596    The work of actually applying the relocation is left to a helper
1597    routine in an attempt to reduce the complexity and size of this
1598    function.  */
1599
1600 static bfd_reloc_status_type
1601 elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,
1602                               bfd *input_bfd,
1603                               bfd *output_bfd,
1604                               asection *input_section,
1605                               bfd_byte *contents,
1606                               bfd_vma value,
1607                               struct bfd_link_info *info,
1608                               asection *sym_sec,
1609                               struct elf_link_hash_entry *h,
1610                               struct elf64_hppa_dyn_hash_entry *dyn_h)
1611 {
1612   int insn;
1613   bfd_vma max_branch_offset = 0;
1614   bfd_vma offset = rel->r_offset;
1615   bfd_signed_vma addend = rel->r_addend;
1616   reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
1617   unsigned int r_type = howto->type;
1618   bfd_byte *hit_data = contents + offset;
1619   struct elf64_hppa_link_hash_table *hppa_info = elf64_hppa_hash_table (info);
1620
1621   insn = bfd_get_32 (input_bfd, hit_data);
1622
1623   switch (r_type)
1624     {
1625     case R_PARISC_NONE:
1626       break;
1627
1628     /* Basic function call support.
1629
1630        Note for a call to a function defined in another dynamic library
1631        we want to redirect the call to a stub.  */
1632
1633     /* PC relative relocs without an implicit offset.  */
1634     case R_PARISC_PCREL21L:
1635     case R_PARISC_PCREL14R:
1636     case R_PARISC_PCREL14F:
1637     case R_PARISC_PCREL14WR:
1638     case R_PARISC_PCREL14DR:
1639     case R_PARISC_PCREL16F:
1640     case R_PARISC_PCREL16WF:
1641     case R_PARISC_PCREL16DF:
1642       {
1643         /* If this is a call to a function defined in another dynamic
1644            library, then redirect the call to the local stub for this
1645            function.  */
1646         if (sym_sec == NULL || sym_sec->output_section == NULL)
1647           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1648                    + hppa_info->stub_sec->output_section->vma);
1649
1650         /* Turn VALUE into a proper PC relative address.  */
1651         value -= (offset + input_section->output_offset
1652                   + input_section->output_section->vma);
1653
1654         /* Adjust for any field selectors.  */
1655         if (r_type == R_PARISC_PCREL21L)
1656           value = hppa_field_adjust (value, -8 + addend, e_lsel);
1657         else if (r_type == R_PARISC_PCREL14F
1658                  || r_type == R_PARISC_PCREL16F
1659                  || r_type == R_PARISC_PCREL16WF
1660                  || r_type == R_PARISC_PCREL16DF)
1661           value = hppa_field_adjust (value, -8 + addend, e_fsel);
1662         else
1663           value = hppa_field_adjust (value, -8 + addend, e_rsel);
1664
1665         /* Apply the relocation to the given instruction.  */
1666         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1667         break;
1668       }
1669
1670     case R_PARISC_PCREL12F:
1671     case R_PARISC_PCREL22F:
1672     case R_PARISC_PCREL17F:
1673     case R_PARISC_PCREL22C:
1674     case R_PARISC_PCREL17C:
1675     case R_PARISC_PCREL17R:
1676       {
1677         /* If this is a call to a function defined in another dynamic
1678            library, then redirect the call to the local stub for this
1679            function.  */
1680         if (sym_sec == NULL || sym_sec->output_section == NULL)
1681           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
1682                    + hppa_info->stub_sec->output_section->vma);
1683
1684         /* Turn VALUE into a proper PC relative address.  */
1685         value -= (offset + input_section->output_offset
1686                   + input_section->output_section->vma);
1687         addend -= 8;
1688
1689         if (r_type == (unsigned int) R_PARISC_PCREL22F)
1690           max_branch_offset = (1 << (22-1)) << 2;
1691         else if (r_type == (unsigned int) R_PARISC_PCREL17F)
1692           max_branch_offset = (1 << (17-1)) << 2;
1693         else if (r_type == (unsigned int) R_PARISC_PCREL12F)
1694           max_branch_offset = (1 << (12-1)) << 2;
1695
1696         /* Make sure we can reach the branch target.  */
1697         if (max_branch_offset != 0
1698             && value + addend + max_branch_offset >= 2*max_branch_offset)
1699           {
1700             (*_bfd_error_handler)
1701               (_("%B(%A+0x%lx): cannot reach %s"),
1702               input_bfd,
1703               input_section,
1704               offset,
1705               h->root.root.string);
1706             bfd_set_error (bfd_error_bad_value);
1707             return bfd_reloc_notsupported;
1708           }
1709
1710         /* Adjust for any field selectors.  */
1711         if (r_type == R_PARISC_PCREL17R)
1712           value = hppa_field_adjust (value, addend, e_rsel);
1713         else
1714           value = hppa_field_adjust (value, addend, e_fsel);
1715
1716         /* All branches are implicitly shifted by 2 places.  */
1717         value >>= 2;
1718
1719         /* Apply the relocation to the given instruction.  */
1720         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1721         break;
1722       }
1723
1724     /* Indirect references to data through the DLT.  */
1725     case R_PARISC_DLTIND14R:
1726     case R_PARISC_DLTIND14F:
1727     case R_PARISC_DLTIND14DR:
1728     case R_PARISC_DLTIND14WR:
1729     case R_PARISC_DLTIND21L:
1730     case R_PARISC_LTOFF_FPTR14R:
1731     case R_PARISC_LTOFF_FPTR14DR:
1732     case R_PARISC_LTOFF_FPTR14WR:
1733     case R_PARISC_LTOFF_FPTR21L:
1734     case R_PARISC_LTOFF_FPTR16F:
1735     case R_PARISC_LTOFF_FPTR16WF:
1736     case R_PARISC_LTOFF_FPTR16DF:
1737     case R_PARISC_LTOFF_TP21L:
1738     case R_PARISC_LTOFF_TP14R:
1739     case R_PARISC_LTOFF_TP14F:
1740     case R_PARISC_LTOFF_TP14WR:
1741     case R_PARISC_LTOFF_TP14DR:
1742     case R_PARISC_LTOFF_TP16F:
1743     case R_PARISC_LTOFF_TP16WF:
1744     case R_PARISC_LTOFF_TP16DF:
1745     case R_PARISC_LTOFF16F:
1746     case R_PARISC_LTOFF16WF:
1747     case R_PARISC_LTOFF16DF:
1748       {
1749         /* If this relocation was against a local symbol, then we still
1750            have not set up the DLT entry (it's not convenient to do so
1751            in the "finalize_dlt" routine because it is difficult to get
1752            to the local symbol's value).
1753
1754            So, if this is a local symbol (h == NULL), then we need to
1755            fill in its DLT entry.
1756
1757            Similarly we may still need to set up an entry in .opd for
1758            a local function which had its address taken.  */
1759         if (dyn_h->h == NULL)
1760           {
1761             /* Now do .opd creation if needed.  */
1762             if (r_type == R_PARISC_LTOFF_FPTR14R
1763                 || r_type == R_PARISC_LTOFF_FPTR14DR
1764                 || r_type == R_PARISC_LTOFF_FPTR14WR
1765                 || r_type == R_PARISC_LTOFF_FPTR21L
1766                 || r_type == R_PARISC_LTOFF_FPTR16F
1767                 || r_type == R_PARISC_LTOFF_FPTR16WF
1768                 || r_type == R_PARISC_LTOFF_FPTR16DF)
1769               {
1770                 /* The first two words of an .opd entry are zero.  */
1771                 memset (hppa_info->opd_sec->contents + dyn_h->opd_offset,
1772                         0, 16);
1773
1774                 /* The next word is the address of the function.  */
1775                 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1776                             (hppa_info->opd_sec->contents
1777                              + dyn_h->opd_offset + 16));
1778
1779                 /* The last word is our local __gp value.  */
1780                 value = _bfd_get_gp_value
1781                           (hppa_info->opd_sec->output_section->owner);
1782                 bfd_put_64 (hppa_info->opd_sec->owner, value,
1783                             (hppa_info->opd_sec->contents
1784                              + dyn_h->opd_offset + 24));
1785
1786                 /* The DLT value is the address of the .opd entry.  */
1787                 value = (dyn_h->opd_offset
1788                          + hppa_info->opd_sec->output_offset
1789                          + hppa_info->opd_sec->output_section->vma);
1790                 addend = 0;
1791               }
1792
1793             bfd_put_64 (hppa_info->dlt_sec->owner,
1794                         value + addend,
1795                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1796           }
1797
1798         /* We want the value of the DLT offset for this symbol, not
1799            the symbol's actual address.  Note that __gp may not point
1800            to the start of the DLT, so we have to compute the absolute
1801            address, then subtract out the value of __gp.  */
1802         value = (dyn_h->dlt_offset
1803                  + hppa_info->dlt_sec->output_offset
1804                  + hppa_info->dlt_sec->output_section->vma);
1805         value -= _bfd_get_gp_value (output_bfd);
1806
1807         /* All DLTIND relocations are basically the same at this point,
1808            except that we need different field selectors for the 21bit
1809            version vs the 14bit versions.  */
1810         if (r_type == R_PARISC_DLTIND21L
1811             || r_type == R_PARISC_LTOFF_FPTR21L
1812             || r_type == R_PARISC_LTOFF_TP21L)
1813           value = hppa_field_adjust (value, 0, e_lsel);
1814         else if (r_type == R_PARISC_DLTIND14F
1815                  || r_type == R_PARISC_LTOFF_FPTR16F
1816                  || r_type == R_PARISC_LTOFF_FPTR16WF
1817                  || r_type == R_PARISC_LTOFF_FPTR16DF
1818                  || r_type == R_PARISC_LTOFF16F
1819                  || r_type == R_PARISC_LTOFF16DF
1820                  || r_type == R_PARISC_LTOFF16WF
1821                  || r_type == R_PARISC_LTOFF_TP16F
1822                  || r_type == R_PARISC_LTOFF_TP16WF
1823                  || r_type == R_PARISC_LTOFF_TP16DF)
1824           value = hppa_field_adjust (value, 0, e_fsel);
1825         else
1826           value = hppa_field_adjust (value, 0, e_rsel);
1827
1828         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1829         break;
1830       }
1831
1832     case R_PARISC_DLTREL14R:
1833     case R_PARISC_DLTREL14F:
1834     case R_PARISC_DLTREL14DR:
1835     case R_PARISC_DLTREL14WR:
1836     case R_PARISC_DLTREL21L:
1837     case R_PARISC_DPREL21L:
1838     case R_PARISC_DPREL14WR:
1839     case R_PARISC_DPREL14DR:
1840     case R_PARISC_DPREL14R:
1841     case R_PARISC_DPREL14F:
1842     case R_PARISC_GPREL16F:
1843     case R_PARISC_GPREL16WF:
1844     case R_PARISC_GPREL16DF:
1845       {
1846         /* Subtract out the global pointer value to make value a DLT
1847            relative address.  */
1848         value -= _bfd_get_gp_value (output_bfd);
1849
1850         /* All DLTREL relocations are basically the same at this point,
1851            except that we need different field selectors for the 21bit
1852            version vs the 14bit versions.  */
1853         if (r_type == R_PARISC_DLTREL21L
1854             || r_type == R_PARISC_DPREL21L)
1855           value = hppa_field_adjust (value, addend, e_lrsel);
1856         else if (r_type == R_PARISC_DLTREL14F
1857                  || r_type == R_PARISC_DPREL14F
1858                  || r_type == R_PARISC_GPREL16F
1859                  || r_type == R_PARISC_GPREL16WF
1860                  || r_type == R_PARISC_GPREL16DF)
1861           value = hppa_field_adjust (value, addend, e_fsel);
1862         else
1863           value = hppa_field_adjust (value, addend, e_rrsel);
1864
1865         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1866         break;
1867       }
1868
1869     case R_PARISC_DIR21L:
1870     case R_PARISC_DIR17R:
1871     case R_PARISC_DIR17F:
1872     case R_PARISC_DIR14R:
1873     case R_PARISC_DIR14F:
1874     case R_PARISC_DIR14WR:
1875     case R_PARISC_DIR14DR:
1876     case R_PARISC_DIR16F:
1877     case R_PARISC_DIR16WF:
1878     case R_PARISC_DIR16DF:
1879       {
1880         /* All DIR relocations are basically the same at this point,
1881            except that branch offsets need to be divided by four, and
1882            we need different field selectors.  Note that we don't
1883            redirect absolute calls to local stubs.  */
1884
1885         if (r_type == R_PARISC_DIR21L)
1886           value = hppa_field_adjust (value, addend, e_lrsel);
1887         else if (r_type == R_PARISC_DIR17F
1888                  || r_type == R_PARISC_DIR16F
1889                  || r_type == R_PARISC_DIR16WF
1890                  || r_type == R_PARISC_DIR16DF
1891                  || r_type == R_PARISC_DIR14F)
1892           value = hppa_field_adjust (value, addend, e_fsel);
1893         else
1894           value = hppa_field_adjust (value, addend, e_rrsel);
1895
1896         if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
1897           /* All branches are implicitly shifted by 2 places.  */
1898           value >>= 2;
1899
1900         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1901         break;
1902       }
1903
1904     case R_PARISC_PLTOFF21L:
1905     case R_PARISC_PLTOFF14R:
1906     case R_PARISC_PLTOFF14F:
1907     case R_PARISC_PLTOFF14WR:
1908     case R_PARISC_PLTOFF14DR:
1909     case R_PARISC_PLTOFF16F:
1910     case R_PARISC_PLTOFF16WF:
1911     case R_PARISC_PLTOFF16DF:
1912       {
1913         /* We want the value of the PLT offset for this symbol, not
1914            the symbol's actual address.  Note that __gp may not point
1915            to the start of the DLT, so we have to compute the absolute
1916            address, then subtract out the value of __gp.  */
1917         value = (dyn_h->plt_offset
1918                  + hppa_info->plt_sec->output_offset
1919                  + hppa_info->plt_sec->output_section->vma);
1920         value -= _bfd_get_gp_value (output_bfd);
1921
1922         /* All PLTOFF relocations are basically the same at this point,
1923            except that we need different field selectors for the 21bit
1924            version vs the 14bit versions.  */
1925         if (r_type == R_PARISC_PLTOFF21L)
1926           value = hppa_field_adjust (value, addend, e_lrsel);
1927         else if (r_type == R_PARISC_PLTOFF14F
1928                  || r_type == R_PARISC_PLTOFF16F
1929                  || r_type == R_PARISC_PLTOFF16WF
1930                  || r_type == R_PARISC_PLTOFF16DF)
1931           value = hppa_field_adjust (value, addend, e_fsel);
1932         else
1933           value = hppa_field_adjust (value, addend, e_rrsel);
1934
1935         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
1936         break;
1937       }
1938
1939     case R_PARISC_LTOFF_FPTR32:
1940       {
1941         /* We may still need to create the FPTR itself if it was for
1942            a local symbol.  */
1943         if (dyn_h->h == NULL)
1944           {
1945             /* The first two words of an .opd entry are zero.  */
1946             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1947
1948             /* The next word is the address of the function.  */
1949             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1950                         (hppa_info->opd_sec->contents
1951                          + dyn_h->opd_offset + 16));
1952
1953             /* The last word is our local __gp value.  */
1954             value = _bfd_get_gp_value
1955                       (hppa_info->opd_sec->output_section->owner);
1956             bfd_put_64 (hppa_info->opd_sec->owner, value,
1957                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
1958
1959             /* The DLT value is the address of the .opd entry.  */
1960             value = (dyn_h->opd_offset
1961                      + hppa_info->opd_sec->output_offset
1962                      + hppa_info->opd_sec->output_section->vma);
1963
1964             bfd_put_64 (hppa_info->dlt_sec->owner,
1965                         value,
1966                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
1967           }
1968
1969         /* We want the value of the DLT offset for this symbol, not
1970            the symbol's actual address.  Note that __gp may not point
1971            to the start of the DLT, so we have to compute the absolute
1972            address, then subtract out the value of __gp.  */
1973         value = (dyn_h->dlt_offset
1974                  + hppa_info->dlt_sec->output_offset
1975                  + hppa_info->dlt_sec->output_section->vma);
1976         value -= _bfd_get_gp_value (output_bfd);
1977         bfd_put_32 (input_bfd, value, hit_data);
1978         return bfd_reloc_ok;
1979       }
1980
1981     case R_PARISC_LTOFF_FPTR64:
1982     case R_PARISC_LTOFF_TP64:
1983       {
1984         /* We may still need to create the FPTR itself if it was for
1985            a local symbol.  */
1986         if (dyn_h->h == NULL && r_type == R_PARISC_LTOFF_FPTR64)
1987           {
1988             /* The first two words of an .opd entry are zero.  */
1989             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
1990
1991             /* The next word is the address of the function.  */
1992             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
1993                         (hppa_info->opd_sec->contents
1994                          + dyn_h->opd_offset + 16));
1995
1996             /* The last word is our local __gp value.  */
1997             value = _bfd_get_gp_value
1998                       (hppa_info->opd_sec->output_section->owner);
1999             bfd_put_64 (hppa_info->opd_sec->owner, value,
2000                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
2001
2002             /* The DLT value is the address of the .opd entry.  */
2003             value = (dyn_h->opd_offset
2004                      + hppa_info->opd_sec->output_offset
2005                      + hppa_info->opd_sec->output_section->vma);
2006
2007             bfd_put_64 (hppa_info->dlt_sec->owner,
2008                         value,
2009                         hppa_info->dlt_sec->contents + dyn_h->dlt_offset);
2010           }
2011
2012         /* We want the value of the DLT offset for this symbol, not
2013            the symbol's actual address.  Note that __gp may not point
2014            to the start of the DLT, so we have to compute the absolute
2015            address, then subtract out the value of __gp.  */
2016         value = (dyn_h->dlt_offset
2017                  + hppa_info->dlt_sec->output_offset
2018                  + hppa_info->dlt_sec->output_section->vma);
2019         value -= _bfd_get_gp_value (output_bfd);
2020         bfd_put_64 (input_bfd, value, hit_data);
2021         return bfd_reloc_ok;
2022       }
2023
2024     case R_PARISC_DIR32:
2025       bfd_put_32 (input_bfd, value + addend, hit_data);
2026       return bfd_reloc_ok;
2027
2028     case R_PARISC_DIR64:
2029       bfd_put_64 (input_bfd, value + addend, hit_data);
2030       return bfd_reloc_ok;
2031
2032     case R_PARISC_GPREL64:
2033       /* Subtract out the global pointer value to make value a DLT
2034          relative address.  */
2035       value -= _bfd_get_gp_value (output_bfd);
2036
2037       bfd_put_64 (input_bfd, value + addend, hit_data);
2038       return bfd_reloc_ok;
2039
2040     case R_PARISC_LTOFF64:
2041         /* We want the value of the DLT offset for this symbol, not
2042            the symbol's actual address.  Note that __gp may not point
2043            to the start of the DLT, so we have to compute the absolute
2044            address, then subtract out the value of __gp.  */
2045       value = (dyn_h->dlt_offset
2046                + hppa_info->dlt_sec->output_offset
2047                + hppa_info->dlt_sec->output_section->vma);
2048       value -= _bfd_get_gp_value (output_bfd);
2049
2050       bfd_put_64 (input_bfd, value + addend, hit_data);
2051       return bfd_reloc_ok;
2052
2053     case R_PARISC_PCREL32:
2054       {
2055         /* If this is a call to a function defined in another dynamic
2056            library, then redirect the call to the local stub for this
2057            function.  */
2058         if (sym_sec == NULL || sym_sec->output_section == NULL)
2059           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
2060                    + hppa_info->stub_sec->output_section->vma);
2061
2062         /* Turn VALUE into a proper PC relative address.  */
2063         value -= (offset + input_section->output_offset
2064                   + input_section->output_section->vma);
2065
2066         value += addend;
2067         value -= 8;
2068         bfd_put_32 (input_bfd, value, hit_data);
2069         return bfd_reloc_ok;
2070       }
2071
2072     case R_PARISC_PCREL64:
2073       {
2074         /* If this is a call to a function defined in another dynamic
2075            library, then redirect the call to the local stub for this
2076            function.  */
2077         if (sym_sec == NULL || sym_sec->output_section == NULL)
2078           value = (dyn_h->stub_offset + hppa_info->stub_sec->output_offset
2079                    + hppa_info->stub_sec->output_section->vma);
2080
2081         /* Turn VALUE into a proper PC relative address.  */
2082         value -= (offset + input_section->output_offset
2083                   + input_section->output_section->vma);
2084
2085         value += addend;
2086         value -= 8;
2087         bfd_put_64 (input_bfd, value, hit_data);
2088         return bfd_reloc_ok;
2089       }
2090
2091     case R_PARISC_FPTR64:
2092       {
2093         /* We may still need to create the FPTR itself if it was for
2094            a local symbol.  */
2095         if (dyn_h->h == NULL)
2096           {
2097             /* The first two words of an .opd entry are zero.  */
2098             memset (hppa_info->opd_sec->contents + dyn_h->opd_offset, 0, 16);
2099
2100             /* The next word is the address of the function.  */
2101             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
2102                         (hppa_info->opd_sec->contents
2103                          + dyn_h->opd_offset + 16));
2104
2105             /* The last word is our local __gp value.  */
2106             value = _bfd_get_gp_value
2107                       (hppa_info->opd_sec->output_section->owner);
2108             bfd_put_64 (hppa_info->opd_sec->owner, value,
2109                         hppa_info->opd_sec->contents + dyn_h->opd_offset + 24);
2110           }
2111
2112         if (dyn_h->want_opd)
2113           /* We want the value of the OPD offset for this symbol.  */
2114           value = (dyn_h->opd_offset
2115                    + hppa_info->opd_sec->output_offset
2116                    + hppa_info->opd_sec->output_section->vma);
2117         else
2118           /* We want the address of the symbol.  */
2119           value += addend;
2120
2121         bfd_put_64 (input_bfd, value, hit_data);
2122         return bfd_reloc_ok;
2123       }
2124
2125     case R_PARISC_SECREL32:
2126       bfd_put_32 (input_bfd,
2127                   value + addend - sym_sec->output_section->vma,
2128                   hit_data);
2129       return bfd_reloc_ok;
2130
2131     case R_PARISC_SEGREL32:
2132     case R_PARISC_SEGREL64:
2133       {
2134         /* If this is the first SEGREL relocation, then initialize
2135            the segment base values.  */
2136         if (hppa_info->text_segment_base == (bfd_vma) -1)
2137           bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
2138                                  hppa_info);
2139
2140         /* VALUE holds the absolute address.  We want to include the
2141            addend, then turn it into a segment relative address.
2142
2143            The segment is derived from SYM_SEC.  We assume that there are
2144            only two segments of note in the resulting executable/shlib.
2145            A readonly segment (.text) and a readwrite segment (.data).  */
2146         value += addend;
2147
2148         if (sym_sec->flags & SEC_CODE)
2149           value -= hppa_info->text_segment_base;
2150         else
2151           value -= hppa_info->data_segment_base;
2152
2153         if (r_type == R_PARISC_SEGREL32)
2154           bfd_put_32 (input_bfd, value, hit_data);
2155         else
2156           bfd_put_64 (input_bfd, value, hit_data);
2157         return bfd_reloc_ok;
2158       }
2159
2160     /* Something we don't know how to handle.  */
2161     default:
2162       return bfd_reloc_notsupported;
2163     }
2164
2165   /* Update the instruction word.  */
2166   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
2167   return bfd_reloc_ok;
2168 }
2169
2170 /* Relocate an HPPA ELF section.  */
2171
2172 static bfd_boolean
2173 elf_hppa_relocate_section (bfd *output_bfd,
2174                            struct bfd_link_info *info,
2175                            bfd *input_bfd,
2176                            asection *input_section,
2177                            bfd_byte *contents,
2178                            Elf_Internal_Rela *relocs,
2179                            Elf_Internal_Sym *local_syms,
2180                            asection **local_sections)
2181 {
2182   Elf_Internal_Shdr *symtab_hdr;
2183   Elf_Internal_Rela *rel;
2184   Elf_Internal_Rela *relend;
2185   struct elf64_hppa_link_hash_table *hppa_info;
2186
2187   hppa_info = elf64_hppa_hash_table (info);
2188   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2189
2190   rel = relocs;
2191   relend = relocs + input_section->reloc_count;
2192   for (; rel < relend; rel++)
2193     {
2194       int r_type;
2195       reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
2196       unsigned long r_symndx;
2197       struct elf_link_hash_entry *h;
2198       Elf_Internal_Sym *sym;
2199       asection *sym_sec;
2200       bfd_vma relocation;
2201       bfd_reloc_status_type r;
2202       const char *dyn_name;
2203       char *dynh_buf = NULL;
2204       size_t dynh_buflen = 0;
2205       struct elf64_hppa_dyn_hash_entry *dyn_h = NULL;
2206
2207       r_type = ELF_R_TYPE (rel->r_info);
2208       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
2209         {
2210           bfd_set_error (bfd_error_bad_value);
2211           return FALSE;
2212         }
2213
2214       /* This is a final link.  */
2215       r_symndx = ELF_R_SYM (rel->r_info);
2216       h = NULL;
2217       sym = NULL;
2218       sym_sec = NULL;
2219       if (r_symndx < symtab_hdr->sh_info)
2220         {
2221           /* This is a local symbol.  */
2222           sym = local_syms + r_symndx;
2223           sym_sec = local_sections[r_symndx];
2224           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
2225
2226           /* If this symbol has an entry in the PA64 dynamic hash
2227              table, then get it.  */
2228           dyn_name = get_dyn_name (input_bfd, h, rel,
2229                                    &dynh_buf, &dynh_buflen);
2230           dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
2231                                               dyn_name, FALSE, FALSE);
2232
2233         }
2234       else
2235         {
2236           /* This is not a local symbol.  */
2237           long indx;
2238
2239           relocation = 0;
2240           indx = r_symndx - symtab_hdr->sh_info;
2241           h = elf_sym_hashes (input_bfd)[indx];
2242           while (h->root.type == bfd_link_hash_indirect
2243                  || h->root.type == bfd_link_hash_warning)
2244             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2245           if (h->root.type == bfd_link_hash_defined
2246               || h->root.type == bfd_link_hash_defweak)
2247             {
2248               sym_sec = h->root.u.def.section;
2249
2250               /* If this symbol has an entry in the PA64 dynamic hash
2251                  table, then get it.  */
2252               dyn_name = get_dyn_name (input_bfd, h, rel,
2253                                        &dynh_buf, &dynh_buflen);
2254               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
2255                                                   dyn_name, FALSE, FALSE);
2256
2257               /* If we have a relocation against a symbol defined in a
2258                  shared library and we have not created an entry in the
2259                  PA64 dynamic symbol hash table for it, then we lose.  */
2260               if (!info->relocatable
2261                   && sym_sec->output_section == NULL && dyn_h == NULL)
2262                 {
2263                   (*_bfd_error_handler)
2264                     (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2265                      input_bfd,
2266                      input_section,
2267                      (long) rel->r_offset,
2268                      howto->name,
2269                      h->root.root.string);
2270                 }
2271               else if (sym_sec->output_section)
2272                 relocation = (h->root.u.def.value
2273                               + sym_sec->output_offset
2274                               + sym_sec->output_section->vma);
2275             }
2276           else if (info->unresolved_syms_in_objects == RM_IGNORE
2277                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2278             {
2279               /* If this symbol has an entry in the PA64 dynamic hash
2280                  table, then get it.  */
2281               dyn_name = get_dyn_name (input_bfd, h, rel,
2282                                        &dynh_buf, &dynh_buflen);
2283               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
2284                                                   dyn_name, FALSE, FALSE);
2285
2286               if (!info->relocatable && dyn_h == NULL)
2287                 {
2288                   (*_bfd_error_handler)
2289                     (_("%B(%A): warning: unresolvable relocation against symbol `%s'"),
2290                      input_bfd, input_section, h->root.root.string);
2291                 }
2292             }
2293           else if (h->root.type == bfd_link_hash_undefweak)
2294             {
2295               dyn_name = get_dyn_name (input_bfd, h, rel,
2296                                        &dynh_buf, &dynh_buflen);
2297               dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
2298                                                   dyn_name, FALSE, FALSE);
2299
2300               if (!info->relocatable && dyn_h == NULL)
2301                 {
2302                   (*_bfd_error_handler)
2303                     (_("%B(%A): warning: unresolvable relocation against symbol `%s'"),
2304                      input_bfd, input_section, h->root.root.string);
2305                 }
2306             }
2307           else if (!info->relocatable)
2308             {
2309               /* Ignore dynamic loader defined symbols.  */
2310               if (!elf_hppa_is_dynamic_loader_symbol (h->root.root.string))
2311                 {
2312                   if (!((*info->callbacks->undefined_symbol)
2313                         (info, h->root.root.string, input_bfd,
2314                          input_section, rel->r_offset,
2315                          (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2316                           || ELF_ST_VISIBILITY (h->other)))))
2317                     return FALSE;
2318                   break;
2319                 }
2320             }
2321         }
2322
2323       if (sym_sec != NULL && elf_discarded_section (sym_sec))
2324         {
2325           /* For relocs against symbols from removed linkonce sections,
2326              or sections discarded by a linker script, we just want the
2327              section contents zeroed.  Avoid any special processing.  */
2328           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2329           rel->r_info = 0;
2330           rel->r_addend = 0;
2331           continue;
2332         }
2333
2334       if (info->relocatable)
2335         continue;
2336
2337       r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
2338                                         input_section, contents,
2339                                         relocation, info, sym_sec,
2340                                         h, dyn_h);
2341
2342       if (r != bfd_reloc_ok)
2343         {
2344           switch (r)
2345             {
2346             default:
2347               abort ();
2348             case bfd_reloc_overflow:
2349               {
2350                 const char *sym_name;
2351
2352                 if (h != NULL)
2353                   sym_name = NULL;
2354                 else
2355                   {
2356                     sym_name = bfd_elf_string_from_elf_section (input_bfd,
2357                                                                 symtab_hdr->sh_link,
2358                                                                 sym->st_name);
2359                     if (sym_name == NULL)
2360                       return FALSE;
2361                     if (*sym_name == '\0')
2362                       sym_name = bfd_section_name (input_bfd, sym_sec);
2363                   }
2364
2365                 if (!((*info->callbacks->reloc_overflow)
2366                       (info, (h ? &h->root : NULL), sym_name,
2367                        howto->name, (bfd_vma) 0, input_bfd,
2368                        input_section, rel->r_offset)))
2369                   return FALSE;
2370               }
2371               break;
2372             }
2373         }
2374     }
2375   return TRUE;
2376 }
2377
2378 #endif /* ARCH_SIZE == 64 */