1 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Stephane Carrez (stcarrez@nerim.fr)
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 "elf32-m68hc1x.h"
28 #include "elf/m68hc11.h"
29 #include "opcode/m68hc11.h"
32 #define m68hc12_stub_hash_lookup(table, string, create, copy) \
33 ((struct elf32_m68hc11_stub_hash_entry *) \
34 bfd_hash_lookup ((table), (string), (create), (copy)))
36 static struct elf32_m68hc11_stub_hash_entry
* m68hc12_add_stub
37 (const char *stub_name
,
39 struct m68hc11_elf_link_hash_table
*htab
);
41 static struct bfd_hash_entry
*stub_hash_newfunc
42 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
44 static void m68hc11_elf_set_symbol (bfd
* abfd
, struct bfd_link_info
*info
,
45 const char* name
, bfd_vma value
,
48 static bfd_boolean m68hc11_elf_export_one_stub
49 (struct bfd_hash_entry
*gen_entry
, void *in_arg
);
51 static void scan_sections_for_abi (bfd
*, asection
*, PTR
);
53 struct m68hc11_scan_param
55 struct m68hc11_page_info
* pinfo
;
56 bfd_boolean use_memory_banks
;
60 /* Create a 68HC11/68HC12 ELF linker hash table. */
62 struct m68hc11_elf_link_hash_table
*
63 m68hc11_elf_hash_table_create (bfd
*abfd
)
65 struct m68hc11_elf_link_hash_table
*ret
;
66 bfd_size_type amt
= sizeof (struct m68hc11_elf_link_hash_table
);
68 ret
= (struct m68hc11_elf_link_hash_table
*) bfd_malloc (amt
);
69 if (ret
== (struct m68hc11_elf_link_hash_table
*) NULL
)
73 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
74 _bfd_elf_link_hash_newfunc
))
80 /* Init the stub hash table too. */
81 amt
= sizeof (struct bfd_hash_table
);
82 ret
->stub_hash_table
= (struct bfd_hash_table
*) bfd_malloc (amt
);
83 if (ret
->stub_hash_table
== NULL
)
88 if (!bfd_hash_table_init (ret
->stub_hash_table
, stub_hash_newfunc
))
92 ret
->stub_section
= 0;
93 ret
->add_stub_section
= NULL
;
94 ret
->sym_sec
.abfd
= NULL
;
99 /* Free the derived linker hash table. */
102 m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table
*hash
)
104 struct m68hc11_elf_link_hash_table
*ret
105 = (struct m68hc11_elf_link_hash_table
*) hash
;
107 bfd_hash_table_free (ret
->stub_hash_table
);
108 free (ret
->stub_hash_table
);
109 _bfd_generic_link_hash_table_free (hash
);
112 /* Assorted hash table functions. */
114 /* Initialize an entry in the stub hash table. */
116 static struct bfd_hash_entry
*
117 stub_hash_newfunc (struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
120 /* Allocate the structure if it has not already been allocated by a
124 entry
= bfd_hash_allocate (table
,
125 sizeof (struct elf32_m68hc11_stub_hash_entry
));
130 /* Call the allocation method of the superclass. */
131 entry
= bfd_hash_newfunc (entry
, table
, string
);
134 struct elf32_m68hc11_stub_hash_entry
*eh
;
136 /* Initialize the local fields. */
137 eh
= (struct elf32_m68hc11_stub_hash_entry
*) entry
;
140 eh
->target_value
= 0;
141 eh
->target_section
= NULL
;
147 /* Add a new stub entry to the stub hash. Not all fields of the new
148 stub entry are initialised. */
150 static struct elf32_m68hc11_stub_hash_entry
*
151 m68hc12_add_stub (const char *stub_name
, asection
*section
,
152 struct m68hc11_elf_link_hash_table
*htab
)
154 struct elf32_m68hc11_stub_hash_entry
*stub_entry
;
156 /* Enter this entry into the linker stub hash table. */
157 stub_entry
= m68hc12_stub_hash_lookup (htab
->stub_hash_table
, stub_name
,
159 if (stub_entry
== NULL
)
161 (*_bfd_error_handler
) (_("%s: cannot create stub entry %s"),
162 bfd_archive_filename (section
->owner
),
167 if (htab
->stub_section
== 0)
169 htab
->stub_section
= (*htab
->add_stub_section
) (".tramp",
170 htab
->tramp_section
);
173 stub_entry
->stub_sec
= htab
->stub_section
;
174 stub_entry
->stub_offset
= 0;
178 /* Hook called by the linker routine which adds symbols from an object
179 file. We use it for identify far symbols and force a loading of
180 the trampoline handler. */
183 elf32_m68hc11_add_symbol_hook (bfd
*abfd
, struct bfd_link_info
*info
,
184 Elf_Internal_Sym
*sym
,
185 const char **namep ATTRIBUTE_UNUSED
,
186 flagword
*flagsp ATTRIBUTE_UNUSED
,
187 asection
**secp ATTRIBUTE_UNUSED
,
188 bfd_vma
*valp ATTRIBUTE_UNUSED
)
190 if (sym
->st_other
& STO_M68HC12_FAR
)
192 struct elf_link_hash_entry
*h
;
194 h
= (struct elf_link_hash_entry
*)
195 bfd_link_hash_lookup (info
->hash
, "__far_trampoline",
196 FALSE
, FALSE
, FALSE
);
199 struct bfd_link_hash_entry
* entry
= NULL
;
201 _bfd_generic_link_add_one_symbol (info
, abfd
,
205 (bfd_vma
) 0, (const char*) NULL
,
206 FALSE
, FALSE
, &entry
);
213 /* External entry points for sizing and building linker stubs. */
215 /* Set up various things so that we can make a list of input sections
216 for each output section included in the link. Returns -1 on error,
217 0 when no stubs will be needed, and 1 on success. */
220 elf32_m68hc11_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
223 unsigned int bfd_count
;
224 int top_id
, top_index
;
226 asection
**input_list
, **list
;
228 asection
*text_section
;
229 struct m68hc11_elf_link_hash_table
*htab
;
231 htab
= m68hc11_elf_hash_table (info
);
233 if (htab
->root
.root
.creator
->flavour
!= bfd_target_elf_flavour
)
236 /* Count the number of input BFDs and find the top input section id.
237 Also search for an existing ".tramp" section so that we know
238 where generated trampolines must go. Default to ".text" if we
240 htab
->tramp_section
= 0;
242 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
244 input_bfd
= input_bfd
->link_next
)
247 for (section
= input_bfd
->sections
;
249 section
= section
->next
)
251 const char* name
= bfd_get_section_name (input_bfd
, section
);
253 if (!strcmp (name
, ".tramp"))
254 htab
->tramp_section
= section
;
256 if (!strcmp (name
, ".text"))
257 text_section
= section
;
259 if (top_id
< section
->id
)
260 top_id
= section
->id
;
263 htab
->bfd_count
= bfd_count
;
264 if (htab
->tramp_section
== 0)
265 htab
->tramp_section
= text_section
;
267 /* We can't use output_bfd->section_count here to find the top output
268 section index as some sections may have been removed, and
269 _bfd_strip_section_from_output doesn't renumber the indices. */
270 for (section
= output_bfd
->sections
, top_index
= 0;
272 section
= section
->next
)
274 if (top_index
< section
->index
)
275 top_index
= section
->index
;
278 htab
->top_index
= top_index
;
279 amt
= sizeof (asection
*) * (top_index
+ 1);
280 input_list
= (asection
**) bfd_malloc (amt
);
281 htab
->input_list
= input_list
;
282 if (input_list
== NULL
)
285 /* For sections we aren't interested in, mark their entries with a
286 value we can check later. */
287 list
= input_list
+ top_index
;
289 *list
= bfd_abs_section_ptr
;
290 while (list
-- != input_list
);
292 for (section
= output_bfd
->sections
;
294 section
= section
->next
)
296 if ((section
->flags
& SEC_CODE
) != 0)
297 input_list
[section
->index
] = NULL
;
303 /* Determine and set the size of the stub section for a final link.
305 The basic idea here is to examine all the relocations looking for
306 PC-relative calls to a target that is unreachable with a "bl"
310 elf32_m68hc11_size_stubs (bfd
*output_bfd
, bfd
*stub_bfd
,
311 struct bfd_link_info
*info
,
312 asection
* (*add_stub_section
) (const char*, asection
*))
316 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
317 unsigned int bfd_indx
, bfd_count
;
321 struct m68hc11_elf_link_hash_table
*htab
= m68hc11_elf_hash_table (info
);
323 /* Stash our params away. */
324 htab
->stub_bfd
= stub_bfd
;
325 htab
->add_stub_section
= add_stub_section
;
327 /* Count the number of input BFDs and find the top input section id. */
328 for (input_bfd
= info
->input_bfds
, bfd_count
= 0;
330 input_bfd
= input_bfd
->link_next
)
335 /* We want to read in symbol extension records only once. To do this
336 we need to read in the local symbols in parallel and save them for
337 later use; so hold pointers to the local symbols in an array. */
338 amt
= sizeof (Elf_Internal_Sym
*) * bfd_count
;
339 all_local_syms
= (Elf_Internal_Sym
**) bfd_zmalloc (amt
);
340 if (all_local_syms
== NULL
)
343 /* Walk over all the input BFDs, swapping in local symbols. */
344 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
346 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
348 Elf_Internal_Shdr
*symtab_hdr
;
350 /* We'll need the symbol table in a second. */
351 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
352 if (symtab_hdr
->sh_info
== 0)
355 /* We need an array of the local symbols attached to the input bfd. */
356 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
357 if (local_syms
== NULL
)
359 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
360 symtab_hdr
->sh_info
, 0,
362 /* Cache them for elf_link_input_bfd. */
363 symtab_hdr
->contents
= (unsigned char *) local_syms
;
365 if (local_syms
== NULL
)
367 free (all_local_syms
);
371 all_local_syms
[bfd_indx
] = local_syms
;
374 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
376 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
378 Elf_Internal_Shdr
*symtab_hdr
;
379 Elf_Internal_Sym
*local_syms
;
380 struct elf_link_hash_entry
** sym_hashes
;
382 sym_hashes
= elf_sym_hashes (input_bfd
);
384 /* We'll need the symbol table in a second. */
385 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
386 if (symtab_hdr
->sh_info
== 0)
389 local_syms
= all_local_syms
[bfd_indx
];
391 /* Walk over each section attached to the input bfd. */
392 for (section
= input_bfd
->sections
;
394 section
= section
->next
)
396 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
398 /* If there aren't any relocs, then there's nothing more
400 if ((section
->flags
& SEC_RELOC
) == 0
401 || section
->reloc_count
== 0)
404 /* If this section is a link-once section that will be
405 discarded, then don't create any stubs. */
406 if (section
->output_section
== NULL
407 || section
->output_section
->owner
!= output_bfd
)
410 /* Get the relocs. */
412 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
,
413 (Elf_Internal_Rela
*) NULL
,
415 if (internal_relocs
== NULL
)
416 goto error_ret_free_local
;
418 /* Now examine each relocation. */
419 irela
= internal_relocs
;
420 irelaend
= irela
+ section
->reloc_count
;
421 for (; irela
< irelaend
; irela
++)
423 unsigned int r_type
, r_indx
;
424 struct elf32_m68hc11_stub_hash_entry
*stub_entry
;
427 struct elf_link_hash_entry
*hash
;
428 const char *stub_name
;
429 Elf_Internal_Sym
*sym
;
431 r_type
= ELF32_R_TYPE (irela
->r_info
);
433 /* Only look at 16-bit relocs. */
434 if (r_type
!= (unsigned int) R_M68HC11_16
)
437 /* Now determine the call target, its name, value,
439 r_indx
= ELF32_R_SYM (irela
->r_info
);
440 if (r_indx
< symtab_hdr
->sh_info
)
442 /* It's a local symbol. */
443 Elf_Internal_Shdr
*hdr
;
446 sym
= local_syms
+ r_indx
;
447 is_far
= (sym
&& (sym
->st_other
& STO_M68HC12_FAR
));
451 hdr
= elf_elfsections (input_bfd
)[sym
->st_shndx
];
452 sym_sec
= hdr
->bfd_section
;
453 stub_name
= (bfd_elf_string_from_elf_section
454 (input_bfd
, symtab_hdr
->sh_link
,
456 sym_value
= sym
->st_value
;
461 /* It's an external symbol. */
464 e_indx
= r_indx
- symtab_hdr
->sh_info
;
465 hash
= (struct elf_link_hash_entry
*)
466 (sym_hashes
[e_indx
]);
468 while (hash
->root
.type
== bfd_link_hash_indirect
469 || hash
->root
.type
== bfd_link_hash_warning
)
470 hash
= ((struct elf_link_hash_entry
*)
471 hash
->root
.u
.i
.link
);
473 if (hash
->root
.type
== bfd_link_hash_defined
474 || hash
->root
.type
== bfd_link_hash_defweak
)
476 if (!(hash
->other
& STO_M68HC12_FAR
))
479 else if (hash
->root
.type
== bfd_link_hash_undefweak
)
483 else if (hash
->root
.type
== bfd_link_hash_undefined
)
489 bfd_set_error (bfd_error_bad_value
);
490 goto error_ret_free_internal
;
492 sym_sec
= hash
->root
.u
.def
.section
;
493 sym_value
= hash
->root
.u
.def
.value
;
494 stub_name
= hash
->root
.root
.string
;
498 goto error_ret_free_internal
;
500 stub_entry
= m68hc12_stub_hash_lookup
501 (htab
->stub_hash_table
,
504 if (stub_entry
== NULL
)
506 if (add_stub_section
== 0)
509 stub_entry
= m68hc12_add_stub (stub_name
, section
, htab
);
510 if (stub_entry
== NULL
)
512 error_ret_free_internal
:
513 if (elf_section_data (section
)->relocs
== NULL
)
514 free (internal_relocs
);
515 goto error_ret_free_local
;
519 stub_entry
->target_value
= sym_value
;
520 stub_entry
->target_section
= sym_sec
;
523 /* We're done with the internal relocs, free them. */
524 if (elf_section_data (section
)->relocs
== NULL
)
525 free (internal_relocs
);
529 if (add_stub_section
)
531 /* OK, we've added some stubs. Find out the new size of the
533 for (stub_sec
= htab
->stub_bfd
->sections
;
535 stub_sec
= stub_sec
->next
)
540 bfd_hash_traverse (htab
->stub_hash_table
, htab
->size_one_stub
, htab
);
542 free (all_local_syms
);
545 error_ret_free_local
:
546 free (all_local_syms
);
550 /* Export the trampoline addresses in the symbol table. */
552 m68hc11_elf_export_one_stub (struct bfd_hash_entry
*gen_entry
, void *in_arg
)
554 struct bfd_link_info
*info
;
555 struct m68hc11_elf_link_hash_table
*htab
;
556 struct elf32_m68hc11_stub_hash_entry
*stub_entry
;
560 info
= (struct bfd_link_info
*) in_arg
;
561 htab
= m68hc11_elf_hash_table (info
);
563 /* Massage our args to the form they really have. */
564 stub_entry
= (struct elf32_m68hc11_stub_hash_entry
*) gen_entry
;
566 /* Generate the trampoline according to HC11 or HC12. */
567 result
= (* htab
->build_one_stub
) (gen_entry
, in_arg
);
569 /* Make a printable name that does not conflict with the real function. */
570 name
= alloca (strlen (stub_entry
->root
.string
) + 16);
571 sprintf (name
, "tramp.%s", stub_entry
->root
.string
);
573 /* Export the symbol for debugging/disassembling. */
574 m68hc11_elf_set_symbol (htab
->stub_bfd
, info
, name
,
575 stub_entry
->stub_offset
,
576 stub_entry
->stub_sec
);
580 /* Export a symbol or set its value and section. */
582 m68hc11_elf_set_symbol (bfd
*abfd
, struct bfd_link_info
*info
,
583 const char *name
, bfd_vma value
, asection
*sec
)
585 struct elf_link_hash_entry
*h
;
587 h
= (struct elf_link_hash_entry
*)
588 bfd_link_hash_lookup (info
->hash
, name
, FALSE
, FALSE
, FALSE
);
591 _bfd_generic_link_add_one_symbol (info
, abfd
,
601 h
->root
.type
= bfd_link_hash_defined
;
602 h
->root
.u
.def
.value
= value
;
603 h
->root
.u
.def
.section
= sec
;
608 /* Build all the stubs associated with the current output file. The
609 stubs are kept in a hash table attached to the main linker hash
610 table. This function is called via m68hc12elf_finish in the
614 elf32_m68hc11_build_stubs (bfd
*abfd
, struct bfd_link_info
*info
)
617 struct bfd_hash_table
*table
;
618 struct m68hc11_elf_link_hash_table
*htab
;
619 struct m68hc11_scan_param param
;
621 m68hc11_elf_get_bank_parameters (info
);
622 htab
= m68hc11_elf_hash_table (info
);
624 for (stub_sec
= htab
->stub_bfd
->sections
;
626 stub_sec
= stub_sec
->next
)
630 /* Allocate memory to hold the linker stubs. */
631 size
= stub_sec
->size
;
632 stub_sec
->contents
= (unsigned char *) bfd_zalloc (htab
->stub_bfd
, size
);
633 if (stub_sec
->contents
== NULL
&& size
!= 0)
638 /* Build the stubs as directed by the stub hash table. */
639 table
= htab
->stub_hash_table
;
640 bfd_hash_traverse (table
, m68hc11_elf_export_one_stub
, info
);
642 /* Scan the output sections to see if we use the memory banks.
643 If so, export the symbols that define how the memory banks
644 are mapped. This is used by gdb and the simulator to obtain
645 the information. It can be used by programs to burn the eprom
646 at the good addresses. */
647 param
.use_memory_banks
= FALSE
;
648 param
.pinfo
= &htab
->pinfo
;
649 bfd_map_over_sections (abfd
, scan_sections_for_abi
, ¶m
);
650 if (param
.use_memory_banks
)
652 m68hc11_elf_set_symbol (abfd
, info
, BFD_M68HC11_BANK_START_NAME
,
653 htab
->pinfo
.bank_physical
,
654 bfd_abs_section_ptr
);
655 m68hc11_elf_set_symbol (abfd
, info
, BFD_M68HC11_BANK_VIRTUAL_NAME
,
656 htab
->pinfo
.bank_virtual
,
657 bfd_abs_section_ptr
);
658 m68hc11_elf_set_symbol (abfd
, info
, BFD_M68HC11_BANK_SIZE_NAME
,
659 htab
->pinfo
.bank_size
,
660 bfd_abs_section_ptr
);
667 m68hc11_elf_get_bank_parameters (struct bfd_link_info
*info
)
670 struct m68hc11_page_info
*pinfo
;
671 struct bfd_link_hash_entry
*h
;
673 pinfo
= &m68hc11_elf_hash_table (info
)->pinfo
;
674 if (pinfo
->bank_param_initialized
)
677 pinfo
->bank_virtual
= M68HC12_BANK_VIRT
;
678 pinfo
->bank_mask
= M68HC12_BANK_MASK
;
679 pinfo
->bank_physical
= M68HC12_BANK_BASE
;
680 pinfo
->bank_shift
= M68HC12_BANK_SHIFT
;
681 pinfo
->bank_size
= 1 << M68HC12_BANK_SHIFT
;
683 h
= bfd_link_hash_lookup (info
->hash
, BFD_M68HC11_BANK_START_NAME
,
685 if (h
!= (struct bfd_link_hash_entry
*) NULL
686 && h
->type
== bfd_link_hash_defined
)
687 pinfo
->bank_physical
= (h
->u
.def
.value
688 + h
->u
.def
.section
->output_section
->vma
689 + h
->u
.def
.section
->output_offset
);
691 h
= bfd_link_hash_lookup (info
->hash
, BFD_M68HC11_BANK_VIRTUAL_NAME
,
693 if (h
!= (struct bfd_link_hash_entry
*) NULL
694 && h
->type
== bfd_link_hash_defined
)
695 pinfo
->bank_virtual
= (h
->u
.def
.value
696 + h
->u
.def
.section
->output_section
->vma
697 + h
->u
.def
.section
->output_offset
);
699 h
= bfd_link_hash_lookup (info
->hash
, BFD_M68HC11_BANK_SIZE_NAME
,
701 if (h
!= (struct bfd_link_hash_entry
*) NULL
702 && h
->type
== bfd_link_hash_defined
)
703 pinfo
->bank_size
= (h
->u
.def
.value
704 + h
->u
.def
.section
->output_section
->vma
705 + h
->u
.def
.section
->output_offset
);
707 pinfo
->bank_shift
= 0;
708 for (i
= pinfo
->bank_size
; i
!= 0; i
>>= 1)
711 pinfo
->bank_mask
= (1 << pinfo
->bank_shift
) - 1;
712 pinfo
->bank_physical_end
= pinfo
->bank_physical
+ pinfo
->bank_size
;
713 pinfo
->bank_param_initialized
= 1;
715 h
= bfd_link_hash_lookup (info
->hash
, "__far_trampoline", FALSE
,
717 if (h
!= (struct bfd_link_hash_entry
*) NULL
718 && h
->type
== bfd_link_hash_defined
)
719 pinfo
->trampoline_addr
= (h
->u
.def
.value
720 + h
->u
.def
.section
->output_section
->vma
721 + h
->u
.def
.section
->output_offset
);
724 /* Return 1 if the address is in banked memory.
725 This can be applied to a virtual address and to a physical address. */
727 m68hc11_addr_is_banked (struct m68hc11_page_info
*pinfo
, bfd_vma addr
)
729 if (addr
>= pinfo
->bank_virtual
)
732 if (addr
>= pinfo
->bank_physical
&& addr
<= pinfo
->bank_physical_end
)
738 /* Return the physical address seen by the processor, taking
739 into account banked memory. */
741 m68hc11_phys_addr (struct m68hc11_page_info
*pinfo
, bfd_vma addr
)
743 if (addr
< pinfo
->bank_virtual
)
746 /* Map the address to the memory bank. */
747 addr
-= pinfo
->bank_virtual
;
748 addr
&= pinfo
->bank_mask
;
749 addr
+= pinfo
->bank_physical
;
753 /* Return the page number corresponding to an address in banked memory. */
755 m68hc11_phys_page (struct m68hc11_page_info
*pinfo
, bfd_vma addr
)
757 if (addr
< pinfo
->bank_virtual
)
760 /* Map the address to the memory bank. */
761 addr
-= pinfo
->bank_virtual
;
762 addr
>>= pinfo
->bank_shift
;
767 /* This function is used for relocs which are only used for relaxing,
768 which the linker should otherwise ignore. */
770 bfd_reloc_status_type
771 m68hc11_elf_ignore_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
772 arelent
*reloc_entry
,
773 asymbol
*symbol ATTRIBUTE_UNUSED
,
774 void *data ATTRIBUTE_UNUSED
,
775 asection
*input_section
,
777 char **error_message ATTRIBUTE_UNUSED
)
779 if (output_bfd
!= NULL
)
780 reloc_entry
->address
+= input_section
->output_offset
;
784 bfd_reloc_status_type
785 m68hc11_elf_special_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
786 arelent
*reloc_entry
,
788 void *data ATTRIBUTE_UNUSED
,
789 asection
*input_section
,
791 char **error_message ATTRIBUTE_UNUSED
)
793 if (output_bfd
!= (bfd
*) NULL
794 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
795 && (! reloc_entry
->howto
->partial_inplace
796 || reloc_entry
->addend
== 0))
798 reloc_entry
->address
+= input_section
->output_offset
;
802 if (output_bfd
!= NULL
)
803 return bfd_reloc_continue
;
805 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
806 return bfd_reloc_outofrange
;
812 elf32_m68hc11_gc_mark_hook (asection
*sec
,
813 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
814 Elf_Internal_Rela
*rel
,
815 struct elf_link_hash_entry
*h
,
816 Elf_Internal_Sym
*sym
)
820 switch (ELF32_R_TYPE (rel
->r_info
))
823 switch (h
->root
.type
)
825 case bfd_link_hash_defined
:
826 case bfd_link_hash_defweak
:
827 return h
->root
.u
.def
.section
;
829 case bfd_link_hash_common
:
830 return h
->root
.u
.c
.p
->section
;
838 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
844 elf32_m68hc11_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
845 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
846 asection
*sec ATTRIBUTE_UNUSED
,
847 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
849 /* We don't use got and plt entries for 68hc11/68hc12. */
853 /* Look through the relocs for a section during the first phase.
854 Since we don't do .gots or .plts, we just need to consider the
855 virtual table relocs for gc. */
858 elf32_m68hc11_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
859 asection
*sec
, const Elf_Internal_Rela
*relocs
)
861 Elf_Internal_Shdr
* symtab_hdr
;
862 struct elf_link_hash_entry
** sym_hashes
;
863 struct elf_link_hash_entry
** sym_hashes_end
;
864 const Elf_Internal_Rela
* rel
;
865 const Elf_Internal_Rela
* rel_end
;
867 if (info
->relocatable
)
870 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
871 sym_hashes
= elf_sym_hashes (abfd
);
872 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
);
873 if (!elf_bad_symtab (abfd
))
874 sym_hashes_end
-= symtab_hdr
->sh_info
;
876 rel_end
= relocs
+ sec
->reloc_count
;
878 for (rel
= relocs
; rel
< rel_end
; rel
++)
880 struct elf_link_hash_entry
* h
;
881 unsigned long r_symndx
;
883 r_symndx
= ELF32_R_SYM (rel
->r_info
);
885 if (r_symndx
< symtab_hdr
->sh_info
)
888 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
890 switch (ELF32_R_TYPE (rel
->r_info
))
892 /* This relocation describes the C++ object vtable hierarchy.
893 Reconstruct it for later use during GC. */
894 case R_M68HC11_GNU_VTINHERIT
:
895 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
899 /* This relocation describes which C++ vtable entries are actually
900 used. Record for later use during GC. */
901 case R_M68HC11_GNU_VTENTRY
:
902 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
912 m68hc11_get_relocation_value (bfd
*input_bfd
, struct bfd_link_info
*info
,
913 asection
*input_section
,
914 asection
**local_sections
,
915 Elf_Internal_Sym
*local_syms
,
916 Elf_Internal_Rela
*rel
,
918 bfd_vma
*relocation
, bfd_boolean
*is_far
)
920 Elf_Internal_Shdr
*symtab_hdr
;
921 struct elf_link_hash_entry
**sym_hashes
;
922 unsigned long r_symndx
;
924 struct elf_link_hash_entry
*h
;
925 Elf_Internal_Sym
*sym
;
926 const char* stub_name
= 0;
928 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
929 sym_hashes
= elf_sym_hashes (input_bfd
);
931 r_symndx
= ELF32_R_SYM (rel
->r_info
);
933 /* This is a final link. */
937 if (r_symndx
< symtab_hdr
->sh_info
)
939 sym
= local_syms
+ r_symndx
;
940 sec
= local_sections
[r_symndx
];
941 *relocation
= (sec
->output_section
->vma
944 *is_far
= (sym
&& (sym
->st_other
& STO_M68HC12_FAR
));
946 stub_name
= (bfd_elf_string_from_elf_section
947 (input_bfd
, symtab_hdr
->sh_link
,
952 bfd_boolean unresolved_reloc
, warned
;
954 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
955 r_symndx
, symtab_hdr
, sym_hashes
,
956 h
, sec
, *relocation
, unresolved_reloc
, warned
);
958 *is_far
= (h
&& (h
->other
& STO_M68HC12_FAR
));
959 stub_name
= h
->root
.root
.string
;
963 *name
= h
->root
.root
.string
;
966 *name
= (bfd_elf_string_from_elf_section
967 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
968 if (*name
== NULL
|| **name
== '\0')
969 *name
= bfd_section_name (input_bfd
, sec
);
972 if (*is_far
&& ELF32_R_TYPE (rel
->r_info
) == R_M68HC11_16
)
974 struct elf32_m68hc11_stub_hash_entry
* stub
;
975 struct m68hc11_elf_link_hash_table
*htab
;
977 htab
= m68hc11_elf_hash_table (info
);
978 stub
= m68hc12_stub_hash_lookup (htab
->stub_hash_table
,
979 *name
, FALSE
, FALSE
);
982 *relocation
= stub
->stub_offset
983 + stub
->stub_sec
->output_section
->vma
984 + stub
->stub_sec
->output_offset
;
991 /* Relocate a 68hc11/68hc12 ELF section. */
993 elf32_m68hc11_relocate_section (bfd
*output_bfd ATTRIBUTE_UNUSED
,
994 struct bfd_link_info
*info
,
995 bfd
*input_bfd
, asection
*input_section
,
996 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
997 Elf_Internal_Sym
*local_syms
,
998 asection
**local_sections
)
1000 Elf_Internal_Shdr
*symtab_hdr
;
1001 struct elf_link_hash_entry
**sym_hashes
;
1002 Elf_Internal_Rela
*rel
, *relend
;
1004 struct m68hc11_page_info
*pinfo
;
1005 const struct elf_backend_data
* const ebd
= get_elf_backend_data (input_bfd
);
1007 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1008 sym_hashes
= elf_sym_hashes (input_bfd
);
1010 /* Get memory bank parameters. */
1011 m68hc11_elf_get_bank_parameters (info
);
1012 pinfo
= &m68hc11_elf_hash_table (info
)->pinfo
;
1015 relend
= relocs
+ input_section
->reloc_count
;
1016 for (; rel
< relend
; rel
++)
1020 reloc_howto_type
*howto
;
1021 unsigned long r_symndx
;
1022 Elf_Internal_Sym
*sym
;
1025 bfd_reloc_status_type r
= bfd_reloc_undefined
;
1032 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1033 r_type
= ELF32_R_TYPE (rel
->r_info
);
1035 if (r_type
== R_M68HC11_GNU_VTENTRY
1036 || r_type
== R_M68HC11_GNU_VTINHERIT
)
1039 if (info
->relocatable
)
1041 /* This is a relocatable link. We don't have to change
1042 anything, unless the reloc is against a section symbol,
1043 in which case we have to adjust according to where the
1044 section symbol winds up in the output section. */
1045 if (r_symndx
< symtab_hdr
->sh_info
)
1047 sym
= local_syms
+ r_symndx
;
1048 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1050 sec
= local_sections
[r_symndx
];
1051 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1057 (*ebd
->elf_info_to_howto_rel
) (input_bfd
, &arel
, rel
);
1060 m68hc11_get_relocation_value (input_bfd
, info
, input_section
,
1061 local_sections
, local_syms
,
1062 rel
, &name
, &relocation
, &is_far
);
1064 /* Do the memory bank mapping. */
1065 phys_addr
= m68hc11_phys_addr (pinfo
, relocation
+ rel
->r_addend
);
1066 phys_page
= m68hc11_phys_page (pinfo
, relocation
+ rel
->r_addend
);
1070 /* Reloc used by 68HC12 call instruction. */
1071 bfd_put_16 (input_bfd
, phys_addr
,
1072 (bfd_byte
*) contents
+ rel
->r_offset
);
1073 bfd_put_8 (input_bfd
, phys_page
,
1074 (bfd_byte
*) contents
+ rel
->r_offset
+ 2);
1076 r_type
= R_M68HC11_NONE
;
1079 case R_M68HC11_NONE
:
1083 case R_M68HC11_LO16
:
1084 /* Reloc generated by %addr(expr) gas to obtain the
1085 address as mapped in the memory bank window. */
1086 relocation
= phys_addr
;
1089 case R_M68HC11_PAGE
:
1090 /* Reloc generated by %page(expr) gas to obtain the
1091 page number associated with the address. */
1092 relocation
= phys_page
;
1096 /* Get virtual address of instruction having the relocation. */
1101 msg
= _("Reference to the far symbol `%s' using a wrong "
1102 "relocation may result in incorrect execution");
1103 buf
= alloca (strlen (msg
) + strlen (name
) + 10);
1104 sprintf (buf
, msg
, name
);
1106 (* info
->callbacks
->warning
)
1107 (info
, buf
, name
, input_bfd
, NULL
, rel
->r_offset
);
1110 /* Get virtual address of instruction having the relocation. */
1111 insn_addr
= input_section
->output_section
->vma
1112 + input_section
->output_offset
1115 insn_page
= m68hc11_phys_page (pinfo
, insn_addr
);
1117 if (m68hc11_addr_is_banked (pinfo
, relocation
+ rel
->r_addend
)
1118 && m68hc11_addr_is_banked (pinfo
, insn_addr
)
1119 && phys_page
!= insn_page
)
1124 msg
= _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1125 "as current banked address [%lx:%04lx] (%lx)");
1127 buf
= alloca (strlen (msg
) + 128);
1128 sprintf (buf
, msg
, phys_page
, phys_addr
,
1129 (long) (relocation
+ rel
->r_addend
),
1130 insn_page
, m68hc11_phys_addr (pinfo
, insn_addr
),
1131 (long) (insn_addr
));
1132 if (!((*info
->callbacks
->warning
)
1133 (info
, buf
, name
, input_bfd
, input_section
,
1138 if (phys_page
!= 0 && insn_page
== 0)
1143 msg
= _("reference to a banked address [%lx:%04lx] in the "
1144 "normal address space at %04lx");
1146 buf
= alloca (strlen (msg
) + 128);
1147 sprintf (buf
, msg
, phys_page
, phys_addr
, insn_addr
);
1148 if (!((*info
->callbacks
->warning
)
1149 (info
, buf
, name
, input_bfd
, input_section
,
1153 relocation
= phys_addr
;
1157 /* If this is a banked address use the phys_addr so that
1158 we stay in the banked window. */
1159 if (m68hc11_addr_is_banked (pinfo
, relocation
+ rel
->r_addend
))
1160 relocation
= phys_addr
;
1163 if (r_type
!= R_M68HC11_NONE
)
1164 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1165 contents
, rel
->r_offset
,
1166 relocation
, rel
->r_addend
);
1168 if (r
!= bfd_reloc_ok
)
1170 const char * msg
= (const char *) 0;
1174 case bfd_reloc_overflow
:
1175 if (!((*info
->callbacks
->reloc_overflow
)
1176 (info
, name
, howto
->name
, (bfd_vma
) 0,
1177 input_bfd
, input_section
, rel
->r_offset
)))
1181 case bfd_reloc_undefined
:
1182 if (!((*info
->callbacks
->undefined_symbol
)
1183 (info
, name
, input_bfd
, input_section
,
1184 rel
->r_offset
, TRUE
)))
1188 case bfd_reloc_outofrange
:
1189 msg
= _ ("internal error: out of range error");
1192 case bfd_reloc_notsupported
:
1193 msg
= _ ("internal error: unsupported relocation error");
1196 case bfd_reloc_dangerous
:
1197 msg
= _ ("internal error: dangerous error");
1201 msg
= _ ("internal error: unknown error");
1205 if (!((*info
->callbacks
->warning
)
1206 (info
, msg
, name
, input_bfd
, input_section
,
1219 /* Set and control ELF flags in ELF header. */
1222 _bfd_m68hc11_elf_set_private_flags (bfd
*abfd
, flagword flags
)
1224 BFD_ASSERT (!elf_flags_init (abfd
)
1225 || elf_elfheader (abfd
)->e_flags
== flags
);
1227 elf_elfheader (abfd
)->e_flags
= flags
;
1228 elf_flags_init (abfd
) = TRUE
;
1232 /* Merge backend specific data from an object file to the output
1233 object file when linking. */
1236 _bfd_m68hc11_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1240 bfd_boolean ok
= TRUE
;
1242 /* Check if we have the same endianess */
1243 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
1246 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1247 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1250 new_flags
= elf_elfheader (ibfd
)->e_flags
;
1251 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_M68HC11_ABI
;
1252 old_flags
= elf_elfheader (obfd
)->e_flags
;
1254 if (! elf_flags_init (obfd
))
1256 elf_flags_init (obfd
) = TRUE
;
1257 elf_elfheader (obfd
)->e_flags
= new_flags
;
1258 elf_elfheader (obfd
)->e_ident
[EI_CLASS
]
1259 = elf_elfheader (ibfd
)->e_ident
[EI_CLASS
];
1261 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1262 && bfd_get_arch_info (obfd
)->the_default
)
1264 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1265 bfd_get_mach (ibfd
)))
1272 /* Check ABI compatibility. */
1273 if ((new_flags
& E_M68HC11_I32
) != (old_flags
& E_M68HC11_I32
))
1275 (*_bfd_error_handler
)
1276 (_("%s: linking files compiled for 16-bit integers (-mshort) "
1277 "and others for 32-bit integers"),
1278 bfd_archive_filename (ibfd
));
1281 if ((new_flags
& E_M68HC11_F64
) != (old_flags
& E_M68HC11_F64
))
1283 (*_bfd_error_handler
)
1284 (_("%s: linking files compiled for 32-bit double (-fshort-double) "
1285 "and others for 64-bit double"),
1286 bfd_archive_filename (ibfd
));
1290 /* Processor compatibility. */
1291 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags
, old_flags
))
1293 (*_bfd_error_handler
)
1294 (_("%s: linking files compiled for HCS12 with "
1295 "others compiled for HC12"),
1296 bfd_archive_filename (ibfd
));
1299 new_flags
= ((new_flags
& ~EF_M68HC11_MACH_MASK
)
1300 | (EF_M68HC11_MERGE_MACH (new_flags
, old_flags
)));
1302 elf_elfheader (obfd
)->e_flags
= new_flags
;
1304 new_flags
&= ~(EF_M68HC11_ABI
| EF_M68HC11_MACH_MASK
);
1305 old_flags
&= ~(EF_M68HC11_ABI
| EF_M68HC11_MACH_MASK
);
1307 /* Warn about any other mismatches */
1308 if (new_flags
!= old_flags
)
1310 (*_bfd_error_handler
)
1311 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1312 bfd_archive_filename (ibfd
), (unsigned long) new_flags
,
1313 (unsigned long) old_flags
);
1319 bfd_set_error (bfd_error_bad_value
);
1327 _bfd_m68hc11_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
1329 FILE *file
= (FILE *) ptr
;
1331 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
1333 /* Print normal ELF private data. */
1334 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
1336 /* xgettext:c-format */
1337 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
1339 if (elf_elfheader (abfd
)->e_flags
& E_M68HC11_I32
)
1340 fprintf (file
, _("[abi=32-bit int, "));
1342 fprintf (file
, _("[abi=16-bit int, "));
1344 if (elf_elfheader (abfd
)->e_flags
& E_M68HC11_F64
)
1345 fprintf (file
, _("64-bit double, "));
1347 fprintf (file
, _("32-bit double, "));
1349 if (strcmp (bfd_get_target (abfd
), "elf32-m68hc11") == 0)
1350 fprintf (file
, _("cpu=HC11]"));
1351 else if (elf_elfheader (abfd
)->e_flags
& EF_M68HCS12_MACH
)
1352 fprintf (file
, _("cpu=HCS12]"));
1354 fprintf (file
, _("cpu=HC12]"));
1356 if (elf_elfheader (abfd
)->e_flags
& E_M68HC12_BANKS
)
1357 fprintf (file
, _(" [memory=bank-model]"));
1359 fprintf (file
, _(" [memory=flat]"));
1366 static void scan_sections_for_abi (bfd
*abfd ATTRIBUTE_UNUSED
,
1367 asection
*asect
, void *arg
)
1369 struct m68hc11_scan_param
* p
= (struct m68hc11_scan_param
*) arg
;
1371 if (asect
->vma
>= p
->pinfo
->bank_virtual
)
1372 p
->use_memory_banks
= TRUE
;
1375 /* Tweak the OSABI field of the elf header. */
1378 elf32_m68hc11_post_process_headers (bfd
*abfd
, struct bfd_link_info
*link_info
)
1380 struct m68hc11_scan_param param
;
1385 m68hc11_elf_get_bank_parameters (link_info
);
1387 param
.use_memory_banks
= FALSE
;
1388 param
.pinfo
= &m68hc11_elf_hash_table (link_info
)->pinfo
;
1389 bfd_map_over_sections (abfd
, scan_sections_for_abi
, ¶m
);
1390 if (param
.use_memory_banks
)
1392 Elf_Internal_Ehdr
* i_ehdrp
;
1394 i_ehdrp
= elf_elfheader (abfd
);
1395 i_ehdrp
->e_flags
|= E_M68HC12_BANKS
;