bfd/elf32-m68hc1x.c

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