bfd/elf32-msp430.c

   1 /*  MSP430-specific support for 32-bit ELF
   2     Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3     Contributed by Dmitry Diky <diwil@mail.ru>
   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
 281   if (info->relocatable)
 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];
 452           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 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         {
 460           bfd_boolean unresolved_reloc, warned;
 461
 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);
 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:
 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
 540     case bfd_mach_msp12:
 541       val = E_MSP430_MACH_MSP430x12;
 542       break;
 543
 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
 552     case bfd_mach_msp15:
 553       val = E_MSP430_MACH_MSP430x15;
 554       break;
 555
 556     case bfd_mach_msp16:
 557       val = E_MSP430_MACH_MSP430x16;
 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
 572     case bfd_mach_msp41:
 573       val = E_MSP430_MACH_MSP430x41;
 574       break;
 575
 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;
 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:
 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
 618         case E_MSP430_MACH_MSP430x12:
 619           e_set = bfd_mach_msp12;
 620           break;
 621
 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
 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;
 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
 650         case E_MSP430_MACH_MSP430x41:
 651           e_set = bfd_mach_msp41;
 652           break;
 653
 654         case E_MSP430_MACH_MSP430x42:
 655           e_set = bfd_mach_msp42;
 656           break;
 657
 658         case E_MSP430_MACH_MSP430x43:
 659           e_set = bfd_mach_msp43;
 660           break;
 661
 662         case E_MSP430_MACH_MSP430x44:
 663           e_set = bfd_mach_msp44;
 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"