daily update
[binutils.git] / bfd / elf-m10200.c
blob133d2a9befb02937ce5f5453294db1ef8659b425
1 /* Matsushita 10200 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
26 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
27 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
28 static void mn10200_info_to_howto
29 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
30 static bfd_boolean mn10200_elf_relax_delete_bytes
31 PARAMS ((bfd *, asection *, bfd_vma, int));
32 static bfd_boolean mn10200_elf_symbol_address_p
33 PARAMS ((bfd *, asection *, Elf_Internal_Sym *, bfd_vma));
34 static bfd_reloc_status_type mn10200_elf_final_link_relocate
35 PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *,
36 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
37 struct bfd_link_info *, asection *, int));
38 static bfd_boolean mn10200_elf_relocate_section
39 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
40 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *,
41 asection **));
42 static bfd_boolean mn10200_elf_relax_section
43 PARAMS ((bfd *, asection *, struct bfd_link_info *, bfd_boolean *));
44 static bfd_byte * mn10200_elf_get_relocated_section_contents
45 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
46 bfd_byte *, bfd_boolean, asymbol **));
48 enum reloc_type {
49 R_MN10200_NONE = 0,
50 R_MN10200_32,
51 R_MN10200_16,
52 R_MN10200_8,
53 R_MN10200_24,
54 R_MN10200_PCREL8,
55 R_MN10200_PCREL16,
56 R_MN10200_PCREL24,
57 R_MN10200_MAX
60 static reloc_howto_type elf_mn10200_howto_table[] = {
61 /* Dummy relocation. Does nothing. */
62 HOWTO (R_MN10200_NONE,
65 16,
66 FALSE,
68 complain_overflow_bitfield,
69 bfd_elf_generic_reloc,
70 "R_MN10200_NONE",
71 FALSE,
74 FALSE),
75 /* Standard 32 bit reloc. */
76 HOWTO (R_MN10200_32,
79 32,
80 FALSE,
82 complain_overflow_bitfield,
83 bfd_elf_generic_reloc,
84 "R_MN10200_32",
85 FALSE,
86 0xffffffff,
87 0xffffffff,
88 FALSE),
89 /* Standard 16 bit reloc. */
90 HOWTO (R_MN10200_16,
93 16,
94 FALSE,
96 complain_overflow_bitfield,
97 bfd_elf_generic_reloc,
98 "R_MN10200_16",
99 FALSE,
100 0xffff,
101 0xffff,
102 FALSE),
103 /* Standard 8 bit reloc. */
104 HOWTO (R_MN10200_8,
108 FALSE,
110 complain_overflow_bitfield,
111 bfd_elf_generic_reloc,
112 "R_MN10200_8",
113 FALSE,
114 0xff,
115 0xff,
116 FALSE),
117 /* Standard 24 bit reloc. */
118 HOWTO (R_MN10200_24,
122 FALSE,
124 complain_overflow_bitfield,
125 bfd_elf_generic_reloc,
126 "R_MN10200_24",
127 FALSE,
128 0xffffff,
129 0xffffff,
130 FALSE),
131 /* Simple 8 pc-relative reloc. */
132 HOWTO (R_MN10200_PCREL8,
136 TRUE,
138 complain_overflow_bitfield,
139 bfd_elf_generic_reloc,
140 "R_MN10200_PCREL8",
141 FALSE,
142 0xff,
143 0xff,
144 TRUE),
145 /* Simple 16 pc-relative reloc. */
146 HOWTO (R_MN10200_PCREL16,
150 TRUE,
152 complain_overflow_bitfield,
153 bfd_elf_generic_reloc,
154 "R_MN10200_PCREL16",
155 FALSE,
156 0xffff,
157 0xffff,
158 TRUE),
159 /* Simple 32bit pc-relative reloc with a 1 byte adjustment
160 to get the pc-relative offset correct. */
161 HOWTO (R_MN10200_PCREL24,
165 TRUE,
167 complain_overflow_bitfield,
168 bfd_elf_generic_reloc,
169 "R_MN10200_PCREL24",
170 FALSE,
171 0xffffff,
172 0xffffff,
173 TRUE),
176 struct mn10200_reloc_map {
177 bfd_reloc_code_real_type bfd_reloc_val;
178 unsigned char elf_reloc_val;
181 static const struct mn10200_reloc_map mn10200_reloc_map[] = {
182 { BFD_RELOC_NONE , R_MN10200_NONE , },
183 { BFD_RELOC_32 , R_MN10200_32 , },
184 { BFD_RELOC_16 , R_MN10200_16 , },
185 { BFD_RELOC_8 , R_MN10200_8 , },
186 { BFD_RELOC_24 , R_MN10200_24 , },
187 { BFD_RELOC_8_PCREL , R_MN10200_PCREL8 , },
188 { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },
189 { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },
192 static reloc_howto_type *
193 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
194 bfd *abfd ATTRIBUTE_UNUSED;
195 bfd_reloc_code_real_type code;
197 unsigned int i;
199 for (i = 0;
200 i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);
201 i++)
203 if (mn10200_reloc_map[i].bfd_reloc_val == code)
204 return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];
207 return NULL;
210 /* Set the howto pointer for an MN10200 ELF reloc. */
212 static void
213 mn10200_info_to_howto (abfd, cache_ptr, dst)
214 bfd *abfd ATTRIBUTE_UNUSED;
215 arelent *cache_ptr;
216 Elf_Internal_Rela *dst;
218 unsigned int r_type;
220 r_type = ELF32_R_TYPE (dst->r_info);
221 BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX);
222 cache_ptr->howto = &elf_mn10200_howto_table[r_type];
225 /* Perform a relocation as part of a final link. */
227 static bfd_reloc_status_type
228 mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
229 input_section, contents, offset, value,
230 addend, info, sym_sec, is_local)
231 reloc_howto_type *howto;
232 bfd *input_bfd;
233 bfd *output_bfd ATTRIBUTE_UNUSED;
234 asection *input_section;
235 bfd_byte *contents;
236 bfd_vma offset;
237 bfd_vma value;
238 bfd_vma addend;
239 struct bfd_link_info *info ATTRIBUTE_UNUSED;
240 asection *sym_sec ATTRIBUTE_UNUSED;
241 int is_local ATTRIBUTE_UNUSED;
243 unsigned long r_type = howto->type;
244 bfd_byte *hit_data = contents + offset;
246 switch (r_type)
249 case R_MN10200_NONE:
250 return bfd_reloc_ok;
252 case R_MN10200_32:
253 value += addend;
254 bfd_put_32 (input_bfd, value, hit_data);
255 return bfd_reloc_ok;
257 case R_MN10200_16:
258 value += addend;
260 if ((long) value > 0x7fff || (long) value < -0x8000)
261 return bfd_reloc_overflow;
263 bfd_put_16 (input_bfd, value, hit_data);
264 return bfd_reloc_ok;
266 case R_MN10200_8:
267 value += addend;
269 if ((long) value > 0x7f || (long) value < -0x80)
270 return bfd_reloc_overflow;
272 bfd_put_8 (input_bfd, value, hit_data);
273 return bfd_reloc_ok;
275 case R_MN10200_24:
276 value += addend;
278 if ((long) value > 0x7fffff || (long) value < -0x800000)
279 return bfd_reloc_overflow;
281 value &= 0xffffff;
282 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
283 bfd_put_32 (input_bfd, value, hit_data);
284 return bfd_reloc_ok;
286 case R_MN10200_PCREL8:
287 value -= (input_section->output_section->vma
288 + input_section->output_offset);
289 value -= (offset + 1);
290 value += addend;
292 if ((long) value > 0xff || (long) value < -0x100)
293 return bfd_reloc_overflow;
295 bfd_put_8 (input_bfd, value, hit_data);
296 return bfd_reloc_ok;
298 case R_MN10200_PCREL16:
299 value -= (input_section->output_section->vma
300 + input_section->output_offset);
301 value -= (offset + 2);
302 value += addend;
304 if ((long) value > 0xffff || (long) value < -0x10000)
305 return bfd_reloc_overflow;
307 bfd_put_16 (input_bfd, value, hit_data);
308 return bfd_reloc_ok;
310 case R_MN10200_PCREL24:
311 value -= (input_section->output_section->vma
312 + input_section->output_offset);
313 value -= (offset + 3);
314 value += addend;
316 if ((long) value > 0xffffff || (long) value < -0x1000000)
317 return bfd_reloc_overflow;
319 value &= 0xffffff;
320 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
321 bfd_put_32 (input_bfd, value, hit_data);
322 return bfd_reloc_ok;
324 default:
325 return bfd_reloc_notsupported;
329 /* Relocate an MN10200 ELF section. */
330 static bfd_boolean
331 mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section,
332 contents, relocs, local_syms, local_sections)
333 bfd *output_bfd;
334 struct bfd_link_info *info;
335 bfd *input_bfd;
336 asection *input_section;
337 bfd_byte *contents;
338 Elf_Internal_Rela *relocs;
339 Elf_Internal_Sym *local_syms;
340 asection **local_sections;
342 Elf_Internal_Shdr *symtab_hdr;
343 struct elf_link_hash_entry **sym_hashes;
344 Elf_Internal_Rela *rel, *relend;
346 if (info->relocatable)
347 return TRUE;
349 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
350 sym_hashes = elf_sym_hashes (input_bfd);
352 rel = relocs;
353 relend = relocs + input_section->reloc_count;
354 for (; rel < relend; rel++)
356 int r_type;
357 reloc_howto_type *howto;
358 unsigned long r_symndx;
359 Elf_Internal_Sym *sym;
360 asection *sec;
361 struct elf_link_hash_entry *h;
362 bfd_vma relocation;
363 bfd_reloc_status_type r;
365 r_symndx = ELF32_R_SYM (rel->r_info);
366 r_type = ELF32_R_TYPE (rel->r_info);
367 howto = elf_mn10200_howto_table + r_type;
369 h = NULL;
370 sym = NULL;
371 sec = NULL;
372 if (r_symndx < symtab_hdr->sh_info)
374 sym = local_syms + r_symndx;
375 sec = local_sections[r_symndx];
376 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
378 else
380 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
381 while (h->root.type == bfd_link_hash_indirect
382 || h->root.type == bfd_link_hash_warning)
383 h = (struct elf_link_hash_entry *) h->root.u.i.link;
384 if (h->root.type == bfd_link_hash_defined
385 || h->root.type == bfd_link_hash_defweak)
387 sec = h->root.u.def.section;
388 relocation = (h->root.u.def.value
389 + sec->output_section->vma
390 + sec->output_offset);
392 else if (h->root.type == bfd_link_hash_undefweak)
393 relocation = 0;
394 else
396 if (! ((*info->callbacks->undefined_symbol)
397 (info, h->root.root.string, input_bfd,
398 input_section, rel->r_offset, TRUE)))
399 return FALSE;
400 relocation = 0;
404 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
405 input_section,
406 contents, rel->r_offset,
407 relocation, rel->r_addend,
408 info, sec, h == NULL);
410 if (r != bfd_reloc_ok)
412 const char *name;
413 const char *msg = (const char *) 0;
415 if (h != NULL)
416 name = h->root.root.string;
417 else
419 name = (bfd_elf_string_from_elf_section
420 (input_bfd, symtab_hdr->sh_link, sym->st_name));
421 if (name == NULL || *name == '\0')
422 name = bfd_section_name (input_bfd, sec);
425 switch (r)
427 case bfd_reloc_overflow:
428 if (! ((*info->callbacks->reloc_overflow)
429 (info, name, howto->name, (bfd_vma) 0,
430 input_bfd, input_section, rel->r_offset)))
431 return FALSE;
432 break;
434 case bfd_reloc_undefined:
435 if (! ((*info->callbacks->undefined_symbol)
436 (info, name, input_bfd, input_section,
437 rel->r_offset, TRUE)))
438 return FALSE;
439 break;
441 case bfd_reloc_outofrange:
442 msg = _("internal error: out of range error");
443 goto common_error;
445 case bfd_reloc_notsupported:
446 msg = _("internal error: unsupported relocation error");
447 goto common_error;
449 case bfd_reloc_dangerous:
450 msg = _("internal error: dangerous error");
451 goto common_error;
453 default:
454 msg = _("internal error: unknown error");
455 /* fall through */
457 common_error:
458 if (!((*info->callbacks->warning)
459 (info, msg, name, input_bfd, input_section,
460 rel->r_offset)))
461 return FALSE;
462 break;
467 return TRUE;
470 /* This function handles relaxing for the mn10200.
472 There are quite a few relaxing opportunities available on the mn10200:
474 * jsr:24 -> jsr:16 2 bytes
476 * jmp:24 -> jmp:16 2 bytes
477 * jmp:16 -> bra:8 1 byte
479 * If the previous instruction is a conditional branch
480 around the jump/bra, we may be able to reverse its condition
481 and change its target to the jump's target. The jump/bra
482 can then be deleted. 2 bytes
484 * mov abs24 -> mov abs16 2 byte savings
486 * Most instructions which accept imm24 can relax to imm16 2 bytes
487 - Most instructions which accept imm16 can relax to imm8 1 byte
489 * Most instructions which accept d24 can relax to d16 2 bytes
490 - Most instructions which accept d16 can relax to d8 1 byte
492 abs24, imm24, d24 all look the same at the reloc level. It
493 might make the code simpler if we had different relocs for
494 the various relaxable operand types.
496 We don't handle imm16->imm8 or d16->d8 as they're very rare
497 and somewhat more difficult to support. */
499 static bfd_boolean
500 mn10200_elf_relax_section (abfd, sec, link_info, again)
501 bfd *abfd;
502 asection *sec;
503 struct bfd_link_info *link_info;
504 bfd_boolean *again;
506 Elf_Internal_Shdr *symtab_hdr;
507 Elf_Internal_Rela *internal_relocs;
508 Elf_Internal_Rela *irel, *irelend;
509 bfd_byte *contents = NULL;
510 Elf_Internal_Sym *isymbuf = NULL;
512 /* Assume nothing changes. */
513 *again = FALSE;
515 /* We don't have to do anything for a relocatable link, if
516 this section does not have relocs, or if this is not a
517 code section. */
518 if (link_info->relocatable
519 || (sec->flags & SEC_RELOC) == 0
520 || sec->reloc_count == 0
521 || (sec->flags & SEC_CODE) == 0)
522 return TRUE;
524 /* If this is the first time we have been called for this section,
525 initialize the cooked size. */
526 if (sec->_cooked_size == 0)
527 sec->_cooked_size = sec->_raw_size;
529 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
531 /* Get a copy of the native relocations. */
532 internal_relocs = (_bfd_elf_link_read_relocs
533 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
534 link_info->keep_memory));
535 if (internal_relocs == NULL)
536 goto error_return;
538 /* Walk through them looking for relaxing opportunities. */
539 irelend = internal_relocs + sec->reloc_count;
540 for (irel = internal_relocs; irel < irelend; irel++)
542 bfd_vma symval;
544 /* If this isn't something that can be relaxed, then ignore
545 this reloc. */
546 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
547 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
548 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
549 continue;
551 /* Get the section contents if we haven't done so already. */
552 if (contents == NULL)
554 /* Get cached copy if it exists. */
555 if (elf_section_data (sec)->this_hdr.contents != NULL)
556 contents = elf_section_data (sec)->this_hdr.contents;
557 else
559 /* Go get them off disk. */
560 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
561 if (contents == NULL)
562 goto error_return;
564 if (! bfd_get_section_contents (abfd, sec, contents,
565 (file_ptr) 0, sec->_raw_size))
566 goto error_return;
570 /* Read this BFD's local symbols if we haven't done so already. */
571 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
573 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
574 if (isymbuf == NULL)
575 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
576 symtab_hdr->sh_info, 0,
577 NULL, NULL, NULL);
578 if (isymbuf == NULL)
579 goto error_return;
582 /* Get the value of the symbol referred to by the reloc. */
583 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
585 /* A local symbol. */
586 Elf_Internal_Sym *isym;
587 asection *sym_sec;
589 isym = isymbuf + ELF32_R_SYM (irel->r_info);
590 if (isym->st_shndx == SHN_UNDEF)
591 sym_sec = bfd_und_section_ptr;
592 else if (isym->st_shndx == SHN_ABS)
593 sym_sec = bfd_abs_section_ptr;
594 else if (isym->st_shndx == SHN_COMMON)
595 sym_sec = bfd_com_section_ptr;
596 else
597 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
598 symval = (isym->st_value
599 + sym_sec->output_section->vma
600 + sym_sec->output_offset);
602 else
604 unsigned long indx;
605 struct elf_link_hash_entry *h;
607 /* An external symbol. */
608 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
609 h = elf_sym_hashes (abfd)[indx];
610 BFD_ASSERT (h != NULL);
611 if (h->root.type != bfd_link_hash_defined
612 && h->root.type != bfd_link_hash_defweak)
614 /* This appears to be a reference to an undefined
615 symbol. Just ignore it--it will be caught by the
616 regular reloc processing. */
617 continue;
620 symval = (h->root.u.def.value
621 + h->root.u.def.section->output_section->vma
622 + h->root.u.def.section->output_offset);
625 /* For simplicity of coding, we are going to modify the section
626 contents, the section relocs, and the BFD symbol table. We
627 must tell the rest of the code not to free up this
628 information. It would be possible to instead create a table
629 of changes which have to be made, as is done in coff-mips.c;
630 that would be more work, but would require less memory when
631 the linker is run. */
633 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
634 branch/call. */
635 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
637 bfd_vma value = symval;
639 /* Deal with pc-relative gunk. */
640 value -= (sec->output_section->vma + sec->output_offset);
641 value -= (irel->r_offset + 3);
642 value += irel->r_addend;
644 /* See if the value will fit in 16 bits, note the high value is
645 0x7fff + 2 as the target will be two bytes closer if we are
646 able to relax. */
647 if ((long) value < 0x8001 && (long) value > -0x8000)
649 unsigned char code;
651 /* Get the opcode. */
652 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
654 if (code != 0xe0 && code != 0xe1)
655 continue;
657 /* Note that we've changed the relocs, section contents, etc. */
658 elf_section_data (sec)->relocs = internal_relocs;
659 elf_section_data (sec)->this_hdr.contents = contents;
660 symtab_hdr->contents = (unsigned char *) isymbuf;
662 /* Fix the opcode. */
663 if (code == 0xe0)
664 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
665 else if (code == 0xe1)
666 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
668 /* Fix the relocation's type. */
669 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
670 R_MN10200_PCREL16);
672 /* The opcode got shorter too, so we have to fix the offset. */
673 irel->r_offset -= 1;
675 /* Delete two bytes of data. */
676 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
677 irel->r_offset + 1, 2))
678 goto error_return;
680 /* That will change things, so, we should relax again.
681 Note that this is not required, and it may be slow. */
682 *again = TRUE;
686 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
687 branch. */
688 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
690 bfd_vma value = symval;
692 /* Deal with pc-relative gunk. */
693 value -= (sec->output_section->vma + sec->output_offset);
694 value -= (irel->r_offset + 2);
695 value += irel->r_addend;
697 /* See if the value will fit in 8 bits, note the high value is
698 0x7f + 1 as the target will be one bytes closer if we are
699 able to relax. */
700 if ((long) value < 0x80 && (long) value > -0x80)
702 unsigned char code;
704 /* Get the opcode. */
705 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
707 if (code != 0xfc)
708 continue;
710 /* Note that we've changed the relocs, section contents, etc. */
711 elf_section_data (sec)->relocs = internal_relocs;
712 elf_section_data (sec)->this_hdr.contents = contents;
713 symtab_hdr->contents = (unsigned char *) isymbuf;
715 /* Fix the opcode. */
716 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
718 /* Fix the relocation's type. */
719 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
720 R_MN10200_PCREL8);
722 /* Delete one byte of data. */
723 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
724 irel->r_offset + 1, 1))
725 goto error_return;
727 /* That will change things, so, we should relax again.
728 Note that this is not required, and it may be slow. */
729 *again = TRUE;
733 /* Try to eliminate an unconditional 8 bit pc-relative branch
734 which immediately follows a conditional 8 bit pc-relative
735 branch around the unconditional branch.
737 original: new:
738 bCC lab1 bCC' lab2
739 bra lab2
740 lab1: lab1:
742 This happens when the bCC can't reach lab2 at assembly time,
743 but due to other relaxations it can reach at link time. */
744 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
746 Elf_Internal_Rela *nrel;
747 bfd_vma value = symval;
748 unsigned char code;
750 /* Deal with pc-relative gunk. */
751 value -= (sec->output_section->vma + sec->output_offset);
752 value -= (irel->r_offset + 1);
753 value += irel->r_addend;
755 /* Do nothing if this reloc is the last byte in the section. */
756 if (irel->r_offset == sec->_cooked_size)
757 continue;
759 /* See if the next instruction is an unconditional pc-relative
760 branch, more often than not this test will fail, so we
761 test it first to speed things up. */
762 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
763 if (code != 0xea)
764 continue;
766 /* Also make sure the next relocation applies to the next
767 instruction and that it's a pc-relative 8 bit branch. */
768 nrel = irel + 1;
769 if (nrel == irelend
770 || irel->r_offset + 2 != nrel->r_offset
771 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
772 continue;
774 /* Make sure our destination immediately follows the
775 unconditional branch. */
776 if (symval != (sec->output_section->vma + sec->output_offset
777 + irel->r_offset + 3))
778 continue;
780 /* Now make sure we are a conditional branch. This may not
781 be necessary, but why take the chance.
783 Note these checks assume that R_MN10200_PCREL8 relocs
784 only occur on bCC and bCCx insns. If they occured
785 elsewhere, we'd need to know the start of this insn
786 for this check to be accurate. */
787 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
788 if (code != 0xe0 && code != 0xe1 && code != 0xe2
789 && code != 0xe3 && code != 0xe4 && code != 0xe5
790 && code != 0xe6 && code != 0xe7 && code != 0xe8
791 && code != 0xe9 && code != 0xec && code != 0xed
792 && code != 0xee && code != 0xef && code != 0xfc
793 && code != 0xfd && code != 0xfe && code != 0xff)
794 continue;
796 /* We also have to be sure there is no symbol/label
797 at the unconditional branch. */
798 if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
799 irel->r_offset + 1))
800 continue;
802 /* Note that we've changed the relocs, section contents, etc. */
803 elf_section_data (sec)->relocs = internal_relocs;
804 elf_section_data (sec)->this_hdr.contents = contents;
805 symtab_hdr->contents = (unsigned char *) isymbuf;
807 /* Reverse the condition of the first branch. */
808 switch (code)
810 case 0xfc:
811 code = 0xfd;
812 break;
813 case 0xfd:
814 code = 0xfc;
815 break;
816 case 0xfe:
817 code = 0xff;
818 break;
819 case 0xff:
820 code = 0xfe;
821 break;
822 case 0xe8:
823 code = 0xe9;
824 break;
825 case 0xe9:
826 code = 0xe8;
827 break;
828 case 0xe0:
829 code = 0xe2;
830 break;
831 case 0xe2:
832 code = 0xe0;
833 break;
834 case 0xe3:
835 code = 0xe1;
836 break;
837 case 0xe1:
838 code = 0xe3;
839 break;
840 case 0xe4:
841 code = 0xe6;
842 break;
843 case 0xe6:
844 code = 0xe4;
845 break;
846 case 0xe7:
847 code = 0xe5;
848 break;
849 case 0xe5:
850 code = 0xe7;
851 break;
852 case 0xec:
853 code = 0xed;
854 break;
855 case 0xed:
856 code = 0xec;
857 break;
858 case 0xee:
859 code = 0xef;
860 break;
861 case 0xef:
862 code = 0xee;
863 break;
865 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
867 /* Set the reloc type and symbol for the first branch
868 from the second branch. */
869 irel->r_info = nrel->r_info;
871 /* Make the reloc for the second branch a null reloc. */
872 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
873 R_MN10200_NONE);
875 /* Delete two bytes of data. */
876 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
877 irel->r_offset + 1, 2))
878 goto error_return;
880 /* That will change things, so, we should relax again.
881 Note that this is not required, and it may be slow. */
882 *again = TRUE;
885 /* Try to turn a 24bit immediate, displacement or absolute address
886 into a 16bit immediate, displacement or absolute address. */
887 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
889 bfd_vma value = symval;
891 /* See if the value will fit in 16 bits.
892 We allow any 16bit match here. We prune those we can't
893 handle below. */
894 if ((long) value < 0x7fff && (long) value > -0x8000)
896 unsigned char code;
898 /* All insns which have 24bit operands are 5 bytes long,
899 the first byte will always be 0xf4, but we double check
900 it just in case. */
902 /* Get the first opcode. */
903 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
905 if (code != 0xf4)
906 continue;
908 /* Get the second opcode. */
909 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
911 switch (code & 0xfc)
913 /* mov imm24,dn -> mov imm16,dn */
914 case 0x70:
915 /* Not safe if the high bit is on as relaxing may
916 move the value out of high mem and thus not fit
917 in a signed 16bit value. */
918 if (value & 0x8000)
919 continue;
921 /* Note that we've changed the relocation contents, etc. */
922 elf_section_data (sec)->relocs = internal_relocs;
923 elf_section_data (sec)->this_hdr.contents = contents;
924 symtab_hdr->contents = (unsigned char *) isymbuf;
926 /* Fix the opcode. */
927 bfd_put_8 (abfd, 0xf8 + (code & 0x03),
928 contents + irel->r_offset - 2);
930 /* Fix the relocation's type. */
931 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
932 R_MN10200_16);
934 /* The opcode got shorter too, so we have to fix the
935 offset. */
936 irel->r_offset -= 1;
938 /* Delete two bytes of data. */
939 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
940 irel->r_offset + 1, 2))
941 goto error_return;
943 /* That will change things, so, we should relax again.
944 Note that this is not required, and it may be slow. */
945 *again = TRUE;
946 break;
948 /* mov imm24,an -> mov imm16,an
949 cmp imm24,an -> cmp imm16,an
950 mov (abs24),dn -> mov (abs16),dn
951 mov dn,(abs24) -> mov dn,(abs16)
952 movb dn,(abs24) -> movb dn,(abs16)
953 movbu (abs24),dn -> movbu (abs16),dn */
954 case 0x74:
955 case 0x7c:
956 case 0xc0:
957 case 0x40:
958 case 0x44:
959 case 0xc8:
960 /* Note that we've changed the relocation contents, etc. */
961 elf_section_data (sec)->relocs = internal_relocs;
962 elf_section_data (sec)->this_hdr.contents = contents;
963 symtab_hdr->contents = (unsigned char *) isymbuf;
965 if ((code & 0xfc) == 0x74)
966 code = 0xdc + (code & 0x03);
967 else if ((code & 0xfc) == 0x7c)
968 code = 0xec + (code & 0x03);
969 else if ((code & 0xfc) == 0xc0)
970 code = 0xc8 + (code & 0x03);
971 else if ((code & 0xfc) == 0x40)
972 code = 0xc0 + (code & 0x03);
973 else if ((code & 0xfc) == 0x44)
974 code = 0xc4 + (code & 0x03);
975 else if ((code & 0xfc) == 0xc8)
976 code = 0xcc + (code & 0x03);
978 /* Fix the opcode. */
979 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
981 /* Fix the relocation's type. */
982 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
983 R_MN10200_16);
985 /* The opcode got shorter too, so we have to fix the
986 offset. */
987 irel->r_offset -= 1;
989 /* Delete two bytes of data. */
990 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
991 irel->r_offset + 1, 2))
992 goto error_return;
994 /* That will change things, so, we should relax again.
995 Note that this is not required, and it may be slow. */
996 *again = TRUE;
997 break;
999 /* cmp imm24,dn -> cmp imm16,dn
1000 mov (abs24),an -> mov (abs16),an
1001 mov an,(abs24) -> mov an,(abs16)
1002 add imm24,dn -> add imm16,dn
1003 add imm24,an -> add imm16,an
1004 sub imm24,dn -> sub imm16,dn
1005 sub imm24,an -> sub imm16,an
1006 And all d24->d16 in memory ops. */
1007 case 0x78:
1008 case 0xd0:
1009 case 0x50:
1010 case 0x60:
1011 case 0x64:
1012 case 0x68:
1013 case 0x6c:
1014 case 0x80:
1015 case 0xf0:
1016 case 0x00:
1017 case 0x10:
1018 case 0xb0:
1019 case 0x30:
1020 case 0xa0:
1021 case 0x20:
1022 case 0x90:
1023 /* Not safe if the high bit is on as relaxing may
1024 move the value out of high mem and thus not fit
1025 in a signed 16bit value. */
1026 if (((code & 0xfc) == 0x78
1027 || (code & 0xfc) == 0x60
1028 || (code & 0xfc) == 0x64
1029 || (code & 0xfc) == 0x68
1030 || (code & 0xfc) == 0x6c
1031 || (code & 0xfc) == 0x80
1032 || (code & 0xfc) == 0xf0
1033 || (code & 0xfc) == 0x00
1034 || (code & 0xfc) == 0x10
1035 || (code & 0xfc) == 0xb0
1036 || (code & 0xfc) == 0x30
1037 || (code & 0xfc) == 0xa0
1038 || (code & 0xfc) == 0x20
1039 || (code & 0xfc) == 0x90)
1040 && (value & 0x8000) != 0)
1041 continue;
1043 /* Note that we've changed the relocation contents, etc. */
1044 elf_section_data (sec)->relocs = internal_relocs;
1045 elf_section_data (sec)->this_hdr.contents = contents;
1046 symtab_hdr->contents = (unsigned char *) isymbuf;
1048 /* Fix the opcode. */
1049 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1051 if ((code & 0xfc) == 0x78)
1052 code = 0x48 + (code & 0x03);
1053 else if ((code & 0xfc) == 0xd0)
1054 code = 0x30 + (code & 0x03);
1055 else if ((code & 0xfc) == 0x50)
1056 code = 0x20 + (code & 0x03);
1057 else if ((code & 0xfc) == 0x60)
1058 code = 0x18 + (code & 0x03);
1059 else if ((code & 0xfc) == 0x64)
1060 code = 0x08 + (code & 0x03);
1061 else if ((code & 0xfc) == 0x68)
1062 code = 0x1c + (code & 0x03);
1063 else if ((code & 0xfc) == 0x6c)
1064 code = 0x0c + (code & 0x03);
1065 else if ((code & 0xfc) == 0x80)
1066 code = 0xc0 + (code & 0x07);
1067 else if ((code & 0xfc) == 0xf0)
1068 code = 0xb0 + (code & 0x07);
1069 else if ((code & 0xfc) == 0x00)
1070 code = 0x80 + (code & 0x07);
1071 else if ((code & 0xfc) == 0x10)
1072 code = 0xa0 + (code & 0x07);
1073 else if ((code & 0xfc) == 0xb0)
1074 code = 0x70 + (code & 0x07);
1075 else if ((code & 0xfc) == 0x30)
1076 code = 0x60 + (code & 0x07);
1077 else if ((code & 0xfc) == 0xa0)
1078 code = 0xd0 + (code & 0x07);
1079 else if ((code & 0xfc) == 0x20)
1080 code = 0x90 + (code & 0x07);
1081 else if ((code & 0xfc) == 0x90)
1082 code = 0x50 + (code & 0x07);
1084 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1086 /* Fix the relocation's type. */
1087 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1088 R_MN10200_16);
1090 /* Delete one bytes of data. */
1091 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1092 irel->r_offset + 2, 1))
1093 goto error_return;
1095 /* That will change things, so, we should relax again.
1096 Note that this is not required, and it may be slow. */
1097 *again = TRUE;
1098 break;
1100 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1101 case 0xc4:
1102 /* Note that we've changed the reldection contents, etc. */
1103 elf_section_data (sec)->relocs = internal_relocs;
1104 elf_section_data (sec)->this_hdr.contents = contents;
1105 symtab_hdr->contents = (unsigned char *) isymbuf;
1107 bfd_put_8 (abfd, 0xcc + (code & 0x03),
1108 contents + irel->r_offset - 2);
1110 bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1111 contents + irel->r_offset - 1);
1113 /* Fix the relocation's type. */
1114 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1115 R_MN10200_16);
1117 /* The reloc will be applied one byte in front of its
1118 current location. */
1119 irel->r_offset -= 1;
1121 /* Delete one bytes of data. */
1122 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1123 irel->r_offset + 2, 1))
1124 goto error_return;
1126 /* That will change things, so, we should relax again.
1127 Note that this is not required, and it may be slow. */
1128 *again = TRUE;
1129 break;
1135 if (isymbuf != NULL
1136 && symtab_hdr->contents != (unsigned char *) isymbuf)
1138 if (! link_info->keep_memory)
1139 free (isymbuf);
1140 else
1142 /* Cache the symbols for elf_link_input_bfd. */
1143 symtab_hdr->contents = (unsigned char *) isymbuf;
1147 if (contents != NULL
1148 && elf_section_data (sec)->this_hdr.contents != contents)
1150 if (! link_info->keep_memory)
1151 free (contents);
1152 else
1154 /* Cache the section contents for elf_link_input_bfd. */
1155 elf_section_data (sec)->this_hdr.contents = contents;
1159 if (internal_relocs != NULL
1160 && elf_section_data (sec)->relocs != internal_relocs)
1161 free (internal_relocs);
1163 return TRUE;
1165 error_return:
1166 if (isymbuf != NULL
1167 && symtab_hdr->contents != (unsigned char *) isymbuf)
1168 free (isymbuf);
1169 if (contents != NULL
1170 && elf_section_data (sec)->this_hdr.contents != contents)
1171 free (contents);
1172 if (internal_relocs != NULL
1173 && elf_section_data (sec)->relocs != internal_relocs)
1174 free (internal_relocs);
1176 return FALSE;
1179 /* Delete some bytes from a section while relaxing. */
1181 static bfd_boolean
1182 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1183 bfd *abfd;
1184 asection *sec;
1185 bfd_vma addr;
1186 int count;
1188 Elf_Internal_Shdr *symtab_hdr;
1189 unsigned int sec_shndx;
1190 bfd_byte *contents;
1191 Elf_Internal_Rela *irel, *irelend;
1192 Elf_Internal_Rela *irelalign;
1193 bfd_vma toaddr;
1194 Elf_Internal_Sym *isym;
1195 Elf_Internal_Sym *isymend;
1196 struct elf_link_hash_entry **sym_hashes;
1197 struct elf_link_hash_entry **end_hashes;
1198 unsigned int symcount;
1200 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1202 contents = elf_section_data (sec)->this_hdr.contents;
1204 /* The deletion must stop at the next ALIGN reloc for an aligment
1205 power larger than the number of bytes we are deleting. */
1207 irelalign = NULL;
1208 toaddr = sec->_cooked_size;
1210 irel = elf_section_data (sec)->relocs;
1211 irelend = irel + sec->reloc_count;
1213 /* Actually delete the bytes. */
1214 memmove (contents + addr, contents + addr + count,
1215 (size_t) (toaddr - addr - count));
1216 sec->_cooked_size -= count;
1218 /* Adjust all the relocs. */
1219 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1221 /* Get the new reloc address. */
1222 if ((irel->r_offset > addr
1223 && irel->r_offset < toaddr))
1224 irel->r_offset -= count;
1227 /* Adjust the local symbols defined in this section. */
1228 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1229 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1230 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1232 if (isym->st_shndx == sec_shndx
1233 && isym->st_value > addr
1234 && isym->st_value < toaddr)
1235 isym->st_value -= count;
1238 /* Now adjust the global symbols defined in this section. */
1239 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1240 - symtab_hdr->sh_info);
1241 sym_hashes = elf_sym_hashes (abfd);
1242 end_hashes = sym_hashes + symcount;
1243 for (; sym_hashes < end_hashes; sym_hashes++)
1245 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1246 if ((sym_hash->root.type == bfd_link_hash_defined
1247 || sym_hash->root.type == bfd_link_hash_defweak)
1248 && sym_hash->root.u.def.section == sec
1249 && sym_hash->root.u.def.value > addr
1250 && sym_hash->root.u.def.value < toaddr)
1252 sym_hash->root.u.def.value -= count;
1256 return TRUE;
1259 /* Return TRUE if a symbol exists at the given address, else return
1260 FALSE. */
1261 static bfd_boolean
1262 mn10200_elf_symbol_address_p (abfd, sec, isym, addr)
1263 bfd *abfd;
1264 asection *sec;
1265 Elf_Internal_Sym *isym;
1266 bfd_vma addr;
1268 Elf_Internal_Shdr *symtab_hdr;
1269 unsigned int sec_shndx;
1270 Elf_Internal_Sym *isymend;
1271 struct elf_link_hash_entry **sym_hashes;
1272 struct elf_link_hash_entry **end_hashes;
1273 unsigned int symcount;
1275 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1277 /* Examine all the local symbols. */
1278 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1279 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1281 if (isym->st_shndx == sec_shndx
1282 && isym->st_value == addr)
1283 return TRUE;
1286 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1287 - symtab_hdr->sh_info);
1288 sym_hashes = elf_sym_hashes (abfd);
1289 end_hashes = sym_hashes + symcount;
1290 for (; sym_hashes < end_hashes; sym_hashes++)
1292 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1293 if ((sym_hash->root.type == bfd_link_hash_defined
1294 || sym_hash->root.type == bfd_link_hash_defweak)
1295 && sym_hash->root.u.def.section == sec
1296 && sym_hash->root.u.def.value == addr)
1297 return TRUE;
1300 return FALSE;
1303 /* This is a version of bfd_generic_get_relocated_section_contents
1304 which uses mn10200_elf_relocate_section. */
1306 static bfd_byte *
1307 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1308 data, relocatable, symbols)
1309 bfd *output_bfd;
1310 struct bfd_link_info *link_info;
1311 struct bfd_link_order *link_order;
1312 bfd_byte *data;
1313 bfd_boolean relocatable;
1314 asymbol **symbols;
1316 Elf_Internal_Shdr *symtab_hdr;
1317 asection *input_section = link_order->u.indirect.section;
1318 bfd *input_bfd = input_section->owner;
1319 asection **sections = NULL;
1320 Elf_Internal_Rela *internal_relocs = NULL;
1321 Elf_Internal_Sym *isymbuf = NULL;
1323 /* We only need to handle the case of relaxing, or of having a
1324 particular set of section contents, specially. */
1325 if (relocatable
1326 || elf_section_data (input_section)->this_hdr.contents == NULL)
1327 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1328 link_order, data,
1329 relocatable,
1330 symbols);
1332 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1334 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1335 (size_t) input_section->_raw_size);
1337 if ((input_section->flags & SEC_RELOC) != 0
1338 && input_section->reloc_count > 0)
1340 Elf_Internal_Sym *isym;
1341 Elf_Internal_Sym *isymend;
1342 asection **secpp;
1343 bfd_size_type amt;
1345 internal_relocs = (_bfd_elf_link_read_relocs
1346 (input_bfd, input_section, (PTR) NULL,
1347 (Elf_Internal_Rela *) NULL, FALSE));
1348 if (internal_relocs == NULL)
1349 goto error_return;
1351 if (symtab_hdr->sh_info != 0)
1353 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1354 if (isymbuf == NULL)
1355 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1356 symtab_hdr->sh_info, 0,
1357 NULL, NULL, NULL);
1358 if (isymbuf == NULL)
1359 goto error_return;
1362 amt = symtab_hdr->sh_info;
1363 amt *= sizeof (asection *);
1364 sections = (asection **) bfd_malloc (amt);
1365 if (sections == NULL && amt != 0)
1366 goto error_return;
1368 isymend = isymbuf + symtab_hdr->sh_info;
1369 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1371 asection *isec;
1373 if (isym->st_shndx == SHN_UNDEF)
1374 isec = bfd_und_section_ptr;
1375 else if (isym->st_shndx == SHN_ABS)
1376 isec = bfd_abs_section_ptr;
1377 else if (isym->st_shndx == SHN_COMMON)
1378 isec = bfd_com_section_ptr;
1379 else
1380 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1382 *secpp = isec;
1385 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1386 input_section, data, internal_relocs,
1387 isymbuf, sections))
1388 goto error_return;
1390 if (sections != NULL)
1391 free (sections);
1392 if (isymbuf != NULL
1393 && symtab_hdr->contents != (unsigned char *) isymbuf)
1394 free (isymbuf);
1395 if (elf_section_data (input_section)->relocs != internal_relocs)
1396 free (internal_relocs);
1399 return data;
1401 error_return:
1402 if (sections != NULL)
1403 free (sections);
1404 if (isymbuf != NULL
1405 && symtab_hdr->contents != (unsigned char *) isymbuf)
1406 free (isymbuf);
1407 if (internal_relocs != NULL
1408 && elf_section_data (input_section)->relocs != internal_relocs)
1409 free (internal_relocs);
1410 return NULL;
1413 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1414 #define TARGET_LITTLE_NAME "elf32-mn10200"
1415 #define ELF_ARCH bfd_arch_mn10200
1416 #define ELF_MACHINE_CODE EM_MN10200
1417 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200
1418 #define ELF_MAXPAGESIZE 0x1000
1420 #define elf_backend_rela_normal 1
1421 #define elf_info_to_howto mn10200_info_to_howto
1422 #define elf_info_to_howto_rel 0
1423 #define elf_backend_relocate_section mn10200_elf_relocate_section
1424 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1425 #define bfd_elf32_bfd_get_relocated_section_contents \
1426 mn10200_elf_get_relocated_section_contents
1428 #define elf_symbol_leading_char '_'
1430 #include "elf32-target.h"