bfd/elf32-m68hc1x.c

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