bfd/elf32-m68hc1x.c

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