1 /* Motorola 68HC11-specific support for 32-bit ELF
2 Copyright (C) 1999-2020 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
28 #include "elf32-m68hc1x.h"
29 #include "elf/m68hc11.h"
30 #include "opcode/m68hc11.h"
32 /* Relocation functions. */
33 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
34 (bfd
*, bfd_reloc_code_real_type
);
35 static bfd_boolean m68hc11_info_to_howto_rel
36 (bfd
*, arelent
*, Elf_Internal_Rela
*);
38 /* Trampoline generation. */
39 static bfd_boolean m68hc11_elf_size_one_stub
40 (struct bfd_hash_entry
*gen_entry
, void *in_arg
);
41 static bfd_boolean m68hc11_elf_build_one_stub
42 (struct bfd_hash_entry
*gen_entry
, void *in_arg
);
43 static struct bfd_link_hash_table
* m68hc11_elf_bfd_link_hash_table_create
46 /* Linker relaxation. */
47 static bfd_boolean m68hc11_elf_relax_section
48 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
49 static void m68hc11_elf_relax_delete_bytes
50 (bfd
*, asection
*, bfd_vma
, int);
51 static void m68hc11_relax_group
52 (bfd
*, asection
*, bfd_byte
*, unsigned, unsigned long, unsigned long);
53 static int compare_reloc (const void *, const void *);
55 /* Use REL instead of RELA to save space */
58 /* The Motorola 68HC11 microcontroller only addresses 64Kb but we also
59 support a memory bank switching mechanism similar to 68HC12.
60 We must handle 8 and 16-bit relocations. The 32-bit relocation
61 are used for debugging sections (DWARF2) to represent a virtual
63 The 3-bit and 16-bit PC rel relocation is only used by 68HC12. */
64 static reloc_howto_type elf_m68hc11_howto_table
[] = {
65 /* This reloc does nothing. */
66 HOWTO (R_M68HC11_NONE
, /* type */
68 3, /* size (0 = byte, 1 = short, 2 = long) */
70 FALSE
, /* pc_relative */
72 complain_overflow_dont
,/* complain_on_overflow */
73 bfd_elf_generic_reloc
, /* special_function */
74 "R_M68HC11_NONE", /* name */
75 FALSE
, /* partial_inplace */
78 FALSE
), /* pcrel_offset */
80 /* A 8 bit absolute relocation */
81 HOWTO (R_M68HC11_8
, /* type */
83 0, /* size (0 = byte, 1 = short, 2 = long) */
85 FALSE
, /* pc_relative */
87 complain_overflow_bitfield
, /* complain_on_overflow */
88 bfd_elf_generic_reloc
, /* special_function */
89 "R_M68HC11_8", /* name */
90 FALSE
, /* partial_inplace */
91 0x00ff, /* src_mask */
92 0x00ff, /* dst_mask */
93 FALSE
), /* pcrel_offset */
95 /* A 8 bit absolute relocation (upper address) */
96 HOWTO (R_M68HC11_HI8
, /* type */
98 0, /* size (0 = byte, 1 = short, 2 = long) */
100 FALSE
, /* pc_relative */
102 complain_overflow_bitfield
, /* complain_on_overflow */
103 bfd_elf_generic_reloc
, /* special_function */
104 "R_M68HC11_HI8", /* name */
105 FALSE
, /* partial_inplace */
106 0x00ff, /* src_mask */
107 0x00ff, /* dst_mask */
108 FALSE
), /* pcrel_offset */
110 /* A 8 bit absolute relocation (upper address) */
111 HOWTO (R_M68HC11_LO8
, /* type */
113 0, /* size (0 = byte, 1 = short, 2 = long) */
115 FALSE
, /* pc_relative */
117 complain_overflow_dont
, /* complain_on_overflow */
118 bfd_elf_generic_reloc
, /* special_function */
119 "R_M68HC11_LO8", /* name */
120 FALSE
, /* partial_inplace */
121 0x00ff, /* src_mask */
122 0x00ff, /* dst_mask */
123 FALSE
), /* pcrel_offset */
125 /* A 8 bit PC-rel relocation */
126 HOWTO (R_M68HC11_PCREL_8
, /* type */
128 0, /* size (0 = byte, 1 = short, 2 = long) */
130 TRUE
, /* pc_relative */
132 complain_overflow_bitfield
, /* complain_on_overflow */
133 bfd_elf_generic_reloc
, /* special_function */
134 "R_M68HC11_PCREL_8", /* name */
135 FALSE
, /* partial_inplace */
136 0x00ff, /* src_mask */
137 0x00ff, /* dst_mask */
138 TRUE
), /* pcrel_offset */
140 /* A 16 bit absolute relocation */
141 HOWTO (R_M68HC11_16
, /* type */
143 1, /* size (0 = byte, 1 = short, 2 = long) */
145 FALSE
, /* pc_relative */
147 complain_overflow_dont
/*bitfield */ , /* complain_on_overflow */
148 bfd_elf_generic_reloc
, /* special_function */
149 "R_M68HC11_16", /* name */
150 FALSE
, /* partial_inplace */
151 0xffff, /* src_mask */
152 0xffff, /* dst_mask */
153 FALSE
), /* pcrel_offset */
155 /* A 32 bit absolute relocation. This one is never used for the
156 code relocation. It's used by gas for -gstabs generation. */
157 HOWTO (R_M68HC11_32
, /* type */
159 2, /* size (0 = byte, 1 = short, 2 = long) */
161 FALSE
, /* pc_relative */
163 complain_overflow_bitfield
, /* complain_on_overflow */
164 bfd_elf_generic_reloc
, /* special_function */
165 "R_M68HC11_32", /* name */
166 FALSE
, /* partial_inplace */
167 0xffffffff, /* src_mask */
168 0xffffffff, /* dst_mask */
169 FALSE
), /* pcrel_offset */
171 /* A 3 bit absolute relocation */
172 HOWTO (R_M68HC11_3B
, /* type */
174 0, /* size (0 = byte, 1 = short, 2 = long) */
176 FALSE
, /* pc_relative */
178 complain_overflow_bitfield
, /* complain_on_overflow */
179 bfd_elf_generic_reloc
, /* special_function */
180 "R_M68HC11_4B", /* name */
181 FALSE
, /* partial_inplace */
182 0x003, /* src_mask */
183 0x003, /* dst_mask */
184 FALSE
), /* pcrel_offset */
186 /* A 16 bit PC-rel relocation */
187 HOWTO (R_M68HC11_PCREL_16
, /* type */
189 1, /* size (0 = byte, 1 = short, 2 = long) */
191 TRUE
, /* pc_relative */
193 complain_overflow_dont
, /* complain_on_overflow */
194 bfd_elf_generic_reloc
, /* special_function */
195 "R_M68HC11_PCREL_16", /* name */
196 FALSE
, /* partial_inplace */
197 0xffff, /* src_mask */
198 0xffff, /* dst_mask */
199 TRUE
), /* pcrel_offset */
201 /* GNU extension to record C++ vtable hierarchy */
202 HOWTO (R_M68HC11_GNU_VTINHERIT
, /* type */
204 1, /* size (0 = byte, 1 = short, 2 = long) */
206 FALSE
, /* pc_relative */
208 complain_overflow_dont
, /* complain_on_overflow */
209 NULL
, /* special_function */
210 "R_M68HC11_GNU_VTINHERIT", /* name */
211 FALSE
, /* partial_inplace */
214 FALSE
), /* pcrel_offset */
216 /* GNU extension to record C++ vtable member usage */
217 HOWTO (R_M68HC11_GNU_VTENTRY
, /* type */
219 1, /* size (0 = byte, 1 = short, 2 = long) */
221 FALSE
, /* pc_relative */
223 complain_overflow_dont
, /* complain_on_overflow */
224 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
225 "R_M68HC11_GNU_VTENTRY", /* name */
226 FALSE
, /* partial_inplace */
229 FALSE
), /* pcrel_offset */
231 /* A 24 bit relocation */
232 HOWTO (R_M68HC11_24
, /* type */
234 1, /* size (0 = byte, 1 = short, 2 = long) */
236 FALSE
, /* pc_relative */
238 complain_overflow_bitfield
, /* complain_on_overflow */
239 bfd_elf_generic_reloc
, /* special_function */
240 "R_M68HC11_24", /* name */
241 FALSE
, /* partial_inplace */
242 0xffffff, /* src_mask */
243 0xffffff, /* dst_mask */
244 FALSE
), /* pcrel_offset */
246 /* A 16-bit low relocation */
247 HOWTO (R_M68HC11_LO16
, /* type */
249 1, /* size (0 = byte, 1 = short, 2 = long) */
251 FALSE
, /* pc_relative */
253 complain_overflow_bitfield
, /* complain_on_overflow */
254 bfd_elf_generic_reloc
, /* special_function */
255 "R_M68HC11_LO16", /* name */
256 FALSE
, /* partial_inplace */
257 0xffff, /* src_mask */
258 0xffff, /* dst_mask */
259 FALSE
), /* pcrel_offset */
261 /* A page relocation */
262 HOWTO (R_M68HC11_PAGE
, /* type */
264 0, /* size (0 = byte, 1 = short, 2 = long) */
266 FALSE
, /* pc_relative */
268 complain_overflow_bitfield
, /* complain_on_overflow */
269 bfd_elf_generic_reloc
, /* special_function */
270 "R_M68HC11_PAGE", /* name */
271 FALSE
, /* partial_inplace */
272 0x00ff, /* src_mask */
273 0x00ff, /* dst_mask */
274 FALSE
), /* pcrel_offset */
283 /* Mark beginning of a jump instruction (any form). */
284 HOWTO (R_M68HC11_RL_JUMP
, /* type */
286 1, /* size (0 = byte, 1 = short, 2 = long) */
288 FALSE
, /* pc_relative */
290 complain_overflow_dont
, /* complain_on_overflow */
291 m68hc11_elf_ignore_reloc
, /* special_function */
292 "R_M68HC11_RL_JUMP", /* name */
293 TRUE
, /* partial_inplace */
296 TRUE
), /* pcrel_offset */
298 /* Mark beginning of Gcc relaxation group instruction. */
299 HOWTO (R_M68HC11_RL_GROUP
, /* type */
301 1, /* size (0 = byte, 1 = short, 2 = long) */
303 FALSE
, /* pc_relative */
305 complain_overflow_dont
, /* complain_on_overflow */
306 m68hc11_elf_ignore_reloc
, /* special_function */
307 "R_M68HC11_RL_GROUP", /* name */
308 TRUE
, /* partial_inplace */
311 TRUE
), /* pcrel_offset */
314 /* Map BFD reloc types to M68HC11 ELF reloc types. */
316 struct m68hc11_reloc_map
318 bfd_reloc_code_real_type bfd_reloc_val
;
319 unsigned char elf_reloc_val
;
322 static const struct m68hc11_reloc_map m68hc11_reloc_map
[] = {
323 {BFD_RELOC_NONE
, R_M68HC11_NONE
,},
324 {BFD_RELOC_8
, R_M68HC11_8
},
325 {BFD_RELOC_M68HC11_HI8
, R_M68HC11_HI8
},
326 {BFD_RELOC_M68HC11_LO8
, R_M68HC11_LO8
},
327 {BFD_RELOC_8_PCREL
, R_M68HC11_PCREL_8
},
328 {BFD_RELOC_16_PCREL
, R_M68HC11_PCREL_16
},
329 {BFD_RELOC_16
, R_M68HC11_16
},
330 {BFD_RELOC_32
, R_M68HC11_32
},
331 {BFD_RELOC_M68HC11_3B
, R_M68HC11_3B
},
333 {BFD_RELOC_VTABLE_INHERIT
, R_M68HC11_GNU_VTINHERIT
},
334 {BFD_RELOC_VTABLE_ENTRY
, R_M68HC11_GNU_VTENTRY
},
336 {BFD_RELOC_M68HC11_LO16
, R_M68HC11_LO16
},
337 {BFD_RELOC_M68HC11_PAGE
, R_M68HC11_PAGE
},
338 {BFD_RELOC_M68HC11_24
, R_M68HC11_24
},
340 {BFD_RELOC_M68HC11_RL_JUMP
, R_M68HC11_RL_JUMP
},
341 {BFD_RELOC_M68HC11_RL_GROUP
, R_M68HC11_RL_GROUP
},
344 static reloc_howto_type
*
345 bfd_elf32_bfd_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
346 bfd_reloc_code_real_type code
)
351 i
< sizeof (m68hc11_reloc_map
) / sizeof (struct m68hc11_reloc_map
);
354 if (m68hc11_reloc_map
[i
].bfd_reloc_val
== code
)
355 return &elf_m68hc11_howto_table
[m68hc11_reloc_map
[i
].elf_reloc_val
];
361 static reloc_howto_type
*
362 bfd_elf32_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
368 i
< (sizeof (elf_m68hc11_howto_table
)
369 / sizeof (elf_m68hc11_howto_table
[0]));
371 if (elf_m68hc11_howto_table
[i
].name
!= NULL
372 && strcasecmp (elf_m68hc11_howto_table
[i
].name
, r_name
) == 0)
373 return &elf_m68hc11_howto_table
[i
];
378 /* Set the howto pointer for an M68HC11 ELF reloc. */
381 m68hc11_info_to_howto_rel (bfd
*abfd
,
382 arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
386 r_type
= ELF32_R_TYPE (dst
->r_info
);
387 if (r_type
>= (unsigned int) R_M68HC11_max
)
389 /* xgettext:c-format */
390 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
392 bfd_set_error (bfd_error_bad_value
);
395 cache_ptr
->howto
= &elf_m68hc11_howto_table
[r_type
];
400 /* Far trampoline generation. */
402 /* Build a 68HC11 trampoline stub. */
404 m68hc11_elf_build_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
406 struct elf32_m68hc11_stub_hash_entry
*stub_entry
;
407 struct bfd_link_info
*info
;
408 struct m68hc11_elf_link_hash_table
*htab
;
412 bfd_vma sym_value
, phys_page
, phys_addr
;
414 /* Massage our args to the form they really have. */
415 stub_entry
= (struct elf32_m68hc11_stub_hash_entry
*) gen_entry
;
416 info
= (struct bfd_link_info
*) in_arg
;
418 /* Fail if the target section could not be assigned to an output
419 section. The user should fix his linker script. */
420 if (stub_entry
->target_section
->output_section
== NULL
421 && info
->non_contiguous_regions
)
423 _bfd_error_handler (_("Could not assign '%pA' to an output section. "
424 "Retry without --enable-non-contiguous-regions.\n"),
425 stub_entry
->target_section
);
429 htab
= m68hc11_elf_hash_table (info
);
433 stub_sec
= stub_entry
->stub_sec
;
435 /* Make a note of the offset within the stubs for this entry. */
436 stub_entry
->stub_offset
= stub_sec
->size
;
437 stub_sec
->size
+= 10;
438 loc
= stub_sec
->contents
+ stub_entry
->stub_offset
;
440 stub_bfd
= stub_sec
->owner
;
442 /* Create the trampoline call stub:
450 sym_value
= (stub_entry
->target_value
451 + stub_entry
->target_section
->output_offset
452 + stub_entry
->target_section
->output_section
->vma
);
453 phys_addr
= m68hc11_phys_addr (&htab
->pinfo
, sym_value
);
454 phys_page
= m68hc11_phys_page (&htab
->pinfo
, sym_value
);
456 /* pshb; ldab #%page(sym) */
457 bfd_put_8 (stub_bfd
, 0x37, loc
);
458 bfd_put_8 (stub_bfd
, 0xC6, loc
+ 1);
459 bfd_put_8 (stub_bfd
, phys_page
, loc
+ 2);
462 /* ldy #%addr(sym) */
463 bfd_put_8 (stub_bfd
, 0x18, loc
);
464 bfd_put_8 (stub_bfd
, 0xCE, loc
+ 1);
465 bfd_put_16 (stub_bfd
, phys_addr
, loc
+ 2);
468 /* jmp __trampoline */
469 bfd_put_8 (stub_bfd
, 0x7E, loc
);
470 bfd_put_16 (stub_bfd
, htab
->pinfo
.trampoline_addr
, loc
+ 1);
475 /* As above, but don't actually build the stub. Just bump offset so
476 we know stub section sizes. */
479 m68hc11_elf_size_one_stub (struct bfd_hash_entry
*gen_entry
,
480 void *in_arg ATTRIBUTE_UNUSED
)
482 struct elf32_m68hc11_stub_hash_entry
*stub_entry
;
484 /* Massage our args to the form they really have. */
485 stub_entry
= (struct elf32_m68hc11_stub_hash_entry
*) gen_entry
;
487 stub_entry
->stub_sec
->size
+= 10;
491 /* Create a 68HC11 ELF linker hash table. */
493 static struct bfd_link_hash_table
*
494 m68hc11_elf_bfd_link_hash_table_create (bfd
*abfd
)
496 struct m68hc11_elf_link_hash_table
*ret
;
498 ret
= m68hc11_elf_hash_table_create (abfd
);
499 if (ret
== (struct m68hc11_elf_link_hash_table
*) NULL
)
502 ret
->size_one_stub
= m68hc11_elf_size_one_stub
;
503 ret
->build_one_stub
= m68hc11_elf_build_one_stub
;
505 return &ret
->root
.root
;
509 /* 68HC11 Linker Relaxation. */
511 struct m68hc11_direct_relax
515 unsigned char direct_code
;
516 } m68hc11_direct_relax_table
[] = {
517 { "adca", 0xB9, 0x99 },
518 { "adcb", 0xF9, 0xD9 },
519 { "adda", 0xBB, 0x9B },
520 { "addb", 0xFB, 0xDB },
521 { "addd", 0xF3, 0xD3 },
522 { "anda", 0xB4, 0x94 },
523 { "andb", 0xF4, 0xD4 },
524 { "cmpa", 0xB1, 0x91 },
525 { "cmpb", 0xF1, 0xD1 },
526 { "cpd", 0xB3, 0x93 },
527 { "cpxy", 0xBC, 0x9C },
528 /* { "cpy", 0xBC, 0x9C }, */
529 { "eora", 0xB8, 0x98 },
530 { "eorb", 0xF8, 0xD8 },
531 { "jsr", 0xBD, 0x9D },
532 { "ldaa", 0xB6, 0x96 },
533 { "ldab", 0xF6, 0xD6 },
534 { "ldd", 0xFC, 0xDC },
535 { "lds", 0xBE, 0x9E },
536 { "ldxy", 0xFE, 0xDE },
537 /* { "ldy", 0xFE, 0xDE },*/
538 { "oraa", 0xBA, 0x9A },
539 { "orab", 0xFA, 0xDA },
540 { "sbca", 0xB2, 0x92 },
541 { "sbcb", 0xF2, 0xD2 },
542 { "staa", 0xB7, 0x97 },
543 { "stab", 0xF7, 0xD7 },
544 { "std", 0xFD, 0xDD },
545 { "sts", 0xBF, 0x9F },
546 { "stxy", 0xFF, 0xDF },
547 /* { "sty", 0xFF, 0xDF },*/
548 { "suba", 0xB0, 0x90 },
549 { "subb", 0xF0, 0xD0 },
550 { "subd", 0xB3, 0x93 },
554 static struct m68hc11_direct_relax
*
555 find_relaxable_insn (unsigned char code
)
559 for (i
= 0; m68hc11_direct_relax_table
[i
].name
; i
++)
560 if (m68hc11_direct_relax_table
[i
].code
== code
)
561 return &m68hc11_direct_relax_table
[i
];
567 compare_reloc (const void *e1
, const void *e2
)
569 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
570 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
572 if (i1
->r_offset
== i2
->r_offset
)
575 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
578 #define M6811_OP_LDX_IMMEDIATE (0xCE)
581 m68hc11_relax_group (bfd
*abfd
, asection
*sec
, bfd_byte
*contents
,
582 unsigned value
, unsigned long offset
,
583 unsigned long end_group
)
586 unsigned long start_offset
;
587 unsigned long ldx_offset
= offset
;
588 unsigned long ldx_size
;
592 /* First instruction of the relax group must be a
593 LDX #value or LDY #value. If this is not the case,
594 ignore the relax group. */
595 code
= bfd_get_8 (abfd
, contents
+ offset
);
600 code
= bfd_get_8 (abfd
, contents
+ offset
);
602 ldx_size
= offset
- ldx_offset
+ 3;
604 if (code
!= M6811_OP_LDX_IMMEDIATE
|| offset
>= end_group
)
608 /* We can remove the LDX/LDY only when all bset/brclr instructions
609 of the relax group have been converted to use direct addressing
612 while (offset
< end_group
)
619 start_offset
= offset
;
620 code
= bfd_get_8 (abfd
, contents
+ offset
);
625 code
= bfd_get_8 (abfd
, contents
+ offset
);
628 /* Check the instruction and translate to use direct addressing mode. */
655 /* This instruction is not recognized and we are not
656 at end of the relax group. Ignore and don't remove
657 the first LDX (we don't know what it is used for...). */
661 new_value
= (unsigned) bfd_get_8 (abfd
, contents
+ offset
+ 1);
663 if ((new_value
& 0xff00) == 0 && bset_use_y
== relax_ldy
)
665 bfd_put_8 (abfd
, code
, contents
+ offset
);
666 bfd_put_8 (abfd
, new_value
, contents
+ offset
+ 1);
667 if (start_offset
!= offset
)
669 m68hc11_elf_relax_delete_bytes (abfd
, sec
, start_offset
,
670 offset
- start_offset
);
678 offset
= start_offset
+ isize
;
682 /* Remove the move instruction (3 or 4 bytes win). */
683 m68hc11_elf_relax_delete_bytes (abfd
, sec
, ldx_offset
, ldx_size
);
687 /* This function handles relaxing for the 68HC11.
690 and somewhat more difficult to support. */
693 m68hc11_elf_relax_section (bfd
*abfd
, asection
*sec
,
694 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
696 Elf_Internal_Shdr
*symtab_hdr
;
697 Elf_Internal_Rela
*internal_relocs
;
698 Elf_Internal_Rela
*free_relocs
= NULL
;
699 Elf_Internal_Rela
*irel
, *irelend
;
700 bfd_byte
*contents
= NULL
;
701 bfd_byte
*free_contents
= NULL
;
702 Elf32_External_Sym
*free_extsyms
= NULL
;
703 Elf_Internal_Rela
*prev_insn_branch
= NULL
;
704 Elf_Internal_Rela
*prev_insn_group
= NULL
;
705 unsigned insn_group_value
= 0;
706 Elf_Internal_Sym
*isymbuf
= NULL
;
708 /* Assume nothing changes. */
711 /* We don't have to do anything for a relocatable link, if
712 this section does not have relocs, or if this is not a
714 if (bfd_link_relocatable (link_info
)
715 || (sec
->flags
& SEC_RELOC
) == 0
716 || sec
->reloc_count
== 0
717 || (sec
->flags
& SEC_CODE
) == 0)
720 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
722 /* Get a copy of the native relocations. */
723 internal_relocs
= (_bfd_elf_link_read_relocs
724 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
725 link_info
->keep_memory
));
726 if (internal_relocs
== NULL
)
728 if (! link_info
->keep_memory
)
729 free_relocs
= internal_relocs
;
731 /* Checking for branch relaxation relies on the relocations to
732 be sorted on 'r_offset'. This is not guaranteed so we must sort. */
733 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
736 /* Walk through them looking for relaxing opportunities. */
737 irelend
= internal_relocs
+ sec
->reloc_count
;
738 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
742 Elf_Internal_Sym
*isym
;
746 /* If this isn't something that can be relaxed, then ignore
748 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_M68HC11_16
749 && ELF32_R_TYPE (irel
->r_info
) != (int) R_M68HC11_RL_JUMP
750 && ELF32_R_TYPE (irel
->r_info
) != (int) R_M68HC11_RL_GROUP
)
752 prev_insn_branch
= 0;
757 /* Get the section contents if we haven't done so already. */
758 if (contents
== NULL
)
760 /* Get cached copy if it exists. */
761 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
762 contents
= elf_section_data (sec
)->this_hdr
.contents
;
765 /* Go get them off disk. */
766 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
771 /* Try to eliminate an unconditional 8 bit pc-relative branch
772 which immediately follows a conditional 8 bit pc-relative
773 branch around the unconditional branch.
780 This happens when the bCC can't reach lab2 at assembly time,
781 but due to other relaxations it can reach at link time. */
782 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_M68HC11_RL_JUMP
)
784 Elf_Internal_Rela
*nrel
;
786 unsigned char roffset
;
788 prev_insn_branch
= 0;
791 /* Do nothing if this reloc is the last byte in the section. */
792 if (irel
->r_offset
+ 2 >= sec
->size
)
795 /* See if the next instruction is an unconditional pc-relative
796 branch, more often than not this test will fail, so we
797 test it first to speed things up. */
798 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 2);
802 /* Also make sure the next relocation applies to the next
803 instruction and that it's a pc-relative 8 bit branch. */
806 || irel
->r_offset
+ 3 != nrel
->r_offset
807 || ELF32_R_TYPE (nrel
->r_info
) != (int) R_M68HC11_16
)
810 /* Make sure our destination immediately follows the
811 unconditional branch. */
812 roffset
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
816 prev_insn_branch
= irel
;
821 /* Read this BFD's symbols if we haven't done so already. */
822 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
824 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
826 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
827 symtab_hdr
->sh_info
, 0,
833 /* Get the value of the symbol referred to by the reloc. */
834 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
836 /* A local symbol. */
837 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
838 is_far
= isym
->st_other
& STO_M68HC12_FAR
;
839 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
840 symval
= (isym
->st_value
841 + sym_sec
->output_section
->vma
842 + sym_sec
->output_offset
);
847 struct elf_link_hash_entry
*h
;
849 /* An external symbol. */
850 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
851 h
= elf_sym_hashes (abfd
)[indx
];
852 BFD_ASSERT (h
!= NULL
);
853 if (h
->root
.type
!= bfd_link_hash_defined
854 && h
->root
.type
!= bfd_link_hash_defweak
)
856 /* This appears to be a reference to an undefined
857 symbol. Just ignore it--it will be caught by the
858 regular reloc processing. */
859 prev_insn_branch
= 0;
864 is_far
= h
->other
& STO_M68HC12_FAR
;
866 sym_sec
= h
->root
.u
.def
.section
;
867 symval
= (h
->root
.u
.def
.value
868 + sym_sec
->output_section
->vma
869 + sym_sec
->output_offset
);
872 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_M68HC11_RL_GROUP
)
874 prev_insn_branch
= 0;
877 /* Do nothing if this reloc is the last byte in the section. */
878 if (irel
->r_offset
== sec
->size
)
881 prev_insn_group
= irel
;
882 insn_group_value
= isym
->st_value
;
886 /* When we relax some bytes, the size of our section changes.
887 This affects the layout of next input sections that go in our
888 output section. When the symbol is part of another section that
889 will go in the same output section as the current one, it's
890 final address may now be incorrect (too far). We must let the
891 linker re-compute all section offsets before processing this
895 .sect .text section size = 6 section size = 4
898 .sect .text.foo_bar output_offset = 6 output_offset = 4
902 If we process the reloc now, the jmp bar is replaced by a
903 relative branch to the initial bar address (output_offset 6). */
904 if (*again
&& sym_sec
!= sec
905 && sym_sec
->output_section
== sec
->output_section
)
908 prev_insn_branch
= 0;
913 /* Try to turn a far branch to a near branch. */
914 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_M68HC11_16
920 offset
= value
- (prev_insn_branch
->r_offset
921 + sec
->output_section
->vma
922 + sec
->output_offset
+ 2);
924 /* If the offset is still out of -128..+127 range,
925 leave that far branch unchanged. */
926 if ((offset
& 0xff80) != 0 && (offset
& 0xff80) != 0xff80)
928 prev_insn_branch
= 0;
932 /* Shrink the branch. */
933 code
= bfd_get_8 (abfd
, contents
+ prev_insn_branch
->r_offset
);
937 bfd_put_8 (abfd
, code
, contents
+ prev_insn_branch
->r_offset
);
938 bfd_put_8 (abfd
, 0xff,
939 contents
+ prev_insn_branch
->r_offset
+ 1);
940 irel
->r_offset
= prev_insn_branch
->r_offset
+ 1;
941 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
943 m68hc11_elf_relax_delete_bytes (abfd
, sec
,
944 irel
->r_offset
+ 1, 1);
949 bfd_put_8 (abfd
, code
, contents
+ prev_insn_branch
->r_offset
);
950 bfd_put_8 (abfd
, 0xff,
951 contents
+ prev_insn_branch
->r_offset
+ 1);
952 irel
->r_offset
= prev_insn_branch
->r_offset
+ 1;
953 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
955 m68hc11_elf_relax_delete_bytes (abfd
, sec
,
956 irel
->r_offset
+ 1, 3);
958 prev_insn_branch
= 0;
962 /* Try to turn a 16 bit address into a 8 bit page0 address. */
963 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_M68HC11_16
964 && (value
& 0xff00) == 0)
967 unsigned short offset
;
968 struct m68hc11_direct_relax
*rinfo
;
970 prev_insn_branch
= 0;
971 offset
= bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
973 if ((offset
& 0xff00) != 0)
981 unsigned long old_sec_size
= sec
->size
;
983 /* Note that we've changed the relocation contents, etc. */
984 elf_section_data (sec
)->relocs
= internal_relocs
;
987 elf_section_data (sec
)->this_hdr
.contents
= contents
;
988 free_contents
= NULL
;
990 symtab_hdr
->contents
= (bfd_byte
*) isymbuf
;
993 m68hc11_relax_group (abfd
, sec
, contents
, offset
,
994 prev_insn_group
->r_offset
,
996 irel
= prev_insn_group
;
998 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1000 if (sec
->size
!= old_sec_size
)
1005 /* Get the opcode. */
1006 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1007 rinfo
= find_relaxable_insn (code
);
1010 prev_insn_group
= 0;
1014 /* Note that we've changed the relocation contents, etc. */
1015 elf_section_data (sec
)->relocs
= internal_relocs
;
1018 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1019 free_contents
= NULL
;
1021 symtab_hdr
->contents
= (bfd_byte
*) isymbuf
;
1022 free_extsyms
= NULL
;
1024 /* Fix the opcode. */
1025 /* printf ("A relaxable case : 0x%02x (%s)\n",
1026 code, rinfo->name); */
1027 bfd_put_8 (abfd
, rinfo
->direct_code
,
1028 contents
+ irel
->r_offset
- 1);
1030 /* Delete one byte of data (upper byte of address). */
1031 m68hc11_elf_relax_delete_bytes (abfd
, sec
, irel
->r_offset
, 1);
1033 /* Fix the relocation's type. */
1034 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1037 /* That will change things, so, we should relax again. */
1040 else if (ELF32_R_TYPE (irel
->r_info
) == R_M68HC11_16
&& !is_far
)
1045 prev_insn_branch
= 0;
1046 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1047 if (code
== 0x7e || code
== 0xbd)
1049 offset
= value
- (irel
->r_offset
1050 + sec
->output_section
->vma
1051 + sec
->output_offset
+ 1);
1052 offset
+= bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1054 /* If the offset is still out of -128..+127 range,
1055 leave that far branch unchanged. */
1056 if ((offset
& 0xff80) == 0 || (offset
& 0xff80) == 0xff80)
1059 /* Note that we've changed the relocation contents, etc. */
1060 elf_section_data (sec
)->relocs
= internal_relocs
;
1063 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1064 free_contents
= NULL
;
1066 symtab_hdr
->contents
= (bfd_byte
*) isymbuf
;
1067 free_extsyms
= NULL
;
1069 /* Shrink the branch. */
1070 code
= (code
== 0x7e) ? 0x20 : 0x8d;
1071 bfd_put_8 (abfd
, code
,
1072 contents
+ irel
->r_offset
- 1);
1073 bfd_put_8 (abfd
, 0xff,
1074 contents
+ irel
->r_offset
);
1075 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1077 m68hc11_elf_relax_delete_bytes (abfd
, sec
,
1078 irel
->r_offset
+ 1, 1);
1079 /* That will change things, so, we should relax again. */
1084 prev_insn_branch
= 0;
1085 prev_insn_group
= 0;
1088 if (free_relocs
!= NULL
)
1094 if (free_contents
!= NULL
)
1096 if (! link_info
->keep_memory
)
1097 free (free_contents
);
1100 /* Cache the section contents for elf_link_input_bfd. */
1101 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1103 free_contents
= NULL
;
1106 if (free_extsyms
!= NULL
)
1108 if (! link_info
->keep_memory
)
1109 free (free_extsyms
);
1112 /* Cache the symbols for elf_link_input_bfd. */
1113 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1115 free_extsyms
= NULL
;
1121 if (free_relocs
!= NULL
)
1123 if (free_contents
!= NULL
)
1124 free (free_contents
);
1125 if (free_extsyms
!= NULL
)
1126 free (free_extsyms
);
1130 /* Delete some bytes from a section while relaxing. */
1133 m68hc11_elf_relax_delete_bytes (bfd
*abfd
, asection
*sec
,
1134 bfd_vma addr
, int count
)
1136 Elf_Internal_Shdr
*symtab_hdr
;
1137 unsigned int sec_shndx
;
1139 Elf_Internal_Rela
*irel
, *irelend
;
1141 Elf_Internal_Sym
*isymbuf
, *isym
, *isymend
;
1142 struct elf_link_hash_entry
**sym_hashes
;
1143 struct elf_link_hash_entry
**end_hashes
;
1144 unsigned int symcount
;
1146 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1147 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1149 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1151 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1155 irel
= elf_section_data (sec
)->relocs
;
1156 irelend
= irel
+ sec
->reloc_count
;
1158 /* Actually delete the bytes. */
1159 memmove (contents
+ addr
, contents
+ addr
+ count
,
1160 (size_t) (toaddr
- addr
- count
));
1164 /* Adjust all the relocs. */
1165 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1168 unsigned char offset
;
1169 unsigned short raddr
;
1170 unsigned long old_offset
;
1173 old_offset
= irel
->r_offset
;
1175 /* See if this reloc was for the bytes we have deleted, in which
1176 case we no longer care about it. Don't delete relocs which
1177 represent addresses, though. */
1178 if (ELF32_R_TYPE (irel
->r_info
) != R_M68HC11_RL_JUMP
1179 && irel
->r_offset
>= addr
&& irel
->r_offset
< addr
+ count
)
1180 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1183 if (ELF32_R_TYPE (irel
->r_info
) == R_M68HC11_NONE
)
1186 /* Get the new reloc address. */
1187 if ((irel
->r_offset
> addr
1188 && irel
->r_offset
< toaddr
))
1189 irel
->r_offset
-= count
;
1191 /* If this is a PC relative reloc, see if the range it covers
1192 includes the bytes we have deleted. */
1193 switch (ELF32_R_TYPE (irel
->r_info
))
1198 case R_M68HC11_RL_JUMP
:
1199 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
);
1202 /* jsr and jmp instruction are also marked with RL_JUMP
1203 relocs but no adjustment must be made. */
1214 /* Special case when we translate a brclr N,y into brclr *<addr>
1215 In this case, the 0x18 page2 prefix is removed.
1216 The reloc offset is not modified but the instruction
1217 size is reduced by 1. */
1218 if (old_offset
== addr
)
1238 offset
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ branch_pos
);
1239 raddr
+= old_offset
;
1240 raddr
+= ((unsigned short) offset
| ((offset
& 0x80) ? 0xff00 : 0));
1241 if (irel
->r_offset
< addr
&& raddr
> addr
)
1244 bfd_put_8 (abfd
, offset
, contents
+ irel
->r_offset
+ branch_pos
);
1246 else if (irel
->r_offset
>= addr
&& raddr
<= addr
)
1249 bfd_put_8 (abfd
, offset
, contents
+ irel
->r_offset
+ branch_pos
);
1253 /*printf ("Not adjusted 0x%04x [0x%4x 0x%4x]\n", raddr,
1254 irel->r_offset, addr);*/
1261 /* Adjust the local symbols defined in this section. */
1262 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1263 for (isym
= isymbuf
; isym
< isymend
; isym
++)
1265 if (isym
->st_shndx
== sec_shndx
1266 && isym
->st_value
> addr
1267 && isym
->st_value
<= toaddr
)
1268 isym
->st_value
-= count
;
1271 /* Now adjust the global symbols defined in this section. */
1272 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1273 - symtab_hdr
->sh_info
);
1274 sym_hashes
= elf_sym_hashes (abfd
);
1275 end_hashes
= sym_hashes
+ symcount
;
1276 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1278 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1279 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1280 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1281 && sym_hash
->root
.u
.def
.section
== sec
1282 && sym_hash
->root
.u
.def
.value
> addr
1283 && sym_hash
->root
.u
.def
.value
<= toaddr
)
1285 sym_hash
->root
.u
.def
.value
-= count
;
1290 /* Specific sections:
1291 - The .page0 is a data section that is mapped in [0x0000..0x00FF].
1292 Page0 accesses are faster on the M68HC11. Soft registers used by GCC-m6811
1293 are located in .page0.
1294 - The .vectors is the section that represents the interrupt
1296 static const struct bfd_elf_special_section elf32_m68hc11_special_sections
[] =
1298 { STRING_COMMA_LEN (".eeprom"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1299 { STRING_COMMA_LEN (".page0"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
1300 { STRING_COMMA_LEN (".softregs"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
},
1301 { STRING_COMMA_LEN (".vectors"), 0, SHT_PROGBITS
, SHF_ALLOC
},
1302 { NULL
, 0, 0, 0, 0 }
1305 #define ELF_ARCH bfd_arch_m68hc11
1306 #define ELF_TARGET_ID M68HC11_ELF_DATA
1307 #define ELF_MACHINE_CODE EM_68HC11
1308 #define ELF_MAXPAGESIZE 0x1000
1310 #define TARGET_BIG_SYM m68hc11_elf32_vec
1311 #define TARGET_BIG_NAME "elf32-m68hc11"
1313 #define elf_info_to_howto NULL
1314 #define elf_info_to_howto_rel m68hc11_info_to_howto_rel
1315 #define bfd_elf32_bfd_relax_section m68hc11_elf_relax_section
1316 #define elf_backend_check_relocs elf32_m68hc11_check_relocs
1317 #define elf_backend_relocate_section elf32_m68hc11_relocate_section
1318 #define elf_backend_add_symbol_hook elf32_m68hc11_add_symbol_hook
1319 #define elf_backend_object_p 0
1320 #define elf_backend_can_gc_sections 1
1321 #define elf_backend_special_sections elf32_m68hc11_special_sections
1322 #define elf_backend_merge_symbol_attribute elf32_m68hc11_merge_symbol_attribute
1324 #define bfd_elf32_bfd_link_hash_table_create \
1325 m68hc11_elf_bfd_link_hash_table_create
1326 #define bfd_elf32_bfd_merge_private_bfd_data \
1327 _bfd_m68hc11_elf_merge_private_bfd_data
1328 #define bfd_elf32_bfd_set_private_flags _bfd_m68hc11_elf_set_private_flags
1329 #define bfd_elf32_bfd_print_private_bfd_data \
1330 _bfd_m68hc11_elf_print_private_bfd_data
1332 #include "elf32-target.h"