Subversion Repositories openrisc

/* Motorola 68HC11/HC12-specific support for 32-bit ELF

   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008

   Free Software Foundation, Inc.

   Contributed by Stephane Carrez (stcarrez@nerim.fr)

   This file is part of BFD, the Binary File Descriptor library.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include "bfd.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "elf-bfd.h"

#include "elf32-m68hc1x.h"

#include "elf/m68hc11.h"

#include "opcode/m68hc11.h"

#define m68hc12_stub_hash_lookup(table, string, create, copy) \

  ((struct elf32_m68hc11_stub_hash_entry *) \

   bfd_hash_lookup ((table), (string), (create), (copy)))

static struct elf32_m68hc11_stub_hash_entry* m68hc12_add_stub

  (const char *stub_name,

   asection *section,

   struct m68hc11_elf_link_hash_table *htab);

static struct bfd_hash_entry *stub_hash_newfunc

  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);

static void m68hc11_elf_set_symbol (bfd* abfd, struct bfd_link_info *info,

                                    const char* name, bfd_vma value,

                                    asection* sec);

static bfd_boolean m68hc11_elf_export_one_stub

  (struct bfd_hash_entry *gen_entry, void *in_arg);

static void scan_sections_for_abi (bfd*, asection*, PTR);

struct m68hc11_scan_param

{

   struct m68hc11_page_info* pinfo;

   bfd_boolean use_memory_banks;

};

/* Create a 68HC11/68HC12 ELF linker hash table.  */

struct m68hc11_elf_link_hash_table*

m68hc11_elf_hash_table_create (bfd *abfd)

{

  struct m68hc11_elf_link_hash_table *ret;

  bfd_size_type amt = sizeof (struct m68hc11_elf_link_hash_table);

  ret = (struct m68hc11_elf_link_hash_table *) bfd_malloc (amt);

  if (ret == (struct m68hc11_elf_link_hash_table *) NULL)

    return NULL;

  memset (ret, 0, amt);

  if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,

                                      _bfd_elf_link_hash_newfunc,

                                      sizeof (struct elf_link_hash_entry)))

    {

      free (ret);

      return NULL;

    }

  /* Init the stub hash table too.  */

  amt = sizeof (struct bfd_hash_table);

  ret->stub_hash_table = (struct bfd_hash_table*) bfd_malloc (amt);

  if (ret->stub_hash_table == NULL)

    {

      free (ret);

      return NULL;

    }

  if (!bfd_hash_table_init (ret->stub_hash_table, stub_hash_newfunc,

                            sizeof (struct elf32_m68hc11_stub_hash_entry)))

    return NULL;

  ret->stub_bfd = NULL;

  ret->stub_section = 0;

  ret->add_stub_section = NULL;

  ret->sym_sec.abfd = NULL;

  return ret;

}

/* Free the derived linker hash table.  */

void

m68hc11_elf_bfd_link_hash_table_free (struct bfd_link_hash_table *hash)

{

  struct m68hc11_elf_link_hash_table *ret

    = (struct m68hc11_elf_link_hash_table *) hash;

  bfd_hash_table_free (ret->stub_hash_table);

  free (ret->stub_hash_table);

  _bfd_generic_link_hash_table_free (hash);

}

/* Assorted hash table functions.  */

/* Initialize an entry in the stub hash table.  */

static struct bfd_hash_entry *

stub_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,

                   const char *string)

{

  /* Allocate the structure if it has not already been allocated by a

     subclass.  */

  if (entry == NULL)

    {

      entry = bfd_hash_allocate (table,

                                 sizeof (struct elf32_m68hc11_stub_hash_entry));

      if (entry == NULL)

        return entry;

    }

  /* Call the allocation method of the superclass.  */

  entry = bfd_hash_newfunc (entry, table, string);

  if (entry != NULL)

    {

      struct elf32_m68hc11_stub_hash_entry *eh;

      /* Initialize the local fields.  */

      eh = (struct elf32_m68hc11_stub_hash_entry *) entry;

      eh->stub_sec = NULL;

      eh->stub_offset = 0;

      eh->target_value = 0;

      eh->target_section = NULL;

    }

  return entry;

}

/* Add a new stub entry to the stub hash.  Not all fields of the new

   stub entry are initialised.  */

static struct elf32_m68hc11_stub_hash_entry *

m68hc12_add_stub (const char *stub_name, asection *section,

                  struct m68hc11_elf_link_hash_table *htab)

{

  struct elf32_m68hc11_stub_hash_entry *stub_entry;

  /* Enter this entry into the linker stub hash table.  */

  stub_entry = m68hc12_stub_hash_lookup (htab->stub_hash_table, stub_name,

                                         TRUE, FALSE);

  if (stub_entry == NULL)

    {

      (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),

                             section->owner, stub_name);

      return NULL;

    }

  if (htab->stub_section == 0)

    {

      htab->stub_section = (*htab->add_stub_section) (".tramp",

                                                      htab->tramp_section);

    }

  stub_entry->stub_sec = htab->stub_section;

  stub_entry->stub_offset = 0;

  return stub_entry;

}

/* Hook called by the linker routine which adds symbols from an object

   file.  We use it for identify far symbols and force a loading of

   the trampoline handler.  */

bfd_boolean

elf32_m68hc11_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,

                               Elf_Internal_Sym *sym,

                               const char **namep ATTRIBUTE_UNUSED,

                               flagword *flagsp ATTRIBUTE_UNUSED,

                               asection **secp ATTRIBUTE_UNUSED,

                               bfd_vma *valp ATTRIBUTE_UNUSED)

{

  if (sym->st_other & STO_M68HC12_FAR)

    {

      struct elf_link_hash_entry *h;

      h = (struct elf_link_hash_entry *)

        bfd_link_hash_lookup (info->hash, "__far_trampoline",

                              FALSE, FALSE, FALSE);

      if (h == NULL)

        {

          struct bfd_link_hash_entry* entry = NULL;

          _bfd_generic_link_add_one_symbol (info, abfd,

                                            "__far_trampoline",

                                            BSF_GLOBAL,

                                            bfd_und_section_ptr,

                                            (bfd_vma) 0, (const char*) NULL,

                                            FALSE, FALSE, &entry);

        }

    }

  return TRUE;

}

/* External entry points for sizing and building linker stubs.  */

/* Set up various things so that we can make a list of input sections

   for each output section included in the link.  Returns -1 on error,

int

elf32_m68hc11_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)

{

  bfd *input_bfd;

  unsigned int bfd_count;

  int top_id, top_index;

  asection *section;

  asection **input_list, **list;

  bfd_size_type amt;

  asection *text_section;

  struct m68hc11_elf_link_hash_table *htab;

  htab = m68hc11_elf_hash_table (info);

  if (bfd_get_flavour (info->output_bfd) != bfd_target_elf_flavour)

    return 0;

  /* Count the number of input BFDs and find the top input section id.

     Also search for an existing ".tramp" section so that we know

     where generated trampolines must go.  Default to ".text" if we

     can't find it.  */

  htab->tramp_section = 0;

  text_section = 0;

  for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;

       input_bfd != NULL;

       input_bfd = input_bfd->link_next)

    {

      bfd_count += 1;

      for (section = input_bfd->sections;

           section != NULL;

           section = section->next)

        {

          const char* name = bfd_get_section_name (input_bfd, section);

          if (!strcmp (name, ".tramp"))

            htab->tramp_section = section;

          if (!strcmp (name, ".text"))

            text_section = section;

          if (top_id < section->id)

            top_id = section->id;

        }

    }

  htab->bfd_count = bfd_count;

  if (htab->tramp_section == 0)

    htab->tramp_section = text_section;

  /* We can't use output_bfd->section_count here to find the top output

     section index as some sections may have been removed, and

     strip_excluded_output_sections doesn't renumber the indices.  */

  for (section = output_bfd->sections, top_index = 0;

       section != NULL;

       section = section->next)

    {

      if (top_index < section->index)

        top_index = section->index;

    }

  htab->top_index = top_index;

  amt = sizeof (asection *) * (top_index + 1);

  input_list = (asection **) bfd_malloc (amt);

  htab->input_list = input_list;

  if (input_list == NULL)

    return -1;

  /* For sections we aren't interested in, mark their entries with a

     value we can check later.  */

  list = input_list + top_index;

  do

    *list = bfd_abs_section_ptr;

  while (list-- != input_list);

  for (section = output_bfd->sections;

       section != NULL;

       section = section->next)

    {

      if ((section->flags & SEC_CODE) != 0)

        input_list[section->index] = NULL;

    }

  return 1;

}

/* Determine and set the size of the stub section for a final link.

   The basic idea here is to examine all the relocations looking for

   PC-relative calls to a target that is unreachable with a "bl"

   instruction.  */

bfd_boolean

elf32_m68hc11_size_stubs (bfd *output_bfd, bfd *stub_bfd,

                          struct bfd_link_info *info,

                          asection * (*add_stub_section) (const char*, asection*))

{

  bfd *input_bfd;

  asection *section;

  Elf_Internal_Sym *local_syms, **all_local_syms;

  unsigned int bfd_indx, bfd_count;

  bfd_size_type amt;

  asection *stub_sec;

  struct m68hc11_elf_link_hash_table *htab = m68hc11_elf_hash_table (info);

  /* Stash our params away.  */

  htab->stub_bfd = stub_bfd;

  htab->add_stub_section = add_stub_section;

  /* Count the number of input BFDs and find the top input section id.  */

  for (input_bfd = info->input_bfds, bfd_count = 0;

       input_bfd != NULL;

       input_bfd = input_bfd->link_next)

    {

      bfd_count += 1;

    }

  /* We want to read in symbol extension records only once.  To do this

     we need to read in the local symbols in parallel and save them for

     later use; so hold pointers to the local symbols in an array.  */

  amt = sizeof (Elf_Internal_Sym *) * bfd_count;

  all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);

  if (all_local_syms == NULL)

    return FALSE;

  /* Walk over all the input BFDs, swapping in local symbols.  */

  for (input_bfd = info->input_bfds, bfd_indx = 0;

       input_bfd != NULL;

       input_bfd = input_bfd->link_next, bfd_indx++)

    {

      Elf_Internal_Shdr *symtab_hdr;

      /* We'll need the symbol table in a second.  */

      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;

      if (symtab_hdr->sh_info == 0)

        continue;

      /* We need an array of the local symbols attached to the input bfd.  */

      local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;

      if (local_syms == NULL)

        {

          local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,

                                             symtab_hdr->sh_info, 0,

                                             NULL, NULL, NULL);

          /* Cache them for elf_link_input_bfd.  */

          symtab_hdr->contents = (unsigned char *) local_syms;

        }

      if (local_syms == NULL)

        {

          free (all_local_syms);

          return FALSE;

        }

      all_local_syms[bfd_indx] = local_syms;

    }

  for (input_bfd = info->input_bfds, bfd_indx = 0;

       input_bfd != NULL;

       input_bfd = input_bfd->link_next, bfd_indx++)

    {

      Elf_Internal_Shdr *symtab_hdr;

      Elf_Internal_Sym *local_syms;

      struct elf_link_hash_entry ** sym_hashes;

      sym_hashes = elf_sym_hashes (input_bfd);

      /* We'll need the symbol table in a second.  */

      symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;

      if (symtab_hdr->sh_info == 0)

        continue;

      local_syms = all_local_syms[bfd_indx];

      /* Walk over each section attached to the input bfd.  */

      for (section = input_bfd->sections;

           section != NULL;

           section = section->next)

        {

          Elf_Internal_Rela *internal_relocs, *irelaend, *irela;

          /* If there aren't any relocs, then there's nothing more

             to do.  */

          if ((section->flags & SEC_RELOC) == 0

              || section->reloc_count == 0)

            continue;

          /* If this section is a link-once section that will be

             discarded, then don't create any stubs.  */

          if (section->output_section == NULL

              || section->output_section->owner != output_bfd)

            continue;

          /* Get the relocs.  */

          internal_relocs

            = _bfd_elf_link_read_relocs (input_bfd, section, NULL,

                                         (Elf_Internal_Rela *) NULL,

                                         info->keep_memory);

          if (internal_relocs == NULL)

            goto error_ret_free_local;

          /* Now examine each relocation.  */

          irela = internal_relocs;

          irelaend = irela + section->reloc_count;

          for (; irela < irelaend; irela++)

            {

              unsigned int r_type, r_indx;

              struct elf32_m68hc11_stub_hash_entry *stub_entry;

              asection *sym_sec;

              bfd_vma sym_value;

              struct elf_link_hash_entry *hash;

              const char *stub_name;

              Elf_Internal_Sym *sym;

              r_type = ELF32_R_TYPE (irela->r_info);

              /* Only look at 16-bit relocs.  */

              if (r_type != (unsigned int) R_M68HC11_16)

                continue;

              /* Now determine the call target, its name, value,

                 section.  */

              r_indx = ELF32_R_SYM (irela->r_info);

              if (r_indx < symtab_hdr->sh_info)

                {

                  /* It's a local symbol.  */

                  Elf_Internal_Shdr *hdr;

                  bfd_boolean is_far;

                  sym = local_syms + r_indx;

                  is_far = (sym && (sym->st_other & STO_M68HC12_FAR));

                  if (!is_far)

                    continue;

                  if (sym->st_shndx >= elf_numsections (input_bfd))

                    sym_sec = NULL;

                  else

                    {

                      hdr = elf_elfsections (input_bfd)[sym->st_shndx];

                      sym_sec = hdr->bfd_section;

                    }

                  stub_name = (bfd_elf_string_from_elf_section

                               (input_bfd, symtab_hdr->sh_link,

                                sym->st_name));

                  sym_value = sym->st_value;

                  hash = NULL;

                }

              else

                {

                  /* It's an external symbol.  */

                  int e_indx;

                  e_indx = r_indx - symtab_hdr->sh_info;

                  hash = (struct elf_link_hash_entry *)

                    (sym_hashes[e_indx]);

                  while (hash->root.type == bfd_link_hash_indirect

                         || hash->root.type == bfd_link_hash_warning)

                    hash = ((struct elf_link_hash_entry *)

                            hash->root.u.i.link);

                  if (hash->root.type == bfd_link_hash_defined

                      || hash->root.type == bfd_link_hash_defweak

                      || hash->root.type == bfd_link_hash_new)

                    {

                      if (!(hash->other & STO_M68HC12_FAR))

                        continue;

                    }

                  else if (hash->root.type == bfd_link_hash_undefweak)

                    {

                      continue;

                    }

                  else if (hash->root.type == bfd_link_hash_undefined)

                    {

                      continue;

                    }

                  else

                    {

                      bfd_set_error (bfd_error_bad_value);

                      goto error_ret_free_internal;

                    }

                  sym_sec = hash->root.u.def.section;

                  sym_value = hash->root.u.def.value;

                  stub_name = hash->root.root.string;

                }

              if (!stub_name)

                goto error_ret_free_internal;

              stub_entry = m68hc12_stub_hash_lookup

                (htab->stub_hash_table,

                 stub_name,

                 FALSE, FALSE);

              if (stub_entry == NULL)

                {

                  if (add_stub_section == 0)

                    continue;

                  stub_entry = m68hc12_add_stub (stub_name, section, htab);

                  if (stub_entry == NULL)

                    {

                    error_ret_free_internal:

                      if (elf_section_data (section)->relocs == NULL)

                        free (internal_relocs);

                      goto error_ret_free_local;

                    }

                }

              stub_entry->target_value = sym_value;

              stub_entry->target_section = sym_sec;

            }

          /* We're done with the internal relocs, free them.  */

          if (elf_section_data (section)->relocs == NULL)

            free (internal_relocs);

        }

    }

  if (add_stub_section)

    {

      /* OK, we've added some stubs.  Find out the new size of the

         stub sections.  */

      for (stub_sec = htab->stub_bfd->sections;

           stub_sec != NULL;

           stub_sec = stub_sec->next)

        {

          stub_sec->size = 0;

        }

      bfd_hash_traverse (htab->stub_hash_table, htab->size_one_stub, htab);

    }

  free (all_local_syms);

  return TRUE;

 error_ret_free_local:

  free (all_local_syms);

  return FALSE;

}

/* Export the trampoline addresses in the symbol table.  */

static bfd_boolean

m68hc11_elf_export_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)

{

  struct bfd_link_info *info;

  struct m68hc11_elf_link_hash_table *htab;

  struct elf32_m68hc11_stub_hash_entry *stub_entry;

  char* name;

  bfd_boolean result;

  info = (struct bfd_link_info *) in_arg;

  htab = m68hc11_elf_hash_table (info);

  /* Massage our args to the form they really have.  */

  stub_entry = (struct elf32_m68hc11_stub_hash_entry *) gen_entry;

  /* Generate the trampoline according to HC11 or HC12.  */

  result = (* htab->build_one_stub) (gen_entry, in_arg);

  /* Make a printable name that does not conflict with the real function.  */

  name = alloca (strlen (stub_entry->root.string) + 16);

  sprintf (name, "tramp.%s", stub_entry->root.string);

  /* Export the symbol for debugging/disassembling.  */

  m68hc11_elf_set_symbol (htab->stub_bfd, info, name,

                          stub_entry->stub_offset,

                          stub_entry->stub_sec);

  return result;

}

/* Export a symbol or set its value and section.  */

static void

m68hc11_elf_set_symbol (bfd *abfd, struct bfd_link_info *info,

                        const char *name, bfd_vma value, asection *sec)

{

  struct elf_link_hash_entry *h;

  h = (struct elf_link_hash_entry *)

    bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, FALSE);

  if (h == NULL)

    {

      _bfd_generic_link_add_one_symbol (info, abfd,

                                        name,

                                        BSF_GLOBAL,

                                        sec,

                                        value,

                                        (const char*) NULL,

                                        TRUE, FALSE, NULL);

    }

  else

    {

      h->root.type = bfd_link_hash_defined;

      h->root.u.def.value = value;

      h->root.u.def.section = sec;

    }

}

/* Build all the stubs associated with the current output file.  The

   stubs are kept in a hash table attached to the main linker hash

   table.  This function is called via m68hc12elf_finish in the

   linker.  */

bfd_boolean

elf32_m68hc11_build_stubs (bfd *abfd, struct bfd_link_info *info)

{

  asection *stub_sec;

  struct bfd_hash_table *table;

  struct m68hc11_elf_link_hash_table *htab;

  struct m68hc11_scan_param param;

  m68hc11_elf_get_bank_parameters (info);

  htab = m68hc11_elf_hash_table (info);

  for (stub_sec = htab->stub_bfd->sections;

       stub_sec != NULL;

       stub_sec = stub_sec->next)

    {

      bfd_size_type size;

      /* Allocate memory to hold the linker stubs.  */

      size = stub_sec->size;

      stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);

      if (stub_sec->contents == NULL && size != 0)

        return FALSE;

      stub_sec->size = 0;

    }

  /* Build the stubs as directed by the stub hash table.  */

  table = htab->stub_hash_table;

  bfd_hash_traverse (table, m68hc11_elf_export_one_stub, info);

  /* Scan the output sections to see if we use the memory banks.

     If so, export the symbols that define how the memory banks

     are mapped.  This is used by gdb and the simulator to obtain

     the information.  It can be used by programs to burn the eprom

     at the good addresses.  */

  param.use_memory_banks = FALSE;

  param.pinfo = &htab->pinfo;

  bfd_map_over_sections (abfd, scan_sections_for_abi, &param);

  if (param.use_memory_banks)

    {

      m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_START_NAME,

                              htab->pinfo.bank_physical,

                              bfd_abs_section_ptr);

      m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_VIRTUAL_NAME,

                              htab->pinfo.bank_virtual,

                              bfd_abs_section_ptr);

      m68hc11_elf_set_symbol (abfd, info, BFD_M68HC11_BANK_SIZE_NAME,

                              htab->pinfo.bank_size,

                              bfd_abs_section_ptr);

    }

  return TRUE;

}

void

m68hc11_elf_get_bank_parameters (struct bfd_link_info *info)

{

  unsigned i;

  struct m68hc11_page_info *pinfo;

  struct bfd_link_hash_entry *h;

  pinfo = &m68hc11_elf_hash_table (info)->pinfo;

  if (pinfo->bank_param_initialized)

    return;

  pinfo->bank_virtual = M68HC12_BANK_VIRT;

  pinfo->bank_mask = M68HC12_BANK_MASK;

  pinfo->bank_physical = M68HC12_BANK_BASE;

  pinfo->bank_shift = M68HC12_BANK_SHIFT;

  pinfo->bank_size = 1 << M68HC12_BANK_SHIFT;