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