1 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 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"
33 #define m68hc12_stub_hash_lookup(table, string, create, copy) \
34 ((struct elf32_m68hc11_stub_hash_entry *) \
35 bfd_hash_lookup ((table), (string), (create), (copy)))
37 static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub
38 (const char *stub_name,
40 struct m68hc11_elf_link_hash_table *htab);
42 static struct bfd_hash_entry *stub_hash_newfunc
43 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
45 static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info,
46 const char* name, bfd_vma value,
49 static bfd_boolean m68hc11_elf_export_one_stub
50 (struct bfd_hash_entry *gen_entry, void *in_arg);
52 static void scan_sections_for_abi (bfd*, asection*, PTR);
54 struct m68hc11_scan_param
56 struct m68hc11_page_info* pinfo;
57 bfd_boolean use_memory_banks;
61 /* Create a 68HC11/68HC12 ELF linker hash table. */
63 struct m68hc11_elf_link_hash_table*
64 m68hc11_elf_hash_table_create (bfd *abfd)
66 struct m68hc11_elf_link_hash_table *ret;
67 bfd_size_type amt = sizeof (struct m68hc11_elf_link_hash_table);
69 ret = (struct m68hc11_elf_link_hash_table *) bfd_malloc (amt);
70 if (ret == (struct m68hc11_elf_link_hash_table *) NULL)
74 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
75 _bfd_elf_link_hash_newfunc,
76 sizeof (struct elf_link_hash_entry)))
82 /* Init the stub hash table too. */
83 amt = sizeof (struct bfd_hash_table);
84 ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt);
85 if (ret->stub_hash_table == NULL)
90 if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc,
91 sizeof (struct elf32_m68hc11_stub_hash_entry)))
95 ret->stub_section = 0;
96 ret->add_stub_section = NULL;
97 ret->sym_sec.abfd = NULL;
102 /* Free the derived linker hash table. */
105 m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table *hash)
107 struct m68hc11_elf_link_hash_table *ret
108 = (struct m68hc11_elf_link_hash_table *) hash;
110 bfd_hash_table_free (ret->stub_hash_table);
111 free (ret->stub_hash_table);
112 _bfd_generic_link_hash_table_free (hash);
115 /* Assorted hash table functions. */
117 /* Initialize an entry in the stub hash table. */
119 static struct bfd_hash_entry *
120 stub_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
123 /* Allocate the structure if it has not already been allocated by a
127 entry = bfd_hash_allocate (table,
128 sizeof (struct elf32_m68hc11_stub_hash_entry));
133 /* Call the allocation method of the superclass. */
134 entry = bfd_hash_newfunc (entry, table, string);
137 struct elf32_m68hc11_stub_hash_entry *eh;
139 /* Initialize the local fields. */
140 eh = (struct elf32_m68hc11_stub_hash_entry *) entry;
143 eh->target_value = 0;
144 eh->target_section = NULL;
150 /* Add a new stub entry to the stub hash. Not all fields of the new
151 stub entry are initialised. */
153 static struct elf32_m68hc11_stub_hash_entry *
154 m68hc12_add_stub (const char *stub_name, asection *section,
155 struct m68hc11_elf_link_hash_table *htab)
157 struct elf32_m68hc11_stub_hash_entry *stub_entry;
159 /* Enter this entry into the linker stub hash table. */
160 stub_entry = m68hc12_stub_hash_lookup (htab->stub_hash_table, stub_name,
162 if (stub_entry == NULL)
164 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
165 section->owner, stub_name);
169 if (htab->stub_section == 0)
171 htab->stub_section = (*htab->add_stub_section) (".tramp",
172 htab->tramp_section);
175 stub_entry->stub_sec = htab->stub_section;
176 stub_entry->stub_offset = 0;
180 /* Hook called by the linker routine which adds symbols from an object
181 file. We use it for identify far symbols and force a loading of
182 the trampoline handler. */
185 elf32_m68hc11_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
186 Elf_Internal_Sym *sym,
187 const char **namep ATTRIBUTE_UNUSED,
188 flagword *flagsp ATTRIBUTE_UNUSED,
189 asection **secp ATTRIBUTE_UNUSED,
190 bfd_vma *valp ATTRIBUTE_UNUSED)
192 if (sym->st_other & STO_M68HC12_FAR)
194 struct elf_link_hash_entry *h;
196 h = (struct elf_link_hash_entry *)
197 bfd_link_hash_lookup (info->hash, "__far_trampoline",
198 FALSE, FALSE, FALSE);
201 struct bfd_link_hash_entry* entry = NULL;
203 _bfd_generic_link_add_one_symbol (info, abfd,
207 (bfd_vma) 0, (const char*) NULL,
208 FALSE, FALSE, &entry);
215 /* External entry points for sizing and building linker stubs. */
217 /* Set up various things so that we can make a list of input sections
218 for each output section included in the link. Returns -1 on error,
219 0 when no stubs will be needed, and 1 on success. */
222 elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
225 unsigned int bfd_count;
226 int top_id, top_index;
228 asection **input_list, **list;
230 asection *text_section;
231 struct m68hc11_elf_link_hash_table *htab;
233 htab = m68hc11_elf_hash_table (info);
235 if (htab->root.root.creator->flavour != bfd_target_elf_flavour)
238 /* Count the number of input BFDs and find the top input section id.
239 Also search for an existing ".tramp" section so that we know
240 where generated trampolines must go. Default to ".text" if we
242 htab->tramp_section = 0;
244 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
246 input_bfd = input_bfd->link_next)
249 for (section = input_bfd->sections;
251 section = section->next)
253 const char* name = bfd_get_section_name (input_bfd, section);
255 if (!strcmp (name, ".tramp"))
256 htab->tramp_section = section;
258 if (!strcmp (name, ".text"))
259 text_section = section;
261 if (top_id < section->id)
262 top_id = section->id;
265 htab->bfd_count = bfd_count;
266 if (htab->tramp_section == 0)
267 htab->tramp_section = text_section;
269 /* We can't use output_bfd->section_count here to find the top output
270 section index as some sections may have been removed, and
271 strip_excluded_output_sections doesn't renumber the indices. */
272 for (section = output_bfd->sections, top_index = 0;
274 section = section->next)
276 if (top_index < section->index)
277 top_index = section->index;
280 htab->top_index = top_index;
281 amt = sizeof (asection *) * (top_index + 1);
282 input_list = (asection **) bfd_malloc (amt);
283 htab->input_list = input_list;
284 if (input_list == NULL)
287 /* For sections we aren't interested in, mark their entries with a
288 value we can check later. */
289 list = input_list + top_index;
291 *list = bfd_abs_section_ptr;
292 while (list-- != input_list);
294 for (section = output_bfd->sections;
296 section = section->next)
298 if ((section->flags & SEC_CODE) != 0)
299 input_list[section->index] = NULL;
305 /* Determine and set the size of the stub section for a final link.
307 The basic idea here is to examine all the relocations looking for
308 PC-relative calls to a target that is unreachable with a "bl"
312 elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,
313 struct bfd_link_info *info,
314 asection * (*add_stub_section) (const char*, asection*))
318 Elf_Internal_Sym *local_syms, **all_local_syms;
319 unsigned int bfd_indx, bfd_count;
323 struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);
325 /* Stash our params away. */
326 htab->stub_bfd = stub_bfd;
327 htab->add_stub_section = add_stub_section;
329 /* Count the number of input BFDs and find the top input section id. */
330 for (input_bfd = info->input_bfds, bfd_count = 0;
332 input_bfd = input_bfd->link_next)
337 /* We want to read in symbol extension records only once. To do this
338 we need to read in the local symbols in parallel and save them for
339 later use; so hold pointers to the local symbols in an array. */
340 amt = sizeof (Elf_Internal_Sym *) * bfd_count;
341 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
342 if (all_local_syms == NULL)
345 /* Walk over all the input BFDs, swapping in local symbols. */
346 for (input_bfd = info->input_bfds, bfd_indx = 0;
348 input_bfd = input_bfd->link_next, bfd_indx++)
350 Elf_Internal_Shdr *symtab_hdr;
352 /* We'll need the symbol table in a second. */
353 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
354 if (symtab_hdr->sh_info == 0)
357 /* We need an array of the local symbols attached to the input bfd. */
358 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
359 if (local_syms == NULL)
361 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
362 symtab_hdr->sh_info, 0,
364 /* Cache them for elf_link_input_bfd. */
365 symtab_hdr->contents = (unsigned char *) local_syms;
367 if (local_syms == NULL)
369 free (all_local_syms);
373 all_local_syms[bfd_indx] = local_syms;
376 for (input_bfd = info->input_bfds, bfd_indx = 0;
378 input_bfd = input_bfd->link_next, bfd_indx++)
380 Elf_Internal_Shdr *symtab_hdr;
381 Elf_Internal_Sym *local_syms;
382 struct elf_link_hash_entry ** sym_hashes;
384 sym_hashes = elf_sym_hashes (input_bfd);
386 /* We'll need the symbol table in a second. */
387 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
388 if (symtab_hdr->sh_info == 0)
391 local_syms = all_local_syms[bfd_indx];
393 /* Walk over each section attached to the input bfd. */
394 for (section = input_bfd->sections;
396 section = section->next)
398 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
400 /* If there aren't any relocs, then there's nothing more
402 if ((section->flags & SEC_RELOC) == 0
403 || section->reloc_count == 0)
406 /* If this section is a link-once section that will be
407 discarded, then don't create any stubs. */
408 if (section->output_section == NULL
409 || section->output_section->owner != output_bfd)
412 /* Get the relocs. */
414 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
415 (Elf_Internal_Rela *) NULL,
417 if (internal_relocs == NULL)
418 goto error_ret_free_local;
420 /* Now examine each relocation. */
421 irela = internal_relocs;
422 irelaend = irela + section->reloc_count;
423 for (; irela < irelaend; irela++)
425 unsigned int r_type, r_indx;
426 struct elf32_m68hc11_stub_hash_entry *stub_entry;
429 struct elf_link_hash_entry *hash;
430 const char *stub_name;
431 Elf_Internal_Sym *sym;
433 r_type = ELF32_R_TYPE (irela->r_info);
435 /* Only look at 16-bit relocs. */
436 if (r_type != (unsigned int) R_M68HC11_16)
439 /* Now determine the call target, its name, value,
441 r_indx = ELF32_R_SYM (irela->r_info);
442 if (r_indx < symtab_hdr->sh_info)
444 /* It's a local symbol. */
445 Elf_Internal_Shdr *hdr;
448 sym = local_syms + r_indx;
449 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
453 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
454 sym_sec = hdr->bfd_section;
455 stub_name = (bfd_elf_string_from_elf_section
456 (input_bfd, symtab_hdr->sh_link,
458 sym_value = sym->st_value;
463 /* It's an external symbol. */
466 e_indx = r_indx - symtab_hdr->sh_info;
467 hash = (struct elf_link_hash_entry *)
468 (sym_hashes[e_indx]);
470 while (hash->root.type == bfd_link_hash_indirect
471 || hash->root.type == bfd_link_hash_warning)
472 hash = ((struct elf_link_hash_entry *)
473 hash->root.u.i.link);
475 if (hash->root.type == bfd_link_hash_defined
476 || hash->root.type == bfd_link_hash_defweak
477 || hash->root.type == bfd_link_hash_new)
479 if (!(hash->other & STO_M68HC12_FAR))
482 else if (hash->root.type == bfd_link_hash_undefweak)
486 else if (hash->root.type == bfd_link_hash_undefined)
492 bfd_set_error (bfd_error_bad_value);
493 goto error_ret_free_internal;
495 sym_sec = hash->root.u.def.section;
496 sym_value = hash->root.u.def.value;
497 stub_name = hash->root.root.string;
501 goto error_ret_free_internal;
503 stub_entry = m68hc12_stub_hash_lookup
504 (htab->stub_hash_table,
507 if (stub_entry == NULL)
509 if (add_stub_section == 0)
512 stub_entry = m68hc12_add_stub (stub_name, section, htab);
513 if (stub_entry == NULL)
515 error_ret_free_internal:
516 if (elf_section_data (section)->relocs == NULL)
517 free (internal_relocs);
518 goto error_ret_free_local;
522 stub_entry->target_value = sym_value;
523 stub_entry->target_section = sym_sec;
526 /* We're done with the internal relocs, free them. */
527 if (elf_section_data (section)->relocs == NULL)
528 free (internal_relocs);
532 if (add_stub_section)
534 /* OK, we've added some stubs. Find out the new size of the
536 for (stub_sec = htab->stub_bfd->sections;
538 stub_sec = stub_sec->next)
543 bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);
545 free (all_local_syms);
548 error_ret_free_local:
549 free (all_local_syms);
553 /* Export the trampoline addresses in the symbol table. */
555 m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
557 struct bfd_link_info *info;
558 struct m68hc11_elf_link_hash_table *htab;
559 struct elf32_m68hc11_stub_hash_entry *stub_entry;
563 info = (struct bfd_link_info *) in_arg;
564 htab = m68hc11_elf_hash_table (info);
566 /* Massage our args to the form they really have. */
567 stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
569 /* Generate the trampoline according to HC11 or HC12. */
570 result = (* htab->build_one_stub) (gen_entry, in_arg);
572 /* Make a printable name that does not conflict with the real function. */
573 name = alloca (strlen (stub_entry->root.string) + 16);
574 sprintf (name, "tramp.%s", stub_entry->root.string);
576 /* Export the symbol for debugging/disassembling. */
577 m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
578 stub_entry->stub_offset,
579 stub_entry->stub_sec);
583 /* Export a symbol or set its value and section. */
585 m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,
586 const char *name, bfd_vma value, asection *sec)
588 struct elf_link_hash_entry *h;
590 h = (struct elf_link_hash_entry *)
591 bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
594 _bfd_generic_link_add_one_symbol (info, abfd,
604 h->root.type = bfd_link_hash_defined;
605 h->root.u.def.value = value;
606 h->root.u.def.section = sec;
611 /* Build all the stubs associated with the current output file. The
612 stubs are kept in a hash table attached to the main linker hash
613 table. This function is called via m68hc12elf_finish in the
617 elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)
620 struct bfd_hash_table *table;
621 struct m68hc11_elf_link_hash_table *htab;
622 struct m68hc11_scan_param param;
624 m68hc11_elf_get_bank_parameters (info);
625 htab = m68hc11_elf_hash_table (info);
627 for (stub_sec = htab->stub_bfd->sections;
629 stub_sec = stub_sec->next)
633 /* Allocate memory to hold the linker stubs. */
634 size = stub_sec->size;
635 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
636 if (stub_sec->contents == NULL && size != 0)
641 /* Build the stubs as directed by the stub hash table. */
642 table = htab->stub_hash_table;
643 bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);
645 /* Scan the output sections to see if we use the memory banks.
646 If so, export the symbols that define how the memory banks
647 are mapped. This is used by gdb and the simulator to obtain
648 the information. It can be used by programs to burn the eprom
649 at the good addresses. */
650 param.use_memory_banks = FALSE;
651 param.pinfo = &htab->pinfo;
652 bfd_map_over_sections (abfd, scan_sections_for_abi, ¶m);
653 if (param.use_memory_banks)
655 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,
656 htab->pinfo.bank_physical,
657 bfd_abs_section_ptr);
658 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,
659 htab->pinfo.bank_virtual,
660 bfd_abs_section_ptr);
661 m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,
662 htab->pinfo.bank_size,
663 bfd_abs_section_ptr);
670 m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)
673 struct m68hc11_page_info *pinfo;
674 struct bfd_link_hash_entry *h;
676 pinfo = &m68hc11_elf_hash_table (info)->pinfo;
677 if (pinfo->bank_param_initialized)
680 pinfo->bank_virtual = M68HC12_BANK_VIRT;
681 pinfo->bank_mask = M68HC12_BANK_MASK;
682 pinfo->bank_physical = M68HC12_BANK_BASE;
683 pinfo->bank_shift = M68HC12_BANK_SHIFT;
684 pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;
686 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME,
688 if (h != (struct bfd_link_hash_entry*) NULL
689 && h->type == bfd_link_hash_defined)
690 pinfo->bank_physical = (h->u.def.value
691 + h->u.def.section->output_section->vma
692 + h->u.def.section->output_offset);
694 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME,
696 if (h != (struct bfd_link_hash_entry*) NULL
697 && h->type == bfd_link_hash_defined)
698 pinfo->bank_virtual = (h->u.def.value
699 + h->u.def.section->output_section->vma
700 + h->u.def.section->output_offset);
702 h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME,
704 if (h != (struct bfd_link_hash_entry*) NULL
705 && h->type == bfd_link_hash_defined)
706 pinfo->bank_size = (h->u.def.value
707 + h->u.def.section->output_section->vma
708 + h->u.def.section->output_offset);
710 pinfo->bank_shift = 0;
711 for (i = pinfo->bank_size; i != 0; i >>= 1)
714 pinfo->bank_mask = (1 << pinfo->bank_shift) - 1;
715 pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size;
716 pinfo->bank_param_initialized = 1;
718 h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE,
720 if (h != (struct bfd_link_hash_entry*) NULL
721 && h->type == bfd_link_hash_defined)
722 pinfo->trampoline_addr = (h->u.def.value
723 + h->u.def.section->output_section->vma
724 + h->u.def.section->output_offset);
727 /* Return 1 if the address is in banked memory.
728 This can be applied to a virtual address and to a physical address. */
730 m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr)
732 if (addr >= pinfo->bank_virtual)
735 if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end)
741 /* Return the physical address seen by the processor, taking
742 into account banked memory. */
744 m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr)
746 if (addr < pinfo->bank_virtual)
749 /* Map the address to the memory bank. */
750 addr -= pinfo->bank_virtual;
751 addr &= pinfo->bank_mask;
752 addr += pinfo->bank_physical;
756 /* Return the page number corresponding to an address in banked memory. */
758 m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr)
760 if (addr < pinfo->bank_virtual)
763 /* Map the address to the memory bank. */
764 addr -= pinfo->bank_virtual;
765 addr >>= pinfo->bank_shift;
770 /* This function is used for relocs which are only used for relaxing,
771 which the linker should otherwise ignore. */
773 bfd_reloc_status_type
774 m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
775 arelent *reloc_entry,
776 asymbol *symbol ATTRIBUTE_UNUSED,
777 void *data ATTRIBUTE_UNUSED,
778 asection *input_section,
780 char **error_message ATTRIBUTE_UNUSED)
782 if (output_bfd != NULL)
783 reloc_entry->address += input_section->output_offset;
787 bfd_reloc_status_type
788 m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED,
789 arelent *reloc_entry,
791 void *data ATTRIBUTE_UNUSED,
792 asection *input_section,
794 char **error_message ATTRIBUTE_UNUSED)
796 if (output_bfd != (bfd *) NULL
797 && (symbol->flags & BSF_SECTION_SYM) == 0
798 && (! reloc_entry->howto->partial_inplace
799 || reloc_entry->addend == 0))
801 reloc_entry->address += input_section->output_offset;
805 if (output_bfd != NULL)
806 return bfd_reloc_continue;
808 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
809 return bfd_reloc_outofrange;
814 /* Look through the relocs for a section during the first phase.
815 Since we don't do .gots or .plts, we just need to consider the
816 virtual table relocs for gc. */
819 elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
820 asection *sec, const Elf_Internal_Rela *relocs)
822 Elf_Internal_Shdr * symtab_hdr;
823 struct elf_link_hash_entry ** sym_hashes;
824 struct elf_link_hash_entry ** sym_hashes_end;
825 const Elf_Internal_Rela * rel;
826 const Elf_Internal_Rela * rel_end;
828 if (info->relocatable)
831 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
832 sym_hashes = elf_sym_hashes (abfd);
833 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
834 if (!elf_bad_symtab (abfd))
835 sym_hashes_end -= symtab_hdr->sh_info;
837 rel_end = relocs + sec->reloc_count;
839 for (rel = relocs; rel < rel_end; rel++)
841 struct elf_link_hash_entry * h;
842 unsigned long r_symndx;
844 r_symndx = ELF32_R_SYM (rel->r_info);
846 if (r_symndx < symtab_hdr->sh_info)
850 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
851 while (h->root.type == bfd_link_hash_indirect
852 || h->root.type == bfd_link_hash_warning)
853 h = (struct elf_link_hash_entry *) h->root.u.i.link;
856 switch (ELF32_R_TYPE (rel->r_info))
858 /* This relocation describes the C++ object vtable hierarchy.
859 Reconstruct it for later use during GC. */
860 case R_M68HC11_GNU_VTINHERIT:
861 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
865 /* This relocation describes which C++ vtable entries are actually
866 used. Record for later use during GC. */
867 case R_M68HC11_GNU_VTENTRY:
868 BFD_ASSERT (h != NULL);
870 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
879 /* Relocate a 68hc11/68hc12 ELF section. */
881 elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
882 struct bfd_link_info *info,
883 bfd *input_bfd, asection *input_section,
884 bfd_byte *contents, Elf_Internal_Rela *relocs,
885 Elf_Internal_Sym *local_syms,
886 asection **local_sections)
888 Elf_Internal_Shdr *symtab_hdr;
889 struct elf_link_hash_entry **sym_hashes;
890 Elf_Internal_Rela *rel, *relend;
891 const char *name = NULL;
892 struct m68hc11_page_info *pinfo;
893 const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
895 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
896 sym_hashes = elf_sym_hashes (input_bfd);
898 /* Get memory bank parameters. */
899 m68hc11_elf_get_bank_parameters (info);
900 pinfo = &m68hc11_elf_hash_table (info)->pinfo;
903 relend = relocs + input_section->reloc_count;
904 for (; rel < relend; rel++)
908 reloc_howto_type *howto;
909 unsigned long r_symndx;
910 Elf_Internal_Sym *sym;
912 bfd_vma relocation = 0;
913 bfd_reloc_status_type r = bfd_reloc_undefined;
918 bfd_boolean is_far = FALSE;
919 struct elf_link_hash_entry *h;
920 const char* stub_name = 0;
922 r_symndx = ELF32_R_SYM (rel->r_info);
923 r_type = ELF32_R_TYPE (rel->r_info);
925 if (r_type == R_M68HC11_GNU_VTENTRY
926 || r_type == R_M68HC11_GNU_VTINHERIT )
929 (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
935 if (r_symndx < symtab_hdr->sh_info)
937 sym = local_syms + r_symndx;
938 sec = local_sections[r_symndx];
939 relocation = (sec->output_section->vma
942 is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
944 stub_name = (bfd_elf_string_from_elf_section
945 (input_bfd, symtab_hdr->sh_link,
950 bfd_boolean unresolved_reloc, warned;
952 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
953 r_symndx, symtab_hdr, sym_hashes,
954 h, sec, relocation, unresolved_reloc,
957 is_far = (h && (h->other & STO_M68HC12_FAR));
958 stub_name = h->root.root.string;
961 if (sec != NULL && elf_discarded_section (sec))
963 /* For relocs against symbols from removed linkonce sections,
964 or sections discarded by a linker script, we just want the
965 section contents zeroed. Avoid any special processing. */
966 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
972 if (info->relocatable)
974 /* This is a relocatable link. We don't have to change
975 anything, unless the reloc is against a section symbol,
976 in which case we have to adjust according to where the
977 section symbol winds up in the output section. */
978 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
979 rel->r_addend += sec->output_offset;
984 name = h->root.root.string;
987 name = (bfd_elf_string_from_elf_section
988 (input_bfd, symtab_hdr->sh_link, sym->st_name));
989 if (name == NULL || *name == '\0')
990 name = bfd_section_name (input_bfd, sec);
993 if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
995 struct elf32_m68hc11_stub_hash_entry* stub;
996 struct m68hc11_elf_link_hash_table *htab;
998 htab = m68hc11_elf_hash_table (info);
999 stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
1000 name, FALSE, FALSE);
1003 relocation = stub->stub_offset
1004 + stub->stub_sec->output_section->vma
1005 + stub->stub_sec->output_offset;
1010 /* Do the memory bank mapping. */
1011 phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1012 phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1016 /* Reloc used by 68HC12 call instruction. */
1017 bfd_put_16 (input_bfd, phys_addr,
1018 (bfd_byte*) contents + rel->r_offset);
1019 bfd_put_8 (input_bfd, phys_page,
1020 (bfd_byte*) contents + rel->r_offset + 2);
1022 r_type = R_M68HC11_NONE;
1025 case R_M68HC11_NONE:
1029 case R_M68HC11_LO16:
1030 /* Reloc generated by %addr(expr) gas to obtain the
1031 address as mapped in the memory bank window. */
1032 relocation = phys_addr;
1035 case R_M68HC11_PAGE:
1036 /* Reloc generated by %page(expr) gas to obtain the
1037 page number associated with the address. */
1038 relocation = phys_page;
1042 /* Get virtual address of instruction having the relocation. */
1047 msg = _("Reference to the far symbol `%s' using a wrong "
1048 "relocation may result in incorrect execution");
1049 buf = alloca (strlen (msg) + strlen (name) + 10);
1050 sprintf (buf, msg, name);
1052 (* info->callbacks->warning)
1053 (info, buf, name, input_bfd, NULL, rel->r_offset);
1056 /* Get virtual address of instruction having the relocation. */
1057 insn_addr = input_section->output_section->vma
1058 + input_section->output_offset
1061 insn_page = m68hc11_phys_page (pinfo, insn_addr);
1063 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1064 && m68hc11_addr_is_banked (pinfo, insn_addr)
1065 && phys_page != insn_page)
1070 msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1071 "as current banked address [%lx:%04lx] (%lx)");
1073 buf = alloca (strlen (msg) + 128);
1074 sprintf (buf, msg, phys_page, phys_addr,
1075 (long) (relocation + rel->r_addend),
1076 insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1077 (long) (insn_addr));
1078 if (!((*info->callbacks->warning)
1079 (info, buf, name, input_bfd, input_section,
1084 if (phys_page != 0 && insn_page == 0)
1089 msg = _("reference to a banked address [%lx:%04lx] in the "
1090 "normal address space at %04lx");
1092 buf = alloca (strlen (msg) + 128);
1093 sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1094 if (!((*info->callbacks->warning)
1095 (info, buf, name, input_bfd, input_section,
1099 relocation = phys_addr;
1103 /* If this is a banked address use the phys_addr so that
1104 we stay in the banked window. */
1105 if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1106 relocation = phys_addr;
1109 if (r_type != R_M68HC11_NONE)
1110 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1111 contents, rel->r_offset,
1112 relocation, rel->r_addend);
1114 if (r != bfd_reloc_ok)
1116 const char * msg = (const char *) 0;
1120 case bfd_reloc_overflow:
1121 if (!((*info->callbacks->reloc_overflow)
1122 (info, NULL, name, howto->name, (bfd_vma) 0,
1123 input_bfd, input_section, rel->r_offset)))
1127 case bfd_reloc_undefined:
1128 if (!((*info->callbacks->undefined_symbol)
1129 (info, name, input_bfd, input_section,
1130 rel->r_offset, TRUE)))
1134 case bfd_reloc_outofrange:
1135 msg = _ ("internal error: out of range error");
1138 case bfd_reloc_notsupported:
1139 msg = _ ("internal error: unsupported relocation error");
1142 case bfd_reloc_dangerous:
1143 msg = _ ("internal error: dangerous error");
1147 msg = _ ("internal error: unknown error");
1151 if (!((*info->callbacks->warning)
1152 (info, msg, name, input_bfd, input_section,
1165 /* Set and control ELF flags in ELF header. */
1168 _bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
1170 BFD_ASSERT (!elf_flags_init (abfd)
1171 || elf_elfheader (abfd)->e_flags == flags);
1173 elf_elfheader (abfd)->e_flags = flags;
1174 elf_flags_init (abfd) = TRUE;
1178 /* Merge backend specific data from an object file to the output
1179 object file when linking. */
1182 _bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1186 bfd_boolean ok = TRUE;
1188 /* Check if we have the same endianess */
1189 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1192 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1193 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1196 new_flags = elf_elfheader (ibfd)->e_flags;
1197 elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1198 old_flags = elf_elfheader (obfd)->e_flags;
1200 if (! elf_flags_init (obfd))
1202 elf_flags_init (obfd) = TRUE;
1203 elf_elfheader (obfd)->e_flags = new_flags;
1204 elf_elfheader (obfd)->e_ident[EI_CLASS]
1205 = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1207 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1208 && bfd_get_arch_info (obfd)->the_default)
1210 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1211 bfd_get_mach (ibfd)))
1218 /* Check ABI compatibility. */
1219 if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1221 (*_bfd_error_handler)
1222 (_("%B: linking files compiled for 16-bit integers (-mshort) "
1223 "and others for 32-bit integers"), ibfd);
1226 if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1228 (*_bfd_error_handler)
1229 (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1230 "and others for 64-bit double"), ibfd);
1234 /* Processor compatibility. */
1235 if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1237 (*_bfd_error_handler)
1238 (_("%B: linking files compiled for HCS12 with "
1239 "others compiled for HC12"), ibfd);
1242 new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1243 | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1245 elf_elfheader (obfd)->e_flags = new_flags;
1247 new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1248 old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1250 /* Warn about any other mismatches */
1251 if (new_flags != old_flags)
1253 (*_bfd_error_handler)
1254 (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1255 ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
1261 bfd_set_error (bfd_error_bad_value);
1269 _bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
1271 FILE *file = (FILE *) ptr;
1273 BFD_ASSERT (abfd != NULL && ptr != NULL);
1275 /* Print normal ELF private data. */
1276 _bfd_elf_print_private_bfd_data (abfd, ptr);
1278 /* xgettext:c-format */
1279 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1281 if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1282 fprintf (file, _("[abi=32-bit int, "));
1284 fprintf (file, _("[abi=16-bit int, "));
1286 if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1287 fprintf (file, _("64-bit double, "));
1289 fprintf (file, _("32-bit double, "));
1291 if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1292 fprintf (file, _("cpu=HC11]"));
1293 else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1294 fprintf (file, _("cpu=HCS12]"));
1296 fprintf (file, _("cpu=HC12]"));
1298 if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1299 fprintf (file, _(" [memory=bank-model]"));
1301 fprintf (file, _(" [memory=flat]"));
1308 static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1309 asection *asect, void *arg)
1311 struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1313 if (asect->vma >= p->pinfo->bank_virtual)
1314 p->use_memory_banks = TRUE;
1317 /* Tweak the OSABI field of the elf header. */
1320 elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
1322 struct m68hc11_scan_param param;
1327 m68hc11_elf_get_bank_parameters (link_info);
1329 param.use_memory_banks = FALSE;
1330 param.pinfo = &m68hc11_elf_hash_table (link_info)->pinfo;
1331 bfd_map_over_sections (abfd, scan_sections_for_abi, ¶m);
1332 if (param.use_memory_banks)
1334 Elf_Internal_Ehdr * i_ehdrp;
1336 i_ehdrp = elf_elfheader (abfd);
1337 i_ehdrp->e_flags |= E_M68HC12_BANKS;