projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move putchar_filtered() to utils.c.
[deliverable/binutils-gdb.git] / bfd / elf-m10200.c
1 /* Matsushita 10200 specific support for 32-bit ELF
2 Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libbfd.h"
23 #include "elf-bfd.h"
24
25 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
26 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
27 static void mn10200_info_to_howto
28 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
29 static boolean mn10200_elf_relax_delete_bytes
30 PARAMS ((bfd *, asection *, bfd_vma, int));
31 static boolean mn10200_elf_symbol_address_p
32 PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
33
34 /* We have to use RELA instructions since md_apply_fix3 in the assembler
35 does absolutely nothing. */
36 #define USE_RELA
37
38 enum reloc_type
39 {
40 R_MN10200_NONE = 0,
41 R_MN10200_32,
42 R_MN10200_16,
43 R_MN10200_8,
44 R_MN10200_24,
45 R_MN10200_PCREL8,
46 R_MN10200_PCREL16,
47 R_MN10200_PCREL24,
48 R_MN10200_MAX
49 };
50
51 static reloc_howto_type elf_mn10200_howto_table[] =
52 {
53 /* Dummy relocation. Does nothing. */
54 HOWTO (R_MN10200_NONE,
55 0,
56 2,
57 16,
58 false,
59 0,
60 complain_overflow_bitfield,
61 bfd_elf_generic_reloc,
62 "R_MN10200_NONE",
63 false,
64 0,
65 0,
66 false),
67 /* Standard 32 bit reloc. */
68 HOWTO (R_MN10200_32,
69 0,
70 2,
71 32,
72 false,
73 0,
74 complain_overflow_bitfield,
75 bfd_elf_generic_reloc,
76 "R_MN10200_32",
77 false,
78 0xffffffff,
79 0xffffffff,
80 false),
81 /* Standard 16 bit reloc. */
82 HOWTO (R_MN10200_16,
83 0,
84 1,
85 16,
86 false,
87 0,
88 complain_overflow_bitfield,
89 bfd_elf_generic_reloc,
90 "R_MN10200_16",
91 false,
92 0xffff,
93 0xffff,
94 false),
95 /* Standard 8 bit reloc. */
96 HOWTO (R_MN10200_8,
97 0,
98 0,
99 8,
100 false,
101 0,
102 complain_overflow_bitfield,
103 bfd_elf_generic_reloc,
104 "R_MN10200_8",
105 false,
106 0xff,
107 0xff,
108 false),
109 /* Standard 24 bit reloc. */
110 HOWTO (R_MN10200_24,
111 0,
112 2,
113 24,
114 false,
115 0,
116 complain_overflow_bitfield,
117 bfd_elf_generic_reloc,
118 "R_MN10200_24",
119 false,
120 0xffffff,
121 0xffffff,
122 false),
123 /* Simple 8 pc-relative reloc. */
124 HOWTO (R_MN10200_PCREL8,
125 0,
126 0,
127 8,
128 true,
129 0,
130 complain_overflow_bitfield,
131 bfd_elf_generic_reloc,
132 "R_MN10200_PCREL8",
133 false,
134 0xff,
135 0xff,
136 true),
137 /* Simple 16 pc-relative reloc. */
138 HOWTO (R_MN10200_PCREL16,
139 0,
140 1,
141 16,
142 true,
143 0,
144 complain_overflow_bitfield,
145 bfd_elf_generic_reloc,
146 "R_MN10200_PCREL16",
147 false,
148 0xffff,
149 0xffff,
150 true),
151 /* Simple 32bit pc-relative reloc with a 1 byte adjustment
152 to get the pc-relative offset correct. */
153 HOWTO (R_MN10200_PCREL24,
154 0,
155 2,
156 24,
157 true,
158 0,
159 complain_overflow_bitfield,
160 bfd_elf_generic_reloc,
161 "R_MN10200_PCREL24",
162 false,
163 0xffffff,
164 0xffffff,
165 true),
166 };
167
168 struct mn10200_reloc_map
169 {
170 bfd_reloc_code_real_type bfd_reloc_val;
171 unsigned char elf_reloc_val;
172 };
173
174 static const struct mn10200_reloc_map mn10200_reloc_map[] =
175 {
176 { BFD_RELOC_NONE, R_MN10200_NONE, },
177 { BFD_RELOC_32, R_MN10200_32, },
178 { BFD_RELOC_16, R_MN10200_16, },
179 { BFD_RELOC_8, R_MN10200_8, },
180 { BFD_RELOC_24, R_MN10200_24, },
181 { BFD_RELOC_8_PCREL, R_MN10200_PCREL8, },
182 { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },
183 { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },
184 };
185
186 static reloc_howto_type *
187 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
188 bfd *abfd ATTRIBUTE_UNUSED;
189 bfd_reloc_code_real_type code;
190 {
191 unsigned int i;
192
193 for (i = 0;
194 i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);
195 i++)
196 {
197 if (mn10200_reloc_map[i].bfd_reloc_val == code)
198 return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];
199 }
200
201 return NULL;
202 }
203
204 /* Set the howto pointer for an MN10200 ELF reloc. */
205
206 static void
207 mn10200_info_to_howto (abfd, cache_ptr, dst)
208 bfd *abfd ATTRIBUTE_UNUSED;
209 arelent *cache_ptr;
210 Elf32_Internal_Rela *dst;
211 {
212 unsigned int r_type;
213
214 r_type = ELF32_R_TYPE (dst->r_info);
215 BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX);
216 cache_ptr->howto = &elf_mn10200_howto_table[r_type];
217 }
218
219 /* Perform a relocation as part of a final link. */
220 static bfd_reloc_status_type
221 mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
222 input_section, contents, offset, value,
223 addend, info, sym_sec, is_local)
224 reloc_howto_type *howto;
225 bfd *input_bfd;
226 bfd *output_bfd ATTRIBUTE_UNUSED;
227 asection *input_section;
228 bfd_byte *contents;
229 bfd_vma offset;
230 bfd_vma value;
231 bfd_vma addend;
232 struct bfd_link_info *info ATTRIBUTE_UNUSED;
233 asection *sym_sec ATTRIBUTE_UNUSED;
234 int is_local ATTRIBUTE_UNUSED;
235 {
236 unsigned long r_type = howto->type;
237 bfd_byte *hit_data = contents + offset;
238
239 switch (r_type)
240 {
241
242 case R_MN10200_NONE:
243 return bfd_reloc_ok;
244
245 case R_MN10200_32:
246 value += addend;
247 bfd_put_32 (input_bfd, value, hit_data);
248 return bfd_reloc_ok;
249
250 case R_MN10200_16:
251 value += addend;
252
253 if ((long)value > 0x7fff || (long)value < -0x8000)
254 return bfd_reloc_overflow;
255
256 bfd_put_16 (input_bfd, value, hit_data);
257 return bfd_reloc_ok;
258
259 case R_MN10200_8:
260 value += addend;
261
262 if ((long)value > 0x7f || (long)value < -0x80)
263 return bfd_reloc_overflow;
264
265 bfd_put_8 (input_bfd, value, hit_data);
266 return bfd_reloc_ok;
267
268 case R_MN10200_24:
269 value += addend;
270
271 if ((long)value > 0x7fffff || (long)value < -0x800000)
272 return bfd_reloc_overflow;
273
274 value &= 0xffffff;
275 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
276 bfd_put_32 (input_bfd, value, hit_data);
277 return bfd_reloc_ok;
278
279 case R_MN10200_PCREL8:
280 value -= (input_section->output_section->vma
281 + input_section->output_offset);
282 value -= (offset + 1);
283 value += addend;
284
285 if ((long)value > 0xff || (long)value < -0x100)
286 return bfd_reloc_overflow;
287
288 bfd_put_8 (input_bfd, value, hit_data);
289 return bfd_reloc_ok;
290
291 case R_MN10200_PCREL16:
292 value -= (input_section->output_section->vma
293 + input_section->output_offset);
294 value -= (offset + 2);
295 value += addend;
296
297 if ((long)value > 0xffff || (long)value < -0x10000)
298 return bfd_reloc_overflow;
299
300 bfd_put_16 (input_bfd, value, hit_data);
301 return bfd_reloc_ok;
302
303 case R_MN10200_PCREL24:
304 value -= (input_section->output_section->vma
305 + input_section->output_offset);
306 value -= (offset + 3);
307 value += addend;
308
309 if ((long)value > 0xffffff || (long)value < -0x1000000)
310 return bfd_reloc_overflow;
311
312 value &= 0xffffff;
313 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
314 bfd_put_32 (input_bfd, value, hit_data);
315 return bfd_reloc_ok;
316
317 default:
318 return bfd_reloc_notsupported;
319 }
320 }
321 \f
322 /* Relocate an MN10200 ELF section. */
323 static boolean
324 mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section,
325 contents, relocs, local_syms, local_sections)
326 bfd *output_bfd;
327 struct bfd_link_info *info;
328 bfd *input_bfd;
329 asection *input_section;
330 bfd_byte *contents;
331 Elf_Internal_Rela *relocs;
332 Elf_Internal_Sym *local_syms;
333 asection **local_sections;
334 {
335 Elf_Internal_Shdr *symtab_hdr;
336 struct elf_link_hash_entry **sym_hashes;
337 Elf_Internal_Rela *rel, *relend;
338
339 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
340 sym_hashes = elf_sym_hashes (input_bfd);
341
342 rel = relocs;
343 relend = relocs + input_section->reloc_count;
344 for (; rel < relend; rel++)
345 {
346 int r_type;
347 reloc_howto_type *howto;
348 unsigned long r_symndx;
349 Elf_Internal_Sym *sym;
350 asection *sec;
351 struct elf_link_hash_entry *h;
352 bfd_vma relocation;
353 bfd_reloc_status_type r;
354
355 r_symndx = ELF32_R_SYM (rel->r_info);
356 r_type = ELF32_R_TYPE (rel->r_info);
357 howto = elf_mn10200_howto_table + r_type;
358
359 if (info->relocateable)
360 {
361 /* This is a relocateable link. We don't have to change
362 anything, unless the reloc is against a section symbol,
363 in which case we have to adjust according to where the
364 section symbol winds up in the output section. */
365 if (r_symndx < symtab_hdr->sh_info)
366 {
367 sym = local_syms + r_symndx;
368 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
369 {
370 sec = local_sections[r_symndx];
371 rel->r_addend += sec->output_offset + sym->st_value;
372 }
373 }
374
375 continue;
376 }
377
378 /* This is a final link. */
379 h = NULL;
380 sym = NULL;
381 sec = NULL;
382 if (r_symndx < symtab_hdr->sh_info)
383 {
384 sym = local_syms + r_symndx;
385 sec = local_sections[r_symndx];
386 relocation = (sec->output_section->vma
387 + sec->output_offset
388 + sym->st_value);
389 }
390 else
391 {
392 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
393 while (h->root.type == bfd_link_hash_indirect
394 || h->root.type == bfd_link_hash_warning)
395 h = (struct elf_link_hash_entry *) h->root.u.i.link;
396 if (h->root.type == bfd_link_hash_defined
397 || h->root.type == bfd_link_hash_defweak)
398 {
399 sec = h->root.u.def.section;
400 relocation = (h->root.u.def.value
401 + sec->output_section->vma
402 + sec->output_offset);
403 }
404 else if (h->root.type == bfd_link_hash_undefweak)
405 relocation = 0;
406 else
407 {
408 if (! ((*info->callbacks->undefined_symbol)
409 (info, h->root.root.string, input_bfd,
410 input_section, rel->r_offset, true)))
411 return false;
412 relocation = 0;
413 }
414 }
415
416 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
417 input_section,
418 contents, rel->r_offset,
419 relocation, rel->r_addend,
420 info, sec, h == NULL);
421
422 if (r != bfd_reloc_ok)
423 {
424 const char *name;
425 const char *msg = (const char *)0;
426
427 if (h != NULL)
428 name = h->root.root.string;
429 else
430 {
431 name = (bfd_elf_string_from_elf_section
432 (input_bfd, symtab_hdr->sh_link, sym->st_name));
433 if (name == NULL || *name == '\0')
434 name = bfd_section_name (input_bfd, sec);
435 }
436
437 switch (r)
438 {
439 case bfd_reloc_overflow:
440 if (! ((*info->callbacks->reloc_overflow)
441 (info, name, howto->name, (bfd_vma) 0,
442 input_bfd, input_section, rel->r_offset)))
443 return false;
444 break;
445
446 case bfd_reloc_undefined:
447 if (! ((*info->callbacks->undefined_symbol)
448 (info, name, input_bfd, input_section,
449 rel->r_offset, true)))
450 return false;
451 break;
452
453 case bfd_reloc_outofrange:
454 msg = _("internal error: out of range error");
455 goto common_error;
456
457 case bfd_reloc_notsupported:
458 msg = _("internal error: unsupported relocation error");
459 goto common_error;
460
461 case bfd_reloc_dangerous:
462 msg = _("internal error: dangerous error");
463 goto common_error;
464
465 default:
466 msg = _("internal error: unknown error");
467 /* fall through */
468
469 common_error:
470 if (!((*info->callbacks->warning)
471 (info, msg, name, input_bfd, input_section,
472 rel->r_offset)))
473 return false;
474 break;
475 }
476 }
477 }
478
479 return true;
480 }
481
482 /* This function handles relaxing for the mn10200.
483
484 There's quite a few relaxing opportunites available on the mn10200:
485
486 * jsr:24 -> jsr:16 2 bytes
487
488 * jmp:24 -> jmp:16 2 bytes
489 * jmp:16 -> bra:8 1 byte
490
491 * If the previous instruction is a conditional branch
492 around the jump/bra, we may be able to reverse its condition
493 and change its target to the jump's target. The jump/bra
494 can then be deleted. 2 bytes
495
496 * mov abs24 -> mov abs16 2 byte savings
497
498 * Most instructions which accept imm24 can relax to imm16 2 bytes
499 - Most instructions which accept imm16 can relax to imm8 1 byte
500
501 * Most instructions which accept d24 can relax to d16 2 bytes
502 - Most instructions which accept d16 can relax to d8 1 byte
503
504 abs24, imm24, d24 all look the same at the reloc level. It
505 might make the code simpler if we had different relocs for
506 the various relaxable operand types.
507
508 We don't handle imm16->imm8 or d16->d8 as they're very rare
509 and somewhat more difficult to support. */
510
511 static boolean
512 mn10200_elf_relax_section (abfd, sec, link_info, again)
513 bfd *abfd;
514 asection *sec;
515 struct bfd_link_info *link_info;
516 boolean *again;
517 {
518 Elf_Internal_Shdr *symtab_hdr;
519 Elf_Internal_Rela *internal_relocs;
520 Elf_Internal_Rela *free_relocs = NULL;
521 Elf_Internal_Rela *irel, *irelend;
522 bfd_byte *contents = NULL;
523 bfd_byte *free_contents = NULL;
524 Elf32_External_Sym *extsyms = NULL;
525 Elf32_External_Sym *free_extsyms = NULL;
526
527 /* Assume nothing changes. */
528 *again = false;
529
530 /* We don't have to do anything for a relocateable link, if
531 this section does not have relocs, or if this is not a
532 code section. */
533 if (link_info->relocateable
534 || (sec->flags & SEC_RELOC) == 0
535 || sec->reloc_count == 0
536 || (sec->flags & SEC_CODE) == 0)
537 return true;
538
539 /* If this is the first time we have been called for this section,
540 initialize the cooked size. */
541 if (sec->_cooked_size == 0)
542 sec->_cooked_size = sec->_raw_size;
543
544 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
545
546 /* Get a copy of the native relocations. */
547 internal_relocs = (_bfd_elf32_link_read_relocs
548 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
549 link_info->keep_memory));
550 if (internal_relocs == NULL)
551 goto error_return;
552 if (! link_info->keep_memory)
553 free_relocs = internal_relocs;
554
555 /* Walk through them looking for relaxing opportunities. */
556 irelend = internal_relocs + sec->reloc_count;
557 for (irel = internal_relocs; irel < irelend; irel++)
558 {
559 bfd_vma symval;
560
561 /* If this isn't something that can be relaxed, then ignore
562 this reloc. */
563 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
564 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
565 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
566 continue;
567
568 /* Get the section contents if we haven't done so already. */
569 if (contents == NULL)
570 {
571 /* Get cached copy if it exists. */
572 if (elf_section_data (sec)->this_hdr.contents != NULL)
573 contents = elf_section_data (sec)->this_hdr.contents;
574 else
575 {
576 /* Go get them off disk. */
577 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
578 if (contents == NULL)
579 goto error_return;
580 free_contents = contents;
581
582 if (! bfd_get_section_contents (abfd, sec, contents,
583 (file_ptr) 0, sec->_raw_size))
584 goto error_return;
585 }
586 }
587
588 /* Read this BFD's symbols if we haven't done so already. */
589 if (extsyms == NULL)
590 {
591 /* Get cached copy if it exists. */
592 if (symtab_hdr->contents != NULL)
593 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
594 else
595 {
596 /* Go get them off disk. */
597 extsyms = ((Elf32_External_Sym *)
598 bfd_malloc (symtab_hdr->sh_size));
599 if (extsyms == NULL)
600 goto error_return;
601 free_extsyms = extsyms;
602 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
603 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
604 != symtab_hdr->sh_size))
605 goto error_return;
606 }
607 }
608
609 /* Get the value of the symbol referred to by the reloc. */
610 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
611 {
612 Elf_Internal_Sym isym;
613 asection *sym_sec;
614
615 /* A local symbol. */
616 bfd_elf32_swap_symbol_in (abfd,
617 extsyms + ELF32_R_SYM (irel->r_info),
618 &isym);
619
620 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
621 symval = (isym.st_value
622 + sym_sec->output_section->vma
623 + sym_sec->output_offset);
624 }
625 else
626 {
627 unsigned long indx;
628 struct elf_link_hash_entry *h;
629
630 /* An external symbol. */
631 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
632 h = elf_sym_hashes (abfd)[indx];
633 BFD_ASSERT (h != NULL);
634 if (h->root.type != bfd_link_hash_defined
635 && h->root.type != bfd_link_hash_defweak)
636 {
637 /* This appears to be a reference to an undefined
638 symbol. Just ignore it--it will be caught by the
639 regular reloc processing. */
640 continue;
641 }
642
643 symval = (h->root.u.def.value
644 + h->root.u.def.section->output_section->vma
645 + h->root.u.def.section->output_offset);
646 }
647
648 /* For simplicity of coding, we are going to modify the section
649 contents, the section relocs, and the BFD symbol table. We
650 must tell the rest of the code not to free up this
651 information. It would be possible to instead create a table
652 of changes which have to be made, as is done in coff-mips.c;
653 that would be more work, but would require less memory when
654 the linker is run. */
655
656 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
657 branch/call. */
658 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
659 {
660 bfd_vma value = symval;
661
662 /* Deal with pc-relative gunk. */
663 value -= (sec->output_section->vma + sec->output_offset);
664 value -= (irel->r_offset + 3);
665 value += irel->r_addend;
666
667 /* See if the value will fit in 16 bits, note the high value is
668 0x7fff + 2 as the target will be two bytes closer if we are
669 able to relax. */
670 if ((long)value < 0x8001 && (long)value > -0x8000)
671 {
672 unsigned char code;
673
674 /* Get the opcode. */
675 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
676
677 if (code != 0xe0 && code != 0xe1)
678 continue;
679
680 /* Note that we've changed the relocs, section contents, etc. */
681 elf_section_data (sec)->relocs = internal_relocs;
682 free_relocs = NULL;
683
684 elf_section_data (sec)->this_hdr.contents = contents;
685 free_contents = NULL;
686
687 symtab_hdr->contents = (bfd_byte *) extsyms;
688 free_extsyms = NULL;
689
690 /* Fix the opcode. */
691 if (code == 0xe0)
692 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
693 else if (code == 0xe1)
694 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
695
696 /* Fix the relocation's type. */
697 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
698 R_MN10200_PCREL16);
699
700 /* The opcode got shorter too, so we have to fix the offset. */
701 irel->r_offset -= 1;
702
703 /* Delete two bytes of data. */
704 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
705 irel->r_offset + 1, 2))
706 goto error_return;
707
708 /* That will change things, so, we should relax again.
709 Note that this is not required, and it may be slow. */
710 *again = true;
711 }
712 }
713
714 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
715 branch. */
716 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
717 {
718 bfd_vma value = symval;
719
720 /* Deal with pc-relative gunk. */
721 value -= (sec->output_section->vma + sec->output_offset);
722 value -= (irel->r_offset + 2);
723 value += irel->r_addend;
724
725 /* See if the value will fit in 8 bits, note the high value is
726 0x7f + 1 as the target will be one bytes closer if we are
727 able to relax. */
728 if ((long)value < 0x80 && (long)value > -0x80)
729 {
730 unsigned char code;
731
732 /* Get the opcode. */
733 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
734
735 if (code != 0xfc)
736 continue;
737
738 /* Note that we've changed the relocs, section contents, etc. */
739 elf_section_data (sec)->relocs = internal_relocs;
740 free_relocs = NULL;
741
742 elf_section_data (sec)->this_hdr.contents = contents;
743 free_contents = NULL;
744
745 symtab_hdr->contents = (bfd_byte *) extsyms;
746 free_extsyms = NULL;
747
748 /* Fix the opcode. */
749 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
750
751 /* Fix the relocation's type. */
752 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
753 R_MN10200_PCREL8);
754
755 /* Delete one byte of data. */
756 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
757 irel->r_offset + 1, 1))
758 goto error_return;
759
760 /* That will change things, so, we should relax again.
761 Note that this is not required, and it may be slow. */
762 *again = true;
763 }
764 }
765
766 /* Try to eliminate an unconditional 8 bit pc-relative branch
767 which immediately follows a conditional 8 bit pc-relative
768 branch around the unconditional branch.
769
770 original: new:
771 bCC lab1 bCC' lab2
772 bra lab2
773 lab1: lab1:
774
775 This happens when the bCC can't reach lab2 at assembly time,
776 but due to other relaxations it can reach at link time. */
777 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
778 {
779 Elf_Internal_Rela *nrel;
780 bfd_vma value = symval;
781 unsigned char code;
782
783 /* Deal with pc-relative gunk. */
784 value -= (sec->output_section->vma + sec->output_offset);
785 value -= (irel->r_offset + 1);
786 value += irel->r_addend;
787
788 /* Do nothing if this reloc is the last byte in the section. */
789 if (irel->r_offset == sec->_cooked_size)
790 continue;
791
792 /* See if the next instruction is an unconditional pc-relative
793 branch, more often than not this test will fail, so we
794 test it first to speed things up. */
795 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
796 if (code != 0xea)
797 continue;
798
799 /* Also make sure the next relocation applies to the next
800 instruction and that it's a pc-relative 8 bit branch. */
801 nrel = irel + 1;
802 if (nrel == irelend
803 || irel->r_offset + 2 != nrel->r_offset
804 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
805 continue;
806
807 /* Make sure our destination immediately follows the
808 unconditional branch. */
809 if (symval != (sec->output_section->vma + sec->output_offset
810 + irel->r_offset + 3))
811 continue;
812
813 /* Now make sure we are a conditional branch. This may not
814 be necessary, but why take the chance.
815
816 Note these checks assume that R_MN10200_PCREL8 relocs
817 only occur on bCC and bCCx insns. If they occured
818 elsewhere, we'd need to know the start of this insn
819 for this check to be accurate. */
820 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
821 if (code != 0xe0 && code != 0xe1 && code != 0xe2
822 && code != 0xe3 && code != 0xe4 && code != 0xe5
823 && code != 0xe6 && code != 0xe7 && code != 0xe8
824 && code != 0xe9 && code != 0xec && code != 0xed
825 && code != 0xee && code != 0xef && code != 0xfc
826 && code != 0xfd && code != 0xfe && code != 0xff)
827 continue;
828
829 /* We also have to be sure there is no symbol/label
830 at the unconditional branch. */
831 if (mn10200_elf_symbol_address_p (abfd, sec, extsyms,
832 irel->r_offset + 1))
833 continue;
834
835 /* Note that we've changed the relocs, section contents, etc. */
836 elf_section_data (sec)->relocs = internal_relocs;
837 free_relocs = NULL;
838
839 elf_section_data (sec)->this_hdr.contents = contents;
840 free_contents = NULL;
841
842 symtab_hdr->contents = (bfd_byte *) extsyms;
843 free_extsyms = NULL;
844
845 /* Reverse the condition of the first branch. */
846 switch (code)
847 {
848 case 0xfc:
849 code = 0xfd;
850 break;
851 case 0xfd:
852 code = 0xfc;
853 break;
854 case 0xfe:
855 code = 0xff;
856 break;
857 case 0xff:
858 code = 0xfe;
859 break;
860 case 0xe8:
861 code = 0xe9;
862 break;
863 case 0xe9:
864 code = 0xe8;
865 break;
866 case 0xe0:
867 code = 0xe2;
868 break;
869 case 0xe2:
870 code = 0xe0;
871 break;
872 case 0xe3:
873 code = 0xe1;
874 break;
875 case 0xe1:
876 code = 0xe3;
877 break;
878 case 0xe4:
879 code = 0xe6;
880 break;
881 case 0xe6:
882 code = 0xe4;
883 break;
884 case 0xe7:
885 code = 0xe5;
886 break;
887 case 0xe5:
888 code = 0xe7;
889 break;
890 case 0xec:
891 code = 0xed;
892 break;
893 case 0xed:
894 code = 0xec;
895 break;
896 case 0xee:
897 code = 0xef;
898 break;
899 case 0xef:
900 code = 0xee;
901 break;
902 }
903 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
904
905 /* Set the reloc type and symbol for the first branch
906 from the second branch. */
907 irel->r_info = nrel->r_info;
908
909 /* Make the reloc for the second branch a null reloc. */
910 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
911 R_MN10200_NONE);
912
913 /* Delete two bytes of data. */
914 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
915 irel->r_offset + 1, 2))
916 goto error_return;
917
918 /* That will change things, so, we should relax again.
919 Note that this is not required, and it may be slow. */
920 *again = true;
921 }
922
923 /* Try to turn a 24bit immediate, displacement or absolute address
924 into a 16bit immediate, displacement or absolute address. */
925 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
926 {
927 bfd_vma value = symval;
928
929 /* See if the value will fit in 16 bits.
930 We allow any 16bit match here. We prune those we can't
931 handle below. */
932 if ((long)value < 0x7fff && (long)value > -0x8000)
933 {
934 unsigned char code;
935
936 /* All insns which have 24bit operands are 5 bytes long,
937 the first byte will always be 0xf4, but we double check
938 it just in case. */
939
940 /* Get the first opcode. */
941 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
942
943 if (code != 0xf4)
944 continue;
945
946 /* Get the second opcode. */
947 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
948
949 switch (code & 0xfc)
950 {
951 /* mov imm24,dn -> mov imm16,dn */
952 case 0x70:
953 /* Not safe if the high bit is on as relaxing may
954 move the value out of high mem and thus not fit
955 in a signed 16bit value. */
956 if (value & 0x8000)
957 continue;
958
959 /* Note that we've changed the reldection contents, etc. */
960 elf_section_data (sec)->relocs = internal_relocs;
961 free_relocs = NULL;
962
963 elf_section_data (sec)->this_hdr.contents = contents;
964 free_contents = NULL;
965
966 symtab_hdr->contents = (bfd_byte *) extsyms;
967 free_extsyms = NULL;
968
969 /* Fix the opcode. */
970 bfd_put_8 (abfd, 0xf8 + (code & 0x03),
971 contents + irel->r_offset - 2);
972
973 /* Fix the relocation's type. */
974 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
975 R_MN10200_16);
976
977 /* The opcode got shorter too, so we have to fix the
978 offset. */
979 irel->r_offset -= 1;
980
981 /* Delete two bytes of data. */
982 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
983 irel->r_offset + 1, 2))
984 goto error_return;
985
986 /* That will change things, so, we should relax again.
987 Note that this is not required, and it may be slow. */
988 *again = true;
989 break;
990
991 /* mov imm24,an -> mov imm16,an
992 cmp imm24,an -> cmp imm16,an
993 mov (abs24),dn -> mov (abs16),dn
994 mov dn,(abs24) -> mov dn,(abs16)
995 movb dn,(abs24) -> movb dn,(abs16)
996 movbu (abs24),dn -> movbu (abs16),dn */
997 case 0x74:
998 case 0x7c:
999 case 0xc0:
1000 case 0x40:
1001 case 0x44:
1002 case 0xc8:
1003 /* Note that we've changed the reldection contents, etc. */
1004 elf_section_data (sec)->relocs = internal_relocs;
1005 free_relocs = NULL;
1006
1007 elf_section_data (sec)->this_hdr.contents = contents;
1008 free_contents = NULL;
1009
1010 symtab_hdr->contents = (bfd_byte *) extsyms;
1011 free_extsyms = NULL;
1012
1013 if ((code & 0xfc) == 0x74)
1014 code = 0xdc + (code & 0x03);
1015 else if ((code & 0xfc) == 0x7c)
1016 code = 0xec + (code & 0x03);
1017 else if ((code & 0xfc) == 0xc0)
1018 code = 0xc8 + (code & 0x03);
1019 else if ((code & 0xfc) == 0x40)
1020 code = 0xc0 + (code & 0x03);
1021 else if ((code & 0xfc) == 0x44)
1022 code = 0xc4 + (code & 0x03);
1023 else if ((code & 0xfc) == 0xc8)
1024 code = 0xcc + (code & 0x03);
1025
1026 /* Fix the opcode. */
1027 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1028
1029 /* Fix the relocation's type. */
1030 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1031 R_MN10200_16);
1032
1033 /* The opcode got shorter too, so we have to fix the
1034 offset. */
1035 irel->r_offset -= 1;
1036
1037 /* Delete two bytes of data. */
1038 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1039 irel->r_offset + 1, 2))
1040 goto error_return;
1041
1042 /* That will change things, so, we should relax again.
1043 Note that this is not required, and it may be slow. */
1044 *again = true;
1045 break;
1046
1047 /* cmp imm24,dn -> cmp imm16,dn
1048 mov (abs24),an -> mov (abs16),an
1049 mov an,(abs24) -> mov an,(abs16)
1050 add imm24,dn -> add imm16,dn
1051 add imm24,an -> add imm16,an
1052 sub imm24,dn -> sub imm16,dn
1053 sub imm24,an -> sub imm16,an
1054 And all d24->d16 in memory ops. */
1055 case 0x78:
1056 case 0xd0:
1057 case 0x50:
1058 case 0x60:
1059 case 0x64:
1060 case 0x68:
1061 case 0x6c:
1062 case 0x80:
1063 case 0xf0:
1064 case 0x00:
1065 case 0x10:
1066 case 0xb0:
1067 case 0x30:
1068 case 0xa0:
1069 case 0x20:
1070 case 0x90:
1071 /* Not safe if the high bit is on as relaxing may
1072 move the value out of high mem and thus not fit
1073 in a signed 16bit value. */
1074 if (((code & 0xfc) == 0x78
1075 || (code & 0xfc) == 0x60
1076 || (code & 0xfc) == 0x64
1077 || (code & 0xfc) == 0x68
1078 || (code & 0xfc) == 0x6c
1079 || (code & 0xfc) == 0x80
1080 || (code & 0xfc) == 0xf0
1081 || (code & 0xfc) == 0x00
1082 || (code & 0xfc) == 0x10
1083 || (code & 0xfc) == 0xb0
1084 || (code & 0xfc) == 0x30
1085 || (code & 0xfc) == 0xa0
1086 || (code & 0xfc) == 0x20
1087 || (code & 0xfc) == 0x90)
1088 && (value & 0x8000) != 0)
1089 continue;
1090
1091 /* Note that we've changed the reldection contents, etc. */
1092 elf_section_data (sec)->relocs = internal_relocs;
1093 free_relocs = NULL;
1094
1095 elf_section_data (sec)->this_hdr.contents = contents;
1096 free_contents = NULL;
1097
1098 symtab_hdr->contents = (bfd_byte *) extsyms;
1099 free_extsyms = NULL;
1100
1101 /* Fix the opcode. */
1102 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1103
1104 if ((code & 0xfc) == 0x78)
1105 code = 0x48 + (code & 0x03);
1106 else if ((code & 0xfc) == 0xd0)
1107 code = 0x30 + (code & 0x03);
1108 else if ((code & 0xfc) == 0x50)
1109 code = 0x20 + (code & 0x03);
1110 else if ((code & 0xfc) == 0x60)
1111 code = 0x18 + (code & 0x03);
1112 else if ((code & 0xfc) == 0x64)
1113 code = 0x08 + (code & 0x03);
1114 else if ((code & 0xfc) == 0x68)
1115 code = 0x1c + (code & 0x03);
1116 else if ((code & 0xfc) == 0x6c)
1117 code = 0x0c + (code & 0x03);
1118 else if ((code & 0xfc) == 0x80)
1119 code = 0xc0 + (code & 0x07);
1120 else if ((code & 0xfc) == 0xf0)
1121 code = 0xb0 + (code & 0x07);
1122 else if ((code & 0xfc) == 0x00)
1123 code = 0x80 + (code & 0x07);
1124 else if ((code & 0xfc) == 0x10)
1125 code = 0xa0 + (code & 0x07);
1126 else if ((code & 0xfc) == 0xb0)
1127 code = 0x70 + (code & 0x07);
1128 else if ((code & 0xfc) == 0x30)
1129 code = 0x60 + (code & 0x07);
1130 else if ((code & 0xfc) == 0xa0)
1131 code = 0xd0 + (code & 0x07);
1132 else if ((code & 0xfc) == 0x20)
1133 code = 0x90 + (code & 0x07);
1134 else if ((code & 0xfc) == 0x90)
1135 code = 0x50 + (code & 0x07);
1136
1137 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1138
1139 /* Fix the relocation's type. */
1140 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1141 R_MN10200_16);
1142
1143 /* Delete one bytes of data. */
1144 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1145 irel->r_offset + 2, 1))
1146 goto error_return;
1147
1148 /* That will change things, so, we should relax again.
1149 Note that this is not required, and it may be slow. */
1150 *again = true;
1151 break;
1152
1153 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1154 case 0xc4:
1155 /* Note that we've changed the reldection contents, etc. */
1156 elf_section_data (sec)->relocs = internal_relocs;
1157 free_relocs = NULL;
1158
1159 elf_section_data (sec)->this_hdr.contents = contents;
1160 free_contents = NULL;
1161
1162 symtab_hdr->contents = (bfd_byte *) extsyms;
1163 free_extsyms = NULL;
1164
1165 bfd_put_8 (abfd, 0xcc + (code & 0x03),
1166 contents + irel->r_offset - 2);
1167
1168 bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1169 contents + irel->r_offset - 1);
1170
1171 /* Fix the relocation's type. */
1172 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1173 R_MN10200_16);
1174
1175 /* The reloc will be applied one byte in front of its
1176 current location. */
1177 irel->r_offset -= 1;
1178
1179 /* Delete one bytes of data. */
1180 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1181 irel->r_offset + 2, 1))
1182 goto error_return;
1183
1184 /* That will change things, so, we should relax again.
1185 Note that this is not required, and it may be slow. */
1186 *again = true;
1187 break;
1188 }
1189 }
1190 }
1191 }
1192
1193 if (free_relocs != NULL)
1194 {
1195 free (free_relocs);
1196 free_relocs = NULL;
1197 }
1198
1199 if (free_contents != NULL)
1200 {
1201 if (! link_info->keep_memory)
1202 free (free_contents);
1203 else
1204 {
1205 /* Cache the section contents for elf_link_input_bfd. */
1206 elf_section_data (sec)->this_hdr.contents = contents;
1207 }
1208 free_contents = NULL;
1209 }
1210
1211 if (free_extsyms != NULL)
1212 {
1213 if (! link_info->keep_memory)
1214 free (free_extsyms);
1215 else
1216 {
1217 /* Cache the symbols for elf_link_input_bfd. */
1218 symtab_hdr->contents = extsyms;
1219 }
1220 free_extsyms = NULL;
1221 }
1222
1223 return true;
1224
1225 error_return:
1226 if (free_relocs != NULL)
1227 free (free_relocs);
1228 if (free_contents != NULL)
1229 free (free_contents);
1230 if (free_extsyms != NULL)
1231 free (free_extsyms);
1232 return false;
1233 }
1234
1235 /* Delete some bytes from a section while relaxing. */
1236
1237 static boolean
1238 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1239 bfd *abfd;
1240 asection *sec;
1241 bfd_vma addr;
1242 int count;
1243 {
1244 Elf_Internal_Shdr *symtab_hdr;
1245 Elf32_External_Sym *extsyms;
1246 int shndx, index;
1247 bfd_byte *contents;
1248 Elf_Internal_Rela *irel, *irelend;
1249 Elf_Internal_Rela *irelalign;
1250 bfd_vma toaddr;
1251 Elf32_External_Sym *esym, *esymend;
1252 struct elf_link_hash_entry *sym_hash;
1253
1254 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1255 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1256
1257 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1258
1259 contents = elf_section_data (sec)->this_hdr.contents;
1260
1261 /* The deletion must stop at the next ALIGN reloc for an aligment
1262 power larger than the number of bytes we are deleting. */
1263
1264 irelalign = NULL;
1265 toaddr = sec->_cooked_size;
1266
1267 irel = elf_section_data (sec)->relocs;
1268 irelend = irel + sec->reloc_count;
1269
1270 /* Actually delete the bytes. */
1271 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1272 sec->_cooked_size -= count;
1273
1274 /* Adjust all the relocs. */
1275 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1276 {
1277 /* Get the new reloc address. */
1278 if ((irel->r_offset > addr
1279 && irel->r_offset < toaddr))
1280 irel->r_offset -= count;
1281 }
1282
1283 /* Adjust the local symbols defined in this section. */
1284 esym = extsyms;
1285 esymend = esym + symtab_hdr->sh_info;
1286 for (; esym < esymend; esym++)
1287 {
1288 Elf_Internal_Sym isym;
1289
1290 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1291
1292 if (isym.st_shndx == shndx
1293 && isym.st_value > addr
1294 && isym.st_value < toaddr)
1295 {
1296 isym.st_value -= count;
1297 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1298 }
1299 }
1300
1301 /* Now adjust the global symbols defined in this section. */
1302 esym = extsyms + symtab_hdr->sh_info;
1303 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1304 for (index = 0; esym < esymend; esym++, index++)
1305 {
1306 Elf_Internal_Sym isym;
1307
1308 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1309 sym_hash = elf_sym_hashes (abfd)[index];
1310 if (isym.st_shndx == shndx
1311 && ((sym_hash)->root.type == bfd_link_hash_defined
1312 || (sym_hash)->root.type == bfd_link_hash_defweak)
1313 && (sym_hash)->root.u.def.section == sec
1314 && (sym_hash)->root.u.def.value > addr
1315 && (sym_hash)->root.u.def.value < toaddr)
1316 {
1317 (sym_hash)->root.u.def.value -= count;
1318 }
1319 }
1320
1321 return true;
1322 }
1323
1324 /* Return true if a symbol exists at the given address, else return
1325 false. */
1326 static boolean
1327 mn10200_elf_symbol_address_p (abfd, sec, extsyms, addr)
1328 bfd *abfd;
1329 asection *sec;
1330 Elf32_External_Sym *extsyms;
1331 bfd_vma addr;
1332 {
1333 Elf_Internal_Shdr *symtab_hdr;
1334 int shndx;
1335 Elf32_External_Sym *esym, *esymend;
1336 struct elf_link_hash_entry **sym_hash, **sym_hash_end;
1337
1338 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1339 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1340
1341 /* Examine all the symbols. */
1342 esym = extsyms;
1343 esymend = esym + symtab_hdr->sh_info;
1344 for (; esym < esymend; esym++)
1345 {
1346 Elf_Internal_Sym isym;
1347
1348 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1349
1350 if (isym.st_shndx == shndx
1351 && isym.st_value == addr)
1352 return true;
1353 }
1354
1355 sym_hash = elf_sym_hashes (abfd);
1356 sym_hash_end = (sym_hash
1357 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1358 - symtab_hdr->sh_info));
1359 for (; sym_hash < sym_hash_end; sym_hash++)
1360 {
1361 if (((*sym_hash)->root.type == bfd_link_hash_defined
1362 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1363 && (*sym_hash)->root.u.def.section == sec
1364 && (*sym_hash)->root.u.def.value == addr)
1365 return true;
1366 }
1367 return false;
1368 }
1369
1370 /* This is a version of bfd_generic_get_relocated_section_contents
1371 which uses mn10200_elf_relocate_section. */
1372
1373 static bfd_byte *
1374 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1375 data, relocateable, symbols)
1376 bfd *output_bfd;
1377 struct bfd_link_info *link_info;
1378 struct bfd_link_order *link_order;
1379 bfd_byte *data;
1380 boolean relocateable;
1381 asymbol **symbols;
1382 {
1383 Elf_Internal_Shdr *symtab_hdr;
1384 asection *input_section = link_order->u.indirect.section;
1385 bfd *input_bfd = input_section->owner;
1386 asection **sections = NULL;
1387 Elf_Internal_Rela *internal_relocs = NULL;
1388 Elf32_External_Sym *external_syms = NULL;
1389 Elf_Internal_Sym *internal_syms = NULL;
1390
1391 /* We only need to handle the case of relaxing, or of having a
1392 particular set of section contents, specially. */
1393 if (relocateable
1394 || elf_section_data (input_section)->this_hdr.contents == NULL)
1395 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1396 link_order, data,
1397 relocateable,
1398 symbols);
1399
1400 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1401
1402 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1403 input_section->_raw_size);
1404
1405 if ((input_section->flags & SEC_RELOC) != 0
1406 && input_section->reloc_count > 0)
1407 {
1408 Elf_Internal_Sym *isymp;
1409 asection **secpp;
1410 Elf32_External_Sym *esym, *esymend;
1411
1412 if (symtab_hdr->contents != NULL)
1413 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1414 else
1415 {
1416 external_syms = ((Elf32_External_Sym *)
1417 bfd_malloc (symtab_hdr->sh_info
1418 * sizeof (Elf32_External_Sym)));
1419 if (external_syms == NULL && symtab_hdr->sh_info > 0)
1420 goto error_return;
1421 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1422 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
1423 symtab_hdr->sh_info, input_bfd)
1424 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
1425 goto error_return;
1426 }
1427
1428 internal_relocs = (_bfd_elf32_link_read_relocs
1429 (input_bfd, input_section, (PTR) NULL,
1430 (Elf_Internal_Rela *) NULL, false));
1431 if (internal_relocs == NULL)
1432 goto error_return;
1433
1434 internal_syms = ((Elf_Internal_Sym *)
1435 bfd_malloc (symtab_hdr->sh_info
1436 * sizeof (Elf_Internal_Sym)));
1437 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1438 goto error_return;
1439
1440 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
1441 * sizeof (asection *));
1442 if (sections == NULL && symtab_hdr->sh_info > 0)
1443 goto error_return;
1444
1445 isymp = internal_syms;
1446 secpp = sections;
1447 esym = external_syms;
1448 esymend = esym + symtab_hdr->sh_info;
1449 for (; esym < esymend; ++esym, ++isymp, ++secpp)
1450 {
1451 asection *isec;
1452
1453 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1454
1455 if (isymp->st_shndx == SHN_UNDEF)
1456 isec = bfd_und_section_ptr;
1457 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1458 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1459 else if (isymp->st_shndx == SHN_ABS)
1460 isec = bfd_abs_section_ptr;
1461 else if (isymp->st_shndx == SHN_COMMON)
1462 isec = bfd_com_section_ptr;
1463 else
1464 {
1465 /* Who knows? */
1466 isec = NULL;
1467 }
1468
1469 *secpp = isec;
1470 }
1471
1472 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1473 input_section, data, internal_relocs,
1474 internal_syms, sections))
1475 goto error_return;
1476
1477 if (sections != NULL)
1478 free (sections);
1479 sections = NULL;
1480 if (internal_syms != NULL)
1481 free (internal_syms);
1482 internal_syms = NULL;
1483 if (external_syms != NULL && symtab_hdr->contents == NULL)
1484 free (external_syms);
1485 external_syms = NULL;
1486 if (internal_relocs != elf_section_data (input_section)->relocs)
1487 free (internal_relocs);
1488 internal_relocs = NULL;
1489 }
1490
1491 return data;
1492
1493 error_return:
1494 if (internal_relocs != NULL
1495 && internal_relocs != elf_section_data (input_section)->relocs)
1496 free (internal_relocs);
1497 if (external_syms != NULL && symtab_hdr->contents == NULL)
1498 free (external_syms);
1499 if (internal_syms != NULL)
1500 free (internal_syms);
1501 if (sections != NULL)
1502 free (sections);
1503 return NULL;
1504 }
1505
1506 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1507 #define TARGET_LITTLE_NAME "elf32-mn10200"
1508 #define ELF_ARCH bfd_arch_mn10200
1509 #define ELF_MACHINE_CODE EM_CYGNUS_MN10200
1510 #define ELF_MAXPAGESIZE 0x1000
1511
1512 #define elf_info_to_howto mn10200_info_to_howto
1513 #define elf_info_to_howto_rel 0
1514 #define elf_backend_relocate_section mn10200_elf_relocate_section
1515 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1516 #define bfd_elf32_bfd_get_relocated_section_contents \
1517 mn10200_elf_get_relocated_section_contents
1518
1519 #define elf_symbol_leading_char '_'
1520
1521 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.062027 seconds and 4 git commands to generate.