bfd/elf32-m68hc1x.c

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