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