1 /* Motorola 68HC11-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed by Stephane Carrez (stcarrez@nerim.fr)
4 (Heavily copied from the D10V port by Martin Hunt (hunt@cygnus.com))
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 #include "elf/m68hc11.h"
29 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
30 PARAMS ((bfd *, bfd_reloc_code_real_type));
31 static void m68hc11_info_to_howto_rel
32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
34 static bfd_reloc_status_type m68hc11_elf_ignore_reloc
35 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
37 /* GC mark and sweep. */
38 static asection *elf32_m68hc11_gc_mark_hook
39 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
40 struct elf_link_hash_entry *, Elf_Internal_Sym *));
41 static boolean elf32_m68hc11_gc_sweep_hook
42 PARAMS ((bfd *, struct bfd_link_info *, asection *,
43 const Elf_Internal_Rela *));
44 static boolean elf32_m68hc11_check_relocs
45 PARAMS ((bfd *, struct bfd_link_info *, asection *,
46 const Elf_Internal_Rela *));
47 static boolean elf32_m68hc11_relocate_section
48 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
49 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
50 static boolean m68hc11_elf_relax_section
51 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
52 static void m68hc11_elf_relax_delete_bytes
53 PARAMS ((bfd *, asection *, bfd_vma, int));
54 static void m68hc11_relax_group
55 PARAMS ((bfd *, asection *, bfd_byte *, unsigned,
56 unsigned long, unsigned long));
57 static int compare_reloc PARAMS ((const void *, const void *));
60 boolean _bfd_m68hc11_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
61 boolean _bfd_m68hc11_elf_set_private_flags PARAMS ((bfd *, flagword));
62 boolean _bfd_m68hc11_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
64 /* Use REL instead of RELA to save space */
67 /* The Motorola 68HC11 microcontroler only addresses 64Kb.
68 We must handle 8 and 16-bit relocations. The 32-bit relocation
69 is defined but not used except by gas when -gstabs is used (which
71 The 3-bit and 16-bit PC rel relocation is only used by 68HC12. */
72 static reloc_howto_type elf_m68hc11_howto_table[] = {
73 /* This reloc does nothing. */
74 HOWTO (R_M68HC11_NONE, /* type */
76 2, /* size (0 = byte, 1 = short, 2 = long) */
78 false, /* pc_relative */
80 complain_overflow_dont,/* complain_on_overflow */
81 bfd_elf_generic_reloc, /* special_function */
82 "R_M68HC11_NONE", /* name */
83 false, /* partial_inplace */
86 false), /* pcrel_offset */
88 /* A 8 bit absolute relocation */
89 HOWTO (R_M68HC11_8, /* type */
91 0, /* size (0 = byte, 1 = short, 2 = long) */
93 false, /* pc_relative */
95 complain_overflow_bitfield, /* complain_on_overflow */
96 bfd_elf_generic_reloc, /* special_function */
97 "R_M68HC11_8", /* name */
98 false, /* partial_inplace */
99 0x00ff, /* src_mask */
100 0x00ff, /* dst_mask */
101 false), /* pcrel_offset */
103 /* A 8 bit absolute relocation (upper address) */
104 HOWTO (R_M68HC11_HI8, /* type */
106 0, /* size (0 = byte, 1 = short, 2 = long) */
108 false, /* pc_relative */
110 complain_overflow_bitfield, /* complain_on_overflow */
111 bfd_elf_generic_reloc, /* special_function */
112 "R_M68HC11_HI8", /* name */
113 false, /* partial_inplace */
114 0x00ff, /* src_mask */
115 0x00ff, /* dst_mask */
116 false), /* pcrel_offset */
118 /* A 8 bit absolute relocation (upper address) */
119 HOWTO (R_M68HC11_LO8, /* type */
121 0, /* size (0 = byte, 1 = short, 2 = long) */
123 false, /* pc_relative */
125 complain_overflow_dont, /* complain_on_overflow */
126 bfd_elf_generic_reloc, /* special_function */
127 "R_M68HC11_LO8", /* name */
128 false, /* partial_inplace */
129 0x00ff, /* src_mask */
130 0x00ff, /* dst_mask */
131 false), /* pcrel_offset */
133 /* A 8 bit PC-rel relocation */
134 HOWTO (R_M68HC11_PCREL_8, /* type */
136 0, /* size (0 = byte, 1 = short, 2 = long) */
138 true, /* pc_relative */
140 complain_overflow_bitfield, /* complain_on_overflow */
141 bfd_elf_generic_reloc, /* special_function */
142 "R_M68HC11_PCREL_8", /* name */
143 false, /* partial_inplace */
144 0x00ff, /* src_mask */
145 0x00ff, /* dst_mask */
146 false), /* pcrel_offset */
148 /* A 16 bit absolute relocation */
149 HOWTO (R_M68HC11_16, /* type */
151 1, /* size (0 = byte, 1 = short, 2 = long) */
153 false, /* pc_relative */
155 complain_overflow_dont /*bitfield */ , /* complain_on_overflow */
156 bfd_elf_generic_reloc, /* special_function */
157 "R_M68HC11_16", /* name */
158 false, /* partial_inplace */
159 0xffff, /* src_mask */
160 0xffff, /* dst_mask */
161 false), /* pcrel_offset */
163 /* A 32 bit absolute relocation. This one is never used for the
164 code relocation. It's used by gas for -gstabs generation. */
165 HOWTO (R_M68HC11_32, /* type */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
169 false, /* pc_relative */
171 complain_overflow_bitfield, /* complain_on_overflow */
172 bfd_elf_generic_reloc, /* special_function */
173 "R_M68HC11_32", /* name */
174 false, /* partial_inplace */
175 0xffffffff, /* src_mask */
176 0xffffffff, /* dst_mask */
177 false), /* pcrel_offset */
179 /* A 3 bit absolute relocation */
180 HOWTO (R_M68HC11_3B, /* type */
182 0, /* size (0 = byte, 1 = short, 2 = long) */
184 false, /* pc_relative */
186 complain_overflow_bitfield, /* complain_on_overflow */
187 bfd_elf_generic_reloc, /* special_function */
188 "R_M68HC11_4B", /* name */
189 false, /* partial_inplace */
190 0x003, /* src_mask */
191 0x003, /* dst_mask */
192 false), /* pcrel_offset */
194 /* A 16 bit PC-rel relocation */
195 HOWTO (R_M68HC11_PCREL_16, /* type */
197 1, /* size (0 = byte, 1 = short, 2 = long) */
199 true, /* pc_relative */
201 complain_overflow_dont, /* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_M68HC11_PCREL_16", /* name */
204 false, /* partial_inplace */
205 0xffff, /* src_mask */
206 0xffff, /* dst_mask */
207 false), /* pcrel_offset */
209 /* GNU extension to record C++ vtable hierarchy */
210 HOWTO (R_M68HC11_GNU_VTINHERIT, /* type */
212 1, /* size (0 = byte, 1 = short, 2 = long) */
214 false, /* pc_relative */
216 complain_overflow_dont, /* complain_on_overflow */
217 NULL, /* special_function */
218 "R_M68HC11_GNU_VTINHERIT", /* name */
219 false, /* partial_inplace */
222 false), /* pcrel_offset */
224 /* GNU extension to record C++ vtable member usage */
225 HOWTO (R_M68HC11_GNU_VTENTRY, /* type */
227 1, /* size (0 = byte, 1 = short, 2 = long) */
229 false, /* pc_relative */
231 complain_overflow_dont, /* complain_on_overflow */
232 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
233 "R_M68HC11_GNU_VTENTRY", /* name */
234 false, /* partial_inplace */
237 false), /* pcrel_offset */
239 /* A 24 bit relocation */
240 HOWTO (R_M68HC11_24, /* type */
242 1, /* size (0 = byte, 1 = short, 2 = long) */
244 false, /* pc_relative */
246 complain_overflow_bitfield, /* complain_on_overflow */
247 bfd_elf_generic_reloc, /* special_function */
248 "R_M68HC11_24", /* name */
249 false, /* partial_inplace */
250 0xffff, /* src_mask */
251 0xffff, /* dst_mask */
252 false), /* pcrel_offset */
254 /* A 16-bit low relocation */
255 HOWTO (R_M68HC11_LO16, /* type */
257 1, /* size (0 = byte, 1 = short, 2 = long) */
259 false, /* pc_relative */
261 complain_overflow_bitfield, /* complain_on_overflow */
262 bfd_elf_generic_reloc, /* special_function */
263 "R_M68HC11_LO16", /* name */
264 false, /* partial_inplace */
265 0xffff, /* src_mask */
266 0xffff, /* dst_mask */
267 false), /* pcrel_offset */
269 /* A page relocation */
270 HOWTO (R_M68HC11_PAGE, /* type */
272 0, /* size (0 = byte, 1 = short, 2 = long) */
274 false, /* pc_relative */
276 complain_overflow_bitfield, /* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_M68HC11_PAGE", /* name */
279 false, /* partial_inplace */
280 0x00ff, /* src_mask */
281 0x00ff, /* dst_mask */
282 false), /* pcrel_offset */
291 /* Mark beginning of a jump instruction (any form). */
292 HOWTO (R_M68HC11_RL_JUMP, /* type */
294 1, /* size (0 = byte, 1 = short, 2 = long) */
296 false, /* pc_relative */
298 complain_overflow_dont, /* complain_on_overflow */
299 m68hc11_elf_ignore_reloc, /* special_function */
300 "R_M68HC11_RL_JUMP", /* name */
301 true, /* partial_inplace */
304 true), /* pcrel_offset */
306 /* Mark beginning of Gcc relaxation group instruction. */
307 HOWTO (R_M68HC11_RL_GROUP, /* type */
309 1, /* size (0 = byte, 1 = short, 2 = long) */
311 false, /* pc_relative */
313 complain_overflow_dont, /* complain_on_overflow */
314 m68hc11_elf_ignore_reloc, /* special_function */
315 "R_M68HC11_RL_GROUP", /* name */
316 true, /* partial_inplace */
319 true), /* pcrel_offset */
322 /* Map BFD reloc types to M68HC11 ELF reloc types. */
324 struct m68hc11_reloc_map
326 bfd_reloc_code_real_type bfd_reloc_val;
327 unsigned char elf_reloc_val;
330 static const struct m68hc11_reloc_map m68hc11_reloc_map[] = {
331 {BFD_RELOC_NONE, R_M68HC11_NONE,},
332 {BFD_RELOC_8, R_M68HC11_8},
333 {BFD_RELOC_M68HC11_HI8, R_M68HC11_HI8},
334 {BFD_RELOC_M68HC11_LO8, R_M68HC11_LO8},
335 {BFD_RELOC_8_PCREL, R_M68HC11_PCREL_8},
336 {BFD_RELOC_16_PCREL, R_M68HC11_PCREL_16},
337 {BFD_RELOC_16, R_M68HC11_16},
338 {BFD_RELOC_32, R_M68HC11_32},
339 {BFD_RELOC_M68HC11_3B, R_M68HC11_3B},
341 {BFD_RELOC_VTABLE_INHERIT, R_M68HC11_GNU_VTINHERIT},
342 {BFD_RELOC_VTABLE_ENTRY, R_M68HC11_GNU_VTENTRY},
344 {BFD_RELOC_M68HC11_LO16, R_M68HC11_LO16},
345 {BFD_RELOC_M68HC11_PAGE, R_M68HC11_PAGE},
346 {BFD_RELOC_M68HC11_24, R_M68HC11_24},
348 {BFD_RELOC_M68HC11_RL_JUMP, R_M68HC11_RL_JUMP},
349 {BFD_RELOC_M68HC11_RL_GROUP, R_M68HC11_RL_GROUP},
352 static reloc_howto_type *
353 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
354 bfd *abfd ATTRIBUTE_UNUSED;
355 bfd_reloc_code_real_type code;
360 i < sizeof (m68hc11_reloc_map) / sizeof (struct m68hc11_reloc_map);
363 if (m68hc11_reloc_map[i].bfd_reloc_val == code)
364 return &elf_m68hc11_howto_table[m68hc11_reloc_map[i].elf_reloc_val];
370 /* This function is used for relocs which are only used for relaxing,
371 which the linker should otherwise ignore. */
373 static bfd_reloc_status_type
374 m68hc11_elf_ignore_reloc (abfd, reloc_entry, symbol, data, input_section,
375 output_bfd, error_message)
376 bfd *abfd ATTRIBUTE_UNUSED;
377 arelent *reloc_entry;
378 asymbol *symbol ATTRIBUTE_UNUSED;
379 PTR data ATTRIBUTE_UNUSED;
380 asection *input_section;
382 char **error_message ATTRIBUTE_UNUSED;
384 if (output_bfd != NULL)
385 reloc_entry->address += input_section->output_offset;
389 /* Set the howto pointer for an M68HC11 ELF reloc. */
392 m68hc11_info_to_howto_rel (abfd, cache_ptr, dst)
393 bfd *abfd ATTRIBUTE_UNUSED;
395 Elf32_Internal_Rel *dst;
399 r_type = ELF32_R_TYPE (dst->r_info);
400 BFD_ASSERT (r_type < (unsigned int) R_M68HC11_max);
401 cache_ptr->howto = &elf_m68hc11_howto_table[r_type];
405 elf32_m68hc11_gc_mark_hook (sec, info, rel, h, sym)
407 struct bfd_link_info *info ATTRIBUTE_UNUSED;
408 Elf_Internal_Rela *rel;
409 struct elf_link_hash_entry *h;
410 Elf_Internal_Sym *sym;
414 switch (ELF32_R_TYPE (rel->r_info))
417 switch (h->root.type)
419 case bfd_link_hash_defined:
420 case bfd_link_hash_defweak:
421 return h->root.u.def.section;
423 case bfd_link_hash_common:
424 return h->root.u.c.p->section;
432 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
438 elf32_m68hc11_gc_sweep_hook (abfd, info, sec, relocs)
439 bfd *abfd ATTRIBUTE_UNUSED;
440 struct bfd_link_info *info ATTRIBUTE_UNUSED;
441 asection *sec ATTRIBUTE_UNUSED;
442 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
444 /* We don't use got and plt entries for 68hc11/68hc12. */
448 struct m68hc11_direct_relax
452 unsigned char direct_code;
453 } m68hc11_direct_relax_table[] = {
454 { "adca", 0xB9, 0x99 },
455 { "adcb", 0xF9, 0xD9 },
456 { "adda", 0xBB, 0x9B },
457 { "addb", 0xFB, 0xDB },
458 { "addd", 0xF3, 0xD3 },
459 { "anda", 0xB4, 0x94 },
460 { "andb", 0xF4, 0xD4 },
461 { "cmpa", 0xB1, 0x91 },
462 { "cmpb", 0xF1, 0xD1 },
463 { "cpd", 0xB3, 0x93 },
464 { "cpxy", 0xBC, 0x9C },
465 /* { "cpy", 0xBC, 0x9C }, */
466 { "eora", 0xB8, 0x98 },
467 { "eorb", 0xF8, 0xD8 },
468 { "jsr", 0xBD, 0x9D },
469 { "ldaa", 0xB6, 0x96 },
470 { "ldab", 0xF6, 0xD6 },
471 { "ldd", 0xFC, 0xDC },
472 { "lds", 0xBE, 0x9E },
473 { "ldxy", 0xFE, 0xDE },
474 /* { "ldy", 0xFE, 0xDE },*/
475 { "oraa", 0xBA, 0x9A },
476 { "orab", 0xFA, 0xDA },
477 { "sbca", 0xB2, 0x92 },
478 { "sbcb", 0xF2, 0xD2 },
479 { "staa", 0xB7, 0x97 },
480 { "stab", 0xF7, 0xD7 },
481 { "std", 0xFD, 0xDD },
482 { "sts", 0xBF, 0x9F },
483 { "stxy", 0xFF, 0xDF },
484 /* { "sty", 0xFF, 0xDF },*/
485 { "suba", 0xB0, 0x90 },
486 { "subb", 0xF0, 0xD0 },
487 { "subd", 0xB3, 0x93 },
491 static struct m68hc11_direct_relax *
492 find_relaxable_insn (unsigned char code)
496 for (i = 0; m68hc11_direct_relax_table[i].name; i++)
497 if (m68hc11_direct_relax_table[i].code == code)
498 return &m68hc11_direct_relax_table[i];
504 compare_reloc (e1, e2)
508 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
509 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
511 if (i1->r_offset == i2->r_offset)
514 return i1->r_offset < i2->r_offset ? -1 : 1;
517 #define M6811_OP_LDX_IMMEDIATE (0xCE)
520 m68hc11_relax_group (abfd, sec, contents, value, offset, end_group)
525 unsigned long offset;
526 unsigned long end_group;
529 unsigned long start_offset;
530 unsigned long ldx_offset = offset;
531 unsigned long ldx_size;
535 /* First instruction of the relax group must be a
536 LDX #value or LDY #value. If this is not the case,
537 ignore the relax group. */
538 code = bfd_get_8 (abfd, contents + offset);
543 code = bfd_get_8 (abfd, contents + offset);
545 ldx_size = offset - ldx_offset + 3;
547 if (code != M6811_OP_LDX_IMMEDIATE || offset >= end_group)
551 /* We can remove the LDX/LDY only when all bset/brclr instructions
552 of the relax group have been converted to use direct addressing
555 while (offset < end_group)
562 start_offset = offset;
563 code = bfd_get_8 (abfd, contents + offset);
568 code = bfd_get_8 (abfd, contents + offset);
571 /* Check the instruction and translate to use direct addressing mode. */
598 /* This instruction is not recognized and we are not
599 at end of the relax group. Ignore and don't remove
600 the first LDX (we don't know what it is used for...). */
604 new_value = (unsigned) bfd_get_8 (abfd, contents + offset + 1);
606 if ((new_value & 0xff00) == 0 && bset_use_y == relax_ldy)
608 bfd_put_8 (abfd, code, contents + offset);
609 bfd_put_8 (abfd, new_value, contents + offset + 1);
610 if (start_offset != offset)
612 m68hc11_elf_relax_delete_bytes (abfd, sec, start_offset,
613 offset - start_offset);
621 offset = start_offset + isize;
625 /* Remove the move instruction (3 or 4 bytes win). */
626 m68hc11_elf_relax_delete_bytes (abfd, sec, ldx_offset, ldx_size);
630 /* This function handles relaxing for the 68HC11.
633 and somewhat more difficult to support. */
636 m68hc11_elf_relax_section (abfd, sec, link_info, again)
639 struct bfd_link_info *link_info;
642 Elf_Internal_Shdr *symtab_hdr;
643 Elf_Internal_Shdr *shndx_hdr;
644 Elf_Internal_Rela *internal_relocs;
645 Elf_Internal_Rela *free_relocs = NULL;
646 Elf_Internal_Rela *irel, *irelend;
647 bfd_byte *contents = NULL;
648 bfd_byte *free_contents = NULL;
649 Elf32_External_Sym *free_extsyms = NULL;
650 Elf_Internal_Rela *prev_insn_branch = NULL;
651 Elf_Internal_Rela *prev_insn_group = NULL;
652 unsigned insn_group_value = 0;
653 Elf_Internal_Sym *isymbuf = NULL;
655 /* Assume nothing changes. */
658 /* We don't have to do anything for a relocateable link, if
659 this section does not have relocs, or if this is not a
661 if (link_info->relocateable
662 || (sec->flags & SEC_RELOC) == 0
663 || sec->reloc_count == 0
664 || (sec->flags & SEC_CODE) == 0)
667 /* If this is the first time we have been called for this section,
668 initialize the cooked size. */
669 if (sec->_cooked_size == 0)
670 sec->_cooked_size = sec->_raw_size;
672 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
673 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
675 /* Get a copy of the native relocations. */
676 internal_relocs = (_bfd_elf32_link_read_relocs
677 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
678 link_info->keep_memory));
679 if (internal_relocs == NULL)
681 if (! link_info->keep_memory)
682 free_relocs = internal_relocs;
684 /* Checking for branch relaxation relies on the relocations to
685 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
686 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
689 /* Walk through them looking for relaxing opportunities. */
690 irelend = internal_relocs + sec->reloc_count;
691 for (irel = internal_relocs; irel < irelend; irel++)
695 Elf_Internal_Sym *isym;
697 /* If this isn't something that can be relaxed, then ignore
699 if (ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_16
700 && ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_RL_JUMP
701 && ELF32_R_TYPE (irel->r_info) != (int) R_M68HC11_RL_GROUP)
703 prev_insn_branch = 0;
708 /* Get the section contents if we haven't done so already. */
709 if (contents == NULL)
711 /* Get cached copy if it exists. */
712 if (elf_section_data (sec)->this_hdr.contents != NULL)
713 contents = elf_section_data (sec)->this_hdr.contents;
716 /* Go get them off disk. */
717 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
718 if (contents == NULL)
720 free_contents = contents;
722 if (! bfd_get_section_contents (abfd, sec, contents,
723 (file_ptr) 0, sec->_raw_size))
728 /* Try to eliminate an unconditional 8 bit pc-relative branch
729 which immediately follows a conditional 8 bit pc-relative
730 branch around the unconditional branch.
737 This happens when the bCC can't reach lab2 at assembly time,
738 but due to other relaxations it can reach at link time. */
739 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_RL_JUMP)
741 Elf_Internal_Rela *nrel;
743 unsigned char roffset;
745 prev_insn_branch = 0;
748 /* Do nothing if this reloc is the last byte in the section. */
749 if (irel->r_offset == sec->_cooked_size)
752 /* See if the next instruction is an unconditional pc-relative
753 branch, more often than not this test will fail, so we
754 test it first to speed things up. */
755 code = bfd_get_8 (abfd, contents + irel->r_offset + 2);
759 /* Also make sure the next relocation applies to the next
760 instruction and that it's a pc-relative 8 bit branch. */
763 || irel->r_offset + 3 != nrel->r_offset
764 || ELF32_R_TYPE (nrel->r_info) != (int) R_M68HC11_16)
767 /* Make sure our destination immediately follows the
768 unconditional branch. */
769 roffset = bfd_get_8 (abfd, contents + irel->r_offset + 1);
773 prev_insn_branch = irel;
778 /* Read this BFD's symbols if we haven't done so already. */
779 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
781 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
783 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
784 symtab_hdr->sh_info, 0,
790 /* Get the value of the symbol referred to by the reloc. */
791 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
793 /* A local symbol. */
796 isym = isymbuf + ELF32_R_SYM (irel->r_info);
797 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
798 symval = (isym->st_value
799 + sym_sec->output_section->vma
800 + sym_sec->output_offset);
805 struct elf_link_hash_entry *h;
807 /* An external symbol. */
808 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
809 h = elf_sym_hashes (abfd)[indx];
810 BFD_ASSERT (h != NULL);
811 if (h->root.type != bfd_link_hash_defined
812 && h->root.type != bfd_link_hash_defweak)
814 /* This appears to be a reference to an undefined
815 symbol. Just ignore it--it will be caught by the
816 regular reloc processing. */
817 prev_insn_branch = 0;
822 symval = (h->root.u.def.value
823 + h->root.u.def.section->output_section->vma
824 + h->root.u.def.section->output_offset);
827 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_RL_GROUP)
829 prev_insn_branch = 0;
832 /* Do nothing if this reloc is the last byte in the section. */
833 if (irel->r_offset == sec->_cooked_size)
836 prev_insn_group = irel;
837 insn_group_value = isym->st_value;
842 /* Try to turn a far branch to a near branch. */
843 if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_16
849 offset = value - (prev_insn_branch->r_offset
850 + sec->output_section->vma
851 + sec->output_offset + 2);
853 /* If the offset is still out of -128..+127 range,
854 leave that far branch unchanged. */
855 if ((offset & 0xff80) != 0 && (offset & 0xff80) != 0xff80)
857 prev_insn_branch = 0;
861 /* Shrink the branch. */
862 code = bfd_get_8 (abfd, contents + prev_insn_branch->r_offset);
866 bfd_put_8 (abfd, code, contents + prev_insn_branch->r_offset);
867 bfd_put_8 (abfd, offset,
868 contents + prev_insn_branch->r_offset + 1);
869 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
871 m68hc11_elf_relax_delete_bytes (abfd, sec,
877 bfd_put_8 (abfd, code, contents + prev_insn_branch->r_offset);
878 bfd_put_8 (abfd, offset,
879 contents + prev_insn_branch->r_offset + 1);
880 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
882 m68hc11_elf_relax_delete_bytes (abfd, sec,
883 irel->r_offset - 1, 3);
885 prev_insn_branch = 0;
888 /* Try to turn a 16 bit address into a 8 bit page0 address. */
889 else if (ELF32_R_TYPE (irel->r_info) == (int) R_M68HC11_16
890 && (value & 0xff00) == 0)
893 unsigned short offset;
894 struct m68hc11_direct_relax *rinfo;
896 prev_insn_branch = 0;
897 offset = bfd_get_16 (abfd, contents + irel->r_offset);
899 if ((offset & 0xff00) != 0)
907 /* Note that we've changed the reldection contents, etc. */
908 elf_section_data (sec)->relocs = internal_relocs;
911 elf_section_data (sec)->this_hdr.contents = contents;
912 free_contents = NULL;
914 symtab_hdr->contents = (bfd_byte *) isymbuf;
917 m68hc11_relax_group (abfd, sec, contents, offset,
918 prev_insn_group->r_offset,
920 irel = prev_insn_group;
922 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
927 /* Get the opcode. */
928 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
929 rinfo = find_relaxable_insn (code);
936 /* Note that we've changed the reldection contents, etc. */
937 elf_section_data (sec)->relocs = internal_relocs;
940 elf_section_data (sec)->this_hdr.contents = contents;
941 free_contents = NULL;
943 symtab_hdr->contents = (bfd_byte *) isymbuf;
946 /* Fix the opcode. */
947 /* printf ("A relaxable case : 0x%02x (%s)\n",
948 code, rinfo->name); */
949 bfd_put_8 (abfd, rinfo->direct_code,
950 contents + irel->r_offset - 1);
952 /* Delete one byte of data (upper byte of address). */
953 m68hc11_elf_relax_delete_bytes (abfd, sec, irel->r_offset, 1);
955 /* Fix the relocation's type. */
956 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
959 /* That will change things, so, we should relax again.
960 Note that this is not required, and it may be slow. */
963 else if (ELF32_R_TYPE (irel->r_info) == R_M68HC11_16)
968 prev_insn_branch = 0;
969 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
972 offset = value - (irel->r_offset
973 + sec->output_section->vma
974 + sec->output_offset + 1);
975 offset += bfd_get_16 (abfd, contents + irel->r_offset);
977 /* If the offset is still out of -128..+127 range,
978 leave that far branch unchanged. */
979 if ((offset & 0xff80) == 0 || (offset & 0xff80) == 0xff80)
982 /* Note that we've changed the reldection contents, etc. */
983 elf_section_data (sec)->relocs = internal_relocs;
986 elf_section_data (sec)->this_hdr.contents = contents;
987 free_contents = NULL;
989 symtab_hdr->contents = (bfd_byte *) isymbuf;
992 /* Shrink the branch. */
994 bfd_put_8 (abfd, code,
995 contents + irel->r_offset - 1);
996 bfd_put_8 (abfd, offset,
997 contents + irel->r_offset);
998 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1000 m68hc11_elf_relax_delete_bytes (abfd, sec,
1001 irel->r_offset + 1, 1);
1005 prev_insn_branch = 0;
1008 if (free_relocs != NULL)
1014 if (free_contents != NULL)
1016 if (! link_info->keep_memory)
1017 free (free_contents);
1020 /* Cache the section contents for elf_link_input_bfd. */
1021 elf_section_data (sec)->this_hdr.contents = contents;
1023 free_contents = NULL;
1026 if (free_extsyms != NULL)
1028 if (! link_info->keep_memory)
1029 free (free_extsyms);
1032 /* Cache the symbols for elf_link_input_bfd. */
1033 symtab_hdr->contents = (unsigned char *) isymbuf;
1035 free_extsyms = NULL;
1041 if (free_relocs != NULL)
1043 if (free_contents != NULL)
1044 free (free_contents);
1045 if (free_extsyms != NULL)
1046 free (free_extsyms);
1050 /* Delete some bytes from a section while relaxing. */
1053 m68hc11_elf_relax_delete_bytes (abfd, sec, addr, count)
1059 Elf_Internal_Shdr *symtab_hdr;
1060 unsigned int sec_shndx;
1062 Elf_Internal_Rela *irel, *irelend;
1064 Elf_Internal_Sym *isymbuf, *isym, *isymend;
1065 struct elf_link_hash_entry **sym_hashes;
1066 struct elf_link_hash_entry **end_hashes;
1067 unsigned int symcount;
1069 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1070 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1072 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1074 contents = elf_section_data (sec)->this_hdr.contents;
1076 toaddr = sec->_cooked_size;
1078 irel = elf_section_data (sec)->relocs;
1079 irelend = irel + sec->reloc_count;
1081 /* Actually delete the bytes. */
1082 memmove (contents + addr, contents + addr + count,
1083 (size_t) (toaddr - addr - count));
1085 sec->_cooked_size -= count;
1087 /* Adjust all the relocs. */
1088 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1091 unsigned char offset;
1092 unsigned short raddr;
1093 unsigned long old_offset;
1096 old_offset = irel->r_offset;
1098 /* See if this reloc was for the bytes we have deleted, in which
1099 case we no longer care about it. Don't delete relocs which
1100 represent addresses, though. */
1101 if (ELF32_R_TYPE (irel->r_info) != R_M68HC11_RL_JUMP
1102 && irel->r_offset >= addr && irel->r_offset < addr + count)
1103 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1106 if (ELF32_R_TYPE (irel->r_info) == R_M68HC11_NONE)
1109 /* Get the new reloc address. */
1110 if ((irel->r_offset > addr
1111 && irel->r_offset < toaddr))
1112 irel->r_offset -= count;
1114 /* If this is a PC relative reloc, see if the range it covers
1115 includes the bytes we have deleted. */
1116 switch (ELF32_R_TYPE (irel->r_info))
1121 case R_M68HC11_RL_JUMP:
1122 code = bfd_get_8 (abfd, contents + irel->r_offset);
1125 /* jsr and jmp instruction are also marked with RL_JUMP
1126 relocs but no adjustment must be made. */
1137 /* Special case when we translate a brclr N,y into brclr *<addr>
1138 In this case, the 0x18 page2 prefix is removed.
1139 The reloc offset is not modified but the instruction
1140 size is reduced by 1. */
1141 if (old_offset == addr)
1161 offset = bfd_get_8 (abfd, contents + irel->r_offset + branch_pos);
1162 raddr += old_offset;
1163 raddr += ((unsigned short) offset | ((offset & 0x80) ? 0xff00 : 0));
1164 if (irel->r_offset < addr && raddr >= addr)
1167 bfd_put_8 (abfd, offset, contents + irel->r_offset + branch_pos);
1169 else if (irel->r_offset >= addr && raddr <= addr)
1172 bfd_put_8 (abfd, offset, contents + irel->r_offset + branch_pos);
1176 /*printf ("Not adjusted 0x%04x [0x%4x 0x%4x]\n", raddr,
1177 irel->r_offset, addr);*/
1184 /* Adjust the local symbols defined in this section. */
1185 isymend = isymbuf + symtab_hdr->sh_info;
1186 for (isym = isymbuf; isym < isymend; isym++)
1188 if (isym->st_shndx == sec_shndx
1189 && isym->st_value > addr
1190 && isym->st_value < toaddr)
1191 isym->st_value -= count;
1194 /* Now adjust the global symbols defined in this section. */
1195 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1196 - symtab_hdr->sh_info);
1197 sym_hashes = elf_sym_hashes (abfd);
1198 end_hashes = sym_hashes + symcount;
1199 for (; sym_hashes < end_hashes; sym_hashes++)
1201 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1202 if ((sym_hash->root.type == bfd_link_hash_defined
1203 || sym_hash->root.type == bfd_link_hash_defweak)
1204 && sym_hash->root.u.def.section == sec
1205 && sym_hash->root.u.def.value > addr
1206 && sym_hash->root.u.def.value < toaddr)
1208 sym_hash->root.u.def.value -= count;
1213 /* Look through the relocs for a section during the first phase.
1214 Since we don't do .gots or .plts, we just need to consider the
1215 virtual table relocs for gc. */
1218 elf32_m68hc11_check_relocs (abfd, info, sec, relocs)
1220 struct bfd_link_info * info;
1222 const Elf_Internal_Rela * relocs;
1224 Elf_Internal_Shdr * symtab_hdr;
1225 struct elf_link_hash_entry ** sym_hashes;
1226 struct elf_link_hash_entry ** sym_hashes_end;
1227 const Elf_Internal_Rela * rel;
1228 const Elf_Internal_Rela * rel_end;
1230 if (info->relocateable)
1233 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1234 sym_hashes = elf_sym_hashes (abfd);
1235 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1236 if (!elf_bad_symtab (abfd))
1237 sym_hashes_end -= symtab_hdr->sh_info;
1239 rel_end = relocs + sec->reloc_count;
1241 for (rel = relocs; rel < rel_end; rel++)
1243 struct elf_link_hash_entry * h;
1244 unsigned long r_symndx;
1246 r_symndx = ELF32_R_SYM (rel->r_info);
1248 if (r_symndx < symtab_hdr->sh_info)
1251 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
1253 switch (ELF32_R_TYPE (rel->r_info))
1255 /* This relocation describes the C++ object vtable hierarchy.
1256 Reconstruct it for later use during GC. */
1257 case R_M68HC11_GNU_VTINHERIT:
1258 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1262 /* This relocation describes which C++ vtable entries are actually
1263 used. Record for later use during GC. */
1264 case R_M68HC11_GNU_VTENTRY:
1265 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1274 /* Relocate a 68hc11/68hc12 ELF section. */
1276 elf32_m68hc11_relocate_section (output_bfd, info, input_bfd, input_section,
1277 contents, relocs, local_syms, local_sections)
1278 bfd *output_bfd ATTRIBUTE_UNUSED;
1279 struct bfd_link_info *info;
1281 asection *input_section;
1283 Elf_Internal_Rela *relocs;
1284 Elf_Internal_Sym *local_syms;
1285 asection **local_sections;
1287 Elf_Internal_Shdr *symtab_hdr;
1288 struct elf_link_hash_entry **sym_hashes;
1289 Elf_Internal_Rela *rel, *relend;
1292 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1293 sym_hashes = elf_sym_hashes (input_bfd);
1296 relend = relocs + input_section->reloc_count;
1297 for (; rel < relend; rel++)
1300 reloc_howto_type *howto;
1301 unsigned long r_symndx;
1302 Elf_Internal_Sym *sym;
1304 struct elf_link_hash_entry *h;
1306 bfd_reloc_status_type r;
1308 r_symndx = ELF32_R_SYM (rel->r_info);
1309 r_type = ELF32_R_TYPE (rel->r_info);
1311 if (r_type == R_M68HC11_GNU_VTENTRY
1312 || r_type == R_M68HC11_GNU_VTINHERIT )
1315 howto = elf_m68hc11_howto_table + r_type;
1317 if (info->relocateable)
1319 /* This is a relocateable link. We don't have to change
1320 anything, unless the reloc is against a section symbol,
1321 in which case we have to adjust according to where the
1322 section symbol winds up in the output section. */
1323 if (r_symndx < symtab_hdr->sh_info)
1325 sym = local_syms + r_symndx;
1326 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1328 sec = local_sections[r_symndx];
1329 rel->r_addend += sec->output_offset + sym->st_value;
1336 /* This is a final link. */
1340 if (r_symndx < symtab_hdr->sh_info)
1342 sym = local_syms + r_symndx;
1343 sec = local_sections[r_symndx];
1344 relocation = (sec->output_section->vma
1345 + sec->output_offset
1350 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1351 while (h->root.type == bfd_link_hash_indirect
1352 || h->root.type == bfd_link_hash_warning)
1353 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1354 if (h->root.type == bfd_link_hash_defined
1355 || h->root.type == bfd_link_hash_defweak)
1357 sec = h->root.u.def.section;
1358 relocation = (h->root.u.def.value
1359 + sec->output_section->vma
1360 + sec->output_offset);
1362 else if (h->root.type == bfd_link_hash_undefweak)
1366 if (!((*info->callbacks->undefined_symbol)
1367 (info, h->root.root.string, input_bfd,
1368 input_section, rel->r_offset, true)))
1375 name = h->root.root.string;
1378 name = (bfd_elf_string_from_elf_section
1379 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1380 if (name == NULL || *name == '\0')
1381 name = bfd_section_name (input_bfd, sec);
1384 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1385 contents, rel->r_offset,
1386 relocation, rel->r_addend);
1388 if (r != bfd_reloc_ok)
1390 const char * msg = (const char *) 0;
1394 case bfd_reloc_overflow:
1395 if (!((*info->callbacks->reloc_overflow)
1396 (info, name, howto->name, (bfd_vma) 0,
1397 input_bfd, input_section, rel->r_offset)))
1401 case bfd_reloc_undefined:
1402 if (!((*info->callbacks->undefined_symbol)
1403 (info, name, input_bfd, input_section,
1404 rel->r_offset, true)))
1408 case bfd_reloc_outofrange:
1409 msg = _ ("internal error: out of range error");
1412 case bfd_reloc_notsupported:
1413 msg = _ ("internal error: unsupported relocation error");
1416 case bfd_reloc_dangerous:
1417 msg = _ ("internal error: dangerous error");
1421 msg = _ ("internal error: unknown error");
1425 if (!((*info->callbacks->warning)
1426 (info, msg, name, input_bfd, input_section,
1439 /* Set and control ELF flags in ELF header. */
1442 _bfd_m68hc11_elf_set_private_flags (abfd, flags)
1446 BFD_ASSERT (!elf_flags_init (abfd)
1447 || elf_elfheader (abfd)->e_flags == flags);
1449 elf_elfheader (abfd)->e_flags = flags;
1450 elf_flags_init (abfd) = true;
1454 /* Merge backend specific data from an object file to the output
1455 object file when linking. */
1458 _bfd_m68hc11_elf_merge_private_bfd_data (ibfd, obfd)
1466 /* Check if we have the same endianess */
1467 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
1470 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1471 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1474 new_flags = elf_elfheader (ibfd)->e_flags;
1475 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1476 old_flags = elf_elfheader (obfd)->e_flags;
1478 if (! elf_flags_init (obfd))
1480 elf_flags_init (obfd) = true;
1481 elf_elfheader (obfd)->e_flags = new_flags;
1482 elf_elfheader (obfd)->e_ident[EI_CLASS]
1483 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1485 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1486 && bfd_get_arch_info (obfd)->the_default)
1488 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1489 bfd_get_mach (ibfd)))
1496 /* Check ABI compatibility. */
1497 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1499 (*_bfd_error_handler)
1500 (_("%s: linking files compiled for 16-bit integers (-mshort) "
1501 "and others for 32-bit integers"),
1502 bfd_archive_filename (ibfd));
1505 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1507 (*_bfd_error_handler)
1508 (_("%s: linking files compiled for 32-bit double (-fshort-double) "
1509 "and others for 64-bit double"),
1510 bfd_archive_filename (ibfd));
1513 new_flags &= ~EF_M68HC11_ABI;
1514 old_flags &= ~EF_M68HC11_ABI;
1516 /* Warn about any other mismatches */
1517 if (new_flags != old_flags)
1519 (*_bfd_error_handler)
1520 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1521 bfd_archive_filename (ibfd), (unsigned long) new_flags,
1522 (unsigned long) old_flags);
1528 bfd_set_error (bfd_error_bad_value);
1536 _bfd_m68hc11_elf_print_private_bfd_data (abfd, ptr)
1540 FILE *file = (FILE *) ptr;
1542 BFD_ASSERT (abfd != NULL && ptr != NULL);
1544 /* Print normal ELF private data. */
1545 _bfd_elf_print_private_bfd_data (abfd, ptr);
1547 /* xgettext:c-format */
1548 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1550 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1551 fprintf (file, _("[abi=32-bit int,"));
1553 fprintf (file, _("[abi=16-bit int,"));
1555 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1556 fprintf (file, _(" 64-bit double]"));
1558 fprintf (file, _(" 32-bit double]"));
1560 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1561 fprintf (file, _(" [memory=bank-model]"));
1563 fprintf (file, _(" [memory=flat]"));
1570 /* Below is the only difference between elf32-m68hc12.c and elf32-m68hc11.c.
1571 The Motorola spec says to use a different Elf machine code. */
1572 #define ELF_ARCH bfd_arch_m68hc11
1573 #define ELF_MACHINE_CODE EM_68HC11
1574 #define ELF_MAXPAGESIZE 0x1000
1576 #define TARGET_BIG_SYM bfd_elf32_m68hc11_vec
1577 #define TARGET_BIG_NAME "elf32-m68hc11"
1579 #define elf_info_to_howto 0
1580 #define elf_info_to_howto_rel m68hc11_info_to_howto_rel
1581 #define bfd_elf32_bfd_relax_section m68hc11_elf_relax_section
1582 #define elf_backend_gc_mark_hook elf32_m68hc11_gc_mark_hook
1583 #define elf_backend_gc_sweep_hook elf32_m68hc11_gc_sweep_hook
1584 #define elf_backend_check_relocs elf32_m68hc11_check_relocs
1585 #define elf_backend_relocate_section elf32_m68hc11_relocate_section
1586 #define elf_backend_object_p 0
1587 #define elf_backend_final_write_processing 0
1588 #define elf_backend_can_gc_sections 1
1589 #define bfd_elf32_bfd_merge_private_bfd_data \
1590 _bfd_m68hc11_elf_merge_private_bfd_data
1591 #define bfd_elf32_bfd_set_private_flags _bfd_m68hc11_elf_set_private_flags
1592 #define bfd_elf32_bfd_print_private_bfd_data \
1593 _bfd_m68hc11_elf_print_private_bfd_data
1595 #include "elf32-target.h"