bfd/elf32-msp430.c

   1 /*  MSP430-specific support for 32-bit ELF
   2     Copyright (C) 2002, 2003 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 (h, sym_hashes, r_symndx, symtab_hdr,
 463                                    relocation, sec, unresolved_reloc,
 464                                    info, warned);
 465         }
 466
 467       r = msp430_final_link_relocate (howto, input_bfd, input_section,
 468                                       contents, rel, relocation);
 469
 470       if (r != bfd_reloc_ok)
 471         {
 472           const char *msg = (const char *) NULL;
 473
 474           switch (r)
 475             {
 476             case bfd_reloc_overflow:
 477               r = info->callbacks->reloc_overflow
 478                   (info, name, howto->name, (bfd_vma) 0,
 479                    input_bfd, input_section, rel->r_offset);
 480               break;
 481
 482             case bfd_reloc_undefined:
 483               r = info->callbacks->undefined_symbol
 484                   (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 485               break;
 486
 487             case bfd_reloc_outofrange:
 488               msg = _("internal error: out of range error");
 489               break;
 490
 491             case bfd_reloc_notsupported:
 492               msg = _("internal error: unsupported relocation error");
 493               break;
 494
 495             case bfd_reloc_dangerous:
 496               msg = _("internal error: dangerous relocation");
 497               break;
 498
 499             default:
 500               msg = _("internal error: unknown error");
 501               break;
 502             }
 503
 504           if (msg)
 505             r = info->callbacks->warning
 506                 (info, msg, name, input_bfd, input_section, rel->r_offset);
 507
 508           if (!r)
 509             return FALSE;
 510         }
 511
 512     }
 513
 514   return TRUE;
 515 }
 516
 517 /* The final processing done just before writing out a MSP430 ELF object
 518    file.  This gets the MSP430 architecture right based on the machine
 519    number.  */
 520
 521 static void
 522 bfd_elf_msp430_final_write_processing (abfd, linker)
 523      bfd *abfd;
 524      bfd_boolean linker ATTRIBUTE_UNUSED;
 525 {
 526   unsigned long val;
 527
 528   switch (bfd_get_mach (abfd))
 529     {
 530     default:
 531     case bfd_mach_msp110:
 532       val = E_MSP430_MACH_MSP430x11x1;
 533       break;
 534
 535     case bfd_mach_msp11:
 536       val = E_MSP430_MACH_MSP430x11;
 537       break;
 538
 539     case bfd_mach_msp12:
 540       val = E_MSP430_MACH_MSP430x12;
 541       break;
 542
 543     case bfd_mach_msp13:
 544       val = E_MSP430_MACH_MSP430x13;
 545       break;
 546
 547     case bfd_mach_msp14:
 548       val = E_MSP430_MACH_MSP430x14;
 549       break;
 550
 551     case bfd_mach_msp15:
 552       val = E_MSP430_MACH_MSP430x15;
 553       break;
 554
 555     case bfd_mach_msp16:
 556       val = E_MSP430_MACH_MSP430x16;
 557       break;
 558
 559     case bfd_mach_msp31:
 560       val = E_MSP430_MACH_MSP430x31;
 561       break;
 562
 563     case bfd_mach_msp32:
 564       val = E_MSP430_MACH_MSP430x32;
 565       break;
 566
 567     case bfd_mach_msp33:
 568       val = E_MSP430_MACH_MSP430x33;
 569       break;
 570
 571     case bfd_mach_msp41:
 572       val = E_MSP430_MACH_MSP430x41;
 573       break;
 574
 575     case bfd_mach_msp42:
 576       val = E_MSP430_MACH_MSP430x42;
 577       break;
 578
 579     case bfd_mach_msp43:
 580       val = E_MSP430_MACH_MSP430x43;
 581       break;
 582
 583     case bfd_mach_msp44:
 584       val = E_MSP430_MACH_MSP430x44;
 585       break;
 586     }
 587
 588   elf_elfheader (abfd)->e_machine = EM_MSP430;
 589   elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
 590   elf_elfheader (abfd)->e_flags |= val;
 591 }
 592
 593 /* Set the right machine number.  */
 594
 595 static bfd_boolean
 596 elf32_msp430_object_p (abfd)
 597      bfd *abfd;
 598 {
 599   int e_set = bfd_mach_msp14;
 600
 601   if (elf_elfheader (abfd)->e_machine == EM_MSP430
 602       || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
 603     {
 604       int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
 605
 606       switch (e_mach)
 607         {
 608         default:
 609         case E_MSP430_MACH_MSP430x11:
 610           e_set = bfd_mach_msp11;
 611           break;
 612
 613         case E_MSP430_MACH_MSP430x11x1:
 614           e_set = bfd_mach_msp110;
 615           break;
 616
 617         case E_MSP430_MACH_MSP430x12:
 618           e_set = bfd_mach_msp12;
 619           break;
 620
 621         case E_MSP430_MACH_MSP430x13:
 622           e_set = bfd_mach_msp13;
 623           break;
 624
 625         case E_MSP430_MACH_MSP430x14:
 626           e_set = bfd_mach_msp14;
 627           break;
 628
 629         case E_MSP430_MACH_MSP430x15:
 630           e_set = bfd_mach_msp15;
 631           break;
 632
 633         case E_MSP430_MACH_MSP430x16:
 634           e_set = bfd_mach_msp16;
 635           break;
 636
 637         case E_MSP430_MACH_MSP430x31:
 638           e_set = bfd_mach_msp31;
 639           break;
 640
 641         case E_MSP430_MACH_MSP430x32:
 642           e_set = bfd_mach_msp32;
 643           break;
 644
 645         case E_MSP430_MACH_MSP430x33:
 646           e_set = bfd_mach_msp33;
 647           break;
 648
 649         case E_MSP430_MACH_MSP430x41:
 650           e_set = bfd_mach_msp41;
 651           break;
 652
 653         case E_MSP430_MACH_MSP430x42:
 654           e_set = bfd_mach_msp42;
 655           break;
 656
 657         case E_MSP430_MACH_MSP430x43:
 658           e_set = bfd_mach_msp43;
 659           break;
 660
 661         case E_MSP430_MACH_MSP430x44:
 662           e_set = bfd_mach_msp44;
 663           break;
 664         }
 665     }
 666
 667   return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
 668 }
 669
 670 static void
 671 elf32_msp430_post_process_headers (abfd, link_info)
 672      bfd *abfd;
 673      struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
 674 {
 675   Elf_Internal_Ehdr *i_ehdrp;   /* ELF file header, internal form.  */
 676
 677   i_ehdrp = elf_elfheader (abfd);
 678
 679 #ifndef ELFOSABI_STANDALONE
 680 #define ELFOSABI_STANDALONE     255
 681 #endif
 682
 683   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE;
 684 }
 685
 686
 687 #define ELF_ARCH                bfd_arch_msp430
 688 #define ELF_MACHINE_CODE        EM_MSP430
 689 #define ELF_MACHINE_ALT1        EM_MSP430_OLD
 690 #define ELF_MAXPAGESIZE         1
 691
 692 #define TARGET_LITTLE_SYM       bfd_elf32_msp430_vec
 693 #define TARGET_LITTLE_NAME      "elf32-msp430"
 694
 695 #define elf_info_to_howto                    msp430_info_to_howto_rela
 696 #define elf_info_to_howto_rel                NULL
 697 #define elf_backend_relocate_section         elf32_msp430_relocate_section
 698 #define elf_backend_gc_mark_hook             elf32_msp430_gc_mark_hook
 699 #define elf_backend_gc_sweep_hook            elf32_msp430_gc_sweep_hook
 700 #define elf_backend_check_relocs             elf32_msp430_check_relocs
 701 #define elf_backend_can_gc_sections          1
 702 #define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
 703 #define elf_backend_object_p                 elf32_msp430_object_p
 704 #define elf_backend_post_process_headers     elf32_msp430_post_process_headers
 705
 706 #include "elf32-target.h"