[binutils.git] / bfd / elf32-msp430.c

/*  MSP430-specific support for 32-bit ELF
    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Dmitry Diky <[email protected]>

    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 "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/msp430.h"

static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
  PARAMS ((bfd *, bfd_reloc_code_real_type));

static void msp430_info_to_howto_rela
  PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));

static asection *elf32_msp430_gc_mark_hook
  PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
	   struct elf_link_hash_entry *, Elf_Internal_Sym *));

static bfd_boolean elf32_msp430_gc_sweep_hook
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
	   const Elf_Internal_Rela *));

static bfd_boolean elf32_msp430_check_relocs
  PARAMS ((bfd *, struct bfd_link_info *, asection *,
	   const Elf_Internal_Rela *));

static bfd_reloc_status_type msp430_final_link_relocate
  PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
	   Elf_Internal_Rela *, bfd_vma));

static bfd_boolean elf32_msp430_relocate_section
  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
	   Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));

static void bfd_elf_msp430_final_write_processing
  PARAMS ((bfd *, bfd_boolean));

static bfd_boolean elf32_msp430_object_p
  PARAMS ((bfd *));

static void elf32_msp430_post_process_headers
  PARAMS ((bfd *, struct bfd_link_info *));

/* Use RELA instead of REL.  */
#undef USE_REL

static reloc_howto_type elf_msp430_howto_table[] =
{
  HOWTO (R_MSP430_NONE,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield,	/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_NONE",	/* name */
	 FALSE,			/* partial_inplace */
	 0,			/* src_mask */
	 0,			/* dst_mask */
	 FALSE),		/* pcrel_offset */

  HOWTO (R_MSP430_32,		/* type */
	 0,			/* rightshift */
	 2,			/* size (0 = byte, 1 = short, 2 = long) */
	 32,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield,	/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_32",		/* name */
	 FALSE,			/* partial_inplace */
	 0xffffffff,		/* src_mask */
	 0xffffffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A 13 bit PC relative relocation.  */
  HOWTO (R_MSP430_10_PCREL,	/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 10,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_bitfield,	/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_13_PCREL",	/* name */
	 FALSE,			/* partial_inplace */
	 0xfff,			/* src_mask */
	 0xfff,			/* dst_mask */
	 TRUE),			/* pcrel_offset */

  /* A 16 bit absolute relocation.  */
  HOWTO (R_MSP430_16,		/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_16",		/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A 16 bit absolute relocation for command address.  */
  HOWTO (R_MSP430_16_PCREL,	/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_16_PCREL",	/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 TRUE),			/* pcrel_offset */

  /* A 16 bit absolute relocation, byte operations.  */
  HOWTO (R_MSP430_16_BYTE,	/* type */
	 0,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 FALSE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_16_BYTE",	/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 FALSE),		/* pcrel_offset */

  /* A 16 bit absolute relocation for command address.  */
  HOWTO (R_MSP430_16_PCREL_BYTE,/* type */
	 1,			/* rightshift */
	 1,			/* size (0 = byte, 1 = short, 2 = long) */
	 16,			/* bitsize */
	 TRUE,			/* pc_relative */
	 0,			/* bitpos */
	 complain_overflow_dont,/* complain_on_overflow */
	 bfd_elf_generic_reloc,	/* special_function */
	 "R_MSP430_16_PCREL_BYTE",	/* name */
	 FALSE,			/* partial_inplace */
	 0xffff,		/* src_mask */
	 0xffff,		/* dst_mask */
	 TRUE)			/* pcrel_offset */
};

/* Map BFD reloc types to MSP430 ELF reloc types.  */

struct msp430_reloc_map
{
  bfd_reloc_code_real_type bfd_reloc_val;
  unsigned int elf_reloc_val;
};

static const struct msp430_reloc_map msp430_reloc_map[] =
  {
    {BFD_RELOC_NONE, R_MSP430_NONE},
    {BFD_RELOC_32, R_MSP430_32},
    {BFD_RELOC_MSP430_10_PCREL, R_MSP430_10_PCREL},
    {BFD_RELOC_16, R_MSP430_16_BYTE},
    {BFD_RELOC_MSP430_16_PCREL, R_MSP430_16_PCREL},
    {BFD_RELOC_MSP430_16, R_MSP430_16},
    {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE},
    {BFD_RELOC_MSP430_16_BYTE, R_MSP430_16_BYTE}
  };

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 < ARRAY_SIZE (msp430_reloc_map); i++)
    if (msp430_reloc_map[i].bfd_reloc_val == code)
      return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val];

  return NULL;
}

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

static void
msp430_info_to_howto_rela (abfd, cache_ptr, dst)
     bfd *abfd ATTRIBUTE_UNUSED;
     arelent *cache_ptr;
     Elf_Internal_Rela *dst;
{
  unsigned int r_type;

  r_type = ELF32_R_TYPE (dst->r_info);
  BFD_ASSERT (r_type < (unsigned int) R_MSP430_max);
  cache_ptr->howto = &elf_msp430_howto_table[r_type];
}

static asection *
elf32_msp430_gc_mark_hook (sec, info, rel, h, sym)
     asection *sec;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     Elf_Internal_Rela *rel;
     struct elf_link_hash_entry *h;
     Elf_Internal_Sym *sym;
{
  if (h != NULL)
    {
      switch (ELF32_R_TYPE (rel->r_info))
	{
	default:
	  switch (h->root.type)
	    {
	    case bfd_link_hash_defined:
	    case bfd_link_hash_defweak:
	      return h->root.u.def.section;

	    case bfd_link_hash_common:
	      return h->root.u.c.p->section;

	    default:
	      break;
	    }
	}
    }
  else
    return bfd_section_from_elf_index (sec->owner, sym->st_shndx);

  return NULL;
}

static bfd_boolean
elf32_msp430_gc_sweep_hook (abfd, info, sec, relocs)
     bfd *abfd ATTRIBUTE_UNUSED;
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
     asection *sec ATTRIBUTE_UNUSED;
     const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
{
  /* We don't use got and plt entries for msp430.  */
  return TRUE;
}

/* Look through the relocs for a section during the first phase.
   Since we don't do .gots or .plts, we just need to consider the
   virtual table relocs for gc.  */

static bfd_boolean
elf32_msp430_check_relocs (abfd, info, sec, relocs)
     bfd *abfd;
     struct bfd_link_info *info;
     asection *sec;
     const Elf_Internal_Rela *relocs;
{
  Elf_Internal_Shdr *symtab_hdr;
  struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
  const Elf_Internal_Rela *rel;
  const Elf_Internal_Rela *rel_end;

  if (info->relocatable)
    return TRUE;

  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (abfd);
  sym_hashes_end =
      sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
  if (!elf_bad_symtab (abfd))
    sym_hashes_end -= symtab_hdr->sh_info;

  rel_end = relocs + sec->reloc_count;
  for (rel = relocs; rel < rel_end; rel++)
    {
      struct elf_link_hash_entry *h;
      unsigned long r_symndx;

      r_symndx = ELF32_R_SYM (rel->r_info);
      if (r_symndx < symtab_hdr->sh_info)
	h = NULL;
      else
	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
    }

  return TRUE;
}

/* Perform a single relocation.  By default we use the standard BFD
   routines, but a few relocs, we have to do them ourselves.  */

static bfd_reloc_status_type
msp430_final_link_relocate (howto, input_bfd, input_section,
			    contents, rel, relocation)
     reloc_howto_type *howto;
     bfd *input_bfd;
     asection *input_section;
     bfd_byte *contents;
     Elf_Internal_Rela *rel;
     bfd_vma relocation;
{
  bfd_reloc_status_type r = bfd_reloc_ok;
  bfd_vma x;
  bfd_signed_vma srel;

  switch (howto->type)
    {
    case R_MSP430_10_PCREL:
      contents += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      srel -= rel->r_offset;
      srel -= 2;		/* Branch instructions add 2 to the PC...  */
      srel -= (input_section->output_section->vma +
	       input_section->output_offset);

      if (srel & 1)
	return bfd_reloc_outofrange;

      /* MSP430 addresses commands as words.  */
      srel >>= 1;

      /* Check for an overflow.  */
      if (srel < -512 || srel > 511)
	return bfd_reloc_overflow;

      x = bfd_get_16 (input_bfd, contents);
      x = (x & 0xfc00) | (srel & 0x3ff);
      bfd_put_16 (input_bfd, x, contents);
      break;

    case R_MSP430_16_PCREL:
      contents += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      srel -= rel->r_offset;
      /* Only branch instructions add 2 to the PC...  */
      srel -= (input_section->output_section->vma +
	       input_section->output_offset);

      if (srel & 1)
	return bfd_reloc_outofrange;

      bfd_put_16 (input_bfd, srel & 0xffff, contents);
      break;

    case R_MSP430_16_PCREL_BYTE:
      contents += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      srel -= rel->r_offset;
      /* Only branch instructions add 2 to the PC...  */
      srel -= (input_section->output_section->vma +
	       input_section->output_offset);

      bfd_put_16 (input_bfd, srel & 0xffff, contents);
      break;

    case R_MSP430_16_BYTE:
      contents += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;
      bfd_put_16 (input_bfd, srel & 0xffff, contents);
      break;

    case R_MSP430_16:
      contents += rel->r_offset;
      srel = (bfd_signed_vma) relocation;
      srel += rel->r_addend;

      if (srel & 1)
	return bfd_reloc_notsupported;

      bfd_put_16 (input_bfd, srel & 0xffff, contents);
      break;

    default:
      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
				    contents, rel->r_offset,
				    relocation, rel->r_addend);
    }

  return r;
}

/* Relocate an MSP430 ELF section.  */

static bfd_boolean
elf32_msp430_relocate_section (output_bfd, info, input_bfd, input_section,
			       contents, relocs, local_syms, local_sections)
     bfd *output_bfd ATTRIBUTE_UNUSED;
     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;
  Elf_Internal_Rela *relend;

  symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
  sym_hashes = elf_sym_hashes (input_bfd);
  relend = relocs + input_section->reloc_count;

  for (rel = relocs; rel < relend; rel++)
    {
      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;
      const char *name = NULL;
      int r_type;

      /* This is a final link.  */

      r_type = ELF32_R_TYPE (rel->r_info);
      r_symndx = ELF32_R_SYM (rel->r_info);
      howto = elf_msp430_howto_table + ELF32_R_TYPE (rel->r_info);
      h = NULL;
      sym = NULL;
      sec = NULL;

      if (r_symndx < symtab_hdr->sh_info)
	{
	  sym = local_syms + r_symndx;
	  sec = local_sections[r_symndx];
	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);

	  name = bfd_elf_string_from_elf_section
	      (input_bfd, symtab_hdr->sh_link, sym->st_name);
	  name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	}
      else
	{
	  bfd_boolean unresolved_reloc, warned;

	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
				   r_symndx, symtab_hdr, sym_hashes,
				   h, sec, relocation,
				   unresolved_reloc, warned);
	}

      r = msp430_final_link_relocate (howto, input_bfd, input_section,
				      contents, rel, relocation);

      if (r != bfd_reloc_ok)
	{
	  const char *msg = (const char *) NULL;

	  switch (r)
	    {
	    case bfd_reloc_overflow:
	      r = info->callbacks->reloc_overflow
		  (info, name, howto->name, (bfd_vma) 0,
		   input_bfd, input_section, rel->r_offset);
	      break;

	    case bfd_reloc_undefined:
	      r = info->callbacks->undefined_symbol
		  (info, name, input_bfd, input_section, rel->r_offset, TRUE);
	      break;

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

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

	    case bfd_reloc_dangerous:
	      msg = _("internal error: dangerous relocation");
	      break;

	    default:
	      msg = _("internal error: unknown error");
	      break;
	    }

	  if (msg)
	    r = info->callbacks->warning
		(info, msg, name, input_bfd, input_section, rel->r_offset);

	  if (!r)
	    return FALSE;
	}

    }

  return TRUE;
}

/* The final processing done just before writing out a MSP430 ELF object
   file.  This gets the MSP430 architecture right based on the machine
   number.  */

static void
bfd_elf_msp430_final_write_processing (abfd, linker)
     bfd *abfd;
     bfd_boolean linker ATTRIBUTE_UNUSED;
{
  unsigned long val;

  switch (bfd_get_mach (abfd))
    {
    default:
    case bfd_mach_msp110:
      val = E_MSP430_MACH_MSP430x11x1;
      break;

    case bfd_mach_msp11:
      val = E_MSP430_MACH_MSP430x11;
      break;

    case bfd_mach_msp12:
      val = E_MSP430_MACH_MSP430x12;
      break;

    case bfd_mach_msp13:
      val = E_MSP430_MACH_MSP430x13;
      break;

    case bfd_mach_msp14:
      val = E_MSP430_MACH_MSP430x14;
      break;

    case bfd_mach_msp15:
      val = E_MSP430_MACH_MSP430x15;
      break;

    case bfd_mach_msp16:
      val = E_MSP430_MACH_MSP430x16;
      break;

    case bfd_mach_msp31:
      val = E_MSP430_MACH_MSP430x31;
      break;

    case bfd_mach_msp32:
      val = E_MSP430_MACH_MSP430x32;
      break;

    case bfd_mach_msp33:
      val = E_MSP430_MACH_MSP430x33;
      break;

    case bfd_mach_msp41:
      val = E_MSP430_MACH_MSP430x41;
      break;

    case bfd_mach_msp42:
      val = E_MSP430_MACH_MSP430x42;
      break;

    case bfd_mach_msp43:
      val = E_MSP430_MACH_MSP430x43;
      break;

    case bfd_mach_msp44:
      val = E_MSP430_MACH_MSP430x44;
      break;
    }

  elf_elfheader (abfd)->e_machine = EM_MSP430;
  elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
  elf_elfheader (abfd)->e_flags |= val;
}

/* Set the right machine number.  */

static bfd_boolean
elf32_msp430_object_p (abfd)
     bfd *abfd;
{
  int e_set = bfd_mach_msp14;

  if (elf_elfheader (abfd)->e_machine == EM_MSP430
      || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
    {
      int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;

      switch (e_mach)
	{
	default:
	case E_MSP430_MACH_MSP430x11:
	  e_set = bfd_mach_msp11;
	  break;

	case E_MSP430_MACH_MSP430x11x1:
	  e_set = bfd_mach_msp110;
	  break;

	case E_MSP430_MACH_MSP430x12:
	  e_set = bfd_mach_msp12;
	  break;

	case E_MSP430_MACH_MSP430x13:
	  e_set = bfd_mach_msp13;
	  break;

	case E_MSP430_MACH_MSP430x14:
	  e_set = bfd_mach_msp14;
	  break;

	case E_MSP430_MACH_MSP430x15:
	  e_set = bfd_mach_msp15;
	  break;

	case E_MSP430_MACH_MSP430x16:
	  e_set = bfd_mach_msp16;
	  break;

	case E_MSP430_MACH_MSP430x31:
	  e_set = bfd_mach_msp31;
	  break;

	case E_MSP430_MACH_MSP430x32:
	  e_set = bfd_mach_msp32;
	  break;

	case E_MSP430_MACH_MSP430x33:
	  e_set = bfd_mach_msp33;
	  break;

	case E_MSP430_MACH_MSP430x41:
	  e_set = bfd_mach_msp41;
	  break;

	case E_MSP430_MACH_MSP430x42:
	  e_set = bfd_mach_msp42;
	  break;

	case E_MSP430_MACH_MSP430x43:
	  e_set = bfd_mach_msp43;
	  break;

	case E_MSP430_MACH_MSP430x44:
	  e_set = bfd_mach_msp44;
	  break;
	}
    }

  return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
}

static void
elf32_msp430_post_process_headers (abfd, link_info)
     bfd *abfd;
     struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
{
  Elf_Internal_Ehdr *i_ehdrp;	/* ELF file header, internal form.  */

  i_ehdrp = elf_elfheader (abfd);

#ifndef ELFOSABI_STANDALONE
#define ELFOSABI_STANDALONE	255
#endif

  i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE;
}


#define ELF_ARCH		bfd_arch_msp430
#define ELF_MACHINE_CODE	EM_MSP430
#define ELF_MACHINE_ALT1	EM_MSP430_OLD
#define ELF_MAXPAGESIZE		1

#define TARGET_LITTLE_SYM       bfd_elf32_msp430_vec
#define TARGET_LITTLE_NAME	"elf32-msp430"

#define elf_info_to_howto	             msp430_info_to_howto_rela
#define elf_info_to_howto_rel	             NULL
#define elf_backend_relocate_section         elf32_msp430_relocate_section
#define elf_backend_gc_mark_hook             elf32_msp430_gc_mark_hook
#define elf_backend_gc_sweep_hook            elf32_msp430_gc_sweep_hook
#define elf_backend_check_relocs             elf32_msp430_check_relocs
#define elf_backend_can_gc_sections          1
#define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
#define elf_backend_object_p		     elf32_msp430_object_p
#define elf_backend_post_process_headers     elf32_msp430_post_process_headers

#include "elf32-target.h"
Commit	Line	Data
2469cfa2	1	/* MSP430-specific support for 32-bit ELF
b2a8e766	2	Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
2469cfa2 NC	3	Contributed by Dmitry Diky <[email protected]>
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 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 "libiberty.h"
	24	#include "libbfd.h"
	25	#include "elf-bfd.h"
	26	#include "elf/msp430.h"
	27
	28	static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
	29	PARAMS ((bfd *, bfd_reloc_code_real_type));
	30
	31	static void msp430_info_to_howto_rela
	32	PARAMS ((bfd , arelent , Elf_Internal_Rela *));
	33
	34	static asection *elf32_msp430_gc_mark_hook
	35	PARAMS ((asection , struct bfd_link_info , Elf_Internal_Rela *,
	36	struct elf_link_hash_entry , Elf_Internal_Sym ));
	37
	38	static bfd_boolean elf32_msp430_gc_sweep_hook
	39	PARAMS ((bfd , struct bfd_link_info , asection *,
	40	const Elf_Internal_Rela *));
	41
	42	static bfd_boolean elf32_msp430_check_relocs
	43	PARAMS ((bfd , struct bfd_link_info , asection *,
	44	const Elf_Internal_Rela *));
	45
	46	static bfd_reloc_status_type msp430_final_link_relocate
	47	PARAMS ((reloc_howto_type , bfd , asection , bfd_byte ,
	48	Elf_Internal_Rela *, bfd_vma));
	49
	50	static bfd_boolean elf32_msp430_relocate_section
	51	PARAMS ((bfd , struct bfd_link_info , bfd , asection , bfd_byte *,
	52	Elf_Internal_Rela , Elf_Internal_Sym , asection **));
	53
	54	static void bfd_elf_msp430_final_write_processing
	55	PARAMS ((bfd *, bfd_boolean));
	56
	57	static bfd_boolean elf32_msp430_object_p
	58	PARAMS ((bfd *));
	59
	60	static void elf32_msp430_post_process_headers
	61	PARAMS ((bfd , struct bfd_link_info ));
	62
	63	/* Use RELA instead of REL. */
	64	#undef USE_REL
	65
	66	static reloc_howto_type elf_msp430_howto_table[] =
67	{
68	HOWTO (R_MSP430_NONE, /* type */
69	0, /* rightshift */
70	2, /* size (0 = byte, 1 = short, 2 = long) */
71	32, /* bitsize */
72	FALSE, /* pc_relative */
73	0, /* bitpos */
74	complain_overflow_bitfield, /* complain_on_overflow */
75	bfd_elf_generic_reloc, /* special_function */
76	"R_MSP430_NONE", /* name */
77	FALSE, /* partial_inplace */
78	0, /* src_mask */
79	0, /* dst_mask */
80	FALSE), /* pcrel_offset */
81
82	HOWTO (R_MSP430_32, /* type */
83	0, /* rightshift */
84	2, /* size (0 = byte, 1 = short, 2 = long) */
85	32, /* bitsize */
86	FALSE, /* pc_relative */
87	0, /* bitpos */
88	complain_overflow_bitfield, /* complain_on_overflow */
89	bfd_elf_generic_reloc, /* special_function */
90	"R_MSP430_32", /* name */
91	FALSE, /* partial_inplace */
92	0xffffffff, /* src_mask */
93	0xffffffff, /* dst_mask */
94	FALSE), /* pcrel_offset */
95
96	/* A 13 bit PC relative relocation. */
97	HOWTO (R_MSP430_10_PCREL, /* type */
98	1, /* rightshift */
99	1, /* size (0 = byte, 1 = short, 2 = long) */
100	10, /* bitsize */
101	TRUE, /* pc_relative */
102	0, /* bitpos */
103	complain_overflow_bitfield, /* complain_on_overflow */
104	bfd_elf_generic_reloc, /* special_function */
105	"R_MSP430_13_PCREL", /* name */
106	FALSE, /* partial_inplace */
107	0xfff, /* src_mask */
108	0xfff, /* dst_mask */
109	TRUE), /* pcrel_offset */
110
111	/* A 16 bit absolute relocation. */
112	HOWTO (R_MSP430_16, /* type */
113	0, /* rightshift */
114	1, /* size (0 = byte, 1 = short, 2 = long) */
115	16, /* bitsize */
116	FALSE, /* pc_relative */
117	0, /* bitpos */
118	complain_overflow_dont,/* complain_on_overflow */
119	bfd_elf_generic_reloc, /* special_function */
120	"R_MSP430_16", /* name */
121	FALSE, /* partial_inplace */
122	0xffff, /* src_mask */
123	0xffff, /* dst_mask */
124	FALSE), /* pcrel_offset */
125
126	/* A 16 bit absolute relocation for command address. */
127	HOWTO (R_MSP430_16_PCREL, /* type */
128	1, /* rightshift */
129	1, /* size (0 = byte, 1 = short, 2 = long) */
130	16, /* bitsize */
131	TRUE, /* pc_relative */
132	0, /* bitpos */
133	complain_overflow_dont,/* complain_on_overflow */
134	bfd_elf_generic_reloc, /* special_function */
135	"R_MSP430_16_PCREL", /* name */
136	FALSE, /* partial_inplace */
137	0xffff, /* src_mask */
138	0xffff, /* dst_mask */
139	TRUE), /* pcrel_offset */
140
141	/* A 16 bit absolute relocation, byte operations. */
142	HOWTO (R_MSP430_16_BYTE, /* type */
143	0, /* rightshift */
144	1, /* size (0 = byte, 1 = short, 2 = long) */
145	16, /* bitsize */
146	FALSE, /* pc_relative */
147	0, /* bitpos */
148	complain_overflow_dont,/* complain_on_overflow */
149	bfd_elf_generic_reloc, /* special_function */
150	"R_MSP430_16_BYTE", /* name */
151	FALSE, /* partial_inplace */
152	0xffff, /* src_mask */
153	0xffff, /* dst_mask */
154	FALSE), /* pcrel_offset */
155
156	/* A 16 bit absolute relocation for command address. */
157	HOWTO (R_MSP430_16_PCREL_BYTE,/* type */
158	1, /* rightshift */
159	1, /* size (0 = byte, 1 = short, 2 = long) */
160	16, /* bitsize */
161	TRUE, /* pc_relative */
162	0, /* bitpos */
163	complain_overflow_dont,/* complain_on_overflow */
164	bfd_elf_generic_reloc, /* special_function */
165	"R_MSP430_16_PCREL_BYTE", /* name */
166	FALSE, /* partial_inplace */
167	0xffff, /* src_mask */
168	0xffff, /* dst_mask */
169	TRUE) /* pcrel_offset */
170	};
171
172	/* Map BFD reloc types to MSP430 ELF reloc types. */
173
174	struct msp430_reloc_map
175	{
176	bfd_reloc_code_real_type bfd_reloc_val;
177	unsigned int elf_reloc_val;
178	};
179
180	static const struct msp430_reloc_map msp430_reloc_map[] =
181	{
182	{BFD_RELOC_NONE, R_MSP430_NONE},
183	{BFD_RELOC_32, R_MSP430_32},
184	{BFD_RELOC_MSP430_10_PCREL, R_MSP430_10_PCREL},
185	{BFD_RELOC_16, R_MSP430_16_BYTE},
186	{BFD_RELOC_MSP430_16_PCREL, R_MSP430_16_PCREL},
187	{BFD_RELOC_MSP430_16, R_MSP430_16},
188	{BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE},
189	{BFD_RELOC_MSP430_16_BYTE, R_MSP430_16_BYTE}
190	};
191
192	static reloc_howto_type *
193	bfd_elf32_bfd_reloc_type_lookup (abfd, code)
194	bfd *abfd ATTRIBUTE_UNUSED;
195	bfd_reloc_code_real_type code;
196	{
197	unsigned int i;
198
199	for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++)
200	if (msp430_reloc_map[i].bfd_reloc_val == code)
201	return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val];
202
203	return NULL;
204	}
205
206	/* Set the howto pointer for an MSP430 ELF reloc. */
207
208	static void
209	msp430_info_to_howto_rela (abfd, cache_ptr, dst)
210	bfd *abfd ATTRIBUTE_UNUSED;
211	arelent *cache_ptr;
212	Elf_Internal_Rela *dst;
213	{
214	unsigned int r_type;
215
216	r_type = ELF32_R_TYPE (dst->r_info);
217	BFD_ASSERT (r_type < (unsigned int) R_MSP430_max);
218	cache_ptr->howto = &elf_msp430_howto_table[r_type];
219	}
220
221	static asection *
222	elf32_msp430_gc_mark_hook (sec, info, rel, h, sym)
223	asection *sec;
224	struct bfd_link_info *info ATTRIBUTE_UNUSED;
225	Elf_Internal_Rela *rel;
226	struct elf_link_hash_entry *h;
227	Elf_Internal_Sym *sym;
228	{
229	if (h != NULL)
230	{
231	switch (ELF32_R_TYPE (rel->r_info))
232	{
233	default:
234	switch (h->root.type)
235	{
236	case bfd_link_hash_defined:
237	case bfd_link_hash_defweak:
238	return h->root.u.def.section;
239
240	case bfd_link_hash_common:
241	return h->root.u.c.p->section;
242
243	default:
244	break;
245	}
246	}
247	}
248	else
249	return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
250
251	return NULL;
252	}
253
254	static bfd_boolean
255	elf32_msp430_gc_sweep_hook (abfd, info, sec, relocs)
256	bfd *abfd ATTRIBUTE_UNUSED;
257	struct bfd_link_info *info ATTRIBUTE_UNUSED;
258	asection *sec ATTRIBUTE_UNUSED;
259	const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
260	{
261	/* We don't use got and plt entries for msp430. */
262	return TRUE;
263	}
264
265	/* Look through the relocs for a section during the first phase.
266	Since we don't do .gots or .plts, we just need to consider the
267	virtual table relocs for gc. */
268
269	static bfd_boolean
270	elf32_msp430_check_relocs (abfd, info, sec, relocs)
271	bfd *abfd;
272	struct bfd_link_info *info;
273	asection *sec;
274	const Elf_Internal_Rela *relocs;
275	{
276	Elf_Internal_Shdr *symtab_hdr;
277	struct elf_link_hash_entry sym_hashes, sym_hashes_end;
278	const Elf_Internal_Rela *rel;
279	const Elf_Internal_Rela *rel_end;
280
1049f94e	281	if (info->relocatable)
2469cfa2 NC	282	return TRUE;
	283
	284	symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
	285	sym_hashes = elf_sym_hashes (abfd);
	286	sym_hashes_end =
	287	sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
	288	if (!elf_bad_symtab (abfd))
	289	sym_hashes_end -= symtab_hdr->sh_info;
	290
	291	rel_end = relocs + sec->reloc_count;
	292	for (rel = relocs; rel < rel_end; rel++)
	293	{
	294	struct elf_link_hash_entry *h;
	295	unsigned long r_symndx;
	296
	297	r_symndx = ELF32_R_SYM (rel->r_info);
	298	if (r_symndx < symtab_hdr->sh_info)
	299	h = NULL;
	300	else
	301	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
	302	}
	303
	304	return TRUE;
	305	}
	306
	307	/* Perform a single relocation. By default we use the standard BFD
	308	routines, but a few relocs, we have to do them ourselves. */
	309
	310	static bfd_reloc_status_type
	311	msp430_final_link_relocate (howto, input_bfd, input_section,
	312	contents, rel, relocation)
	313	reloc_howto_type *howto;
	314	bfd *input_bfd;
	315	asection *input_section;
	316	bfd_byte *contents;
	317	Elf_Internal_Rela *rel;
	318	bfd_vma relocation;
	319	{
	320	bfd_reloc_status_type r = bfd_reloc_ok;
	321	bfd_vma x;
	322	bfd_signed_vma srel;
	323
	324	switch (howto->type)
	325	{
	326	case R_MSP430_10_PCREL:
	327	contents += rel->r_offset;
	328	srel = (bfd_signed_vma) relocation;
	329	srel += rel->r_addend;
	330	srel -= rel->r_offset;
	331	srel -= 2; /* Branch instructions add 2 to the PC... */
	332	srel -= (input_section->output_section->vma +
	333	input_section->output_offset);
	334
	335	if (srel & 1)
	336	return bfd_reloc_outofrange;
	337
	338	/* MSP430 addresses commands as words. */
	339	srel >>= 1;
	340
	341	/* Check for an overflow. */
	342	if (srel < -512 \|\| srel > 511)
	343	return bfd_reloc_overflow;
	344
	345	x = bfd_get_16 (input_bfd, contents);
346	x = (x & 0xfc00) \| (srel & 0x3ff);
347	bfd_put_16 (input_bfd, x, contents);
348	break;
349
350	case R_MSP430_16_PCREL:
351	contents += rel->r_offset;
352	srel = (bfd_signed_vma) relocation;
353	srel += rel->r_addend;
354	srel -= rel->r_offset;
355	/* Only branch instructions add 2 to the PC... */
356	srel -= (input_section->output_section->vma +
357	input_section->output_offset);
358
359	if (srel & 1)
360	return bfd_reloc_outofrange;
361
362	bfd_put_16 (input_bfd, srel & 0xffff, contents);
363	break;
364
365	case R_MSP430_16_PCREL_BYTE:
366	contents += rel->r_offset;
367	srel = (bfd_signed_vma) relocation;
368	srel += rel->r_addend;
369	srel -= rel->r_offset;
370	/* Only branch instructions add 2 to the PC... */
371	srel -= (input_section->output_section->vma +
372	input_section->output_offset);
373
374	bfd_put_16 (input_bfd, srel & 0xffff, contents);
375	break;
376
377	case R_MSP430_16_BYTE:
378	contents += rel->r_offset;
379	srel = (bfd_signed_vma) relocation;
380	srel += rel->r_addend;
381	bfd_put_16 (input_bfd, srel & 0xffff, contents);
382	break;
383
384	case R_MSP430_16:
385	contents += rel->r_offset;
386	srel = (bfd_signed_vma) relocation;
387	srel += rel->r_addend;
388
389	if (srel & 1)
390	return bfd_reloc_notsupported;
391
392	bfd_put_16 (input_bfd, srel & 0xffff, contents);
393	break;
394
395	default:
396	r = _bfd_final_link_relocate (howto, input_bfd, input_section,
397	contents, rel->r_offset,
398	relocation, rel->r_addend);
399	}
400
401	return r;
402	}
403
404	/* Relocate an MSP430 ELF section. */
405
406	static bfd_boolean
407	elf32_msp430_relocate_section (output_bfd, info, input_bfd, input_section,
408	contents, relocs, local_syms, local_sections)
409	bfd *output_bfd ATTRIBUTE_UNUSED;
410	struct bfd_link_info *info;
411	bfd *input_bfd;
412	asection *input_section;
413	bfd_byte *contents;
414	Elf_Internal_Rela *relocs;
415	Elf_Internal_Sym *local_syms;
416	asection **local_sections;
417	{
418	Elf_Internal_Shdr *symtab_hdr;
419	struct elf_link_hash_entry **sym_hashes;
420	Elf_Internal_Rela *rel;
421	Elf_Internal_Rela *relend;
422
423	symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
424	sym_hashes = elf_sym_hashes (input_bfd);
425	relend = relocs + input_section->reloc_count;
426
427	for (rel = relocs; rel < relend; rel++)
428	{
429	reloc_howto_type *howto;
430	unsigned long r_symndx;
431	Elf_Internal_Sym *sym;
432	asection *sec;
433	struct elf_link_hash_entry *h;
434	bfd_vma relocation;
435	bfd_reloc_status_type r;
436	const char *name = NULL;
437	int r_type;
438
439	/* This is a final link. */
440
441	r_type = ELF32_R_TYPE (rel->r_info);
442	r_symndx = ELF32_R_SYM (rel->r_info);
443	howto = elf_msp430_howto_table + ELF32_R_TYPE (rel->r_info);
444	h = NULL;
445	sym = NULL;
446	sec = NULL;
447
448	if (r_symndx < symtab_hdr->sh_info)
449	{
450	sym = local_syms + r_symndx;
451	sec = local_sections[r_symndx];
8517fae7	452	relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2469cfa2 NC	453
	454	name = bfd_elf_string_from_elf_section
	455	(input_bfd, symtab_hdr->sh_link, sym->st_name);
	456	name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
	457	}
	458	else
	459	{
59c2e50f	460	bfd_boolean unresolved_reloc, warned;
2469cfa2	461
b2a8e766 AM	462	RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
	463	r_symndx, symtab_hdr, sym_hashes,
	464	h, sec, relocation,
	465	unresolved_reloc, warned);
2469cfa2 NC	466	}
	467
	468	r = msp430_final_link_relocate (howto, input_bfd, input_section,
	469	contents, rel, relocation);
	470
	471	if (r != bfd_reloc_ok)
	472	{
	473	const char msg = (const char ) NULL;
	474
	475	switch (r)
	476	{
	477	case bfd_reloc_overflow:
	478	r = info->callbacks->reloc_overflow
	479	(info, name, howto->name, (bfd_vma) 0,
	480	input_bfd, input_section, rel->r_offset);
	481	break;
	482
	483	case bfd_reloc_undefined:
	484	r = info->callbacks->undefined_symbol
	485	(info, name, input_bfd, input_section, rel->r_offset, TRUE);
	486	break;
	487
	488	case bfd_reloc_outofrange:
	489	msg = _("internal error: out of range error");
	490	break;
	491
	492	case bfd_reloc_notsupported:
	493	msg = _("internal error: unsupported relocation error");
	494	break;
	495
	496	case bfd_reloc_dangerous:
	497	msg = _("internal error: dangerous relocation");
	498	break;
	499
	500	default:
	501	msg = _("internal error: unknown error");
	502	break;
	503	}
	504
	505	if (msg)
	506	r = info->callbacks->warning
	507	(info, msg, name, input_bfd, input_section, rel->r_offset);
	508
	509	if (!r)
	510	return FALSE;
	511	}
	512
	513	}
	514
	515	return TRUE;
	516	}
	517
	518	/* The final processing done just before writing out a MSP430 ELF object
	519	file. This gets the MSP430 architecture right based on the machine
	520	number. */
	521
	522	static void
	523	bfd_elf_msp430_final_write_processing (abfd, linker)
	524	bfd *abfd;
	525	bfd_boolean linker ATTRIBUTE_UNUSED;
	526	{
	527	unsigned long val;
	528
	529	switch (bfd_get_mach (abfd))
530	{
531	default:
2469cfa2 NC	532	case bfd_mach_msp110:
	533	val = E_MSP430_MACH_MSP430x11x1;
	534	break;
	535
	536	case bfd_mach_msp11:
	537	val = E_MSP430_MACH_MSP430x11;
	538	break;
	539
3b260895 NC	540	case bfd_mach_msp12:
	541	val = E_MSP430_MACH_MSP430x12;
	542	break;
	543
2469cfa2 NC	544	case bfd_mach_msp13:
	545	val = E_MSP430_MACH_MSP430x13;
	546	break;
	547
	548	case bfd_mach_msp14:
	549	val = E_MSP430_MACH_MSP430x14;
	550	break;
	551
3b260895 NC	552	case bfd_mach_msp15:
3b260895 NC	553	val = E_MSP430_MACH_MSP430x15;
2469cfa2 NC	554	break;
2469cfa2 NC	555
3b260895 NC	556	case bfd_mach_msp16:
3b260895 NC	557	val = E_MSP430_MACH_MSP430x16;
2469cfa2 NC	558	break;
	559
	560	case bfd_mach_msp31:
	561	val = E_MSP430_MACH_MSP430x31;
	562	break;
	563
	564	case bfd_mach_msp32:
	565	val = E_MSP430_MACH_MSP430x32;
	566	break;
	567
	568	case bfd_mach_msp33:
	569	val = E_MSP430_MACH_MSP430x33;
	570	break;
	571
3b260895 NC	572	case bfd_mach_msp41:
3b260895 NC	573	val = E_MSP430_MACH_MSP430x41;
2469cfa2 NC	574	break;
2469cfa2 NC	575
3b260895 NC	576	case bfd_mach_msp42:
	577	val = E_MSP430_MACH_MSP430x42;
	578	break;
	579
	580	case bfd_mach_msp43:
	581	val = E_MSP430_MACH_MSP430x43;
	582	break;
	583
	584	case bfd_mach_msp44:
	585	val = E_MSP430_MACH_MSP430x44;
2469cfa2 NC	586	break;
	587	}
	588
	589	elf_elfheader (abfd)->e_machine = EM_MSP430;
	590	elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
	591	elf_elfheader (abfd)->e_flags \|= val;
	592	}
	593
	594	/* Set the right machine number. */
	595
	596	static bfd_boolean
	597	elf32_msp430_object_p (abfd)
	598	bfd *abfd;
	599	{
	600	int e_set = bfd_mach_msp14;
	601
	602	if (elf_elfheader (abfd)->e_machine == EM_MSP430
	603	\|\| elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
	604	{
	605	int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
	606
	607	switch (e_mach)
	608	{
	609	default:
2469cfa2 NC	610	case E_MSP430_MACH_MSP430x11:
	611	e_set = bfd_mach_msp11;
	612	break;
	613
	614	case E_MSP430_MACH_MSP430x11x1:
	615	e_set = bfd_mach_msp110;
	616	break;
	617
3b260895 NC	618	case E_MSP430_MACH_MSP430x12:
	619	e_set = bfd_mach_msp12;
	620	break;
	621
2469cfa2 NC	622	case E_MSP430_MACH_MSP430x13:
	623	e_set = bfd_mach_msp13;
	624	break;
	625
	626	case E_MSP430_MACH_MSP430x14:
	627	e_set = bfd_mach_msp14;
	628	break;
	629
3b260895 NC	630	case E_MSP430_MACH_MSP430x15:
	631	e_set = bfd_mach_msp15;
	632	break;
	633
	634	case E_MSP430_MACH_MSP430x16:
	635	e_set = bfd_mach_msp16;
2469cfa2 NC	636	break;
	637
	638	case E_MSP430_MACH_MSP430x31:
	639	e_set = bfd_mach_msp31;
	640	break;
	641
	642	case E_MSP430_MACH_MSP430x32:
	643	e_set = bfd_mach_msp32;
	644	break;
	645
	646	case E_MSP430_MACH_MSP430x33:
	647	e_set = bfd_mach_msp33;
	648	break;
	649
3b260895 NC	650	case E_MSP430_MACH_MSP430x41:
3b260895 NC	651	e_set = bfd_mach_msp41;
2469cfa2 NC	652	break;
2469cfa2 NC	653
3b260895 NC	654	case E_MSP430_MACH_MSP430x42:
3b260895 NC	655	e_set = bfd_mach_msp42;
2469cfa2 NC	656	break;
2469cfa2 NC	657
3b260895 NC	658	case E_MSP430_MACH_MSP430x43:
3b260895 NC	659	e_set = bfd_mach_msp43;
2469cfa2 NC	660	break;
2469cfa2 NC	661
3b260895 NC	662	case E_MSP430_MACH_MSP430x44:
3b260895 NC	663	e_set = bfd_mach_msp44;
2469cfa2 NC	664	break;
	665	}
	666	}
	667
	668	return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
	669	}
	670
	671	static void
	672	elf32_msp430_post_process_headers (abfd, link_info)
	673	bfd *abfd;
	674	struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
	675	{
	676	Elf_Internal_Ehdr i_ehdrp; / ELF file header, internal form. */
	677
	678	i_ehdrp = elf_elfheader (abfd);
	679
	680	#ifndef ELFOSABI_STANDALONE
	681	#define ELFOSABI_STANDALONE 255
	682	#endif
	683
	684	i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE;
	685	}
	686
	687
	688	#define ELF_ARCH bfd_arch_msp430
	689	#define ELF_MACHINE_CODE EM_MSP430
	690	#define ELF_MACHINE_ALT1 EM_MSP430_OLD
	691	#define ELF_MAXPAGESIZE 1
	692
	693	#define TARGET_LITTLE_SYM bfd_elf32_msp430_vec
	694	#define TARGET_LITTLE_NAME "elf32-msp430"
	695
	696	#define elf_info_to_howto msp430_info_to_howto_rela
	697	#define elf_info_to_howto_rel NULL
	698	#define elf_backend_relocate_section elf32_msp430_relocate_section
	699	#define elf_backend_gc_mark_hook elf32_msp430_gc_mark_hook
	700	#define elf_backend_gc_sweep_hook elf32_msp430_gc_sweep_hook
	701	#define elf_backend_check_relocs elf32_msp430_check_relocs
	702	#define elf_backend_can_gc_sections 1
	703	#define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing
	704	#define elf_backend_object_p elf32_msp430_object_p
	705	#define elf_backend_post_process_headers elf32_msp430_post_process_headers
	706
	707	#include "elf32-target.h"