bfd/elf32-m68hc1x.c

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