Subversion Repositories or1k

/* Matsushita 10200 specific support for 32-bit ELF

   Copyright 1996, 1997, 1998, 1999, 2000, 2001

   Free Software Foundation, Inc.

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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "bfd.h"

#include "sysdep.h"

#include "libbfd.h"

#include "elf-bfd.h"

static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup

  PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));

static void mn10200_info_to_howto

  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));

static boolean mn10200_elf_relax_delete_bytes

  PARAMS ((bfd *, asection *, bfd_vma, int));

static boolean mn10200_elf_symbol_address_p

  PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));

/* We have to use RELA instructions since md_apply_fix3 in the assembler

   does absolutely nothing.  */

#define USE_RELA

enum reloc_type {

  R_MN10200_NONE = 0,

  R_MN10200_32,

  R_MN10200_16,

  R_MN10200_8,

  R_MN10200_24,

  R_MN10200_PCREL8,

  R_MN10200_PCREL16,

  R_MN10200_PCREL24,

  R_MN10200_MAX

};

static reloc_howto_type elf_mn10200_howto_table[] = {

  /* Dummy relocation.  Does nothing.  */

  HOWTO (R_MN10200_NONE,

         0,

         2,

         16,

         false,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_NONE",

         false,

         0,

         0,

         false),

  /* Standard 32 bit reloc.  */

  HOWTO (R_MN10200_32,

         0,

         2,

         32,

         false,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_32",

         false,

         0xffffffff,

         0xffffffff,

         false),

  /* Standard 16 bit reloc.  */

  HOWTO (R_MN10200_16,

         0,

         1,

         16,

         false,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_16",

         false,

         0xffff,

         0xffff,

         false),

  /* Standard 8 bit reloc.  */

  HOWTO (R_MN10200_8,

         0,

         0,

         8,

         false,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_8",

         false,

         0xff,

         0xff,

         false),

  /* Standard 24 bit reloc.  */

  HOWTO (R_MN10200_24,

         0,

         2,

         24,

         false,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_24",

         false,

         0xffffff,

         0xffffff,

         false),

  /* Simple 8 pc-relative reloc.  */

  HOWTO (R_MN10200_PCREL8,

         0,

         0,

         8,

         true,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_PCREL8",

         false,

         0xff,

         0xff,

         true),

  /* Simple 16 pc-relative reloc.  */

  HOWTO (R_MN10200_PCREL16,

         0,

         1,

         16,

         true,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_PCREL16",

         false,

         0xffff,

         0xffff,

         true),

  /* Simple 32bit pc-relative reloc with a 1 byte adjustment

     to get the pc-relative offset correct.  */

  HOWTO (R_MN10200_PCREL24,

         0,

         2,

         24,

         true,

         0,

         complain_overflow_bitfield,

         bfd_elf_generic_reloc,

         "R_MN10200_PCREL24",

         false,

         0xffffff,

         0xffffff,

         true),

};

struct mn10200_reloc_map {

  bfd_reloc_code_real_type bfd_reloc_val;

  unsigned char elf_reloc_val;

};

static const struct mn10200_reloc_map mn10200_reloc_map[] = {

  { BFD_RELOC_NONE    , R_MN10200_NONE   , },

  { BFD_RELOC_32      , R_MN10200_32     , },

  { BFD_RELOC_16      , R_MN10200_16     , },

  { BFD_RELOC_8       , R_MN10200_8      , },

  { BFD_RELOC_24      , R_MN10200_24     , },

  { BFD_RELOC_8_PCREL , R_MN10200_PCREL8 , },

  { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },

  { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },

};

static reloc_howto_type *

bfd_elf32_bfd_reloc_type_lookup (abfd, code)

     bfd *abfd ATTRIBUTE_UNUSED;

     bfd_reloc_code_real_type code;

{

  unsigned int i;

  for (i = 0;

       i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);

       i++)

    {

      if (mn10200_reloc_map[i].bfd_reloc_val == code)

        return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];

    }

  return NULL;

}

/* Set the howto pointer for an MN10200 ELF reloc.  */

static void

mn10200_info_to_howto (abfd, cache_ptr, dst)

     bfd *abfd ATTRIBUTE_UNUSED;

     arelent *cache_ptr;

     Elf32_Internal_Rela *dst;

{

  unsigned int r_type;

  r_type = ELF32_R_TYPE (dst->r_info);

  BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX);

  cache_ptr->howto = &elf_mn10200_howto_table[r_type];

}

/* Perform a relocation as part of a final link.  */

static bfd_reloc_status_type

mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,

                                 input_section, contents, offset, value,

                                 addend, info, sym_sec, is_local)

     reloc_howto_type *howto;

     bfd *input_bfd;

     bfd *output_bfd ATTRIBUTE_UNUSED;

     asection *input_section;

     bfd_byte *contents;

     bfd_vma offset;

     bfd_vma value;

     bfd_vma addend;

     struct bfd_link_info *info ATTRIBUTE_UNUSED;

     asection *sym_sec ATTRIBUTE_UNUSED;

     int is_local ATTRIBUTE_UNUSED;

{

  unsigned long r_type = howto->type;

  bfd_byte *hit_data = contents + offset;

  switch (r_type)

    {

    case R_MN10200_NONE:

      return bfd_reloc_ok;

    case R_MN10200_32:

      value += addend;

      bfd_put_32 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_16:

      value += addend;

      if ((long) value > 0x7fff || (long) value < -0x8000)

        return bfd_reloc_overflow;

      bfd_put_16 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_8:

      value += addend;

      if ((long) value > 0x7f || (long) value < -0x80)

        return bfd_reloc_overflow;

      bfd_put_8 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_24:

      value += addend;

      if ((long) value > 0x7fffff || (long) value < -0x800000)

        return bfd_reloc_overflow;

      value &= 0xffffff;

      value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);

      bfd_put_32 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_PCREL8:

      value -= (input_section->output_section->vma

                + input_section->output_offset);

      value -= (offset + 1);

      value += addend;

      if ((long) value > 0xff || (long) value < -0x100)

        return bfd_reloc_overflow;

      bfd_put_8 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_PCREL16:

      value -= (input_section->output_section->vma

                + input_section->output_offset);

      value -= (offset + 2);

      value += addend;

      if ((long) value > 0xffff || (long) value < -0x10000)

        return bfd_reloc_overflow;

      bfd_put_16 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    case R_MN10200_PCREL24:

      value -= (input_section->output_section->vma

                + input_section->output_offset);

      value -= (offset + 3);

      value += addend;

      if ((long) value > 0xffffff || (long) value < -0x1000000)

        return bfd_reloc_overflow;

      value &= 0xffffff;

      value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);

      bfd_put_32 (input_bfd, value, hit_data);

      return bfd_reloc_ok;

    default:

      return bfd_reloc_notsupported;

    }

}

/* Relocate an MN10200 ELF section.  */

static boolean

mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section,

                              contents, relocs, local_syms, local_sections)

     bfd *output_bfd;

     struct bfd_link_info *info;

     bfd *input_bfd;

     asection *input_section;

     bfd_byte *contents;

     Elf_Internal_Rela *relocs;

     Elf_Internal_Sym *local_syms;

     asection **local_sections;

{

  Elf_Internal_Shdr *symtab_hdr;

  struct elf_link_hash_entry **sym_hashes;

  Elf_Internal_Rela *rel, *relend;

  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;

  sym_hashes = elf_sym_hashes (input_bfd);

  rel = relocs;

  relend = relocs + input_section->reloc_count;

  for (; rel < relend; rel++)

    {

      int r_type;

      reloc_howto_type *howto;

      unsigned long r_symndx;

      Elf_Internal_Sym *sym;

      asection *sec;

      struct elf_link_hash_entry *h;

      bfd_vma relocation;

      bfd_reloc_status_type r;

      r_symndx = ELF32_R_SYM (rel->r_info);

      r_type = ELF32_R_TYPE (rel->r_info);

      howto = elf_mn10200_howto_table + r_type;

      if (info->relocateable)

        {

          /* This is a relocateable link.  We don't have to change

             anything, unless the reloc is against a section symbol,

             in which case we have to adjust according to where the

             section symbol winds up in the output section.  */

          if (r_symndx < symtab_hdr->sh_info)

            {

              sym = local_syms + r_symndx;

              if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)

                {

                  sec = local_sections[r_symndx];

                  rel->r_addend += sec->output_offset + sym->st_value;

                }

            }

          continue;

        }

      /* This is a final link.  */

      h = NULL;

      sym = NULL;

      sec = NULL;

      if (r_symndx < symtab_hdr->sh_info)

        {

          sym = local_syms + r_symndx;

          sec = local_sections[r_symndx];

          relocation = (sec->output_section->vma

                        + sec->output_offset

                        + sym->st_value);

        }

      else

        {

          h = sym_hashes[r_symndx - symtab_hdr->sh_info];

          while (h->root.type == bfd_link_hash_indirect

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

            h = (struct elf_link_hash_entry *) h->root.u.i.link;

          if (h->root.type == bfd_link_hash_defined

              || h->root.type == bfd_link_hash_defweak)

            {

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

              relocation = (h->root.u.def.value

                            + sec->output_section->vma

                            + sec->output_offset);

            }

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

            relocation = 0;

          else

            {

              if (! ((*info->callbacks->undefined_symbol)

                     (info, h->root.root.string, input_bfd,

                      input_section, rel->r_offset, true)))

                return false;

              relocation = 0;

            }

        }

      r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,

                                           input_section,

                                           contents, rel->r_offset,

                                           relocation, rel->r_addend,

                                           info, sec, h == NULL);

      if (r != bfd_reloc_ok)

        {

          const char *name;

          const char *msg = (const char *) 0;

          if (h != NULL)

            name = h->root.root.string;

          else

            {

              name = (bfd_elf_string_from_elf_section

                      (input_bfd, symtab_hdr->sh_link, sym->st_name));

              if (name == NULL || *name == '\0')

                name = bfd_section_name (input_bfd, sec);

            }

          switch (r)

            {

            case bfd_reloc_overflow:

              if (! ((*info->callbacks->reloc_overflow)

                     (info, name, howto->name, (bfd_vma) 0,

                      input_bfd, input_section, rel->r_offset)))

                return false;

              break;

            case bfd_reloc_undefined:

              if (! ((*info->callbacks->undefined_symbol)

                     (info, name, input_bfd, input_section,

                      rel->r_offset, true)))

                return false;

              break;

            case bfd_reloc_outofrange:

              msg = _("internal error: out of range error");

              goto common_error;

            case bfd_reloc_notsupported:

              msg = _("internal error: unsupported relocation error");

              goto common_error;

            case bfd_reloc_dangerous:

              msg = _("internal error: dangerous error");

              goto common_error;

            default:

              msg = _("internal error: unknown error");

              /* fall through */

            common_error:

              if (!((*info->callbacks->warning)

                    (info, msg, name, input_bfd, input_section,

                     rel->r_offset)))

                return false;

              break;

            }

        }

    }

  return true;

}

/* This function handles relaxing for the mn10200.

   There's quite a few relaxing opportunites available on the mn10200:

        * jsr:24 -> jsr:16                                         2 bytes

        * jmp:24 -> jmp:16                                         2 bytes

        * jmp:16 -> bra:8                                          1 byte

                * If the previous instruction is a conditional branch

                around the jump/bra, we may be able to reverse its condition

                and change its target to the jump's target.  The jump/bra

                can then be deleted.                               2 bytes

        * mov abs24 -> mov abs16        2 byte savings

        * Most instructions which accept imm24 can relax to imm16  2 bytes

        - Most instructions which accept imm16 can relax to imm8   1 byte

        * Most instructions which accept d24 can relax to d16      2 bytes

        - Most instructions which accept d16 can relax to d8       1 byte

        abs24, imm24, d24 all look the same at the reloc level.  It

        might make the code simpler if we had different relocs for

        the various relaxable operand types.

        We don't handle imm16->imm8 or d16->d8 as they're very rare

        and somewhat more difficult to support.  */

static boolean

mn10200_elf_relax_section (abfd, sec, link_info, again)

     bfd *abfd;

     asection *sec;

     struct bfd_link_info *link_info;

     boolean *again;

{

  Elf_Internal_Shdr *symtab_hdr;

  Elf_Internal_Rela *internal_relocs;

  Elf_Internal_Rela *free_relocs = NULL;

  Elf_Internal_Rela *irel, *irelend;

  bfd_byte *contents = NULL;

  bfd_byte *free_contents = NULL;

  Elf32_External_Sym *extsyms = NULL;

  Elf32_External_Sym *free_extsyms = NULL;

  /* Assume nothing changes.  */

  *again = false;

  /* We don't have to do anything for a relocateable link, if

     this section does not have relocs, or if this is not a

     code section.  */

  if (link_info->relocateable

      || (sec->flags & SEC_RELOC) == 0

      || sec->reloc_count == 0

      || (sec->flags & SEC_CODE) == 0)

    return true;

  /* If this is the first time we have been called for this section,

     initialize the cooked size.  */

  if (sec->_cooked_size == 0)

    sec->_cooked_size = sec->_raw_size;

  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;

  /* Get a copy of the native relocations.  */

  internal_relocs = (_bfd_elf32_link_read_relocs

                     (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,

                      link_info->keep_memory));

  if (internal_relocs == NULL)

    goto error_return;

  if (! link_info->keep_memory)

    free_relocs = internal_relocs;

  /* Walk through them looking for relaxing opportunities.  */

  irelend = internal_relocs + sec->reloc_count;

  for (irel = internal_relocs; irel < irelend; irel++)

    {

      bfd_vma symval;

      /* If this isn't something that can be relaxed, then ignore

         this reloc.  */

      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE

          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8

          || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)

        continue;

      /* Get the section contents if we haven't done so already.  */

      if (contents == NULL)

        {

          /* Get cached copy if it exists.  */

          if (elf_section_data (sec)->this_hdr.contents != NULL)

            contents = elf_section_data (sec)->this_hdr.contents;

          else

            {

              /* Go get them off disk.  */

              contents = (bfd_byte *) bfd_malloc (sec->_raw_size);

              if (contents == NULL)

                goto error_return;

              free_contents = contents;

              if (! bfd_get_section_contents (abfd, sec, contents,

                                              (file_ptr) 0, sec->_raw_size))

                goto error_return;

            }

        }

      /* Read this BFD's symbols if we haven't done so already.  */

      if (extsyms == NULL)

        {

          /* Get cached copy if it exists.  */

          if (symtab_hdr->contents != NULL)

            extsyms = (Elf32_External_Sym *) symtab_hdr->contents;

          else

            {

              /* Go get them off disk.  */

              extsyms = ((Elf32_External_Sym *)

                         bfd_malloc (symtab_hdr->sh_size));

              if (extsyms == NULL)

                goto error_return;

              free_extsyms = extsyms;

              if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0

                  || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)

                      != symtab_hdr->sh_size))

                goto error_return;

            }

        }

      /* Get the value of the symbol referred to by the reloc.  */

      if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)

        {

          Elf_Internal_Sym isym;

          asection *sym_sec;

          /* A local symbol.  */

          bfd_elf32_swap_symbol_in (abfd,

                                    extsyms + ELF32_R_SYM (irel->r_info),

                                    &isym);

          sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);

          symval = (isym.st_value

                    + sym_sec->output_section->vma

                    + sym_sec->output_offset);

        }

      else

        {

          unsigned long indx;

          struct elf_link_hash_entry *h;

          /* An external symbol.  */

          indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;

          h = elf_sym_hashes (abfd)[indx];

          BFD_ASSERT (h != NULL);

          if (h->root.type != bfd_link_hash_defined

              && h->root.type != bfd_link_hash_defweak)

            {

              /* This appears to be a reference to an undefined

                 symbol.  Just ignore it--it will be caught by the

                 regular reloc processing.  */

              continue;

            }

          symval = (h->root.u.def.value

                    + h->root.u.def.section->output_section->vma

                    + h->root.u.def.section->output_offset);

        }

      /* For simplicity of coding, we are going to modify the section

         contents, the section relocs, and the BFD symbol table.  We

         must tell the rest of the code not to free up this

         information.  It would be possible to instead create a table

         of changes which have to be made, as is done in coff-mips.c;

         that would be more work, but would require less memory when

         the linker is run.  */

      /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative

         branch/call.  */

      if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)

        {

          bfd_vma value = symval;

          /* Deal with pc-relative gunk.  */

          value -= (sec->output_section->vma + sec->output_offset);

          value -= (irel->r_offset + 3);

          value += irel->r_addend;

          /* See if the value will fit in 16 bits, note the high value is

             0x7fff + 2 as the target will be two bytes closer if we are

             able to relax.  */

          if ((long) value < 0x8001 && (long) value > -0x8000)

            {

              unsigned char code;

              /* Get the opcode.  */

              code = bfd_get_8 (abfd, contents + irel->r_offset - 1);

              if (code != 0xe0 && code != 0xe1)

                continue;

              /* Note that we've changed the relocs, section contents, etc.  */

              elf_section_data (sec)->relocs = internal_relocs;

              free_relocs = NULL;

              elf_section_data (sec)->this_hdr.contents = contents;

              free_contents = NULL;

              symtab_hdr->contents = (bfd_byte *) extsyms;

              free_extsyms = NULL;

              /* Fix the opcode.  */

              if (code == 0xe0)

                bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);

              else if (code == 0xe1)

                bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);

              /* Fix the relocation's type.  */