projects / deliverable / binutils-gdb.git / blob
? search:


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