Commit | Line | Data |
---|---|---|
0e5136c6 | 1 | /* Intel i860 specific support for 32-bit ELF. |
219d1afa | 2 | Copyright (C) 1993-2018 Free Software Foundation, Inc. |
9d751335 | 3 | |
0e5136c6 | 4 | Full i860 support contributed by Jason Eckhardt <jle@cygnus.com>. |
252b5132 | 5 | |
cd123cb7 | 6 | This file is part of BFD, the Binary File Descriptor library. |
252b5132 | 7 | |
cd123cb7 NC |
8 | This program is free software; you can redistribute it and/or modify |
9 | it under the terms of the GNU General Public License as published by | |
10 | the Free Software Foundation; either version 3 of the License, or | |
11 | (at your option) any later version. | |
252b5132 | 12 | |
cd123cb7 NC |
13 | This program is distributed in the hope that it will be useful, |
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | GNU General Public License for more details. | |
252b5132 | 17 | |
cd123cb7 NC |
18 | You should have received a copy of the GNU General Public License |
19 | along with this program; if not, write to the Free Software | |
20 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
21 | MA 02110-1301, USA. */ | |
252b5132 | 22 | |
252b5132 | 23 | #include "sysdep.h" |
3db64b00 | 24 | #include "bfd.h" |
252b5132 RH |
25 | #include "libbfd.h" |
26 | #include "elf-bfd.h" | |
0e5136c6 JE |
27 | #include "elf/i860.h" |
28 | ||
32d920dd | 29 | /* special_function for R_860_PC26 relocation. */ |
d539b3aa CG |
30 | static bfd_reloc_status_type |
31 | i860_howto_pc26_reloc (bfd *abfd ATTRIBUTE_UNUSED, | |
07d6d2b8 AM |
32 | arelent *reloc_entry, |
33 | asymbol *symbol, | |
34 | void *data ATTRIBUTE_UNUSED, | |
35 | asection *input_section, | |
36 | bfd *output_bfd, | |
37 | char **error_message ATTRIBUTE_UNUSED) | |
d539b3aa | 38 | { |
1c0881dd CG |
39 | bfd_vma insn; |
40 | bfd_vma relocation; | |
41 | bfd_byte *addr; | |
42 | ||
d539b3aa CG |
43 | if (output_bfd != NULL |
44 | && (symbol->flags & BSF_SECTION_SYM) == 0 | |
45 | && (! reloc_entry->howto->partial_inplace | |
46 | || reloc_entry->addend == 0)) | |
47 | { | |
48 | reloc_entry->address += input_section->output_offset; | |
49 | return bfd_reloc_ok; | |
50 | } | |
51 | ||
1c0881dd CG |
52 | /* Used elf32-mips.c as an example. */ |
53 | if (bfd_is_und_section (symbol->section) | |
54 | && output_bfd == (bfd *) NULL) | |
55 | return bfd_reloc_undefined; | |
56 | ||
57 | if (bfd_is_com_section (symbol->section)) | |
58 | relocation = 0; | |
59 | else | |
60 | relocation = symbol->value; | |
61 | ||
62 | relocation += symbol->section->output_section->vma; | |
63 | relocation += symbol->section->output_offset; | |
64 | relocation += reloc_entry->addend; | |
65 | ||
07515404 | 66 | if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
1c0881dd CG |
67 | return bfd_reloc_outofrange; |
68 | ||
69 | /* Adjust for PC-relative relocation. */ | |
70 | relocation -= (input_section->output_section->vma | |
07d6d2b8 AM |
71 | + input_section->output_offset |
72 | + reloc_entry->address | |
73 | + 4); | |
1c0881dd CG |
74 | |
75 | /* Check for target out of range. */ | |
76 | if ((bfd_signed_vma)relocation > (0x3ffffff << 2) | |
b6518b38 | 77 | || (bfd_signed_vma)relocation < (-0x4000000 * 4)) |
1c0881dd CG |
78 | return bfd_reloc_outofrange; |
79 | ||
80 | addr = (bfd_byte *) data + reloc_entry->address; | |
81 | insn = bfd_get_32 (abfd, addr); | |
82 | ||
83 | relocation >>= reloc_entry->howto->rightshift; | |
84 | insn = (insn & ~reloc_entry->howto->dst_mask) | |
07d6d2b8 | 85 | | (relocation & reloc_entry->howto->dst_mask); |
1c0881dd CG |
86 | |
87 | bfd_put_32 (abfd, (bfd_vma) insn, addr); | |
88 | ||
89 | return bfd_reloc_ok; | |
d539b3aa CG |
90 | } |
91 | ||
92 | /* special_function for R_860_PC16 relocation. */ | |
93 | static bfd_reloc_status_type | |
94 | i860_howto_pc16_reloc (bfd *abfd, | |
07d6d2b8 AM |
95 | arelent *reloc_entry, |
96 | asymbol *symbol, | |
97 | void *data, | |
98 | asection *input_section, | |
99 | bfd *output_bfd, | |
100 | char **error_message ATTRIBUTE_UNUSED) | |
d539b3aa CG |
101 | { |
102 | bfd_vma insn; | |
103 | bfd_vma relocation; | |
104 | bfd_byte *addr; | |
105 | ||
106 | if (output_bfd != NULL | |
107 | && (symbol->flags & BSF_SECTION_SYM) == 0 | |
108 | && (! reloc_entry->howto->partial_inplace | |
109 | || reloc_entry->addend == 0)) | |
110 | { | |
111 | reloc_entry->address += input_section->output_offset; | |
112 | return bfd_reloc_ok; | |
113 | } | |
114 | ||
115 | /* Used elf32-mips.c as an example. */ | |
116 | if (bfd_is_und_section (symbol->section) | |
117 | && output_bfd == (bfd *) NULL) | |
118 | return bfd_reloc_undefined; | |
119 | ||
120 | if (bfd_is_com_section (symbol->section)) | |
121 | relocation = 0; | |
122 | else | |
123 | relocation = symbol->value; | |
124 | ||
125 | relocation += symbol->section->output_section->vma; | |
126 | relocation += symbol->section->output_offset; | |
127 | relocation += reloc_entry->addend; | |
128 | ||
07515404 | 129 | if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
d539b3aa CG |
130 | return bfd_reloc_outofrange; |
131 | ||
132 | /* Adjust for PC-relative relocation. */ | |
133 | relocation -= (input_section->output_section->vma | |
07d6d2b8 AM |
134 | + input_section->output_offset |
135 | + reloc_entry->address | |
136 | + 4); | |
d539b3aa CG |
137 | |
138 | /* Check for target out of range. */ | |
139 | if ((bfd_signed_vma)relocation > (0x7fff << 2) | |
b6518b38 | 140 | || (bfd_signed_vma)relocation < (-0x8000 * 4)) |
d539b3aa CG |
141 | return bfd_reloc_outofrange; |
142 | ||
143 | addr = (bfd_byte *) data + reloc_entry->address; | |
144 | insn = bfd_get_32 (abfd, addr); | |
145 | ||
146 | relocation >>= reloc_entry->howto->rightshift; | |
147 | relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff)) | |
07d6d2b8 | 148 | & reloc_entry->howto->dst_mask; |
d539b3aa CG |
149 | insn = (insn & ~reloc_entry->howto->dst_mask) | relocation; |
150 | ||
151 | bfd_put_32 (abfd, (bfd_vma) insn, addr); | |
152 | ||
153 | return bfd_reloc_ok; | |
154 | } | |
155 | ||
156 | /* special_function for R_860_HIGHADJ relocation. */ | |
157 | static bfd_reloc_status_type | |
158 | i860_howto_highadj_reloc (bfd *abfd, | |
07d6d2b8 AM |
159 | arelent *reloc_entry, |
160 | asymbol *symbol, | |
161 | void *data, | |
162 | asection *input_section, | |
163 | bfd *output_bfd, | |
164 | char **error_message ATTRIBUTE_UNUSED) | |
d539b3aa CG |
165 | { |
166 | bfd_vma insn; | |
167 | bfd_vma relocation; | |
168 | bfd_byte *addr; | |
169 | ||
170 | if (output_bfd != NULL | |
171 | && (symbol->flags & BSF_SECTION_SYM) == 0 | |
172 | && (! reloc_entry->howto->partial_inplace | |
173 | || reloc_entry->addend == 0)) | |
174 | { | |
175 | reloc_entry->address += input_section->output_offset; | |
176 | return bfd_reloc_ok; | |
177 | } | |
178 | ||
179 | /* Used elf32-mips.c as an example. */ | |
180 | if (bfd_is_und_section (symbol->section) | |
181 | && output_bfd == (bfd *) NULL) | |
182 | return bfd_reloc_undefined; | |
183 | ||
184 | if (bfd_is_com_section (symbol->section)) | |
185 | relocation = 0; | |
186 | else | |
187 | relocation = symbol->value; | |
188 | ||
189 | relocation += symbol->section->output_section->vma; | |
190 | relocation += symbol->section->output_offset; | |
191 | relocation += reloc_entry->addend; | |
192 | relocation += 0x8000; | |
193 | ||
07515404 | 194 | if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
d539b3aa CG |
195 | return bfd_reloc_outofrange; |
196 | ||
197 | addr = (bfd_byte *) data + reloc_entry->address; | |
198 | insn = bfd_get_32 (abfd, addr); | |
199 | ||
200 | relocation = ((relocation >> 16) & 0xffff); | |
201 | ||
202 | insn = (insn & 0xffff0000) | relocation; | |
203 | ||
204 | bfd_put_32 (abfd, (bfd_vma) insn, addr); | |
205 | ||
206 | return bfd_reloc_ok; | |
207 | } | |
208 | ||
209 | /* special_function for R_860_SPLITn relocations. */ | |
210 | static bfd_reloc_status_type | |
211 | i860_howto_splitn_reloc (bfd *abfd, | |
07d6d2b8 AM |
212 | arelent *reloc_entry, |
213 | asymbol *symbol, | |
214 | void *data, | |
215 | asection *input_section, | |
216 | bfd *output_bfd, | |
217 | char **error_message ATTRIBUTE_UNUSED) | |
d539b3aa CG |
218 | { |
219 | bfd_vma insn; | |
220 | bfd_vma relocation; | |
221 | bfd_byte *addr; | |
222 | ||
223 | if (output_bfd != NULL | |
224 | && (symbol->flags & BSF_SECTION_SYM) == 0 | |
225 | && (! reloc_entry->howto->partial_inplace | |
226 | || reloc_entry->addend == 0)) | |
227 | { | |
228 | reloc_entry->address += input_section->output_offset; | |
229 | return bfd_reloc_ok; | |
230 | } | |
231 | ||
232 | /* Used elf32-mips.c as an example. */ | |
233 | if (bfd_is_und_section (symbol->section) | |
234 | && output_bfd == (bfd *) NULL) | |
235 | return bfd_reloc_undefined; | |
236 | ||
237 | if (bfd_is_com_section (symbol->section)) | |
238 | relocation = 0; | |
239 | else | |
240 | relocation = symbol->value; | |
241 | ||
242 | relocation += symbol->section->output_section->vma; | |
243 | relocation += symbol->section->output_offset; | |
244 | relocation += reloc_entry->addend; | |
245 | ||
07515404 | 246 | if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) |
d539b3aa CG |
247 | return bfd_reloc_outofrange; |
248 | ||
249 | addr = (bfd_byte *) data + reloc_entry->address; | |
250 | insn = bfd_get_32 (abfd, addr); | |
251 | ||
252 | relocation = (((relocation & 0xf800) << 5) | (relocation & 0x7ff)) | |
07d6d2b8 | 253 | & reloc_entry->howto->dst_mask; |
d539b3aa CG |
254 | insn = (insn & ~reloc_entry->howto->dst_mask) | relocation; |
255 | ||
256 | bfd_put_32 (abfd, (bfd_vma) insn, addr); | |
257 | ||
258 | return bfd_reloc_ok; | |
259 | } | |
de24da47 | 260 | |
0e5136c6 JE |
261 | /* This howto table is preliminary. */ |
262 | static reloc_howto_type elf32_i860_howto_table [] = | |
263 | { | |
264 | /* This relocation does nothing. */ | |
265 | HOWTO (R_860_NONE, /* type */ | |
266 | 0, /* rightshift */ | |
6346d5ca AM |
267 | 3, /* size (0 = byte, 1 = short, 2 = long) */ |
268 | 0, /* bitsize */ | |
b34976b6 | 269 | FALSE, /* pc_relative */ |
0e5136c6 | 270 | 0, /* bitpos */ |
6346d5ca | 271 | complain_overflow_dont, /* complain_on_overflow */ |
0e5136c6 JE |
272 | bfd_elf_generic_reloc, /* special_function */ |
273 | "R_860_NONE", /* name */ | |
b34976b6 | 274 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
275 | 0, /* src_mask */ |
276 | 0, /* dst_mask */ | |
b34976b6 | 277 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
278 | |
279 | /* A 32-bit absolute relocation. */ | |
280 | HOWTO (R_860_32, /* type */ | |
281 | 0, /* rightshift */ | |
282 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
283 | 32, /* bitsize */ | |
b34976b6 | 284 | FALSE, /* pc_relative */ |
0e5136c6 JE |
285 | 0, /* bitpos */ |
286 | complain_overflow_bitfield, /* complain_on_overflow */ | |
287 | bfd_elf_generic_reloc, /* special_function */ | |
288 | "R_860_32", /* name */ | |
b34976b6 | 289 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
290 | 0xffffffff, /* src_mask */ |
291 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 292 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
293 | |
294 | HOWTO (R_860_COPY, /* type */ | |
295 | 0, /* rightshift */ | |
296 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
297 | 32, /* bitsize */ | |
b34976b6 | 298 | FALSE, /* pc_relative */ |
0e5136c6 JE |
299 | 0, /* bitpos */ |
300 | complain_overflow_bitfield, /* complain_on_overflow */ | |
301 | bfd_elf_generic_reloc, /* special_function */ | |
302 | "R_860_COPY", /* name */ | |
b34976b6 | 303 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
304 | 0xffffffff, /* src_mask */ |
305 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 306 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
307 | |
308 | HOWTO (R_860_GLOB_DAT, /* type */ | |
309 | 0, /* rightshift */ | |
310 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
311 | 32, /* bitsize */ | |
b34976b6 | 312 | FALSE, /* pc_relative */ |
0e5136c6 JE |
313 | 0, /* bitpos */ |
314 | complain_overflow_bitfield, /* complain_on_overflow */ | |
315 | bfd_elf_generic_reloc, /* special_function */ | |
316 | "R_860_GLOB_DAT", /* name */ | |
b34976b6 | 317 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
318 | 0xffffffff, /* src_mask */ |
319 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 320 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
321 | |
322 | HOWTO (R_860_JUMP_SLOT, /* type */ | |
323 | 0, /* rightshift */ | |
324 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
325 | 32, /* bitsize */ | |
b34976b6 | 326 | FALSE, /* pc_relative */ |
0e5136c6 JE |
327 | 0, /* bitpos */ |
328 | complain_overflow_bitfield, /* complain_on_overflow */ | |
329 | bfd_elf_generic_reloc, /* special_function */ | |
330 | "R_860_JUMP_SLOT", /* name */ | |
b34976b6 | 331 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
332 | 0xffffffff, /* src_mask */ |
333 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 334 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
335 | |
336 | HOWTO (R_860_RELATIVE, /* type */ | |
337 | 0, /* rightshift */ | |
338 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
339 | 32, /* bitsize */ | |
b34976b6 | 340 | FALSE, /* pc_relative */ |
0e5136c6 JE |
341 | 0, /* bitpos */ |
342 | complain_overflow_bitfield, /* complain_on_overflow */ | |
343 | bfd_elf_generic_reloc, /* special_function */ | |
344 | "R_860_RELATIVE", /* name */ | |
b34976b6 | 345 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
346 | 0xffffffff, /* src_mask */ |
347 | 0xffffffff, /* dst_mask */ | |
b34976b6 | 348 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
349 | |
350 | /* A 26-bit PC-relative relocation. */ | |
07d6d2b8 | 351 | HOWTO (R_860_PC26, /* type */ |
fdeafce7 | 352 | 2, /* rightshift */ |
0e5136c6 JE |
353 | 2, /* size (0 = byte, 1 = short, 2 = long) */ |
354 | 26, /* bitsize */ | |
b34976b6 | 355 | TRUE, /* pc_relative */ |
0e5136c6 JE |
356 | 0, /* bitpos */ |
357 | complain_overflow_bitfield, /* complain_on_overflow */ | |
d539b3aa | 358 | i860_howto_pc26_reloc, /* special_function */ |
0e5136c6 | 359 | "R_860_PC26", /* name */ |
b34976b6 | 360 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
361 | 0x3ffffff, /* src_mask */ |
362 | 0x3ffffff, /* dst_mask */ | |
07d6d2b8 | 363 | TRUE), /* pcrel_offset */ |
0e5136c6 | 364 | |
07d6d2b8 | 365 | HOWTO (R_860_PLT26, /* type */ |
0e5136c6 JE |
366 | 0, /* rightshift */ |
367 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
368 | 26, /* bitsize */ | |
b34976b6 | 369 | TRUE, /* pc_relative */ |
0e5136c6 JE |
370 | 0, /* bitpos */ |
371 | complain_overflow_bitfield, /* complain_on_overflow */ | |
372 | bfd_elf_generic_reloc, /* special_function */ | |
373 | "R_860_PLT26", /* name */ | |
b34976b6 | 374 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
375 | 0xffffffff, /* src_mask */ |
376 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 377 | TRUE), /* pcrel_offset */ |
0e5136c6 JE |
378 | |
379 | /* A 16-bit PC-relative relocation. */ | |
07d6d2b8 | 380 | HOWTO (R_860_PC16, /* type */ |
fdeafce7 | 381 | 2, /* rightshift */ |
0e5136c6 JE |
382 | 2, /* size (0 = byte, 1 = short, 2 = long) */ |
383 | 16, /* bitsize */ | |
b34976b6 | 384 | TRUE, /* pc_relative */ |
0e5136c6 JE |
385 | 0, /* bitpos */ |
386 | complain_overflow_bitfield, /* complain_on_overflow */ | |
d539b3aa | 387 | i860_howto_pc16_reloc, /* special_function */ |
0e5136c6 | 388 | "R_860_PC16", /* name */ |
b34976b6 | 389 | FALSE, /* partial_inplace */ |
305d537e JE |
390 | 0x1f07ff, /* src_mask */ |
391 | 0x1f07ff, /* dst_mask */ | |
07d6d2b8 | 392 | TRUE), /* pcrel_offset */ |
0e5136c6 | 393 | |
07d6d2b8 | 394 | HOWTO (R_860_LOW0, /* type */ |
0e5136c6 JE |
395 | 0, /* rightshift */ |
396 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
397 | 16, /* bitsize */ | |
b34976b6 | 398 | FALSE, /* pc_relative */ |
0e5136c6 JE |
399 | 0, /* bitpos */ |
400 | complain_overflow_dont, /* complain_on_overflow */ | |
401 | bfd_elf_generic_reloc, /* special_function */ | |
402 | "R_860_LOW0", /* name */ | |
b34976b6 | 403 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
404 | 0xffff, /* src_mask */ |
405 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 406 | FALSE), /* pcrel_offset */ |
0e5136c6 | 407 | |
07d6d2b8 | 408 | HOWTO (R_860_SPLIT0, /* type */ |
0e5136c6 JE |
409 | 0, /* rightshift */ |
410 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
411 | 16, /* bitsize */ | |
b34976b6 | 412 | FALSE, /* pc_relative */ |
0e5136c6 JE |
413 | 0, /* bitpos */ |
414 | complain_overflow_dont, /* complain_on_overflow */ | |
d539b3aa | 415 | i860_howto_splitn_reloc, /* special_function */ |
0e5136c6 | 416 | "R_860_SPLIT0", /* name */ |
b34976b6 | 417 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
418 | 0x1f07ff, /* src_mask */ |
419 | 0x1f07ff, /* dst_mask */ | |
07d6d2b8 | 420 | FALSE), /* pcrel_offset */ |
0e5136c6 | 421 | |
07d6d2b8 | 422 | HOWTO (R_860_LOW1, /* type */ |
0e5136c6 JE |
423 | 0, /* rightshift */ |
424 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
425 | 16, /* bitsize */ | |
b34976b6 | 426 | FALSE, /* pc_relative */ |
0e5136c6 JE |
427 | 0, /* bitpos */ |
428 | complain_overflow_dont, /* complain_on_overflow */ | |
429 | bfd_elf_generic_reloc, /* special_function */ | |
430 | "R_860_LOW1", /* name */ | |
b34976b6 | 431 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
432 | 0xfffe, /* src_mask */ |
433 | 0xfffe, /* dst_mask */ | |
07d6d2b8 | 434 | FALSE), /* pcrel_offset */ |
0e5136c6 | 435 | |
07d6d2b8 | 436 | HOWTO (R_860_SPLIT1, /* type */ |
0e5136c6 JE |
437 | 0, /* rightshift */ |
438 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
439 | 16, /* bitsize */ | |
b34976b6 | 440 | FALSE, /* pc_relative */ |
0e5136c6 JE |
441 | 0, /* bitpos */ |
442 | complain_overflow_dont, /* complain_on_overflow */ | |
d539b3aa | 443 | i860_howto_splitn_reloc, /* special_function */ |
0e5136c6 | 444 | "R_860_SPLIT1", /* name */ |
b34976b6 | 445 | FALSE, /* partial_inplace */ |
305d537e JE |
446 | 0x1f07fe, /* src_mask */ |
447 | 0x1f07fe, /* dst_mask */ | |
07d6d2b8 | 448 | FALSE), /* pcrel_offset */ |
0e5136c6 | 449 | |
07d6d2b8 | 450 | HOWTO (R_860_LOW2, /* type */ |
0e5136c6 JE |
451 | 0, /* rightshift */ |
452 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
453 | 16, /* bitsize */ | |
b34976b6 | 454 | FALSE, /* pc_relative */ |
0e5136c6 JE |
455 | 0, /* bitpos */ |
456 | complain_overflow_dont, /* complain_on_overflow */ | |
457 | bfd_elf_generic_reloc, /* special_function */ | |
458 | "R_860_LOW2", /* name */ | |
b34976b6 | 459 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
460 | 0xfffc, /* src_mask */ |
461 | 0xfffc, /* dst_mask */ | |
07d6d2b8 | 462 | FALSE), /* pcrel_offset */ |
0e5136c6 | 463 | |
07d6d2b8 | 464 | HOWTO (R_860_SPLIT2, /* type */ |
0e5136c6 JE |
465 | 0, /* rightshift */ |
466 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
467 | 16, /* bitsize */ | |
b34976b6 | 468 | FALSE, /* pc_relative */ |
0e5136c6 JE |
469 | 0, /* bitpos */ |
470 | complain_overflow_dont, /* complain_on_overflow */ | |
d539b3aa | 471 | i860_howto_splitn_reloc, /* special_function */ |
0e5136c6 | 472 | "R_860_SPLIT2", /* name */ |
b34976b6 | 473 | FALSE, /* partial_inplace */ |
305d537e JE |
474 | 0x1f07fc, /* src_mask */ |
475 | 0x1f07fc, /* dst_mask */ | |
07d6d2b8 | 476 | FALSE), /* pcrel_offset */ |
0e5136c6 | 477 | |
07d6d2b8 | 478 | HOWTO (R_860_LOW3, /* type */ |
0e5136c6 JE |
479 | 0, /* rightshift */ |
480 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
481 | 16, /* bitsize */ | |
b34976b6 | 482 | FALSE, /* pc_relative */ |
0e5136c6 JE |
483 | 0, /* bitpos */ |
484 | complain_overflow_dont, /* complain_on_overflow */ | |
485 | bfd_elf_generic_reloc, /* special_function */ | |
486 | "R_860_LOW3", /* name */ | |
b34976b6 | 487 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
488 | 0xfff8, /* src_mask */ |
489 | 0xfff8, /* dst_mask */ | |
07d6d2b8 | 490 | FALSE), /* pcrel_offset */ |
0e5136c6 | 491 | |
07d6d2b8 | 492 | HOWTO (R_860_LOGOT0, /* type */ |
0e5136c6 JE |
493 | 0, /* rightshift */ |
494 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
495 | 16, /* bitsize */ | |
b34976b6 | 496 | FALSE, /* pc_relative */ |
0e5136c6 JE |
497 | 0, /* bitpos */ |
498 | complain_overflow_dont, /* complain_on_overflow */ | |
499 | bfd_elf_generic_reloc, /* special_function */ | |
500 | "R_860_LOGOT0", /* name */ | |
b34976b6 | 501 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
502 | 0, /* src_mask */ |
503 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 504 | TRUE), /* pcrel_offset */ |
0e5136c6 | 505 | |
07d6d2b8 | 506 | HOWTO (R_860_SPGOT0, /* type */ |
0e5136c6 JE |
507 | 0, /* rightshift */ |
508 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
509 | 16, /* bitsize */ | |
b34976b6 | 510 | FALSE, /* pc_relative */ |
0e5136c6 JE |
511 | 0, /* bitpos */ |
512 | complain_overflow_dont, /* complain_on_overflow */ | |
513 | bfd_elf_generic_reloc, /* special_function */ | |
514 | "R_860_SPGOT0", /* name */ | |
b34976b6 | 515 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
516 | 0, /* src_mask */ |
517 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 518 | TRUE), /* pcrel_offset */ |
0e5136c6 | 519 | |
07d6d2b8 | 520 | HOWTO (R_860_LOGOT1, /* type */ |
0e5136c6 JE |
521 | 0, /* rightshift */ |
522 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
523 | 16, /* bitsize */ | |
b34976b6 | 524 | FALSE, /* pc_relative */ |
0e5136c6 JE |
525 | 0, /* bitpos */ |
526 | complain_overflow_dont, /* complain_on_overflow */ | |
527 | bfd_elf_generic_reloc, /* special_function */ | |
528 | "R_860_LOGOT1", /* name */ | |
b34976b6 | 529 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
530 | 0, /* src_mask */ |
531 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 532 | TRUE), /* pcrel_offset */ |
0e5136c6 | 533 | |
07d6d2b8 | 534 | HOWTO (R_860_SPGOT1, /* type */ |
0e5136c6 JE |
535 | 0, /* rightshift */ |
536 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
537 | 16, /* bitsize */ | |
b34976b6 | 538 | FALSE, /* pc_relative */ |
0e5136c6 JE |
539 | 0, /* bitpos */ |
540 | complain_overflow_dont, /* complain_on_overflow */ | |
541 | bfd_elf_generic_reloc, /* special_function */ | |
542 | "R_860_SPGOT1", /* name */ | |
b34976b6 | 543 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
544 | 0, /* src_mask */ |
545 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 546 | TRUE), /* pcrel_offset */ |
0e5136c6 | 547 | |
07d6d2b8 | 548 | HOWTO (R_860_LOGOTOFF0, /* type */ |
0e5136c6 JE |
549 | 0, /* rightshift */ |
550 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
551 | 32, /* bitsize */ | |
b34976b6 | 552 | FALSE, /* pc_relative */ |
0e5136c6 JE |
553 | 0, /* bitpos */ |
554 | complain_overflow_dont, /* complain_on_overflow */ | |
555 | bfd_elf_generic_reloc, /* special_function */ | |
556 | "R_860_LOGOTOFF0", /* name */ | |
b34976b6 | 557 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
558 | 0xffffffff, /* src_mask */ |
559 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 560 | FALSE), /* pcrel_offset */ |
0e5136c6 | 561 | |
07d6d2b8 | 562 | HOWTO (R_860_SPGOTOFF0, /* type */ |
0e5136c6 JE |
563 | 0, /* rightshift */ |
564 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
565 | 32, /* bitsize */ | |
b34976b6 | 566 | FALSE, /* pc_relative */ |
0e5136c6 JE |
567 | 0, /* bitpos */ |
568 | complain_overflow_dont, /* complain_on_overflow */ | |
569 | bfd_elf_generic_reloc, /* special_function */ | |
570 | "R_860_SPGOTOFF0", /* name */ | |
b34976b6 | 571 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
572 | 0xffffffff, /* src_mask */ |
573 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 574 | FALSE), /* pcrel_offset */ |
0e5136c6 | 575 | |
07d6d2b8 | 576 | HOWTO (R_860_LOGOTOFF1, /* type */ |
0e5136c6 JE |
577 | 0, /* rightshift */ |
578 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
579 | 32, /* bitsize */ | |
b34976b6 | 580 | FALSE, /* pc_relative */ |
0e5136c6 JE |
581 | 0, /* bitpos */ |
582 | complain_overflow_dont, /* complain_on_overflow */ | |
583 | bfd_elf_generic_reloc, /* special_function */ | |
584 | "R_860_LOGOTOFF1", /* name */ | |
b34976b6 | 585 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
586 | 0xffffffff, /* src_mask */ |
587 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 588 | FALSE), /* pcrel_offset */ |
0e5136c6 JE |
589 | |
590 | HOWTO (R_860_SPGOTOFF1, /* type */ | |
591 | 0, /* rightshift */ | |
592 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
593 | 32, /* bitsize */ | |
b34976b6 | 594 | FALSE, /* pc_relative */ |
0e5136c6 JE |
595 | 0, /* bitpos */ |
596 | complain_overflow_dont, /* complain_on_overflow */ | |
597 | bfd_elf_generic_reloc, /* special_function */ | |
598 | "R_860_SPGOTOFF1", /* name */ | |
b34976b6 | 599 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
600 | 0xffffffff, /* src_mask */ |
601 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 602 | FALSE), /* pcrel_offset */ |
0e5136c6 | 603 | |
07d6d2b8 | 604 | HOWTO (R_860_LOGOTOFF2, /* type */ |
0e5136c6 JE |
605 | 0, /* rightshift */ |
606 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
607 | 32, /* bitsize */ | |
b34976b6 | 608 | FALSE, /* pc_relative */ |
0e5136c6 JE |
609 | 0, /* bitpos */ |
610 | complain_overflow_dont, /* complain_on_overflow */ | |
611 | bfd_elf_generic_reloc, /* special_function */ | |
612 | "R_860_LOGOTOFF2", /* name */ | |
b34976b6 | 613 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
614 | 0xffffffff, /* src_mask */ |
615 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 616 | FALSE), /* pcrel_offset */ |
0e5136c6 | 617 | |
07d6d2b8 | 618 | HOWTO (R_860_LOGOTOFF3, /* type */ |
0e5136c6 JE |
619 | 0, /* rightshift */ |
620 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
621 | 32, /* bitsize */ | |
b34976b6 | 622 | FALSE, /* pc_relative */ |
0e5136c6 JE |
623 | 0, /* bitpos */ |
624 | complain_overflow_dont, /* complain_on_overflow */ | |
625 | bfd_elf_generic_reloc, /* special_function */ | |
626 | "R_860_LOGOTOFF3", /* name */ | |
b34976b6 | 627 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
628 | 0xffffffff, /* src_mask */ |
629 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 630 | FALSE), /* pcrel_offset */ |
0e5136c6 | 631 | |
07d6d2b8 | 632 | HOWTO (R_860_LOPC, /* type */ |
0e5136c6 JE |
633 | 0, /* rightshift */ |
634 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
635 | 16, /* bitsize */ | |
b34976b6 | 636 | TRUE, /* pc_relative */ |
0e5136c6 JE |
637 | 0, /* bitpos */ |
638 | complain_overflow_bitfield, /* complain_on_overflow */ | |
639 | bfd_elf_generic_reloc, /* special_function */ | |
640 | "R_860_LOPC", /* name */ | |
b34976b6 | 641 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
642 | 0xffff, /* src_mask */ |
643 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 644 | TRUE), /* pcrel_offset */ |
0e5136c6 | 645 | |
07d6d2b8 | 646 | HOWTO (R_860_HIGHADJ, /* type */ |
0e5136c6 JE |
647 | 0, /* rightshift */ |
648 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
649 | 16, /* bitsize */ | |
b34976b6 | 650 | FALSE, /* pc_relative */ |
0e5136c6 JE |
651 | 0, /* bitpos */ |
652 | complain_overflow_dont, /* complain_on_overflow */ | |
d539b3aa | 653 | i860_howto_highadj_reloc, /* special_function */ |
0e5136c6 | 654 | "R_860_HIGHADJ", /* name */ |
b34976b6 | 655 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
656 | 0xffff, /* src_mask */ |
657 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 658 | FALSE), /* pcrel_offset */ |
0e5136c6 | 659 | |
07d6d2b8 | 660 | HOWTO (R_860_HAGOT, /* type */ |
0e5136c6 JE |
661 | 0, /* rightshift */ |
662 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
663 | 16, /* bitsize */ | |
b34976b6 | 664 | FALSE, /* pc_relative */ |
0e5136c6 JE |
665 | 0, /* bitpos */ |
666 | complain_overflow_dont, /* complain_on_overflow */ | |
667 | bfd_elf_generic_reloc, /* special_function */ | |
668 | "R_860_HAGOT", /* name */ | |
b34976b6 | 669 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
670 | 0, /* src_mask */ |
671 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 672 | TRUE), /* pcrel_offset */ |
0e5136c6 | 673 | |
07d6d2b8 | 674 | HOWTO (R_860_HAGOTOFF, /* type */ |
0e5136c6 JE |
675 | 0, /* rightshift */ |
676 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
677 | 32, /* bitsize */ | |
b34976b6 | 678 | FALSE, /* pc_relative */ |
0e5136c6 JE |
679 | 0, /* bitpos */ |
680 | complain_overflow_dont, /* complain_on_overflow */ | |
681 | bfd_elf_generic_reloc, /* special_function */ | |
682 | "R_860_HAGOTOFF", /* name */ | |
b34976b6 | 683 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
684 | 0xffffffff, /* src_mask */ |
685 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 686 | FALSE), /* pcrel_offset */ |
0e5136c6 | 687 | |
07d6d2b8 | 688 | HOWTO (R_860_HAPC, /* type */ |
0e5136c6 JE |
689 | 0, /* rightshift */ |
690 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
691 | 16, /* bitsize */ | |
b34976b6 | 692 | TRUE, /* pc_relative */ |
0e5136c6 JE |
693 | 0, /* bitpos */ |
694 | complain_overflow_bitfield, /* complain_on_overflow */ | |
695 | bfd_elf_generic_reloc, /* special_function */ | |
696 | "R_860_HAPC", /* name */ | |
b34976b6 | 697 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
698 | 0xffff, /* src_mask */ |
699 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 700 | TRUE), /* pcrel_offset */ |
0e5136c6 | 701 | |
07d6d2b8 | 702 | HOWTO (R_860_HIGH, /* type */ |
fdeafce7 | 703 | 16, /* rightshift */ |
0e5136c6 JE |
704 | 2, /* size (0 = byte, 1 = short, 2 = long) */ |
705 | 16, /* bitsize */ | |
b34976b6 | 706 | FALSE, /* pc_relative */ |
0e5136c6 JE |
707 | 0, /* bitpos */ |
708 | complain_overflow_dont, /* complain_on_overflow */ | |
709 | bfd_elf_generic_reloc, /* special_function */ | |
710 | "R_860_HIGH", /* name */ | |
b34976b6 | 711 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
712 | 0xffff, /* src_mask */ |
713 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 714 | FALSE), /* pcrel_offset */ |
0e5136c6 | 715 | |
07d6d2b8 | 716 | HOWTO (R_860_HIGOT, /* type */ |
0e5136c6 JE |
717 | 0, /* rightshift */ |
718 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
719 | 16, /* bitsize */ | |
b34976b6 | 720 | FALSE, /* pc_relative */ |
0e5136c6 JE |
721 | 0, /* bitpos */ |
722 | complain_overflow_dont, /* complain_on_overflow */ | |
723 | bfd_elf_generic_reloc, /* special_function */ | |
724 | "R_860_HIGOT", /* name */ | |
b34976b6 | 725 | FALSE, /* partial_inplace */ |
0e5136c6 JE |
726 | 0, /* src_mask */ |
727 | 0xffff, /* dst_mask */ | |
07d6d2b8 | 728 | TRUE), /* pcrel_offset */ |
0e5136c6 | 729 | |
07d6d2b8 | 730 | HOWTO (R_860_HIGOTOFF, /* type */ |
0e5136c6 JE |
731 | 0, /* rightshift */ |
732 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
733 | 32, /* bitsize */ | |
b34976b6 | 734 | FALSE, /* pc_relative */ |
0e5136c6 JE |
735 | 0, /* bitpos */ |
736 | complain_overflow_dont, /* complain_on_overflow */ | |
737 | bfd_elf_generic_reloc, /* special_function */ | |
738 | "R_860_HIGOTOFF", /* name */ | |
b34976b6 | 739 | TRUE, /* partial_inplace */ |
0e5136c6 JE |
740 | 0xffffffff, /* src_mask */ |
741 | 0xffffffff, /* dst_mask */ | |
07d6d2b8 | 742 | FALSE), /* pcrel_offset */ |
0e5136c6 | 743 | }; |
0e5136c6 JE |
744 | \f |
745 | static unsigned char elf_code_to_howto_index[R_860_max + 1]; | |
746 | ||
747 | static reloc_howto_type * | |
7734b6e9 | 748 | lookup_howto (unsigned int rtype) |
0e5136c6 JE |
749 | { |
750 | static int initialized = 0; | |
751 | int i; | |
752 | int howto_tbl_size = (int) (sizeof (elf32_i860_howto_table) | |
753 | / sizeof (elf32_i860_howto_table[0])); | |
754 | ||
755 | if (! initialized) | |
756 | { | |
757 | initialized = 1; | |
758 | memset (elf_code_to_howto_index, 0xff, | |
759 | sizeof (elf_code_to_howto_index)); | |
760 | for (i = 0; i < howto_tbl_size; i++) | |
07d6d2b8 | 761 | elf_code_to_howto_index[elf32_i860_howto_table[i].type] = i; |
0e5136c6 JE |
762 | } |
763 | ||
f3185997 NC |
764 | if (rtype > R_860_max) |
765 | return NULL; | |
0e5136c6 JE |
766 | i = elf_code_to_howto_index[rtype]; |
767 | if (i >= howto_tbl_size) | |
f3185997 | 768 | return NULL; |
0e5136c6 JE |
769 | return elf32_i860_howto_table + i; |
770 | } | |
771 | ||
0e5136c6 JE |
772 | /* Given a BFD reloc, return the matching HOWTO structure. */ |
773 | static reloc_howto_type * | |
7734b6e9 JE |
774 | elf32_i860_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, |
775 | bfd_reloc_code_real_type code) | |
0e5136c6 JE |
776 | { |
777 | unsigned int rtype; | |
778 | ||
779 | switch (code) | |
780 | { | |
781 | case BFD_RELOC_NONE: | |
782 | rtype = R_860_NONE; | |
783 | break; | |
784 | case BFD_RELOC_32: | |
785 | rtype = R_860_32; | |
786 | break; | |
787 | case BFD_RELOC_860_COPY: | |
788 | rtype = R_860_COPY; | |
789 | break; | |
790 | case BFD_RELOC_860_GLOB_DAT: | |
6609fa74 | 791 | rtype = R_860_GLOB_DAT; |
0e5136c6 JE |
792 | break; |
793 | case BFD_RELOC_860_JUMP_SLOT: | |
794 | rtype = R_860_JUMP_SLOT; | |
795 | break; | |
796 | case BFD_RELOC_860_RELATIVE: | |
797 | rtype = R_860_RELATIVE; | |
798 | break; | |
799 | case BFD_RELOC_860_PC26: | |
800 | rtype = R_860_PC26; | |
801 | break; | |
802 | case BFD_RELOC_860_PLT26: | |
803 | rtype = R_860_PLT26; | |
804 | break; | |
805 | case BFD_RELOC_860_PC16: | |
806 | rtype = R_860_PC16; | |
807 | break; | |
808 | case BFD_RELOC_860_LOW0: | |
809 | rtype = R_860_LOW0; | |
810 | break; | |
811 | case BFD_RELOC_860_SPLIT0: | |
812 | rtype = R_860_SPLIT0; | |
813 | break; | |
814 | case BFD_RELOC_860_LOW1: | |
815 | rtype = R_860_LOW1; | |
816 | break; | |
817 | case BFD_RELOC_860_SPLIT1: | |
818 | rtype = R_860_SPLIT1; | |
819 | break; | |
820 | case BFD_RELOC_860_LOW2: | |
821 | rtype = R_860_LOW2; | |
822 | break; | |
823 | case BFD_RELOC_860_SPLIT2: | |
824 | rtype = R_860_SPLIT2; | |
825 | break; | |
826 | case BFD_RELOC_860_LOW3: | |
827 | rtype = R_860_LOW3; | |
828 | break; | |
829 | case BFD_RELOC_860_LOGOT0: | |
830 | rtype = R_860_LOGOT0; | |
831 | break; | |
832 | case BFD_RELOC_860_SPGOT0: | |
833 | rtype = R_860_SPGOT0; | |
834 | break; | |
835 | case BFD_RELOC_860_LOGOT1: | |
836 | rtype = R_860_LOGOT1; | |
837 | break; | |
838 | case BFD_RELOC_860_SPGOT1: | |
839 | rtype = R_860_SPGOT1; | |
840 | break; | |
841 | case BFD_RELOC_860_LOGOTOFF0: | |
842 | rtype = R_860_LOGOTOFF0; | |
843 | break; | |
844 | case BFD_RELOC_860_SPGOTOFF0: | |
845 | rtype = R_860_SPGOTOFF0; | |
846 | break; | |
847 | case BFD_RELOC_860_LOGOTOFF1: | |
848 | rtype = R_860_LOGOTOFF1; | |
849 | break; | |
850 | case BFD_RELOC_860_SPGOTOFF1: | |
851 | rtype = R_860_SPGOTOFF1; | |
852 | break; | |
853 | case BFD_RELOC_860_LOGOTOFF2: | |
854 | rtype = R_860_LOGOTOFF2; | |
855 | break; | |
856 | case BFD_RELOC_860_LOGOTOFF3: | |
857 | rtype = R_860_LOGOTOFF3; | |
858 | break; | |
859 | case BFD_RELOC_860_LOPC: | |
860 | rtype = R_860_LOPC; | |
861 | break; | |
862 | case BFD_RELOC_860_HIGHADJ: | |
863 | rtype = R_860_HIGHADJ; | |
864 | break; | |
865 | case BFD_RELOC_860_HAGOT: | |
866 | rtype = R_860_HAGOT; | |
867 | break; | |
868 | case BFD_RELOC_860_HAGOTOFF: | |
869 | rtype = R_860_HAGOTOFF; | |
870 | break; | |
871 | case BFD_RELOC_860_HAPC: | |
872 | rtype = R_860_HAPC; | |
873 | break; | |
874 | case BFD_RELOC_860_HIGH: | |
875 | rtype = R_860_HIGH; | |
876 | break; | |
877 | case BFD_RELOC_860_HIGOT: | |
878 | rtype = R_860_HIGOT; | |
879 | break; | |
880 | case BFD_RELOC_860_HIGOTOFF: | |
881 | rtype = R_860_HIGOTOFF; | |
882 | break; | |
883 | default: | |
f3185997 | 884 | return NULL; |
0e5136c6 JE |
885 | } |
886 | return lookup_howto (rtype); | |
887 | } | |
888 | ||
157090f7 AM |
889 | static reloc_howto_type * |
890 | elf32_i860_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, | |
891 | const char *r_name) | |
892 | { | |
893 | unsigned int i; | |
894 | ||
895 | for (i = 0; | |
896 | i < (sizeof (elf32_i860_howto_table) | |
897 | / sizeof (elf32_i860_howto_table[0])); | |
898 | i++) | |
899 | if (elf32_i860_howto_table[i].name != NULL | |
900 | && strcasecmp (elf32_i860_howto_table[i].name, r_name) == 0) | |
901 | return &elf32_i860_howto_table[i]; | |
902 | ||
903 | return NULL; | |
904 | } | |
905 | ||
0e5136c6 | 906 | /* Given a ELF reloc, return the matching HOWTO structure. */ |
f3185997 NC |
907 | |
908 | static bfd_boolean | |
7734b6e9 JE |
909 | elf32_i860_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, |
910 | arelent *bfd_reloc, | |
911 | Elf_Internal_Rela *elf_reloc) | |
0e5136c6 | 912 | { |
dc810e39 AM |
913 | bfd_reloc->howto |
914 | = lookup_howto ((unsigned) ELF32_R_TYPE (elf_reloc->r_info)); | |
f3185997 | 915 | return bfd_reloc->howto != NULL; |
0e5136c6 | 916 | } |
fdeafce7 JE |
917 | \f |
918 | /* Specialized relocation handler for R_860_SPLITn. These relocations | |
919 | involves a 16-bit field that is split into two contiguous parts. */ | |
920 | static bfd_reloc_status_type | |
7734b6e9 JE |
921 | elf32_i860_relocate_splitn (bfd *input_bfd, |
922 | Elf_Internal_Rela *rello, | |
923 | bfd_byte *contents, | |
924 | bfd_vma value) | |
fdeafce7 | 925 | { |
ded0649c | 926 | bfd_vma insn; |
fdeafce7 | 927 | reloc_howto_type *howto; |
dc810e39 | 928 | howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info)); |
fdeafce7 JE |
929 | insn = bfd_get_32 (input_bfd, contents + rello->r_offset); |
930 | ||
fdeafce7 | 931 | /* Relocate. */ |
ded0649c | 932 | value += rello->r_addend; |
fdeafce7 | 933 | |
ded0649c | 934 | /* Separate the fields and insert. */ |
a48c6a54 | 935 | value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask; |
fdeafce7 JE |
936 | insn = (insn & ~howto->dst_mask) | value; |
937 | ||
938 | bfd_put_32 (input_bfd, insn, contents + rello->r_offset); | |
939 | return bfd_reloc_ok; | |
940 | } | |
941 | ||
fdeafce7 JE |
942 | /* Specialized relocation handler for R_860_PC16. This relocation |
943 | involves a 16-bit, PC-relative field that is split into two contiguous | |
944 | parts. */ | |
945 | static bfd_reloc_status_type | |
7734b6e9 JE |
946 | elf32_i860_relocate_pc16 (bfd *input_bfd, |
947 | asection *input_section, | |
948 | Elf_Internal_Rela *rello, | |
949 | bfd_byte *contents, | |
950 | bfd_vma value) | |
fdeafce7 | 951 | { |
ded0649c | 952 | bfd_vma insn; |
d670a150 | 953 | reloc_howto_type *howto; |
dc810e39 | 954 | howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info)); |
d670a150 JE |
955 | insn = bfd_get_32 (input_bfd, contents + rello->r_offset); |
956 | ||
957 | /* Adjust for PC-relative relocation. */ | |
958 | value -= (input_section->output_section->vma | |
959 | + input_section->output_offset); | |
960 | value -= rello->r_offset; | |
961 | ||
d670a150 | 962 | /* Relocate. */ |
ded0649c | 963 | value += rello->r_addend; |
d670a150 | 964 | |
f680ea79 JE |
965 | /* Adjust the value by 4, then separate the fields and insert. */ |
966 | value = (value - 4) >> howto->rightshift; | |
a48c6a54 | 967 | value = (((value & 0xf800) << 5) | (value & 0x7ff)) & howto->dst_mask; |
d670a150 JE |
968 | insn = (insn & ~howto->dst_mask) | value; |
969 | ||
970 | bfd_put_32 (input_bfd, insn, contents + rello->r_offset); | |
971 | return bfd_reloc_ok; | |
972 | ||
fdeafce7 | 973 | } |
fdeafce7 | 974 | |
c1e8b710 JE |
975 | /* Specialized relocation handler for R_860_PC26. This relocation |
976 | involves a 26-bit, PC-relative field which must be adjusted by 4. */ | |
977 | static bfd_reloc_status_type | |
7734b6e9 JE |
978 | elf32_i860_relocate_pc26 (bfd *input_bfd, |
979 | asection *input_section, | |
980 | Elf_Internal_Rela *rello, | |
981 | bfd_byte *contents, | |
982 | bfd_vma value) | |
c1e8b710 JE |
983 | { |
984 | bfd_vma insn; | |
985 | reloc_howto_type *howto; | |
dc810e39 | 986 | howto = lookup_howto ((unsigned) ELF32_R_TYPE (rello->r_info)); |
c1e8b710 JE |
987 | insn = bfd_get_32 (input_bfd, contents + rello->r_offset); |
988 | ||
989 | /* Adjust for PC-relative relocation. */ | |
990 | value -= (input_section->output_section->vma | |
991 | + input_section->output_offset); | |
992 | value -= rello->r_offset; | |
993 | ||
994 | /* Relocate. */ | |
995 | value += rello->r_addend; | |
996 | ||
997 | /* Adjust value by 4 and insert the field. */ | |
6609fa74 | 998 | value = ((value - 4) >> howto->rightshift) & howto->dst_mask; |
c1e8b710 JE |
999 | insn = (insn & ~howto->dst_mask) | value; |
1000 | ||
1001 | bfd_put_32 (input_bfd, insn, contents + rello->r_offset); | |
1002 | return bfd_reloc_ok; | |
1003 | ||
1004 | } | |
1005 | ||
fdeafce7 JE |
1006 | /* Specialized relocation handler for R_860_HIGHADJ. */ |
1007 | static bfd_reloc_status_type | |
7734b6e9 JE |
1008 | elf32_i860_relocate_highadj (bfd *input_bfd, |
1009 | Elf_Internal_Rela *rel, | |
1010 | bfd_byte *contents, | |
1011 | bfd_vma value) | |
fdeafce7 JE |
1012 | { |
1013 | bfd_vma insn; | |
1014 | ||
1015 | insn = bfd_get_32 (input_bfd, contents + rel->r_offset); | |
1016 | ||
fdeafce7 | 1017 | value += rel->r_addend; |
68ffbac6 | 1018 | value += 0x8000; |
fdeafce7 | 1019 | value = ((value >> 16) & 0xffff); |
fdeafce7 JE |
1020 | |
1021 | insn = (insn & 0xffff0000) | value; | |
1022 | ||
1023 | bfd_put_32 (input_bfd, insn, contents + rel->r_offset); | |
1024 | return bfd_reloc_ok; | |
1025 | } | |
1026 | ||
fdeafce7 JE |
1027 | /* Perform a single relocation. By default we use the standard BFD |
1028 | routines. However, we handle some specially. */ | |
1029 | static bfd_reloc_status_type | |
7734b6e9 JE |
1030 | i860_final_link_relocate (reloc_howto_type *howto, |
1031 | bfd *input_bfd, | |
1032 | asection *input_section, | |
1033 | bfd_byte *contents, | |
1034 | Elf_Internal_Rela *rel, | |
1035 | bfd_vma relocation) | |
fdeafce7 JE |
1036 | { |
1037 | return _bfd_final_link_relocate (howto, input_bfd, input_section, | |
1038 | contents, rel->r_offset, relocation, | |
1039 | rel->r_addend); | |
1040 | } | |
1041 | ||
fdeafce7 | 1042 | /* Relocate an i860 ELF section. |
252b5132 | 1043 | |
fdeafce7 | 1044 | This is boiler-plate code copied from fr30. |
fdeafce7 JE |
1045 | |
1046 | The RELOCATE_SECTION function is called by the new ELF backend linker | |
1047 | to handle the relocations for a section. | |
1048 | ||
1049 | The relocs are always passed as Rela structures; if the section | |
1050 | actually uses Rel structures, the r_addend field will always be | |
1051 | zero. | |
1052 | ||
1053 | This function is responsible for adjusting the section contents as | |
1049f94e | 1054 | necessary, and (if using Rela relocs and generating a relocatable |
fdeafce7 JE |
1055 | output file) adjusting the reloc addend as necessary. |
1056 | ||
1057 | This function does not have to worry about setting the reloc | |
1058 | address or the reloc symbol index. | |
1059 | ||
1060 | LOCAL_SYMS is a pointer to the swapped in local symbols. | |
1061 | ||
1062 | LOCAL_SECTIONS is an array giving the section in the input file | |
1063 | corresponding to the st_shndx field of each local symbol. | |
1064 | ||
1065 | The global hash table entry for the global symbols can be found | |
1066 | via elf_sym_hashes (input_bfd). | |
1067 | ||
1049f94e | 1068 | When generating relocatable output, this function must handle |
fdeafce7 JE |
1069 | STB_LOCAL/STT_SECTION symbols specially. The output symbol is |
1070 | going to be the section symbol corresponding to the output | |
1071 | section, which means that the addend must be adjusted | |
1072 | accordingly. */ | |
b34976b6 | 1073 | static bfd_boolean |
7734b6e9 JE |
1074 | elf32_i860_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED, |
1075 | struct bfd_link_info *info, | |
1076 | bfd *input_bfd, | |
1077 | asection *input_section, | |
1078 | bfd_byte *contents, | |
1079 | Elf_Internal_Rela *relocs, | |
1080 | Elf_Internal_Sym *local_syms, | |
1081 | asection **local_sections) | |
fdeafce7 | 1082 | { |
b34976b6 AM |
1083 | Elf_Internal_Shdr *symtab_hdr; |
1084 | struct elf_link_hash_entry **sym_hashes; | |
1085 | Elf_Internal_Rela *rel; | |
1086 | Elf_Internal_Rela *relend; | |
fdeafce7 JE |
1087 | |
1088 | symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; | |
1089 | sym_hashes = elf_sym_hashes (input_bfd); | |
1090 | relend = relocs + input_section->reloc_count; | |
1091 | ||
1092 | for (rel = relocs; rel < relend; rel ++) | |
1093 | { | |
07d6d2b8 AM |
1094 | reloc_howto_type * howto; |
1095 | unsigned long r_symndx; | |
1096 | Elf_Internal_Sym * sym; | |
1097 | asection * sec; | |
fdeafce7 | 1098 | struct elf_link_hash_entry * h; |
07d6d2b8 AM |
1099 | bfd_vma relocation; |
1100 | bfd_reloc_status_type r; | |
1101 | const char * name = NULL; | |
1102 | int r_type; | |
6609fa74 | 1103 | |
fdeafce7 | 1104 | r_type = ELF32_R_TYPE (rel->r_info); |
fdeafce7 JE |
1105 | r_symndx = ELF32_R_SYM (rel->r_info); |
1106 | ||
dc810e39 AM |
1107 | howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info)); |
1108 | h = NULL; | |
1109 | sym = NULL; | |
1110 | sec = NULL; | |
6609fa74 | 1111 | |
fdeafce7 JE |
1112 | if (r_symndx < symtab_hdr->sh_info) |
1113 | { | |
1114 | sym = local_syms + r_symndx; | |
1115 | sec = local_sections [r_symndx]; | |
8517fae7 | 1116 | relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); |
6609fa74 | 1117 | |
fdeafce7 JE |
1118 | name = bfd_elf_string_from_elf_section |
1119 | (input_bfd, symtab_hdr->sh_link, sym->st_name); | |
1120 | name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; | |
1121 | } | |
1122 | else | |
1123 | { | |
62d887d4 | 1124 | bfd_boolean unresolved_reloc, warned, ignored; |
59c2e50f | 1125 | |
b2a8e766 AM |
1126 | RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, |
1127 | r_symndx, symtab_hdr, sym_hashes, | |
1128 | h, sec, relocation, | |
62d887d4 | 1129 | unresolved_reloc, warned, ignored); |
fdeafce7 | 1130 | } |
6609fa74 | 1131 | |
dbaa2011 | 1132 | if (sec != NULL && discarded_section (sec)) |
e4067dbb | 1133 | RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, |
545fd46b | 1134 | rel, 1, relend, howto, 0, contents); |
ab96bf03 | 1135 | |
0e1862bb | 1136 | if (bfd_link_relocatable (info)) |
ab96bf03 AM |
1137 | continue; |
1138 | ||
fdeafce7 JE |
1139 | switch (r_type) |
1140 | { | |
1141 | default: | |
1142 | r = i860_final_link_relocate (howto, input_bfd, input_section, | |
1143 | contents, rel, relocation); | |
1144 | break; | |
1145 | ||
1146 | case R_860_HIGHADJ: | |
1147 | r = elf32_i860_relocate_highadj (input_bfd, rel, contents, | |
1148 | relocation); | |
1149 | break; | |
1150 | ||
fdeafce7 | 1151 | case R_860_PC16: |
d670a150 JE |
1152 | r = elf32_i860_relocate_pc16 (input_bfd, input_section, rel, |
1153 | contents, relocation); | |
fdeafce7 | 1154 | break; |
fdeafce7 | 1155 | |
c1e8b710 JE |
1156 | case R_860_PC26: |
1157 | r = elf32_i860_relocate_pc26 (input_bfd, input_section, rel, | |
1158 | contents, relocation); | |
1159 | break; | |
1160 | ||
fdeafce7 JE |
1161 | case R_860_SPLIT0: |
1162 | case R_860_SPLIT1: | |
1163 | case R_860_SPLIT2: | |
1164 | r = elf32_i860_relocate_splitn (input_bfd, rel, contents, | |
1165 | relocation); | |
1166 | break; | |
1167 | ||
1168 | /* We do not yet handle GOT/PLT/Dynamic relocations. */ | |
1169 | case R_860_COPY: | |
1170 | case R_860_GLOB_DAT: | |
1171 | case R_860_JUMP_SLOT: | |
1172 | case R_860_RELATIVE: | |
1173 | case R_860_PLT26: | |
1174 | case R_860_LOGOT0: | |
1175 | case R_860_SPGOT0: | |
1176 | case R_860_LOGOT1: | |
1177 | case R_860_SPGOT1: | |
1178 | case R_860_LOGOTOFF0: | |
1179 | case R_860_SPGOTOFF0: | |
1180 | case R_860_LOGOTOFF1: | |
1181 | case R_860_SPGOTOFF1: | |
1182 | case R_860_LOGOTOFF2: | |
1183 | case R_860_LOGOTOFF3: | |
1184 | case R_860_LOPC: | |
1185 | case R_860_HAGOT: | |
1186 | case R_860_HAGOTOFF: | |
1187 | case R_860_HAPC: | |
1188 | case R_860_HIGOT: | |
1189 | case R_860_HIGOTOFF: | |
1190 | r = bfd_reloc_notsupported; | |
1191 | break; | |
6609fa74 | 1192 | } |
fdeafce7 JE |
1193 | |
1194 | if (r != bfd_reloc_ok) | |
1195 | { | |
1196 | const char * msg = (const char *) NULL; | |
1197 | ||
1198 | switch (r) | |
1199 | { | |
1200 | case bfd_reloc_overflow: | |
1a72702b | 1201 | (*info->callbacks->reloc_overflow) |
dfeffb9f L |
1202 | (info, (h ? &h->root : NULL), name, howto->name, |
1203 | (bfd_vma) 0, input_bfd, input_section, rel->r_offset); | |
fdeafce7 | 1204 | break; |
6609fa74 | 1205 | |
fdeafce7 | 1206 | case bfd_reloc_undefined: |
1a72702b | 1207 | (*info->callbacks->undefined_symbol) |
b34976b6 | 1208 | (info, name, input_bfd, input_section, rel->r_offset, TRUE); |
fdeafce7 | 1209 | break; |
6609fa74 | 1210 | |
fdeafce7 JE |
1211 | case bfd_reloc_outofrange: |
1212 | msg = _("internal error: out of range error"); | |
1213 | break; | |
1214 | ||
1215 | case bfd_reloc_notsupported: | |
1216 | msg = _("internal error: unsupported relocation error"); | |
1217 | break; | |
1218 | ||
1219 | case bfd_reloc_dangerous: | |
1220 | msg = _("internal error: dangerous relocation"); | |
1221 | break; | |
1222 | ||
1223 | default: | |
1224 | msg = _("internal error: unknown error"); | |
1225 | break; | |
1226 | } | |
1227 | ||
1228 | if (msg) | |
1a72702b AM |
1229 | (*info->callbacks->warning) (info, msg, name, input_bfd, |
1230 | input_section, rel->r_offset); | |
fdeafce7 JE |
1231 | } |
1232 | } | |
1233 | ||
b34976b6 | 1234 | return TRUE; |
fdeafce7 JE |
1235 | } |
1236 | ||
de24da47 JE |
1237 | /* Return whether a symbol name implies a local label. SVR4/860 compilers |
1238 | generate labels of the form ".ep.function_name" to denote the end of a | |
1239 | function prolog. These should be local. | |
1240 | ??? Do any other SVR4 compilers have this convention? If so, this should | |
1241 | be added to the generic routine. */ | |
b34976b6 | 1242 | static bfd_boolean |
7734b6e9 | 1243 | elf32_i860_is_local_label_name (bfd *abfd, const char *name) |
de24da47 JE |
1244 | { |
1245 | if (name[0] == '.' && name[1] == 'e' && name[2] == 'p' && name[3] == '.') | |
b34976b6 | 1246 | return TRUE; |
de24da47 JE |
1247 | |
1248 | return _bfd_elf_is_local_label_name (abfd, name); | |
1249 | } | |
fdeafce7 | 1250 | \f |
6d00b590 | 1251 | #define TARGET_BIG_SYM i860_elf32_vec |
9d751335 | 1252 | #define TARGET_BIG_NAME "elf32-i860" |
6d00b590 | 1253 | #define TARGET_LITTLE_SYM i860_elf32_le_vec |
9d751335 | 1254 | #define TARGET_LITTLE_NAME "elf32-i860-little" |
0e5136c6 JE |
1255 | #define ELF_ARCH bfd_arch_i860 |
1256 | #define ELF_MACHINE_CODE EM_860 | |
1257 | #define ELF_MAXPAGESIZE 4096 | |
1258 | ||
b491616a | 1259 | #define elf_backend_rela_normal 1 |
07d6d2b8 | 1260 | #define elf_info_to_howto_rel NULL |
0e5136c6 | 1261 | #define elf_info_to_howto elf32_i860_info_to_howto_rela |
fdeafce7 | 1262 | #define elf_backend_relocate_section elf32_i860_relocate_section |
0e5136c6 | 1263 | #define bfd_elf32_bfd_reloc_type_lookup elf32_i860_reloc_type_lookup |
157090f7 | 1264 | #define bfd_elf32_bfd_reloc_name_lookup elf32_i860_reloc_name_lookup |
de24da47 | 1265 | #define bfd_elf32_bfd_is_local_label_name elf32_i860_is_local_label_name |
252b5132 RH |
1266 | |
1267 | #include "elf32-target.h" |