Redundant hash table check
[external/binutils.git] / bfd / elf32-m68hc1x.c
1 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
2    Copyright (C) 1999-2016 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 #include "libiberty.h"
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   unsigned 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 = concat ("tramp.", stub_entry->root.string, NULL);
596
597   /* Export the symbol for debugging/disassembling.  */
598   m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
599                           stub_entry->stub_offset,
600                           stub_entry->stub_sec);
601   free (name);
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 (bfd_link_relocatable (info))
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       const char * msg;
960       char * buf;
961       bfd_boolean res;
962
963       r_symndx = ELF32_R_SYM (rel->r_info);
964       r_type = ELF32_R_TYPE (rel->r_info);
965
966       if (r_type == R_M68HC11_GNU_VTENTRY
967           || r_type == R_M68HC11_GNU_VTINHERIT)
968         continue;
969
970       (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
971       howto = arel.howto;
972
973       h = NULL;
974       sym = NULL;
975       sec = NULL;
976       if (r_symndx < symtab_hdr->sh_info)
977         {
978           sym = local_syms + r_symndx;
979           sec = local_sections[r_symndx];
980           relocation = (sec->output_section->vma
981                         + sec->output_offset
982                         + sym->st_value);
983           is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
984           is_xgate_symbol = (sym && (sym->st_target_internal));
985           is_section_symbol = ELF_ST_TYPE (sym->st_info) & STT_SECTION;
986         }
987       else
988         {
989           bfd_boolean unresolved_reloc, warned, ignored;
990
991           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
992                                    r_symndx, symtab_hdr, sym_hashes,
993                                    h, sec, relocation, unresolved_reloc,
994                                    warned, ignored);
995
996           is_far = (h && (h->other & STO_M68HC12_FAR));
997           is_xgate_symbol = (h && (h->target_internal));
998         }
999
1000       if (sec != NULL && discarded_section (sec))
1001         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1002                                          rel, 1, relend, howto, 0, contents);
1003
1004       if (bfd_link_relocatable (info))
1005         {
1006           /* This is a relocatable link.  We don't have to change
1007              anything, unless the reloc is against a section symbol,
1008              in which case we have to adjust according to where the
1009              section symbol winds up in the output section.  */
1010           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1011             rel->r_addend += sec->output_offset;
1012           continue;
1013         }
1014
1015       if (h != NULL)
1016         name = h->root.root.string;
1017       else
1018         {
1019           name = (bfd_elf_string_from_elf_section
1020                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1021           if (name == NULL || *name == '\0')
1022             name = bfd_section_name (input_bfd, sec);
1023         }
1024
1025       if (is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
1026         {
1027           struct elf32_m68hc11_stub_hash_entry* stub;
1028
1029           stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
1030                                            name, FALSE, FALSE);
1031           if (stub)
1032             {
1033               relocation = stub->stub_offset
1034                 + stub->stub_sec->output_section->vma
1035                 + stub->stub_sec->output_offset;
1036               is_far = FALSE;
1037             }
1038         }
1039
1040       /* Do the memory bank mapping.  */
1041       phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1042       phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1043       switch (r_type)
1044         {
1045         case R_M68HC12_LO8XG:
1046           /* This relocation is specific to XGATE IMM16 calls and will precede
1047              a HI8. tc-m68hc11 only generates them in pairs.
1048              Leave the relocation to the HI8XG step.  */
1049           r = bfd_reloc_ok;
1050           r_type = R_M68HC11_NONE;
1051           break;
1052
1053         case R_M68HC12_HI8XG:
1054           /* This relocation is specific to XGATE IMM16 calls and must follow
1055              a LO8XG. Does not actually check that it was a LO8XG.
1056              Adjusts high and low bytes.  */
1057           relocation = phys_addr;
1058           if ((e_flags & E_M68HC11_XGATE_RAMOFFSET)
1059               && (relocation >= 0x2000))
1060             relocation += 0xc000; /* HARDCODED RAM offset for XGATE.  */
1061
1062           /* Fetch 16 bit value including low byte in previous insn.  */
1063           val = (bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset) << 8)
1064             | bfd_get_8 (input_bfd, (bfd_byte*) contents + rel->r_offset - 2);
1065
1066           /* Add on value to preserve carry, then write zero to high byte.  */
1067           relocation += val;
1068
1069           /* Write out top byte.  */
1070           bfd_put_8 (input_bfd, (relocation >> 8) & 0xff,
1071                      (bfd_byte*) contents + rel->r_offset);
1072
1073           /* Write out low byte to previous instruction.  */
1074           bfd_put_8 (input_bfd, relocation & 0xff,
1075                      (bfd_byte*) contents + rel->r_offset - 2);
1076
1077           /* Mark as relocation completed.  */
1078           r = bfd_reloc_ok;
1079           r_type = R_M68HC11_NONE;
1080           break;
1081
1082         /* The HI8 and LO8 relocs are generated by %hi(expr) %lo(expr)
1083            assembler directives. %hi does not support carry.  */
1084         case R_M68HC11_HI8:
1085         case R_M68HC11_LO8:
1086           relocation = phys_addr;
1087           break;
1088
1089         case R_M68HC11_24:
1090           /* Reloc used by 68HC12 call instruction.  */
1091           bfd_put_16 (input_bfd, phys_addr,
1092                       (bfd_byte*) contents + rel->r_offset);
1093           bfd_put_8 (input_bfd, phys_page,
1094                      (bfd_byte*) contents + rel->r_offset + 2);
1095           r = bfd_reloc_ok;
1096           r_type = R_M68HC11_NONE;
1097           break;
1098
1099         case R_M68HC11_NONE:
1100           r = bfd_reloc_ok;
1101           break;
1102
1103         case R_M68HC11_LO16:
1104           /* Reloc generated by %addr(expr) gas to obtain the
1105              address as mapped in the memory bank window.  */
1106           relocation = phys_addr;
1107           break;
1108
1109         case R_M68HC11_PAGE:
1110           /* Reloc generated by %page(expr) gas to obtain the
1111              page number associated with the address.  */
1112           relocation = phys_page;
1113           break;
1114
1115         case R_M68HC11_16:
1116           /* Get virtual address of instruction having the relocation.  */
1117           if (is_far)
1118             {
1119               msg = _("Reference to the far symbol `%s' using a wrong "
1120                       "relocation may result in incorrect execution");
1121               buf = xmalloc (strlen (msg) + strlen (name) + 10);
1122               sprintf (buf, msg, name);
1123
1124               (* info->callbacks->warning)
1125                 (info, buf, name, input_bfd, NULL, rel->r_offset);
1126               free (buf);
1127             }
1128
1129           /* Get virtual address of instruction having the relocation.  */
1130           insn_addr = input_section->output_section->vma
1131             + input_section->output_offset
1132             + rel->r_offset;
1133
1134           insn_page = m68hc11_phys_page (pinfo, insn_addr);
1135
1136          /* If we are linking an S12 instruction against an XGATE symbol, we
1137             need to change the offset of the symbol value so that it's correct
1138             from the S12's perspective.  */
1139           if (is_xgate_symbol)
1140             {
1141               /* The ram in the global space is mapped to 0x2000 in the 16-bit
1142                  address space for S12 and 0xE000 in the 16-bit address space
1143                  for XGATE.  */
1144               if (relocation >= 0xE000)
1145                 {
1146                   /* We offset the address by the difference
1147                      between these two mappings.  */
1148                   relocation -= 0xC000;
1149                   break;
1150                 }
1151               else
1152                 {
1153                   msg = _("XGATE address (%lx) is not within shared RAM"
1154                           "(0xE000-0xFFFF), therefore you must manually offset "
1155                           "the address, and possibly manage the page, in your "
1156                           "code.");
1157                   buf = xmalloc (strlen (msg) + 128);
1158                   sprintf (buf, msg, phys_addr);
1159                   res = (*info->callbacks->warning) (info, buf, name, input_bfd,
1160                                                      input_section, insn_addr);
1161                   free (buf);
1162                   if (! res)
1163                     return FALSE;
1164                   break;
1165                 }
1166             }
1167
1168           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1169               && m68hc11_addr_is_banked (pinfo, insn_addr)
1170               && phys_page != insn_page && !(e_flags & E_M68HC11_NO_BANK_WARNING))
1171             {
1172               msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1173                       "as current banked address [%lx:%04lx] (%lx)");
1174               buf = xmalloc (strlen (msg) + 128);
1175               sprintf (buf, msg, phys_page, phys_addr,
1176                        (long) (relocation + rel->r_addend),
1177                        insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1178                        (long) (insn_addr));
1179               res = (*info->callbacks->warning)
1180                 (info, buf, name, input_bfd, input_section, rel->r_offset);
1181               free (buf);
1182               if (! res)
1183                 return FALSE;
1184               break;
1185             }
1186
1187           if (phys_page != 0 && insn_page == 0)
1188             {
1189               msg = _("reference to a banked address [%lx:%04lx] in the "
1190                       "normal address space at %04lx");
1191               buf = xmalloc (strlen (msg) + 128);
1192               sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1193               res = (*info->callbacks->warning)
1194                 (info, buf, name, input_bfd, input_section, insn_addr);
1195               free (buf);
1196               if (! res)
1197                 return FALSE;
1198
1199               relocation = phys_addr;
1200               break;
1201             }
1202
1203           /* If this is a banked address use the phys_addr so that
1204              we stay in the banked window.  */
1205           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1206             relocation = phys_addr;
1207           break;
1208         }
1209
1210       /* If we are linking an XGATE instruction against an S12 symbol, we
1211          need to change the offset of the symbol value so that it's correct
1212          from the XGATE's perspective.  */
1213       if (!strcmp (howto->name, "R_XGATE_IMM8_LO")
1214           || !strcmp (howto->name, "R_XGATE_IMM8_HI"))
1215         {
1216           /* We can only offset S12 addresses that lie within the non-paged
1217              area of RAM.  */
1218           if (!is_xgate_symbol && !is_section_symbol)
1219             {
1220               /* The ram in the global space is mapped to 0x2000 and stops at
1221                  0x4000 in the 16-bit address space for S12 and 0xE000 in the
1222                  16-bit address space for XGATE.  */
1223               if (relocation >= 0x2000 && relocation < 0x4000)
1224                  /* We offset the address by the difference
1225                    between these two mappings.  */
1226                 relocation += 0xC000;
1227               else
1228                 {
1229                   /* Get virtual address of instruction having the relocation.  */
1230                   insn_addr = input_section->output_section->vma
1231                       + input_section->output_offset + rel->r_offset;
1232
1233                   msg = _("S12 address (%lx) is not within shared RAM"
1234                       "(0x2000-0x4000), therefore you must manually "
1235                       "offset the address in your code");
1236                   buf = xmalloc (strlen (msg) + 128);
1237                   sprintf (buf, msg, phys_addr);
1238                   res = (*info->callbacks->warning) (info, buf, name, input_bfd,
1239                                                      input_section, insn_addr);
1240                   free (buf);
1241                   if (! res)
1242                     return FALSE;
1243                   break;
1244                 }
1245             }
1246         }
1247
1248       if (r_type != R_M68HC11_NONE)
1249         {
1250           if ((r_type == R_M68HC12_PCREL_9) || (r_type == R_M68HC12_PCREL_10))
1251             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1252                                       contents, rel->r_offset,
1253                                       relocation - 2, rel->r_addend);
1254           else
1255             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1256                                           contents, rel->r_offset,
1257                                           relocation, rel->r_addend);
1258         }
1259
1260       if (r != bfd_reloc_ok)
1261         {
1262           switch (r)
1263             {
1264             case bfd_reloc_overflow:
1265               if (!((*info->callbacks->reloc_overflow)
1266                     (info, NULL, name, howto->name, (bfd_vma) 0,
1267                      input_bfd, input_section, rel->r_offset)))
1268                 return FALSE;
1269               break;
1270
1271             case bfd_reloc_undefined:
1272               if (!((*info->callbacks->undefined_symbol)
1273                     (info, name, input_bfd, input_section,
1274                      rel->r_offset, TRUE)))
1275                 return FALSE;
1276               break;
1277
1278             case bfd_reloc_outofrange:
1279               msg = _ ("internal error: out of range error");
1280               goto common_error;
1281
1282             case bfd_reloc_notsupported:
1283               msg = _ ("internal error: unsupported relocation error");
1284               goto common_error;
1285
1286             case bfd_reloc_dangerous:
1287               msg = _ ("internal error: dangerous error");
1288               goto common_error;
1289
1290             default:
1291               msg = _ ("internal error: unknown error");
1292               /* fall through */
1293
1294             common_error:
1295               if (!((*info->callbacks->warning)
1296                     (info, msg, name, input_bfd, input_section,
1297                      rel->r_offset)))
1298                 return FALSE;
1299               break;
1300             }
1301         }
1302     }
1303
1304   return TRUE;
1305 }
1306
1307
1308 \f
1309 /* Set and control ELF flags in ELF header.  */
1310
1311 bfd_boolean
1312 _bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
1313 {
1314   BFD_ASSERT (!elf_flags_init (abfd)
1315               || elf_elfheader (abfd)->e_flags == flags);
1316
1317   elf_elfheader (abfd)->e_flags = flags;
1318   elf_flags_init (abfd) = TRUE;
1319   return TRUE;
1320 }
1321
1322 /* Merge backend specific data from an object file to the output
1323    object file when linking.  */
1324
1325 bfd_boolean
1326 _bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1327 {
1328   flagword old_flags;
1329   flagword new_flags;
1330   bfd_boolean ok = TRUE;
1331
1332   /* Check if we have the same endianness */
1333   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1334     return FALSE;
1335
1336   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1337       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1338     return TRUE;
1339
1340   new_flags = elf_elfheader (ibfd)->e_flags;
1341   elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1342   old_flags = elf_elfheader (obfd)->e_flags;
1343
1344   if (! elf_flags_init (obfd))
1345     {
1346       elf_flags_init (obfd) = TRUE;
1347       elf_elfheader (obfd)->e_flags = new_flags;
1348       elf_elfheader (obfd)->e_ident[EI_CLASS]
1349         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1350
1351       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1352           && bfd_get_arch_info (obfd)->the_default)
1353         {
1354           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1355                                    bfd_get_mach (ibfd)))
1356             return FALSE;
1357         }
1358
1359       return TRUE;
1360     }
1361
1362   /* Check ABI compatibility.  */
1363   if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1364     {
1365       (*_bfd_error_handler)
1366         (_("%B: linking files compiled for 16-bit integers (-mshort) "
1367            "and others for 32-bit integers"), ibfd);
1368       ok = FALSE;
1369     }
1370   if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1371     {
1372       (*_bfd_error_handler)
1373         (_("%B: linking files compiled for 32-bit double (-fshort-double) "
1374            "and others for 64-bit double"), ibfd);
1375       ok = FALSE;
1376     }
1377
1378   /* Processor compatibility.  */
1379   if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1380     {
1381       (*_bfd_error_handler)
1382         (_("%B: linking files compiled for HCS12 with "
1383            "others compiled for HC12"), ibfd);
1384       ok = FALSE;
1385     }
1386   new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1387                | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1388
1389   elf_elfheader (obfd)->e_flags = new_flags;
1390
1391   new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1392   old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1393
1394   /* Warn about any other mismatches */
1395   if (new_flags != old_flags)
1396     {
1397       (*_bfd_error_handler)
1398         (_("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1399          ibfd, (unsigned long) new_flags, (unsigned long) old_flags);
1400       ok = FALSE;
1401     }
1402
1403   if (! ok)
1404     {
1405       bfd_set_error (bfd_error_bad_value);
1406       return FALSE;
1407     }
1408
1409   return TRUE;
1410 }
1411
1412 bfd_boolean
1413 _bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
1414 {
1415   FILE *file = (FILE *) ptr;
1416
1417   BFD_ASSERT (abfd != NULL && ptr != NULL);
1418
1419   /* Print normal ELF private data.  */
1420   _bfd_elf_print_private_bfd_data (abfd, ptr);
1421
1422   /* xgettext:c-format */
1423   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1424
1425   if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1426     fprintf (file, _("[abi=32-bit int, "));
1427   else
1428     fprintf (file, _("[abi=16-bit int, "));
1429
1430   if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1431     fprintf (file, _("64-bit double, "));
1432   else
1433     fprintf (file, _("32-bit double, "));
1434
1435   if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1436     fprintf (file, _("cpu=HC11]"));
1437   else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1438     fprintf (file, _("cpu=HCS12]"));
1439   else
1440     fprintf (file, _("cpu=HC12]"));
1441
1442   if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1443     fprintf (file, _(" [memory=bank-model]"));
1444   else
1445     fprintf (file, _(" [memory=flat]"));
1446
1447   if (elf_elfheader (abfd)->e_flags & E_M68HC11_XGATE_RAMOFFSET)
1448     fprintf (file, _(" [XGATE RAM offsetting]"));
1449
1450   fputc ('\n', file);
1451
1452   return TRUE;
1453 }
1454
1455 static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1456                                    asection *asect, void *arg)
1457 {
1458   struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1459
1460   if (asect->vma >= p->pinfo->bank_virtual)
1461     p->use_memory_banks = TRUE;
1462 }
1463
1464 /* Tweak the OSABI field of the elf header.  */
1465
1466 void
1467 elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
1468 {
1469   struct m68hc11_scan_param param;
1470   struct m68hc11_elf_link_hash_table *htab;
1471
1472   if (link_info == NULL)
1473     return;
1474
1475   htab = m68hc11_elf_hash_table (link_info);
1476   if (htab == NULL)
1477     return;
1478
1479   m68hc11_elf_get_bank_parameters (link_info);
1480
1481   param.use_memory_banks = FALSE;
1482   param.pinfo = & htab->pinfo;
1483
1484   bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
1485
1486   if (param.use_memory_banks)
1487     {
1488       Elf_Internal_Ehdr * i_ehdrp;
1489
1490       i_ehdrp = elf_elfheader (abfd);
1491       i_ehdrp->e_flags |= E_M68HC12_BANKS;
1492     }
1493 }