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