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