Automatic date update in version.in
[external/binutils.git] / bfd / elf32-m68hc1x.c
1 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
3    Contributed by Stephane Carrez (stcarrez@nerim.fr)
4
5    This file is part of BFD, the Binary File Descriptor library.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "alloca-conf.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf32-m68hc1x.h"
29 #include "elf/m68hc11.h"
30 #include "opcode/m68hc11.h"
31
32
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)))
36
37 static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub
38   (const char *stub_name,
39    asection *section,
40    struct m68hc11_elf_link_hash_table *htab);
41
42 static struct bfd_hash_entry *stub_hash_newfunc
43   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
44
45 static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info,
46                                     const char* name, bfd_vma value,
47                                     asection* sec);
48
49 static bfd_boolean m68hc11_elf_export_one_stub
50   (struct bfd_hash_entry *gen_entry, void *in_arg);
51
52 static void scan_sections_for_abi (bfd*, asection*, void *);
53
54 struct m68hc11_scan_param
55 {
56    struct m68hc11_page_info* pinfo;
57    bfd_boolean use_memory_banks;
58 };
59
60
61 /* Destroy a 68HC11/68HC12 ELF linker hash table.  */
62
63 static void
64 m68hc11_elf_bfd_link_hash_table_free (bfd *obfd)
65 {
66   struct m68hc11_elf_link_hash_table *ret
67     = (struct m68hc11_elf_link_hash_table *) obfd->link.hash;
68
69   bfd_hash_table_free (ret->stub_hash_table);
70   free (ret->stub_hash_table);
71   _bfd_elf_link_hash_table_free (obfd);
72 }
73
74 /* Create a 68HC11/68HC12 ELF linker hash table.  */
75
76 struct m68hc11_elf_link_hash_table*
77 m68hc11_elf_hash_table_create (bfd *abfd)
78 {
79   struct m68hc11_elf_link_hash_table *ret;
80   bfd_size_type amt = sizeof (struct m68hc11_elf_link_hash_table);
81
82   ret = (struct m68hc11_elf_link_hash_table *) bfd_zmalloc (amt);
83   if (ret == (struct m68hc11_elf_link_hash_table *) NULL)
84     return NULL;
85
86   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
87                                       _bfd_elf_link_hash_newfunc,
88                                       sizeof (struct elf_link_hash_entry),
89                                       M68HC11_ELF_DATA))
90     {
91       free (ret);
92       return NULL;
93     }
94
95   /* Init the stub hash table too.  */
96   amt = sizeof (struct bfd_hash_table);
97   ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt);
98   if (ret->stub_hash_table == NULL)
99     {
100       _bfd_elf_link_hash_table_free (abfd);
101       return NULL;
102     }
103   if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc,
104                             sizeof (struct elf32_m68hc11_stub_hash_entry)))
105     {
106       free (ret->stub_hash_table);
107       _bfd_elf_link_hash_table_free (abfd);
108       return NULL;
109     }
110   ret->root.root.hash_table_free = m68hc11_elf_bfd_link_hash_table_free;
111
112   return ret;
113 }
114
115 /* Assorted hash table functions.  */
116
117 /* Initialize an entry in the stub hash table.  */
118
119 static struct bfd_hash_entry *
120 stub_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
121                    const char *string)
122 {
123   /* Allocate the structure if it has not already been allocated by a
124      subclass.  */
125   if (entry == NULL)
126     {
127       entry = bfd_hash_allocate (table,
128                                  sizeof (struct elf32_m68hc11_stub_hash_entry));
129       if (entry == NULL)
130         return entry;
131     }
132
133   /* Call the allocation method of the superclass.  */
134   entry = bfd_hash_newfunc (entry, table, string);
135   if (entry != NULL)
136     {
137       struct elf32_m68hc11_stub_hash_entry *eh;
138
139       /* Initialize the local fields.  */
140       eh = (struct elf32_m68hc11_stub_hash_entry *) entry;
141       eh->stub_sec = NULL;
142       eh->stub_offset = 0;
143       eh->target_value = 0;
144       eh->target_section = NULL;
145     }
146
147   return entry;
148 }
149
150 /* Add a new stub entry to the stub hash.  Not all fields of the new
151    stub entry are initialised.  */
152
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)
156 {
157   struct elf32_m68hc11_stub_hash_entry *stub_entry;
158
159   /* Enter this entry into the linker stub hash table.  */
160   stub_entry = m68hc12_stub_hash_lookup (htab->stub_hash_table, stub_name,
161                                          TRUE, FALSE);
162   if (stub_entry == NULL)
163     {
164       (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
165                              section->owner, stub_name);
166       return NULL;
167     }
168
169   if (htab->stub_section == 0)
170     {
171       htab->stub_section = (*htab->add_stub_section) (".tramp",
172                                                       htab->tramp_section);
173     }
174
175   stub_entry->stub_sec = htab->stub_section;
176   stub_entry->stub_offset = 0;
177   return stub_entry;
178 }
179
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.  */
183
184 bfd_boolean
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)
191 {
192   if (sym->st_other & STO_M68HC12_FAR)
193     {
194       struct elf_link_hash_entry *h;
195
196       h = (struct elf_link_hash_entry *)
197         bfd_link_hash_lookup (info->hash, "__far_trampoline",
198                               FALSE, FALSE, FALSE);
199       if (h == NULL)
200         {
201           struct bfd_link_hash_entry* entry = NULL;
202
203           _bfd_generic_link_add_one_symbol (info, abfd,
204                                             "__far_trampoline",
205                                             BSF_GLOBAL,
206                                             bfd_und_section_ptr,
207                                             (bfd_vma) 0, (const char*) NULL,
208                                             FALSE, FALSE, &entry);
209         }
210
211     }
212   return TRUE;
213 }
214
215 /* Merge non-visibility st_other attributes, STO_M68HC12_FAR and
216    STO_M68HC12_INTERRUPT.  */
217
218 void
219 elf32_m68hc11_merge_symbol_attribute (struct elf_link_hash_entry *h,
220                                       const Elf_Internal_Sym *isym,
221                                       bfd_boolean definition,
222                                       bfd_boolean dynamic ATTRIBUTE_UNUSED)
223 {
224   if (definition)
225     h->other = ((isym->st_other & ~ELF_ST_VISIBILITY (-1))
226                 | ELF_ST_VISIBILITY (h->other));
227 }
228
229 /* External entry points for sizing and building linker stubs.  */
230
231 /* Set up various things so that we can make a list of input sections
232    for each output section included in the link.  Returns -1 on error,
233    0 when no stubs will be needed, and 1 on success.  */
234
235 int
236 elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
237 {
238   bfd *input_bfd;
239   unsigned int bfd_count;
240   int top_id, top_index;
241   asection *section;
242   asection **input_list, **list;
243   bfd_size_type amt;
244   asection *text_section;
245   struct m68hc11_elf_link_hash_table *htab;
246
247   htab = m68hc11_elf_hash_table (info);
248   if (htab == NULL)
249     return -1;
250
251   if (bfd_get_flavour (info->output_bfd) != bfd_target_elf_flavour)
252     return 0;
253
254   /* Count the number of input BFDs and find the top input section id.
255      Also search for an existing ".tramp" section so that we know
256      where generated trampolines must go.  Default to ".text" if we
257      can't find it.  */
258   htab->tramp_section = 0;
259   text_section = 0;
260   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
261        input_bfd != NULL;
262        input_bfd = input_bfd->link.next)
263     {
264       bfd_count += 1;
265       for (section = input_bfd->sections;
266            section != NULL;
267            section = section->next)
268         {
269           const char* name = bfd_get_section_name (input_bfd, section);
270
271           if (!strcmp (name, ".tramp"))
272             htab->tramp_section = section;
273
274           if (!strcmp (name, ".text"))
275             text_section = section;
276
277           if (top_id < section->id)
278             top_id = section->id;
279         }
280     }
281   htab->bfd_count = bfd_count;
282   if (htab->tramp_section == 0)
283     htab->tramp_section = text_section;
284
285   /* We can't use output_bfd->section_count here to find the top output
286      section index as some sections may have been removed, and
287      strip_excluded_output_sections doesn't renumber the indices.  */
288   for (section = output_bfd->sections, top_index = 0;
289        section != NULL;
290        section = section->next)
291     {
292       if (top_index < section->index)
293         top_index = section->index;
294     }
295
296   htab->top_index = top_index;
297   amt = sizeof (asection *) * (top_index + 1);
298   input_list = (asection **) bfd_malloc (amt);
299   htab->input_list = input_list;
300   if (input_list == NULL)
301     return -1;
302
303   /* For sections we aren't interested in, mark their entries with a
304      value we can check later.  */
305   list = input_list + top_index;
306   do
307     *list = bfd_abs_section_ptr;
308   while (list-- != input_list);
309
310   for (section = output_bfd->sections;
311        section != NULL;
312        section = section->next)
313     {
314       if ((section->flags & SEC_CODE) != 0)
315         input_list[section->index] = NULL;
316     }
317
318   return 1;
319 }
320
321 /* Determine and set the size of the stub section for a final link.
322
323    The basic idea here is to examine all the relocations looking for
324    PC-relative calls to a target that is unreachable with a "bl"
325    instruction.  */
326
327 bfd_boolean
328 elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,
329                           struct bfd_link_info *info,
330                           asection * (*add_stub_section) (const char*, asection*))
331 {
332   bfd *input_bfd;
333   asection *section;
334   Elf_Internal_Sym *local_syms, **all_local_syms;
335   unsigned int bfd_indx, bfd_count;
336   bfd_size_type amt;
337   asection *stub_sec;
338   struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);
339
340   if (htab == NULL)
341     return FALSE;
342
343   /* Stash our params away.  */
344   htab->stub_bfd = stub_bfd;
345   htab->add_stub_section = add_stub_section;
346
347   /* Count the number of input BFDs and find the top input section id.  */
348   for (input_bfd = info->input_bfds, bfd_count = 0;
349        input_bfd != NULL;
350        input_bfd = input_bfd->link.next)
351     bfd_count += 1;
352
353   /* We want to read in symbol extension records only once.  To do this
354      we need to read in the local symbols in parallel and save them for
355      later use; so hold pointers to the local symbols in an array.  */
356   amt = sizeof (Elf_Internal_Sym *) * bfd_count;
357   all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
358   if (all_local_syms == NULL)
359     return FALSE;
360
361   /* Walk over all the input BFDs, swapping in local symbols.  */
362   for (input_bfd = info->input_bfds, bfd_indx = 0;
363        input_bfd != NULL;
364        input_bfd = input_bfd->link.next, bfd_indx++)
365     {
366       Elf_Internal_Shdr *symtab_hdr;
367
368       /* We'll need the symbol table in a second.  */
369       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
370       if (symtab_hdr->sh_info == 0)
371         continue;
372
373       /* We need an array of the local symbols attached to the input bfd.  */
374       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
375       if (local_syms == NULL)
376         {
377           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
378                                              symtab_hdr->sh_info, 0,
379                                              NULL, NULL, NULL);
380           /* Cache them for elf_link_input_bfd.  */
381           symtab_hdr->contents = (unsigned char *) local_syms;
382         }
383       if (local_syms == NULL)
384         {
385           free (all_local_syms);
386           return FALSE;
387         }
388
389       all_local_syms[bfd_indx] = local_syms;
390     }
391
392   for (input_bfd = info->input_bfds, bfd_indx = 0;
393        input_bfd != NULL;
394        input_bfd = input_bfd->link.next, bfd_indx++)
395     {
396       Elf_Internal_Shdr *symtab_hdr;
397       struct elf_link_hash_entry ** sym_hashes;
398
399       sym_hashes = elf_sym_hashes (input_bfd);
400
401       /* We'll need the symbol table in a second.  */
402       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
403       if (symtab_hdr->sh_info == 0)
404         continue;
405
406       local_syms = all_local_syms[bfd_indx];
407
408       /* Walk over each section attached to the input bfd.  */
409       for (section = input_bfd->sections;
410            section != NULL;
411            section = section->next)
412         {
413           Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
414
415           /* If there aren't any relocs, then there's nothing more
416              to do.  */
417           if ((section->flags & SEC_RELOC) == 0
418               || section->reloc_count == 0)
419             continue;
420
421           /* If this section is a link-once section that will be
422              discarded, then don't create any stubs.  */
423           if (section->output_section == NULL
424               || section->output_section->owner != output_bfd)
425             continue;
426
427           /* Get the relocs.  */
428           internal_relocs
429             = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
430                                          (Elf_Internal_Rela *) NULL,
431                                          info->keep_memory);
432           if (internal_relocs == NULL)
433             goto error_ret_free_local;
434
435           /* Now examine each relocation.  */
436           irela = internal_relocs;
437           irelaend = irela + section->reloc_count;
438           for (; irela < irelaend; irela++)
439             {
440               unsigned int r_type, r_indx;
441               struct elf32_m68hc11_stub_hash_entry *stub_entry;
442               asection *sym_sec;
443               bfd_vma sym_value;
444               struct elf_link_hash_entry *hash;
445               const char *stub_name;
446               Elf_Internal_Sym *sym;
447
448               r_type = ELF32_R_TYPE (irela->r_info);
449
450               /* Only look at 16-bit relocs.  */
451               if (r_type != (unsigned int) R_M68HC11_16)
452                 continue;
453
454               /* Now determine the call target, its name, value,
455                  section.  */
456               r_indx = ELF32_R_SYM (irela->r_info);
457               if (r_indx < symtab_hdr->sh_info)
458                 {
459                   /* It's a local symbol.  */
460                   Elf_Internal_Shdr *hdr;
461                   bfd_boolean is_far;
462
463                   sym = local_syms + r_indx;
464                   is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
465                   if (!is_far)
466                     continue;
467
468                   if (sym->st_shndx >= elf_numsections (input_bfd))
469                     sym_sec = NULL;
470                   else
471                     {
472                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
473                       sym_sec = hdr->bfd_section;
474                     }
475                   stub_name = (bfd_elf_string_from_elf_section
476                                (input_bfd, symtab_hdr->sh_link,
477                                 sym->st_name));
478                   sym_value = sym->st_value;
479                   hash = NULL;
480                 }
481               else
482                 {
483                   /* It's an external symbol.  */
484                   int e_indx;
485
486                   e_indx = r_indx - symtab_hdr->sh_info;
487                   hash = (struct elf_link_hash_entry *)
488                     (sym_hashes[e_indx]);
489
490                   while (hash->root.type == bfd_link_hash_indirect
491                          || hash->root.type == bfd_link_hash_warning)
492                     hash = ((struct elf_link_hash_entry *)
493                             hash->root.u.i.link);
494
495                   if (hash->root.type == bfd_link_hash_defined
496                       || hash->root.type == bfd_link_hash_defweak
497                       || hash->root.type == bfd_link_hash_new)
498                     {
499                       if (!(hash->other & STO_M68HC12_FAR))
500                         continue;
501                     }
502                   else if (hash->root.type == bfd_link_hash_undefweak)
503                     {
504                       continue;
505                     }
506                   else if (hash->root.type == bfd_link_hash_undefined)
507                     {
508                       continue;
509                     }
510                   else
511                     {
512                       bfd_set_error (bfd_error_bad_value);
513                       goto error_ret_free_internal;
514                     }
515                   sym_sec = hash->root.u.def.section;
516                   sym_value = hash->root.u.def.value;
517                   stub_name = hash->root.root.string;
518                 }
519
520               if (!stub_name)
521                 goto error_ret_free_internal;
522
523               stub_entry = m68hc12_stub_hash_lookup
524                 (htab->stub_hash_table,
525                  stub_name,
526                  FALSE, FALSE);
527               if (stub_entry == NULL)
528                 {
529                   if (add_stub_section == 0)
530                     continue;
531
532                   stub_entry = m68hc12_add_stub (stub_name, section, htab);
533                   if (stub_entry == NULL)
534                     {
535                     error_ret_free_internal:
536                       if (elf_section_data (section)->relocs == NULL)
537                         free (internal_relocs);
538                       goto error_ret_free_local;
539                     }
540                 }
541
542               stub_entry->target_value = sym_value;
543               stub_entry->target_section = sym_sec;
544             }
545
546           /* We're done with the internal relocs, free them.  */
547           if (elf_section_data (section)->relocs == NULL)
548             free (internal_relocs);
549         }
550     }
551
552   if (add_stub_section)
553     {
554       /* OK, we've added some stubs.  Find out the new size of the
555          stub sections.  */
556       for (stub_sec = htab->stub_bfd->sections;
557            stub_sec != NULL;
558            stub_sec = stub_sec->next)
559         {
560           stub_sec->size = 0;
561         }
562
563       bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);
564     }
565   free (all_local_syms);
566   return TRUE;
567
568  error_ret_free_local:
569   free (all_local_syms);
570   return FALSE;
571 }
572
573 /* Export the trampoline addresses in the symbol table.  */
574 static bfd_boolean
575 m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
576 {
577   struct bfd_link_info *info;
578   struct m68hc11_elf_link_hash_table *htab;
579   struct elf32_m68hc11_stub_hash_entry *stub_entry;
580   char* name;
581   bfd_boolean result;
582
583   info = (struct bfd_link_info *) in_arg;
584   htab = m68hc11_elf_hash_table (info);
585   if (htab == NULL)
586     return FALSE;
587
588   /* Massage our args to the form they really have.  */
589   stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
590
591   /* Generate the trampoline according to HC11 or HC12.  */
592   result = (* htab->build_one_stub) (gen_entry, in_arg);
593
594   /* Make a printable name that does not conflict with the real function.  */
595   name = alloca (strlen (stub_entry->root.string) + 16);
596   sprintf (name, "tramp.%s", stub_entry->root.string);
597
598   /* Export the symbol for debugging/disassembling.  */
599   m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
600                           stub_entry->stub_offset,
601                           stub_entry->stub_sec);
602   return result;
603 }
604
605 /* Export a symbol or set its value and section.  */
606 static void
607 m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,
608                         const char *name, bfd_vma value, asection *sec)
609 {
610   struct elf_link_hash_entry *h;
611
612   h = (struct elf_link_hash_entry *)
613     bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
614   if (h == NULL)
615     {
616       _bfd_generic_link_add_one_symbol (info, abfd,
617                                         name,
618                                         BSF_GLOBAL,
619                                         sec,
620                                         value,
621                                         (const char*) NULL,
622                                         TRUE, FALSE, NULL);
623     }
624   else
625     {
626       h->root.type = bfd_link_hash_defined;
627       h->root.u.def.value = value;
628       h->root.u.def.section = sec;
629     }
630 }
631
632
633 /* Build all the stubs associated with the current output file.  The
634    stubs are kept in a hash table attached to the main linker hash
635    table.  This function is called via m68hc12elf_finish in the
636    linker.  */
637
638 bfd_boolean
639 elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)
640 {
641   asection *stub_sec;
642   struct bfd_hash_table *table;
643   struct m68hc11_elf_link_hash_table *htab;
644   struct m68hc11_scan_param param;
645
646   m68hc11_elf_get_bank_parameters (info);
647   htab = m68hc11_elf_hash_table (info);
648   if (htab == NULL)
649     return FALSE;
650
651   for (stub_sec = htab->stub_bfd->sections;
652        stub_sec != NULL;
653        stub_sec = stub_sec->next)
654     {
655       bfd_size_type size;
656
657       /* Allocate memory to hold the linker stubs.  */
658       size = stub_sec->size;
659       stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
660       if (stub_sec->contents == NULL && size != 0)
661         return FALSE;
662       stub_sec->size = 0;
663     }
664
665   /* Build the stubs as directed by the stub hash table.  */
666   table = htab->stub_hash_table;
667   bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);
668
669   /* Scan the output sections to see if we use the memory banks.
670      If so, export the symbols that define how the memory banks
671      are mapped.  This is used by gdb and the simulator to obtain
672      the information.  It can be used by programs to burn the eprom
673      at the good addresses.  */
674   param.use_memory_banks = FALSE;
675   param.pinfo = &htab->pinfo;
676   bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
677   if (param.use_memory_banks)
678     {
679       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,
680                               htab->pinfo.bank_physical,
681                               bfd_abs_section_ptr);
682       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,
683                               htab->pinfo.bank_virtual,
684                               bfd_abs_section_ptr);
685       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,
686                               htab->pinfo.bank_size,
687                               bfd_abs_section_ptr);
688     }
689
690   return TRUE;
691 }
692
693 void
694 m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)
695 {
696   unsigned i;
697   struct m68hc11_page_info *pinfo;
698   struct bfd_link_hash_entry *h;
699   struct m68hc11_elf_link_hash_table *htab;
700
701   htab = m68hc11_elf_hash_table (info);
702   if (htab == NULL)
703     return;
704
705   pinfo = & htab->pinfo;
706   if (pinfo->bank_param_initialized)
707     return;
708
709   pinfo->bank_virtual = M68HC12_BANK_VIRT;
710   pinfo->bank_mask = M68HC12_BANK_MASK;
711   pinfo->bank_physical = M68HC12_BANK_BASE;
712   pinfo->bank_shift = M68HC12_BANK_SHIFT;
713   pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;
714
715   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME,
716                             FALSE, FALSE, TRUE);
717   if (h != (struct bfd_link_hash_entry*) NULL
718       && h->type == bfd_link_hash_defined)
719     pinfo->bank_physical = (h->u.def.value
720                             + h->u.def.section->output_section->vma
721                             + h->u.def.section->output_offset);
722
723   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME,
724                             FALSE, FALSE, TRUE);
725   if (h != (struct bfd_link_hash_entry*) NULL
726       && h->type == bfd_link_hash_defined)
727     pinfo->bank_virtual = (h->u.def.value
728                            + h->u.def.section->output_section->vma
729                            + h->u.def.section->output_offset);
730
731   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME,
732                             FALSE, FALSE, TRUE);
733   if (h != (struct bfd_link_hash_entry*) NULL
734       && h->type == bfd_link_hash_defined)
735     pinfo->bank_size = (h->u.def.value
736                         + h->u.def.section->output_section->vma
737                         + h->u.def.section->output_offset);
738
739   pinfo->bank_shift = 0;
740   for (i = pinfo->bank_size; i != 0; i >>= 1)
741     pinfo->bank_shift++;
742   pinfo->bank_shift--;
743   pinfo->bank_mask = (1 << pinfo->bank_shift) - 1;
744   pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size;
745   pinfo->bank_param_initialized = 1;
746
747   h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE,
748                             FALSE, TRUE);
749   if (h != (struct bfd_link_hash_entry*) NULL
750       && h->type == bfd_link_hash_defined)
751     pinfo->trampoline_addr = (h->u.def.value
752                               + h->u.def.section->output_section->vma
753                               + h->u.def.section->output_offset);
754 }
755
756 /* Return 1 if the address is in banked memory.
757    This can be applied to a virtual address and to a physical address.  */
758 int
759 m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr)
760 {
761   if (addr >= pinfo->bank_virtual)
762     return 1;
763
764   if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end)
765     return 1;
766
767   return 0;
768 }
769
770 /* Return the physical address seen by the processor, taking
771    into account banked memory.  */
772 bfd_vma
773 m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr)
774 {
775   if (addr < pinfo->bank_virtual)
776     return addr;
777
778   /* Map the address to the memory bank.  */
779   addr -= pinfo->bank_virtual;
780   addr &= pinfo->bank_mask;
781   addr += pinfo->bank_physical;
782   return addr;
783 }
784
785 /* Return the page number corresponding to an address in banked memory.  */
786 bfd_vma
787 m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr)
788 {
789   if (addr < pinfo->bank_virtual)
790     return 0;
791
792   /* Map the address to the memory bank.  */
793   addr -= pinfo->bank_virtual;
794   addr >>= pinfo->bank_shift;
795   addr &= 0x0ff;
796   return addr;
797 }
798
799 /* This function is used for relocs which are only used for relaxing,
800    which the linker should otherwise ignore.  */
801
802 bfd_reloc_status_type
803 m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
804                           arelent *reloc_entry,
805                           asymbol *symbol ATTRIBUTE_UNUSED,
806                           void *data ATTRIBUTE_UNUSED,
807                           asection *input_section,
808                           bfd *output_bfd,
809                           char **error_message ATTRIBUTE_UNUSED)
810 {
811   if (output_bfd != NULL)
812     reloc_entry->address += input_section->output_offset;
813   return bfd_reloc_ok;
814 }
815
816 bfd_reloc_status_type
817 m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED,
818                            arelent *reloc_entry,
819                            asymbol *symbol,
820                            void *data ATTRIBUTE_UNUSED,
821                            asection *input_section,
822                            bfd *output_bfd,
823                            char **error_message ATTRIBUTE_UNUSED)
824 {
825   if (output_bfd != (bfd *) NULL
826       && (symbol->flags & BSF_SECTION_SYM) == 0
827       && (! reloc_entry->howto->partial_inplace
828           || reloc_entry->addend == 0))
829     {
830       reloc_entry->address += input_section->output_offset;
831       return bfd_reloc_ok;
832     }
833
834   if (output_bfd != NULL)
835     return bfd_reloc_continue;
836
837   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
838     return bfd_reloc_outofrange;
839
840   abort();
841 }
842
843 /* Look through the relocs for a section during the first phase.
844    Since we don't do .gots or .plts, we just need to consider the
845    virtual table relocs for gc.  */
846
847 bfd_boolean
848 elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
849                             asection *sec, const Elf_Internal_Rela *relocs)
850 {
851   Elf_Internal_Shdr *           symtab_hdr;
852   struct elf_link_hash_entry ** sym_hashes;
853   const Elf_Internal_Rela *     rel;
854   const Elf_Internal_Rela *     rel_end;
855
856   if (info->relocatable)
857     return TRUE;
858
859   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
860   sym_hashes = elf_sym_hashes (abfd);
861   rel_end = relocs + sec->reloc_count;
862
863   for (rel = relocs; rel < rel_end; rel++)
864     {
865       struct elf_link_hash_entry * h;
866       unsigned long r_symndx;
867
868       r_symndx = ELF32_R_SYM (rel->r_info);
869
870       if (r_symndx < symtab_hdr->sh_info)
871         h = NULL;
872       else
873         {
874           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
875           while (h->root.type == bfd_link_hash_indirect
876                  || h->root.type == bfd_link_hash_warning)
877             h = (struct elf_link_hash_entry *) h->root.u.i.link;
878
879           /* PR15323, ref flags aren't set for references in the same
880              object.  */
881           h->root.non_ir_ref = 1;
882         }
883
884       switch (ELF32_R_TYPE (rel->r_info))
885         {
886         /* This relocation describes the C++ object vtable hierarchy.
887            Reconstruct it for later use during GC.  */
888         case R_M68HC11_GNU_VTINHERIT:
889           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
890             return FALSE;
891           break;
892
893         /* This relocation describes which C++ vtable entries are actually
894            used.  Record for later use during GC.  */
895         case R_M68HC11_GNU_VTENTRY:
896           BFD_ASSERT (h != NULL);
897           if (h != NULL
898               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
899             return FALSE;
900           break;
901         }
902     }
903
904   return TRUE;
905 }
906
907 /* Relocate a 68hc11/68hc12 ELF section.  */
908 bfd_boolean
909 elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
910                                 struct bfd_link_info *info,
911                                 bfd *input_bfd, asection *input_section,
912                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
913                                 Elf_Internal_Sym *local_syms,
914                                 asection **local_sections)
915 {
916   Elf_Internal_Shdr *symtab_hdr;
917   struct elf_link_hash_entry **sym_hashes;
918   Elf_Internal_Rela *rel, *relend;
919   const char *name = NULL;
920   struct m68hc11_page_info *pinfo;
921   const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
922   struct m68hc11_elf_link_hash_table *htab;
923   unsigned long e_flags;
924
925   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
926   sym_hashes = elf_sym_hashes (input_bfd);
927   e_flags = elf_elfheader (input_bfd)->e_flags;
928
929   htab = m68hc11_elf_hash_table (info);
930   if (htab == NULL)
931     return FALSE;
932
933   /* Get memory bank parameters.  */
934   m68hc11_elf_get_bank_parameters (info);
935
936   pinfo = & htab->pinfo;
937   rel = relocs;
938   relend = relocs + input_section->reloc_count;
939
940   for (; rel < relend; rel++)
941     {
942       int r_type;
943       arelent arel;
944       reloc_howto_type *howto;
945       unsigned long r_symndx;
946       Elf_Internal_Sym *sym;
947       asection *sec;
948       bfd_vma relocation = 0;
949       bfd_reloc_status_type r = bfd_reloc_undefined;
950       bfd_vma phys_page;
951       bfd_vma phys_addr;
952       bfd_vma insn_addr;
953       bfd_vma insn_page;
954       bfd_boolean is_far = FALSE;
955       bfd_boolean is_xgate_symbol = FALSE;
956       bfd_boolean is_section_symbol = FALSE;
957       struct elf_link_hash_entry *h;
958       bfd_vma val;
959
960       r_symndx = ELF32_R_SYM (rel->r_info);
961       r_type = ELF32_R_TYPE (rel->r_info);
962
963       if (r_type == R_M68HC11_GNU_VTENTRY
964           || r_type == R_M68HC11_GNU_VTINHERIT)
965         continue;
966
967       (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
968       howto = arel.howto;
969
970       h = NULL;
971       sym = NULL;
972       sec = NULL;
973       if (r_symndx < symtab_hdr->sh_info)
974         {
975           sym = local_syms + r_symndx;
976           sec = local_sections[r_symndx];
977           relocation = (sec->output_section->vma
978                         + sec->output_offset
979                         + sym->st_value);
980           is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
981           is_xgate_symbol = (sym && (sym->st_target_internal));
982           is_section_symbol = ELF_ST_TYPE (sym->st_info) & STT_SECTION;
983         }
984       else
985         {
986           bfd_boolean unresolved_reloc, warned, ignored;
987
988           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
989                                    r_symndx, symtab_hdr, sym_hashes,
990                                    h, sec, relocation, unresolved_reloc,
991                                    warned, ignored);
992
993           is_far = (h && (h->other & STO_M68HC12_FAR));
994           is_xgate_symbol = (h && (h->target_internal));
995         }
996
997       if (sec != NULL && discarded_section (sec))
998         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
999                                          rel, 1, relend, howto, 0, contents);
1000
1001       if (info->relocatable)
1002         {
1003           /* This is a relocatable link.  We don't have to change
1004              anything, unless the reloc is against a section symbol,
1005              in which case we have to adjust according to where the
1006              section symbol winds up in the output section.  */
1007           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1008             rel->r_addend += sec->output_offset;
1009           continue;
1010         }
1011
1012       if (h != NULL)
1013         name = h->root.root.string;
1014       else
1015         {
1016           name = (bfd_elf_string_from_elf_section
1017                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1018           if (name == NULL || *name == '\0')
1019             name = bfd_section_name (input_bfd, sec);
1020         }
1021
1022       if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
1023         {
1024           struct elf32_m68hc11_stub_hash_entry* stub;
1025
1026           stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
1027                                            name, FALSE, FALSE);
1028           if (stub)
1029             {
1030               relocation = stub->stub_offset
1031                 + stub->stub_sec->output_section->vma
1032                 + stub->stub_sec->output_offset;
1033               is_far = FALSE;
1034             }
1035         }
1036
1037       /* Do the memory bank mapping.  */
1038       phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1039       phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1040       switch (r_type)
1041         {
1042         case R_M68HC12_LO8XG:
1043           /* This relocation is specific to XGATE IMM16 calls and will precede
1044              a HI8. tc-m68hc11 only generates them in pairs.
1045              Leave the relocation to the HI8XG step.  */
1046           r = bfd_reloc_ok;
1047           r_type = R_M68HC11_NONE;
1048           break;
1049
1050         case R_M68HC12_HI8XG:
1051           /* This relocation is specific to XGATE IMM16 calls and must follow
1052              a LO8XG. Does not actually check that it was a LO8XG.
1053              Adjusts high and low bytes.  */
1054           relocation = phys_addr;
1055           if ((e_flags & E_M68HC11_XGATE_RAMOFFSET)
1056               && (relocation >= 0x2000))
1057             relocation += 0xc000; /* HARDCODED RAM offset for XGATE.  */
1058
1059           /* Fetch 16 bit value including low byte in previous insn.  */
1060           val = (bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset) << 8)
1061             | bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset - 2);
1062
1063           /* Add on value to preserve carry, then write zero to high byte.  */
1064           relocation += val;
1065
1066           /* Write out top byte.  */
1067           bfd_put_8 (input_bfd, (relocation >> 8) & 0xff,
1068                      (bfd_byte*) contents + rel->r_offset);
1069
1070           /* Write out low byte to previous instruction.  */
1071           bfd_put_8 (input_bfd, relocation & 0xff,
1072                      (bfd_byte*) contents + rel->r_offset - 2);
1073
1074           /* Mark as relocation completed.  */
1075           r = bfd_reloc_ok;
1076           r_type = R_M68HC11_NONE;
1077           break;
1078
1079         /* The HI8 and LO8 relocs are generated by %hi(expr) %lo(expr)
1080            assembler directives. %hi does not support carry.  */
1081         case R_M68HC11_HI8:
1082         case R_M68HC11_LO8:
1083           relocation = phys_addr;
1084           break;
1085
1086         case R_M68HC11_24:
1087           /* Reloc used by 68HC12 call instruction.  */
1088           bfd_put_16 (input_bfd, phys_addr,
1089                       (bfd_byte*) contents + rel->r_offset);
1090           bfd_put_8 (input_bfd, phys_page,
1091                      (bfd_byte*) contents + rel->r_offset + 2);
1092           r = bfd_reloc_ok;
1093           r_type = R_M68HC11_NONE;
1094           break;
1095
1096         case R_M68HC11_NONE:
1097           r = bfd_reloc_ok;
1098           break;
1099
1100         case R_M68HC11_LO16:
1101           /* Reloc generated by %addr(expr) gas to obtain the
1102              address as mapped in the memory bank window.  */
1103           relocation = phys_addr;
1104           break;
1105
1106         case R_M68HC11_PAGE:
1107           /* Reloc generated by %page(expr) gas to obtain the
1108              page number associated with the address.  */
1109           relocation = phys_page;
1110           break;
1111
1112         case R_M68HC11_16:
1113           /* Get virtual address of instruction having the relocation.  */
1114           if (is_far)
1115             {
1116               const char* msg;
1117               char* buf;
1118               msg = _("Reference to the far symbol `%s' using a wrong "
1119                       "relocation may result in incorrect execution");
1120               buf = alloca (strlen (msg) + strlen (name) + 10);
1121               sprintf (buf, msg, name);
1122
1123               (* info->callbacks->warning)
1124                 (info, buf, name, input_bfd, NULL, rel->r_offset);
1125             }
1126
1127           /* Get virtual address of instruction having the relocation.  */
1128           insn_addr = input_section->output_section->vma
1129             + input_section->output_offset
1130             + rel->r_offset;
1131
1132           insn_page = m68hc11_phys_page (pinfo, insn_addr);
1133
1134          /* If we are linking an S12 instruction against an XGATE symbol, we
1135             need to change the offset of the symbol value so that it's correct
1136             from the S12's perspective.  */
1137           if (is_xgate_symbol)
1138             {
1139               /* The ram in the global space is mapped to 0x2000 in the 16-bit
1140                  address space for S12 and 0xE000 in the 16-bit address space
1141                  for XGATE.  */
1142               if (relocation >= 0xE000)
1143                 {
1144                   /* We offset the address by the difference
1145                      between these two mappings.  */
1146                   relocation -= 0xC000;
1147                   break;
1148                 }
1149               else
1150                 {
1151                   const char * msg;
1152                   char * buf;
1153
1154                   msg = _("XGATE address (%lx) is not within shared RAM"
1155                           "(0xE000-0xFFFF), therefore you must manually offset "
1156                           "the address, and possibly manage the page, in your "
1157                           "code.");
1158                   buf = alloca (strlen (msg) + 128);
1159                   sprintf (buf, msg, phys_addr);
1160                   if (!((*info->callbacks->warning) (info, buf, name, input_bfd,
1161                                                      input_section, insn_addr)))
1162                     return FALSE;
1163                   break;
1164                 }
1165             }
1166
1167           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1168               && m68hc11_addr_is_banked (pinfo, insn_addr)
1169               && phys_page != insn_page && !(e_flags & E_M68HC11_NO_BANK_WARNING))
1170             {
1171               const char * msg;
1172               char * buf;
1173
1174               msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1175                       "as current banked address [%lx:%04lx] (%lx)");
1176
1177               buf = alloca (strlen (msg) + 128);
1178               sprintf (buf, msg, phys_page, phys_addr,
1179                        (long) (relocation + rel->r_addend),
1180                        insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1181                        (long) (insn_addr));
1182               if (!((*info->callbacks->warning)
1183                     (info, buf, name, input_bfd, input_section,
1184                      rel->r_offset)))
1185                 return FALSE;
1186               break;
1187             }
1188
1189           if (phys_page != 0 && insn_page == 0)
1190             {
1191               const char * msg;
1192               char * buf;
1193
1194               msg = _("reference to a banked address [%lx:%04lx] in the "
1195                       "normal address space at %04lx");
1196
1197               buf = alloca (strlen (msg) + 128);
1198               sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1199               if (!((*info->callbacks->warning)
1200                     (info, buf, name, input_bfd, input_section,
1201                      insn_addr)))
1202                 return FALSE;
1203
1204               relocation = phys_addr;
1205               break;
1206             }
1207
1208           /* If this is a banked address use the phys_addr so that
1209              we stay in the banked window.  */
1210           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1211             relocation = phys_addr;
1212           break;
1213         }
1214
1215       /* If we are linking an XGATE instruction against an S12 symbol, we
1216          need to change the offset of the symbol value so that it's correct
1217          from the XGATE's perspective.  */
1218       if (!strcmp (howto->name, "R_XGATE_IMM8_LO")
1219           || !strcmp (howto->name, "R_XGATE_IMM8_HI"))
1220         {
1221           /* We can only offset S12 addresses that lie within the non-paged
1222              area of RAM.  */
1223           if (!is_xgate_symbol && !is_section_symbol)
1224             {
1225               /* The ram in the global space is mapped to 0x2000 and stops at
1226                  0x4000 in the 16-bit address space for S12 and 0xE000 in the
1227                  16-bit address space for XGATE.  */
1228               if (relocation >= 0x2000 && relocation < 0x4000)
1229                  /* We offset the address by the difference
1230                    between these two mappings.  */
1231                 relocation += 0xC000;
1232               else
1233                 {
1234                   const char * msg;
1235                   char * buf;
1236
1237                   /* Get virtual address of instruction having the relocation.  */
1238                   insn_addr = input_section->output_section->vma
1239                       + input_section->output_offset + rel->r_offset;
1240
1241                   msg = _("S12 address (%lx) is not within shared RAM"
1242                       "(0x2000-0x4000), therefore you must manually "
1243                       "offset the address in your code");
1244                   buf = alloca (strlen (msg) + 128);
1245                   sprintf (buf, msg, phys_addr);
1246                   if (!((*info->callbacks->warning) (info, buf, name, input_bfd,
1247                                                      input_section, insn_addr)))
1248                     return FALSE;
1249                   break;
1250                 }
1251             }
1252         }
1253
1254       if (r_type != R_M68HC11_NONE)
1255         {
1256           if ((r_type == R_M68HC12_PCREL_9) || (r_type == R_M68HC12_PCREL_10))
1257             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1258                                       contents, rel->r_offset,
1259                                       relocation - 2, rel->r_addend);
1260           else
1261             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1262                                           contents, rel->r_offset,
1263                                           relocation, rel->r_addend);
1264         }
1265
1266       if (r != bfd_reloc_ok)
1267         {
1268           const char * msg = (const char *) 0;
1269
1270           switch (r)
1271             {
1272             case bfd_reloc_overflow:
1273               if (!((*info->callbacks->reloc_overflow)
1274                     (info, NULL, name, howto->name, (bfd_vma) 0,
1275                      input_bfd, input_section, rel->r_offset)))
1276                 return FALSE;
1277               break;
1278
1279             case bfd_reloc_undefined:
1280               if (!((*info->callbacks->undefined_symbol)
1281                     (info, name, input_bfd, input_section,
1282                      rel->r_offset, TRUE)))
1283                 return FALSE;
1284               break;
1285
1286             case bfd_reloc_outofrange:
1287               msg = _ ("internal error: out of range error");
1288               goto common_error;
1289
1290             case bfd_reloc_notsupported:
1291               msg = _ ("internal error: unsupported relocation error");
1292               goto common_error;
1293
1294             case bfd_reloc_dangerous:
1295               msg = _ ("internal error: dangerous error");
1296               goto common_error;
1297
1298             default:
1299               msg = _ ("internal error: unknown error");
1300               /* fall through */
1301
1302             common_error:
1303               if (!((*info->callbacks->warning)
1304                     (info, msg, name, input_bfd, input_section,
1305                      rel->r_offset)))
1306                 return FALSE;
1307               break;
1308             }
1309         }
1310     }
1311
1312   return TRUE;
1313 }
1314
1315
1316 \f
1317 /* Set and control ELF flags in ELF header.  */
1318
1319 bfd_boolean
1320 _bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
1321 {
1322   BFD_ASSERT (!elf_flags_init (abfd)
1323               || elf_elfheader (abfd)->e_flags == flags);
1324
1325   elf_elfheader (abfd)->e_flags = flags;
1326   elf_flags_init (abfd) = TRUE;
1327   return TRUE;
1328 }
1329
1330 /* Merge backend specific data from an object file to the output
1331    object file when linking.  */
1332
1333 bfd_boolean
1334 _bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1335 {
1336   flagword old_flags;
1337   flagword new_flags;
1338   bfd_boolean ok = TRUE;
1339
1340   /* Check if we have the same endianness */
1341   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1342     return FALSE;
1343
1344   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1345       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1346     return TRUE;
1347
1348   new_flags = elf_elfheader (ibfd)->e_flags;
1349   elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1350   old_flags = elf_elfheader (obfd)->e_flags;
1351
1352   if (! elf_flags_init (obfd))
1353     {
1354       elf_flags_init (obfd) = TRUE;
1355       elf_elfheader (obfd)->e_flags = new_flags;
1356       elf_elfheader (obfd)->e_ident[EI_CLASS]
1357         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1358
1359       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1360           && bfd_get_arch_info (obfd)->the_default)
1361         {
1362           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1363                                    bfd_get_mach (ibfd)))
1364             return FALSE;
1365         }
1366
1367       return TRUE;
1368     }
1369
1370   /* Check ABI compatibility.  */
1371   if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1372     {
1373       (*_bfd_error_handler)
1374         (_("%B: linking files compiled for 16-bit integers (-mshort) "
1375            "and others for 32-bit integers"), ibfd);
1376       ok = FALSE;
1377     }
1378   if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1379     {
1380       (*_bfd_error_handler)
1381         (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1382            "and others for 64-bit double"), ibfd);
1383       ok = FALSE;
1384     }
1385
1386   /* Processor compatibility.  */
1387   if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1388     {
1389       (*_bfd_error_handler)
1390         (_("%B: linking files compiled for HCS12 with "
1391            "others compiled for HC12"), ibfd);
1392       ok = FALSE;
1393     }
1394   new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1395                | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1396
1397   elf_elfheader (obfd)->e_flags = new_flags;
1398
1399   new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1400   old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1401
1402   /* Warn about any other mismatches */
1403   if (new_flags != old_flags)
1404     {
1405       (*_bfd_error_handler)
1406         (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1407          ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
1408       ok = FALSE;
1409     }
1410
1411   if (! ok)
1412     {
1413       bfd_set_error (bfd_error_bad_value);
1414       return FALSE;
1415     }
1416
1417   return TRUE;
1418 }
1419
1420 bfd_boolean
1421 _bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
1422 {
1423   FILE *file = (FILE *) ptr;
1424
1425   BFD_ASSERT (abfd != NULL && ptr != NULL);
1426
1427   /* Print normal ELF private data.  */
1428   _bfd_elf_print_private_bfd_data (abfd, ptr);
1429
1430   /* xgettext:c-format */
1431   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1432
1433   if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1434     fprintf (file, _("[abi=32-bit int, "));
1435   else
1436     fprintf (file, _("[abi=16-bit int, "));
1437
1438   if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1439     fprintf (file, _("64-bit double, "));
1440   else
1441     fprintf (file, _("32-bit double, "));
1442
1443   if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1444     fprintf (file, _("cpu=HC11]"));
1445   else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1446     fprintf (file, _("cpu=HCS12]"));
1447   else
1448     fprintf (file, _("cpu=HC12]"));
1449
1450   if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1451     fprintf (file, _(" [memory=bank-model]"));
1452   else
1453     fprintf (file, _(" [memory=flat]"));
1454
1455   if (elf_elfheader (abfd)->e_flags & E_M68HC11_XGATE_RAMOFFSET)
1456     fprintf (file, _(" [XGATE RAM offsetting]"));
1457
1458   fputc ('\n', file);
1459
1460   return TRUE;
1461 }
1462
1463 static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1464                                    asection *asect, void *arg)
1465 {
1466   struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1467
1468   if (asect->vma >= p->pinfo->bank_virtual)
1469     p->use_memory_banks = TRUE;
1470 }
1471
1472 /* Tweak the OSABI field of the elf header.  */
1473
1474 void
1475 elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
1476 {
1477   struct m68hc11_scan_param param;
1478   struct m68hc11_elf_link_hash_table *htab;
1479
1480   if (link_info == NULL)
1481     return;
1482
1483   htab = m68hc11_elf_hash_table (link_info);
1484   if (htab == NULL)
1485     return;
1486
1487   m68hc11_elf_get_bank_parameters (link_info);
1488
1489   param.use_memory_banks = FALSE;
1490   param.pinfo = & htab->pinfo;
1491
1492   bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
1493
1494   if (param.use_memory_banks)
1495     {
1496       Elf_Internal_Ehdr * i_ehdrp;
1497
1498       i_ehdrp = elf_elfheader (abfd);
1499       i_ehdrp->e_flags |= E_M68HC12_BANKS;
1500     }
1501 }