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                       || hash->root.type == bfd_link_hash_new)
 476                     {
 477                       if (!(hash->other & STO_M68HC12_FAR))
 478                         continue;
 479                     }
 480                   else if (hash->root.type == bfd_link_hash_undefweak)
 481                     {
 482                       continue;
 483                     }
 484                   else if (hash->root.type == bfd_link_hash_undefined)
 485                     {
 486                       continue;
 487                     }
 488                   else
 489                     {
 490                       bfd_set_error (bfd_error_bad_value);
 491                       goto error_ret_free_internal;
 492                     }
 493                   sym_sec = hash->root.u.def.section;
 494                   sym_value = hash->root.u.def.value;
 495                   stub_name = hash->root.root.string;
 496                 }
 497
 498               if (!stub_name)
 499                 goto error_ret_free_internal;
 500
 501               stub_entry = m68hc12_stub_hash_lookup
 502                 (htab->stub_hash_table,
 503                  stub_name,
 504                  FALSE, FALSE);
 505               if (stub_entry == NULL)
 506                 {
 507                   if (add_stub_section == 0)
 508                     continue;
 509
 510                   stub_entry = m68hc12_add_stub (stub_name, section, htab);
 511                   if (stub_entry == NULL)
 512                     {
 513                     error_ret_free_internal:
 514                       if (elf_section_data (section)->relocs == NULL)
 515                         free (internal_relocs);
 516                       goto error_ret_free_local;
 517                     }
 518                 }
 519
 520               stub_entry->target_value = sym_value;
 521               stub_entry->target_section = sym_sec;
 522             }
 523
 524           /* We're done with the internal relocs, free them.  */
 525           if (elf_section_data (section)->relocs == NULL)
 526             free (internal_relocs);
 527         }
 528     }
 529
 530   if (add_stub_section)
 531     {
 532       /* OK, we've added some stubs.  Find out the new size of the
 533          stub sections.  */
 534       for (stub_sec = htab->stub_bfd->sections;
 535            stub_sec != NULL;
 536            stub_sec = stub_sec->next)
 537         {
 538           stub_sec->size = 0;
 539         }
 540
 541       bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);
 542     }
 543   free (all_local_syms);
 544   return TRUE;
 545
 546  error_ret_free_local:
 547   free (all_local_syms);
 548   return FALSE;
 549 }
 550
 551 /* Export the trampoline addresses in the symbol table.  */
 552 static bfd_boolean
 553 m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
 554 {
 555   struct bfd_link_info *info;
 556   struct m68hc11_elf_link_hash_table *htab;
 557   struct elf32_m68hc11_stub_hash_entry *stub_entry;
 558   char* name;
 559   bfd_boolean result;
 560
 561   info = (struct bfd_link_info *) in_arg;
 562   htab = m68hc11_elf_hash_table (info);
 563
 564   /* Massage our args to the form they really have.  */
 565   stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;
 566
 567   /* Generate the trampoline according to HC11 or HC12.  */
 568   result = (* htab->build_one_stub) (gen_entry, in_arg);
 569
 570   /* Make a printable name that does not conflict with the real function.  */
 571   name = alloca (strlen (stub_entry->root.string) + 16);
 572   sprintf (name, "tramp.%s", stub_entry->root.string);
 573
 574   /* Export the symbol for debugging/disassembling.  */
 575   m68hc11_elf_set_symbol (htab->stub_bfd, info, name,
 576                           stub_entry->stub_offset,
 577                           stub_entry->stub_sec);
 578   return result;
 579 }
 580
 581 /* Export a symbol or set its value and section.  */
 582 static void
 583 m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,
 584                         const char *name, bfd_vma value, asection *sec)
 585 {
 586   struct elf_link_hash_entry *h;
 587
 588   h = (struct elf_link_hash_entry *)
 589     bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);
 590   if (h == NULL)
 591     {
 592       _bfd_generic_link_add_one_symbol (info, abfd,
 593                                         name,
 594                                         BSF_GLOBAL,
 595                                         sec,
 596                                         value,
 597                                         (const char*) NULL,
 598                                         TRUE, FALSE, NULL);
 599     }
 600   else
 601     {
 602       h->root.type = bfd_link_hash_defined;
 603       h->root.u.def.value = value;
 604       h->root.u.def.section = sec;
 605     }
 606 }
 607
 608
 609 /* Build all the stubs associated with the current output file.  The
 610    stubs are kept in a hash table attached to the main linker hash
 611    table.  This function is called via m68hc12elf_finish in the
 612    linker.  */
 613
 614 bfd_boolean
 615 elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)
 616 {
 617   asection *stub_sec;
 618   struct bfd_hash_table *table;
 619   struct m68hc11_elf_link_hash_table *htab;
 620   struct m68hc11_scan_param param;
 621
 622   m68hc11_elf_get_bank_parameters (info);
 623   htab = m68hc11_elf_hash_table (info);
 624
 625   for (stub_sec = htab->stub_bfd->sections;
 626        stub_sec != NULL;
 627        stub_sec = stub_sec->next)
 628     {
 629       bfd_size_type size;
 630
 631       /* Allocate memory to hold the linker stubs.  */
 632       size = stub_sec->size;
 633       stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
 634       if (stub_sec->contents == NULL && size != 0)
 635         return FALSE;
 636       stub_sec->size = 0;
 637     }
 638
 639   /* Build the stubs as directed by the stub hash table.  */
 640   table = htab->stub_hash_table;
 641   bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);
 642
 643   /* Scan the output sections to see if we use the memory banks.
 644      If so, export the symbols that define how the memory banks
 645      are mapped.  This is used by gdb and the simulator to obtain
 646      the information.  It can be used by programs to burn the eprom
 647      at the good addresses.  */
 648   param.use_memory_banks = FALSE;
 649   param.pinfo = &htab->pinfo;
 650   bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
 651   if (param.use_memory_banks)
 652     {
 653       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,
 654                               htab->pinfo.bank_physical,
 655                               bfd_abs_section_ptr);
 656       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,
 657                               htab->pinfo.bank_virtual,
 658                               bfd_abs_section_ptr);
 659       m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,
 660                               htab->pinfo.bank_size,
 661                               bfd_abs_section_ptr);
 662     }
 663
 664   return TRUE;
 665 }
 666
 667 void
 668 m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)
 669 {
 670   unsigned i;
 671   struct m68hc11_page_info *pinfo;
 672   struct bfd_link_hash_entry *h;
 673
 674   pinfo = &m68hc11_elf_hash_table (info)->pinfo;
 675   if (pinfo->bank_param_initialized)
 676     return;
 677
 678   pinfo->bank_virtual = M68HC12_BANK_VIRT;
 679   pinfo->bank_mask = M68HC12_BANK_MASK;
 680   pinfo->bank_physical = M68HC12_BANK_BASE;
 681   pinfo->bank_shift = M68HC12_BANK_SHIFT;
 682   pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;
 683
 684   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_START_NAME,
 685                             FALSE, FALSE, TRUE);
 686   if (h != (struct bfd_link_hash_entry*) NULL
 687       && h->type == bfd_link_hash_defined)
 688     pinfo->bank_physical = (h->u.def.value
 689                             + h->u.def.section->output_section->vma
 690                             + h->u.def.section->output_offset);
 691
 692   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_VIRTUAL_NAME,
 693                             FALSE, FALSE, TRUE);
 694   if (h != (struct bfd_link_hash_entry*) NULL
 695       && h->type == bfd_link_hash_defined)
 696     pinfo->bank_virtual = (h->u.def.value
 697                            + h->u.def.section->output_section->vma
 698                            + h->u.def.section->output_offset);
 699
 700   h = bfd_link_hash_lookup (info->hash, BFD_M68HC11_BANK_SIZE_NAME,
 701                             FALSE, FALSE, TRUE);
 702   if (h != (struct bfd_link_hash_entry*) NULL
 703       && h->type == bfd_link_hash_defined)
 704     pinfo->bank_size = (h->u.def.value
 705                         + h->u.def.section->output_section->vma
 706                         + h->u.def.section->output_offset);
 707
 708   pinfo->bank_shift = 0;
 709   for (i = pinfo->bank_size; i != 0; i >>= 1)
 710     pinfo->bank_shift++;
 711   pinfo->bank_shift--;
 712   pinfo->bank_mask = (1 << pinfo->bank_shift) - 1;
 713   pinfo->bank_physical_end = pinfo->bank_physical + pinfo->bank_size;
 714   pinfo->bank_param_initialized = 1;
 715
 716   h = bfd_link_hash_lookup (info->hash, "__far_trampoline", FALSE,
 717                             FALSE, TRUE);
 718   if (h != (struct bfd_link_hash_entry*) NULL
 719       && h->type == bfd_link_hash_defined)
 720     pinfo->trampoline_addr = (h->u.def.value
 721                               + h->u.def.section->output_section->vma
 722                               + h->u.def.section->output_offset);
 723 }
 724
 725 /* Return 1 if the address is in banked memory.
 726    This can be applied to a virtual address and to a physical address.  */
 727 int
 728 m68hc11_addr_is_banked (struct m68hc11_page_info *pinfo, bfd_vma addr)
 729 {
 730   if (addr >= pinfo->bank_virtual)
 731     return 1;
 732
 733   if (addr >= pinfo->bank_physical && addr <= pinfo->bank_physical_end)
 734     return 1;
 735
 736   return 0;
 737 }
 738
 739 /* Return the physical address seen by the processor, taking
 740    into account banked memory.  */
 741 bfd_vma
 742 m68hc11_phys_addr (struct m68hc11_page_info *pinfo, bfd_vma addr)
 743 {
 744   if (addr < pinfo->bank_virtual)
 745     return addr;
 746
 747   /* Map the address to the memory bank.  */
 748   addr -= pinfo->bank_virtual;
 749   addr &= pinfo->bank_mask;
 750   addr += pinfo->bank_physical;
 751   return addr;
 752 }
 753
 754 /* Return the page number corresponding to an address in banked memory.  */
 755 bfd_vma
 756 m68hc11_phys_page (struct m68hc11_page_info *pinfo, bfd_vma addr)
 757 {
 758   if (addr < pinfo->bank_virtual)
 759     return 0;
 760
 761   /* Map the address to the memory bank.  */
 762   addr -= pinfo->bank_virtual;
 763   addr >>= pinfo->bank_shift;
 764   addr &= 0x0ff;
 765   return addr;
 766 }
 767
 768 /* This function is used for relocs which are only used for relaxing,
 769    which the linker should otherwise ignore.  */
 770
 771 bfd_reloc_status_type
 772 m68hc11_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 773                           arelent *reloc_entry,
 774                           asymbol *symbol ATTRIBUTE_UNUSED,
 775                           void *data ATTRIBUTE_UNUSED,
 776                           asection *input_section,
 777                           bfd *output_bfd,
 778                           char **error_message ATTRIBUTE_UNUSED)
 779 {
 780   if (output_bfd != NULL)
 781     reloc_entry->address += input_section->output_offset;
 782   return bfd_reloc_ok;
 783 }
 784
 785 bfd_reloc_status_type
 786 m68hc11_elf_special_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 787                            arelent *reloc_entry,
 788                            asymbol *symbol,
 789                            void *data ATTRIBUTE_UNUSED,
 790                            asection *input_section,
 791                            bfd *output_bfd,
 792                            char **error_message ATTRIBUTE_UNUSED)
 793 {
 794   if (output_bfd != (bfd *) NULL
 795       && (symbol->flags & BSF_SECTION_SYM) == 0
 796       && (! reloc_entry->howto->partial_inplace
 797           || reloc_entry->addend == 0))
 798     {
 799       reloc_entry->address += input_section->output_offset;
 800       return bfd_reloc_ok;
 801     }
 802
 803   if (output_bfd != NULL)
 804     return bfd_reloc_continue;
 805
 806   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 807     return bfd_reloc_outofrange;
 808
 809   abort();
 810 }
 811
 812 asection *
 813 elf32_m68hc11_gc_mark_hook (asection *sec,
 814                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
 815                             Elf_Internal_Rela *rel,
 816                             struct elf_link_hash_entry *h,
 817                             Elf_Internal_Sym *sym)
 818 {
 819   if (h != NULL)
 820     {
 821       switch (ELF32_R_TYPE (rel->r_info))
 822         {
 823         default:
 824           switch (h->root.type)
 825             {
 826             case bfd_link_hash_defined:
 827             case bfd_link_hash_defweak:
 828               return h->root.u.def.section;
 829
 830             case bfd_link_hash_common:
 831               return h->root.u.c.p->section;
 832
 833             default:
 834               break;
 835             }
 836         }
 837     }
 838   else
 839     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 840
 841   return NULL;
 842 }
 843
 844 bfd_boolean
 845 elf32_m68hc11_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
 846                              struct bfd_link_info *info ATTRIBUTE_UNUSED,
 847                              asection *sec ATTRIBUTE_UNUSED,
 848                              const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
 849 {
 850   /* We don't use got and plt entries for 68hc11/68hc12.  */
 851   return TRUE;
 852 }
 853
 854 /* Look through the relocs for a section during the first phase.
 855    Since we don't do .gots or .plts, we just need to consider the
 856    virtual table relocs for gc.  */
 857
 858 bfd_boolean
 859 elf32_m68hc11_check_relocs (bfd *abfd, struct bfd_link_info *info,
 860                             asection *sec, const Elf_Internal_Rela *relocs)
 861 {
 862   Elf_Internal_Shdr *           symtab_hdr;
 863   struct elf_link_hash_entry ** sym_hashes;
 864   struct elf_link_hash_entry ** sym_hashes_end;
 865   const Elf_Internal_Rela *     rel;
 866   const Elf_Internal_Rela *     rel_end;
 867
 868   if (info->relocatable)
 869     return TRUE;
 870
 871   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 872   sym_hashes = elf_sym_hashes (abfd);
 873   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 874   if (!elf_bad_symtab (abfd))
 875     sym_hashes_end -= symtab_hdr->sh_info;
 876
 877   rel_end = relocs + sec->reloc_count;
 878
 879   for (rel = relocs; rel < rel_end; rel++)
 880     {
 881       struct elf_link_hash_entry * h;
 882       unsigned long r_symndx;
 883
 884       r_symndx = ELF32_R_SYM (rel->r_info);
 885
 886       if (r_symndx < symtab_hdr->sh_info)
 887         h = NULL;
 888       else
 889         h = sym_hashes [r_symndx - symtab_hdr->sh_info];
 890
 891       switch (ELF32_R_TYPE (rel->r_info))
 892         {
 893         /* This relocation describes the C++ object vtable hierarchy.
 894            Reconstruct it for later use during GC.  */
 895         case R_M68HC11_GNU_VTINHERIT:
 896           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 897             return FALSE;
 898           break;
 899
 900         /* This relocation describes which C++ vtable entries are actually
 901            used.  Record for later use during GC.  */
 902         case R_M68HC11_GNU_VTENTRY:
 903           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 904             return FALSE;
 905           break;
 906         }
 907     }
 908
 909   return TRUE;
 910 }
 911
 912 static bfd_boolean
 913 m68hc11_get_relocation_value (bfd *input_bfd, struct bfd_link_info *info,
 914                               asection *input_section,
 915                               asection **local_sections,
 916                               Elf_Internal_Sym *local_syms,
 917                               Elf_Internal_Rela *rel,
 918                               const char **name,
 919                               bfd_vma *relocation, bfd_boolean *is_far)
 920 {
 921   Elf_Internal_Shdr *symtab_hdr;
 922   struct elf_link_hash_entry **sym_hashes;
 923   unsigned long r_symndx;
 924   asection *sec;
 925   struct elf_link_hash_entry *h;
 926   Elf_Internal_Sym *sym;
 927   const char* stub_name = 0;
 928
 929   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 930   sym_hashes = elf_sym_hashes (input_bfd);
 931
 932   r_symndx = ELF32_R_SYM (rel->r_info);
 933
 934   /* This is a final link.  */
 935   h = NULL;
 936   sym = NULL;
 937   sec = NULL;
 938   if (r_symndx < symtab_hdr->sh_info)
 939     {
 940       sym = local_syms + r_symndx;
 941       sec = local_sections[r_symndx];
 942       *relocation = (sec->output_section->vma
 943                      + sec->output_offset
 944                      + sym->st_value);
 945       *is_far = (sym && (sym->st_other & STO_M68HC12_FAR));
 946       if (*is_far)
 947         stub_name = (bfd_elf_string_from_elf_section
 948                      (input_bfd, symtab_hdr->sh_link,
 949                       sym->st_name));
 950     }
 951   else
 952     {
 953       bfd_boolean unresolved_reloc, warned;
 954
 955       RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 956                                r_symndx, symtab_hdr, sym_hashes,
 957                                h, sec, *relocation, unresolved_reloc, warned);
 958
 959       *is_far = (h && (h->other & STO_M68HC12_FAR));
 960       stub_name = h->root.root.string;
 961     }
 962
 963   if (h != NULL)
 964     *name = h->root.root.string;
 965   else
 966     {
 967       *name = (bfd_elf_string_from_elf_section
 968                (input_bfd, symtab_hdr->sh_link, sym->st_name));
 969       if (*name == NULL || **name == '\0')
 970         *name = bfd_section_name (input_bfd, sec);
 971     }
 972
 973   if (*is_far && ELF32_R_TYPE (rel->r_info) == R_M68HC11_16)
 974     {
 975       struct elf32_m68hc11_stub_hash_entry* stub;
 976       struct m68hc11_elf_link_hash_table *htab;
 977
 978       htab = m68hc11_elf_hash_table (info);
 979       stub = m68hc12_stub_hash_lookup (htab->stub_hash_table,
 980                                        *name, FALSE, FALSE);
 981       if (stub)
 982         {
 983           *relocation = stub->stub_offset
 984             + stub->stub_sec->output_section->vma
 985             + stub->stub_sec->output_offset;
 986           *is_far = FALSE;
 987         }
 988     }
 989   return TRUE;
 990 }
 991
 992 /* Relocate a 68hc11/68hc12 ELF section.  */
 993 bfd_boolean
 994 elf32_m68hc11_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
 995                                 struct bfd_link_info *info,
 996                                 bfd *input_bfd, asection *input_section,
 997                                 bfd_byte *contents, Elf_Internal_Rela *relocs,
 998                                 Elf_Internal_Sym *local_syms,
 999                                 asection **local_sections)
1000 {
1001   Elf_Internal_Shdr *symtab_hdr;
1002   struct elf_link_hash_entry **sym_hashes;
1003   Elf_Internal_Rela *rel, *relend;
1004   const char *name;
1005   struct m68hc11_page_info *pinfo;
1006   const struct elf_backend_data * const ebd = get_elf_backend_data (input_bfd);
1007
1008   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1009   sym_hashes = elf_sym_hashes (input_bfd);
1010
1011   /* Get memory bank parameters.  */
1012   m68hc11_elf_get_bank_parameters (info);
1013   pinfo = &m68hc11_elf_hash_table (info)->pinfo;
1014
1015   rel = relocs;
1016   relend = relocs + input_section->reloc_count;
1017   for (; rel < relend; rel++)
1018     {
1019       int r_type;
1020       arelent arel;
1021       reloc_howto_type *howto;
1022       unsigned long r_symndx;
1023       Elf_Internal_Sym *sym;
1024       asection *sec;
1025       bfd_vma relocation;
1026       bfd_reloc_status_type r = bfd_reloc_undefined;
1027       bfd_vma phys_page;
1028       bfd_vma phys_addr;
1029       bfd_vma insn_addr;
1030       bfd_vma insn_page;
1031       bfd_boolean is_far;
1032
1033       r_symndx = ELF32_R_SYM (rel->r_info);
1034       r_type = ELF32_R_TYPE (rel->r_info);
1035
1036       if (r_type == R_M68HC11_GNU_VTENTRY
1037           || r_type == R_M68HC11_GNU_VTINHERIT )
1038         continue;
1039
1040       if (info->relocatable)
1041         {
1042           /* This is a relocatable link.  We don't have to change
1043              anything, unless the reloc is against a section symbol,
1044              in which case we have to adjust according to where the
1045              section symbol winds up in the output section.  */
1046           if (r_symndx < symtab_hdr->sh_info)
1047             {
1048               sym = local_syms + r_symndx;
1049               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1050                 {
1051                   sec = local_sections[r_symndx];
1052                   rel->r_addend += sec->output_offset + sym->st_value;
1053                 }
1054             }
1055
1056           continue;
1057         }
1058       (*ebd->elf_info_to_howto_rel) (input_bfd, &arel, rel);
1059       howto = arel.howto;
1060
1061       m68hc11_get_relocation_value (input_bfd, info, input_section,
1062                                     local_sections, local_syms,
1063                                     rel, &name, &relocation, &is_far);
1064
1065       /* Do the memory bank mapping.  */
1066       phys_addr = m68hc11_phys_addr (pinfo, relocation + rel->r_addend);
1067       phys_page = m68hc11_phys_page (pinfo, relocation + rel->r_addend);
1068       switch (r_type)
1069         {
1070         case R_M68HC11_24:
1071           /* Reloc used by 68HC12 call instruction.  */
1072           bfd_put_16 (input_bfd, phys_addr,
1073                       (bfd_byte*) contents + rel->r_offset);
1074           bfd_put_8 (input_bfd, phys_page,
1075                      (bfd_byte*) contents + rel->r_offset + 2);
1076           r = bfd_reloc_ok;
1077           r_type = R_M68HC11_NONE;
1078           break;
1079
1080         case R_M68HC11_NONE:
1081           r = bfd_reloc_ok;
1082           break;
1083
1084         case R_M68HC11_LO16:
1085           /* Reloc generated by %addr(expr) gas to obtain the
1086              address as mapped in the memory bank window.  */
1087           relocation = phys_addr;
1088           break;
1089
1090         case R_M68HC11_PAGE:
1091           /* Reloc generated by %page(expr) gas to obtain the
1092              page number associated with the address.  */
1093           relocation = phys_page;
1094           break;
1095
1096         case R_M68HC11_16:
1097           /* Get virtual address of instruction having the relocation.  */
1098           if (is_far)
1099             {
1100               const char* msg;
1101               char* buf;
1102               msg = _("Reference to the far symbol `%s' using a wrong "
1103                       "relocation may result in incorrect execution");
1104               buf = alloca (strlen (msg) + strlen (name) + 10);
1105               sprintf (buf, msg, name);
1106
1107               (* info->callbacks->warning)
1108                 (info, buf, name, input_bfd, NULL, rel->r_offset);
1109             }
1110
1111           /* Get virtual address of instruction having the relocation.  */
1112           insn_addr = input_section->output_section->vma
1113             + input_section->output_offset
1114             + rel->r_offset;
1115
1116           insn_page = m68hc11_phys_page (pinfo, insn_addr);
1117
1118           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend)
1119               && m68hc11_addr_is_banked (pinfo, insn_addr)
1120               && phys_page != insn_page)
1121             {
1122               const char* msg;
1123               char* buf;
1124
1125               msg = _("banked address [%lx:%04lx] (%lx) is not in the same bank "
1126                       "as current banked address [%lx:%04lx] (%lx)");
1127
1128               buf = alloca (strlen (msg) + 128);
1129               sprintf (buf, msg, phys_page, phys_addr,
1130                        (long) (relocation + rel->r_addend),
1131                        insn_page, m68hc11_phys_addr (pinfo, insn_addr),
1132                        (long) (insn_addr));
1133               if (!((*info->callbacks->warning)
1134                     (info, buf, name, input_bfd, input_section,
1135                      rel->r_offset)))
1136                 return FALSE;
1137               break;
1138             }
1139           if (phys_page != 0 && insn_page == 0)
1140             {
1141               const char* msg;
1142               char* buf;
1143
1144               msg = _("reference to a banked address [%lx:%04lx] in the "
1145                       "normal address space at %04lx");
1146
1147               buf = alloca (strlen (msg) + 128);
1148               sprintf (buf, msg, phys_page, phys_addr, insn_addr);
1149               if (!((*info->callbacks->warning)
1150                     (info, buf, name, input_bfd, input_section,
1151                      insn_addr)))
1152                 return FALSE;
1153
1154               relocation = phys_addr;
1155               break;
1156             }
1157
1158           /* If this is a banked address use the phys_addr so that
1159              we stay in the banked window.  */
1160           if (m68hc11_addr_is_banked (pinfo, relocation + rel->r_addend))
1161             relocation = phys_addr;
1162           break;
1163         }
1164       if (r_type != R_M68HC11_NONE)
1165         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1166                                       contents, rel->r_offset,
1167                                       relocation, rel->r_addend);
1168
1169       if (r != bfd_reloc_ok)
1170         {
1171           const char * msg = (const char *) 0;
1172
1173           switch (r)
1174             {
1175             case bfd_reloc_overflow:
1176               if (!((*info->callbacks->reloc_overflow)
1177                     (info, name, howto->name, (bfd_vma) 0,
1178                      input_bfd, input_section, rel->r_offset)))
1179                 return FALSE;
1180               break;
1181
1182             case bfd_reloc_undefined:
1183               if (!((*info->callbacks->undefined_symbol)
1184                     (info, name, input_bfd, input_section,
1185                      rel->r_offset, TRUE)))
1186                 return FALSE;
1187               break;
1188
1189             case bfd_reloc_outofrange:
1190               msg = _ ("internal error: out of range error");
1191               goto common_error;
1192
1193             case bfd_reloc_notsupported:
1194               msg = _ ("internal error: unsupported relocation error");
1195               goto common_error;
1196
1197             case bfd_reloc_dangerous:
1198               msg = _ ("internal error: dangerous error");
1199               goto common_error;
1200
1201             default:
1202               msg = _ ("internal error: unknown error");
1203               /* fall through */
1204
1205             common_error:
1206               if (!((*info->callbacks->warning)
1207                     (info, msg, name, input_bfd, input_section,
1208                      rel->r_offset)))
1209                 return FALSE;
1210               break;
1211             }
1212         }
1213     }
1214
1215   return TRUE;
1216 }
1217
1218
1219 \f
1220 /* Set and control ELF flags in ELF header.  */
1221
1222 bfd_boolean
1223 _bfd_m68hc11_elf_set_private_flags (bfd *abfd, flagword flags)
1224 {
1225   BFD_ASSERT (!elf_flags_init (abfd)
1226               || elf_elfheader (abfd)->e_flags == flags);
1227
1228   elf_elfheader (abfd)->e_flags = flags;
1229   elf_flags_init (abfd) = TRUE;
1230   return TRUE;
1231 }
1232
1233 /* Merge backend specific data from an object file to the output
1234    object file when linking.  */
1235
1236 bfd_boolean
1237 _bfd_m68hc11_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1238 {
1239   flagword old_flags;
1240   flagword new_flags;
1241   bfd_boolean ok = TRUE;
1242
1243   /* Check if we have the same endianess */
1244   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
1245     return FALSE;
1246
1247   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1248       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1249     return TRUE;
1250
1251   new_flags = elf_elfheader (ibfd)->e_flags;
1252   elf_elfheader (obfd)->e_flags |= new_flags & EF_M68HC11_ABI;
1253   old_flags = elf_elfheader (obfd)->e_flags;
1254
1255   if (! elf_flags_init (obfd))
1256     {
1257       elf_flags_init (obfd) = TRUE;
1258       elf_elfheader (obfd)->e_flags = new_flags;
1259       elf_elfheader (obfd)->e_ident[EI_CLASS]
1260         = elf_elfheader (ibfd)->e_ident[EI_CLASS];
1261
1262       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1263           && bfd_get_arch_info (obfd)->the_default)
1264         {
1265           if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
1266                                    bfd_get_mach (ibfd)))
1267             return FALSE;
1268         }
1269
1270       return TRUE;
1271     }
1272
1273   /* Check ABI compatibility.  */
1274   if ((new_flags & E_M68HC11_I32) != (old_flags & E_M68HC11_I32))
1275     {
1276       (*_bfd_error_handler)
1277         (_("%s: linking files compiled for 16-bit integers (-mshort) "
1278            "and others for 32-bit integers"),
1279          bfd_archive_filename (ibfd));
1280       ok = FALSE;
1281     }
1282   if ((new_flags & E_M68HC11_F64) != (old_flags & E_M68HC11_F64))
1283     {
1284       (*_bfd_error_handler)
1285         (_("%s: linking files compiled for 32-bit double (-fshort-double) "
1286            "and others for 64-bit double"),
1287          bfd_archive_filename (ibfd));
1288       ok = FALSE;
1289     }
1290
1291   /* Processor compatibility.  */
1292   if (!EF_M68HC11_CAN_MERGE_MACH (new_flags, old_flags))
1293     {
1294       (*_bfd_error_handler)
1295         (_("%s: linking files compiled for HCS12 with "
1296            "others compiled for HC12"),
1297          bfd_archive_filename (ibfd));
1298       ok = FALSE;
1299     }
1300   new_flags = ((new_flags & ~EF_M68HC11_MACH_MASK)
1301                | (EF_M68HC11_MERGE_MACH (new_flags, old_flags)));
1302
1303   elf_elfheader (obfd)->e_flags = new_flags;
1304
1305   new_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1306   old_flags &= ~(EF_M68HC11_ABI | EF_M68HC11_MACH_MASK);
1307
1308   /* Warn about any other mismatches */
1309   if (new_flags != old_flags)
1310     {
1311       (*_bfd_error_handler)
1312         (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
1313          bfd_archive_filename (ibfd), (unsigned long) new_flags,
1314          (unsigned long) old_flags);
1315       ok = FALSE;
1316     }
1317
1318   if (! ok)
1319     {
1320       bfd_set_error (bfd_error_bad_value);
1321       return FALSE;
1322     }
1323
1324   return TRUE;
1325 }
1326
1327 bfd_boolean
1328 _bfd_m68hc11_elf_print_private_bfd_data (bfd *abfd, void *ptr)
1329 {
1330   FILE *file = (FILE *) ptr;
1331
1332   BFD_ASSERT (abfd != NULL && ptr != NULL);
1333
1334   /* Print normal ELF private data.  */
1335   _bfd_elf_print_private_bfd_data (abfd, ptr);
1336
1337   /* xgettext:c-format */
1338   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1339
1340   if (elf_elfheader (abfd)->e_flags & E_M68HC11_I32)
1341     fprintf (file, _("[abi=32-bit int, "));
1342   else
1343     fprintf (file, _("[abi=16-bit int, "));
1344
1345   if (elf_elfheader (abfd)->e_flags & E_M68HC11_F64)
1346     fprintf (file, _("64-bit double, "));
1347   else
1348     fprintf (file, _("32-bit double, "));
1349
1350   if (strcmp (bfd_get_target (abfd), "elf32-m68hc11") == 0)
1351     fprintf (file, _("cpu=HC11]"));
1352   else if (elf_elfheader (abfd)->e_flags & EF_M68HCS12_MACH)
1353     fprintf (file, _("cpu=HCS12]"));
1354   else
1355     fprintf (file, _("cpu=HC12]"));
1356
1357   if (elf_elfheader (abfd)->e_flags & E_M68HC12_BANKS)
1358     fprintf (file, _(" [memory=bank-model]"));
1359   else
1360     fprintf (file, _(" [memory=flat]"));
1361
1362   fputc ('\n', file);
1363
1364   return TRUE;
1365 }
1366
1367 static void scan_sections_for_abi (bfd *abfd ATTRIBUTE_UNUSED,
1368                                    asection *asect, void *arg)
1369 {
1370   struct m68hc11_scan_param* p = (struct m68hc11_scan_param*) arg;
1371
1372   if (asect->vma >= p->pinfo->bank_virtual)
1373     p->use_memory_banks = TRUE;
1374 }
1375
1376 /* Tweak the OSABI field of the elf header.  */
1377
1378 void
1379 elf32_m68hc11_post_process_headers (bfd *abfd, struct bfd_link_info *link_info)
1380 {
1381   struct m68hc11_scan_param param;
1382
1383   if (link_info == 0)
1384     return;
1385
1386   m68hc11_elf_get_bank_parameters (link_info);
1387
1388   param.use_memory_banks = FALSE;
1389   param.pinfo = &m68hc11_elf_hash_table (link_info)->pinfo;
1390   bfd_map_over_sections (abfd, scan_sections_for_abi, &param);
1391   if (param.use_memory_banks)
1392     {
1393       Elf_Internal_Ehdr * i_ehdrp;
1394
1395       i_ehdrp = elf_elfheader (abfd);
1396       i_ehdrp->e_flags |= E_M68HC12_BANKS;
1397     }
1398 }
1399