OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [elf-hppa.h] - Blame information for rev 156

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.