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