bfd/elf32-msp430.c

   1 /*  MSP430-specific support for 32-bit ELF
   2     Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2010, 2012
   3     Free Software Foundation, Inc.
   4     Contributed by Dmitry Diky <diwil@mail.ru>
   5
   6     This file is part of BFD, the Binary File Descriptor library.
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 3 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21     MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libiberty.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28 #include "elf/msp430.h"
  29
  30 /* Use RELA instead of REL.  */
  31 #undef USE_REL
  32
  33 static reloc_howto_type elf_msp430_howto_table[] =
  34 {
  35   HOWTO (R_MSP430_NONE,         /* type */
  36          0,                     /* rightshift */
  37          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  38          32,                    /* bitsize */
  39          FALSE,                 /* pc_relative */
  40          0,                     /* bitpos */
  41          complain_overflow_bitfield,/* complain_on_overflow */
  42          bfd_elf_generic_reloc, /* special_function */
  43          "R_MSP430_NONE",       /* name */
  44          FALSE,                 /* partial_inplace */
  45          0,                     /* src_mask */
  46          0,                     /* dst_mask */
  47          FALSE),                /* pcrel_offset */
  48
  49   HOWTO (R_MSP430_32,           /* type */
  50          0,                     /* rightshift */
  51          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  52          32,                    /* bitsize */
  53          FALSE,                 /* pc_relative */
  54          0,                     /* bitpos */
  55          complain_overflow_bitfield,/* complain_on_overflow */
  56          bfd_elf_generic_reloc, /* special_function */
  57          "R_MSP430_32",         /* name */
  58          FALSE,                 /* partial_inplace */
  59          0xffffffff,            /* src_mask */
  60          0xffffffff,            /* dst_mask */
  61          FALSE),                /* pcrel_offset */
  62
  63   /* A 13 bit PC relative relocation.  */
  64   HOWTO (R_MSP430_10_PCREL,     /* type */
  65          1,                     /* rightshift */
  66          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  67          10,                    /* bitsize */
  68          TRUE,                  /* pc_relative */
  69          0,                     /* bitpos */
  70          complain_overflow_bitfield,/* complain_on_overflow */
  71          bfd_elf_generic_reloc, /* special_function */
  72          "R_MSP430_13_PCREL",   /* name */
  73          FALSE,                 /* partial_inplace */
  74          0xfff,                 /* src_mask */
  75          0xfff,                 /* dst_mask */
  76          TRUE),                 /* pcrel_offset */
  77
  78   /* A 16 bit absolute relocation.  */
  79   HOWTO (R_MSP430_16,           /* type */
  80          0,                     /* rightshift */
  81          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  82          16,                    /* bitsize */
  83          FALSE,                 /* pc_relative */
  84          0,                     /* bitpos */
  85          complain_overflow_dont,/* complain_on_overflow */
  86          bfd_elf_generic_reloc, /* special_function */
  87          "R_MSP430_16",         /* name */
  88          FALSE,                 /* partial_inplace */
  89          0,                     /* src_mask */
  90          0xffff,                /* dst_mask */
  91          FALSE),                /* pcrel_offset */
  92
  93   /* A 16 bit absolute relocation for command address.  */
  94   HOWTO (R_MSP430_16_PCREL,     /* type */
  95          1,                     /* rightshift */
  96          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  97          16,                    /* bitsize */
  98          TRUE,                  /* pc_relative */
  99          0,                     /* bitpos */
 100          complain_overflow_dont,/* complain_on_overflow */
 101          bfd_elf_generic_reloc, /* special_function */
 102          "R_MSP430_16_PCREL",   /* name */
 103          FALSE,                 /* partial_inplace */
 104          0,                     /* src_mask */
 105          0xffff,                /* dst_mask */
 106          TRUE),                 /* pcrel_offset */
 107
 108   /* A 16 bit absolute relocation, byte operations.  */
 109   HOWTO (R_MSP430_16_BYTE,      /* type */
 110          0,                     /* rightshift */
 111          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 112          16,                    /* bitsize */
 113          FALSE,                 /* pc_relative */
 114          0,                     /* bitpos */
 115          complain_overflow_dont,/* complain_on_overflow */
 116          bfd_elf_generic_reloc, /* special_function */
 117          "R_MSP430_16_BYTE",    /* name */
 118          FALSE,                 /* partial_inplace */
 119          0xffff,                /* src_mask */
 120          0xffff,                /* dst_mask */
 121          FALSE),                /* pcrel_offset */
 122
 123   /* A 16 bit absolute relocation for command address.  */
 124   HOWTO (R_MSP430_16_PCREL_BYTE,/* type */
 125          1,                     /* rightshift */
 126          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 127          16,                    /* bitsize */
 128          TRUE,                  /* pc_relative */
 129          0,                     /* bitpos */
 130          complain_overflow_dont,/* complain_on_overflow */
 131          bfd_elf_generic_reloc, /* special_function */
 132          "R_MSP430_16_PCREL_BYTE",/* name */
 133          FALSE,                 /* partial_inplace */
 134          0xffff,                /* src_mask */
 135          0xffff,                /* dst_mask */
 136          TRUE),                 /* pcrel_offset */
 137
 138   /* A 13 bit PC relative relocation for complicated polymorphs.  */
 139   HOWTO (R_MSP430_2X_PCREL,     /* type */
 140          1,                     /* rightshift */
 141          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 142          10,                    /* bitsize */
 143          TRUE,                  /* pc_relative */
 144          0,                     /* bitpos */
 145          complain_overflow_bitfield,/* complain_on_overflow */
 146          bfd_elf_generic_reloc, /* special_function */
 147          "R_MSP430_2X_PCREL",   /* name */
 148          FALSE,                 /* partial_inplace */
 149          0xfff,                 /* src_mask */
 150          0xfff,                 /* dst_mask */
 151          TRUE),                 /* pcrel_offset */
 152
 153   /* A 16 bit relaxable relocation for command address.  */
 154   HOWTO (R_MSP430_RL_PCREL,     /* type */
 155          1,                     /* rightshift */
 156          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 157          16,                    /* bitsize */
 158          TRUE,                  /* pc_relative */
 159          0,                     /* bitpos */
 160          complain_overflow_dont,/* complain_on_overflow */
 161          bfd_elf_generic_reloc, /* special_function */
 162          "R_MSP430_RL_PCREL",   /* name */
 163          FALSE,                 /* partial_inplace */
 164          0,                     /* src_mask */
 165          0xffff,                /* dst_mask */
 166          TRUE)                  /* pcrel_offset */
 167 };
 168
 169 /* Map BFD reloc types to MSP430 ELF reloc types.  */
 170
 171 struct msp430_reloc_map
 172 {
 173   bfd_reloc_code_real_type bfd_reloc_val;
 174   unsigned int elf_reloc_val;
 175 };
 176
 177 static const struct msp430_reloc_map msp430_reloc_map[] =
 178   {
 179     {BFD_RELOC_NONE,                 R_MSP430_NONE},
 180     {BFD_RELOC_32,                   R_MSP430_32},
 181     {BFD_RELOC_MSP430_10_PCREL,      R_MSP430_10_PCREL},
 182     {BFD_RELOC_16,                   R_MSP430_16_BYTE},
 183     {BFD_RELOC_MSP430_16_PCREL,      R_MSP430_16_PCREL},
 184     {BFD_RELOC_MSP430_16,            R_MSP430_16},
 185     {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE},
 186     {BFD_RELOC_MSP430_16_BYTE,       R_MSP430_16_BYTE},
 187     {BFD_RELOC_MSP430_2X_PCREL,      R_MSP430_2X_PCREL},
 188     {BFD_RELOC_MSP430_RL_PCREL,      R_MSP430_RL_PCREL}
 189   };
 190
 191 static reloc_howto_type *
 192 bfd_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 193                                  bfd_reloc_code_real_type code)
 194 {
 195   unsigned int i;
 196
 197   for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++)
 198     if (msp430_reloc_map[i].bfd_reloc_val == code)
 199       return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val];
 200
 201   return NULL;
 202 }
 203
 204 static reloc_howto_type *
 205 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 206                                  const char *r_name)
 207 {
 208   unsigned int i;
 209
 210   for (i = 0;
 211        i < (sizeof (elf_msp430_howto_table)
 212             / sizeof (elf_msp430_howto_table[0]));
 213        i++)
 214     if (elf_msp430_howto_table[i].name != NULL
 215         && strcasecmp (elf_msp430_howto_table[i].name, r_name) == 0)
 216       return &elf_msp430_howto_table[i];
 217
 218   return NULL;
 219 }
 220
 221 /* Set the howto pointer for an MSP430 ELF reloc.  */
 222
 223 static void
 224 msp430_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 225                            arelent * cache_ptr,
 226                            Elf_Internal_Rela * dst)
 227 {
 228   unsigned int r_type;
 229
 230   r_type = ELF32_R_TYPE (dst->r_info);
 231   BFD_ASSERT (r_type < (unsigned int) R_MSP430_max);
 232   cache_ptr->howto = &elf_msp430_howto_table[r_type];
 233 }
 234
 235 /* Look through the relocs for a section during the first phase.
 236    Since we don't do .gots or .plts, we just need to consider the
 237    virtual table relocs for gc.  */
 238
 239 static bfd_boolean
 240 elf32_msp430_check_relocs (bfd * abfd, struct bfd_link_info * info,
 241                            asection * sec, const Elf_Internal_Rela * relocs)
 242 {
 243   Elf_Internal_Shdr *symtab_hdr;
 244   struct elf_link_hash_entry **sym_hashes;
 245   const Elf_Internal_Rela *rel;
 246   const Elf_Internal_Rela *rel_end;
 247
 248   if (info->relocatable)
 249     return TRUE;
 250
 251   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 252   sym_hashes = elf_sym_hashes (abfd);
 253
 254   rel_end = relocs + sec->reloc_count;
 255   for (rel = relocs; rel < rel_end; rel++)
 256     {
 257       struct elf_link_hash_entry *h;
 258       unsigned long r_symndx;
 259
 260       r_symndx = ELF32_R_SYM (rel->r_info);
 261       if (r_symndx < symtab_hdr->sh_info)
 262         h = NULL;
 263       else
 264         {
 265           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 266           while (h->root.type == bfd_link_hash_indirect
 267                  || h->root.type == bfd_link_hash_warning)
 268             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 269
 270           /* PR15323, ref flags aren't set for references in the same
 271              object.  */
 272           h->root.non_ir_ref = 1;
 273         }
 274     }
 275
 276   return TRUE;
 277 }
 278
 279 /* Perform a single relocation.  By default we use the standard BFD
 280    routines, but a few relocs, we have to do them ourselves.  */
 281
 282 static bfd_reloc_status_type
 283 msp430_final_link_relocate (reloc_howto_type * howto, bfd * input_bfd,
 284                             asection * input_section, bfd_byte * contents,
 285                             Elf_Internal_Rela * rel, bfd_vma relocation)
 286 {
 287   bfd_reloc_status_type r = bfd_reloc_ok;
 288   bfd_vma x;
 289   bfd_signed_vma srel;
 290
 291   switch (howto->type)
 292     {
 293     case R_MSP430_10_PCREL:
 294       contents += rel->r_offset;
 295       srel = (bfd_signed_vma) relocation;
 296       srel += rel->r_addend;
 297       srel -= rel->r_offset;
 298       srel -= 2;                /* Branch instructions add 2 to the PC...  */
 299       srel -= (input_section->output_section->vma +
 300                input_section->output_offset);
 301
 302       if (srel & 1)
 303         return bfd_reloc_outofrange;
 304
 305       /* MSP430 addresses commands as words.  */
 306       srel >>= 1;
 307
 308       /* Check for an overflow.  */
 309       if (srel < -512 || srel > 511)
 310         return bfd_reloc_overflow;
 311
 312       x = bfd_get_16 (input_bfd, contents);
 313       x = (x & 0xfc00) | (srel & 0x3ff);
 314       bfd_put_16 (input_bfd, x, contents);
 315       break;
 316
 317     case R_MSP430_2X_PCREL:
 318       contents += rel->r_offset;
 319       srel = (bfd_signed_vma) relocation;
 320       srel += rel->r_addend;
 321       srel -= rel->r_offset;
 322       srel -= 2;                /* Branch instructions add 2 to the PC...  */
 323       srel -= (input_section->output_section->vma +
 324                input_section->output_offset);
 325
 326       if (srel & 1)
 327         return bfd_reloc_outofrange;
 328
 329       /* MSP430 addresses commands as words.  */
 330       srel >>= 1;
 331
 332       /* Check for an overflow.  */
 333       if (srel < -512 || srel > 511)
 334         return bfd_reloc_overflow;
 335
 336       x = bfd_get_16 (input_bfd, contents);
 337       x = (x & 0xfc00) | (srel & 0x3ff);
 338       bfd_put_16 (input_bfd, x, contents);
 339       /* Handle second jump instruction.  */
 340       x = bfd_get_16 (input_bfd, contents - 2);
 341       srel += 1;
 342       x = (x & 0xfc00) | (srel & 0x3ff);
 343       bfd_put_16 (input_bfd, x, contents - 2);
 344       break;
 345
 346     case R_MSP430_RL_PCREL:
 347     case R_MSP430_16_PCREL:
 348       contents += rel->r_offset;
 349       srel = (bfd_signed_vma) relocation;
 350       srel += rel->r_addend;
 351       srel -= rel->r_offset;
 352       /* Only branch instructions add 2 to the PC...  */
 353       srel -= (input_section->output_section->vma +
 354                input_section->output_offset);
 355
 356       if (srel & 1)
 357         return bfd_reloc_outofrange;
 358
 359       bfd_put_16 (input_bfd, srel & 0xffff, contents);
 360       break;
 361
 362     case R_MSP430_16_PCREL_BYTE:
 363       contents += rel->r_offset;
 364       srel = (bfd_signed_vma) relocation;
 365       srel += rel->r_addend;
 366       srel -= rel->r_offset;
 367       /* Only branch instructions add 2 to the PC...  */
 368       srel -= (input_section->output_section->vma +
 369                input_section->output_offset);
 370
 371       bfd_put_16 (input_bfd, srel & 0xffff, contents);
 372       break;
 373
 374     case R_MSP430_16_BYTE:
 375       contents += rel->r_offset;
 376       srel = (bfd_signed_vma) relocation;
 377       srel += rel->r_addend;
 378       bfd_put_16 (input_bfd, srel & 0xffff, contents);
 379       break;
 380
 381     case R_MSP430_16:
 382       contents += rel->r_offset;
 383       srel = (bfd_signed_vma) relocation;
 384       srel += rel->r_addend;
 385
 386       if (srel & 1)
 387         return bfd_reloc_notsupported;
 388
 389       bfd_put_16 (input_bfd, srel & 0xffff, contents);
 390       break;
 391
 392     default:
 393       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 394                                     contents, rel->r_offset,
 395                                     relocation, rel->r_addend);
 396     }
 397
 398   return r;
 399 }
 400
 401 /* Relocate an MSP430 ELF section.  */
 402
 403 static bfd_boolean
 404 elf32_msp430_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
 405                                struct bfd_link_info * info,
 406                                bfd * input_bfd,
 407                                asection * input_section,
 408                                bfd_byte * contents,
 409                                Elf_Internal_Rela * relocs,
 410                                Elf_Internal_Sym * local_syms,
 411                                asection ** local_sections)
 412 {
 413   Elf_Internal_Shdr *symtab_hdr;
 414   struct elf_link_hash_entry **sym_hashes;
 415   Elf_Internal_Rela *rel;
 416   Elf_Internal_Rela *relend;
 417
 418   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 419   sym_hashes = elf_sym_hashes (input_bfd);
 420   relend = relocs + input_section->reloc_count;
 421
 422   for (rel = relocs; rel < relend; rel++)
 423     {
 424       reloc_howto_type *howto;
 425       unsigned long r_symndx;
 426       Elf_Internal_Sym *sym;
 427       asection *sec;
 428       struct elf_link_hash_entry *h;
 429       bfd_vma relocation;
 430       bfd_reloc_status_type r;
 431       const char *name = NULL;
 432       int r_type;
 433
 434       r_type = ELF32_R_TYPE (rel->r_info);
 435       r_symndx = ELF32_R_SYM (rel->r_info);
 436       howto = elf_msp430_howto_table + r_type;
 437       h = NULL;
 438       sym = NULL;
 439       sec = NULL;
 440
 441       if (r_symndx < symtab_hdr->sh_info)
 442         {
 443           sym = local_syms + r_symndx;
 444           sec = local_sections[r_symndx];
 445           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 446
 447           name = bfd_elf_string_from_elf_section
 448               (input_bfd, symtab_hdr->sh_link, sym->st_name);
 449           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 450         }
 451       else
 452         {
 453           bfd_boolean unresolved_reloc, warned;
 454
 455           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 456                                    r_symndx, symtab_hdr, sym_hashes,
 457                                    h, sec, relocation,
 458                                    unresolved_reloc, warned);
 459         }
 460
 461       if (sec != NULL && discarded_section (sec))
 462         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 463                                          rel, 1, relend, howto, 0, contents);
 464
 465       if (info->relocatable)
 466         continue;
 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, (h ? &h->root : NULL), name, howto->name,
 480                    (bfd_vma) 0, input_bfd, input_section,
 481                    rel->r_offset);
 482               break;
 483
 484             case bfd_reloc_undefined:
 485               r = info->callbacks->undefined_symbol
 486                   (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 487               break;
 488
 489             case bfd_reloc_outofrange:
 490               msg = _("internal error: out of range error");
 491               break;
 492
 493             case bfd_reloc_notsupported:
 494               msg = _("internal error: unsupported relocation error");
 495               break;
 496
 497             case bfd_reloc_dangerous:
 498               msg = _("internal error: dangerous relocation");
 499               break;
 500
 501             default:
 502               msg = _("internal error: unknown error");
 503               break;
 504             }
 505
 506           if (msg)
 507             r = info->callbacks->warning
 508                 (info, msg, name, input_bfd, input_section, rel->r_offset);
 509
 510           if (!r)
 511             return FALSE;
 512         }
 513
 514     }
 515
 516   return TRUE;
 517 }
 518
 519 /* The final processing done just before writing out a MSP430 ELF object
 520    file.  This gets the MSP430 architecture right based on the machine
 521    number.  */
 522
 523 static void
 524 bfd_elf_msp430_final_write_processing (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 (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 /* These functions handle relaxing for the msp430.
 671    Relaxation required only in two cases:
 672     - Bad hand coding like jumps from one section to another or
 673       from file to file.
 674     - Sibling calls. This will affect only 'jump label' polymorph. Without
 675       relaxing this enlarges code by 2 bytes. Sibcalls implemented but
 676       do not work in gcc's port by the reason I do not know.
 677    Anyway, if a relaxation required, user should pass -relax option to the
 678    linker.
 679
 680    There are quite a few relaxing opportunities available on the msp430:
 681
 682    ================================================================
 683
 684    1. 3 words -> 1 word
 685
 686    eq      ==      jeq label                    jne +4; br lab
 687    ne      !=      jne label                    jeq +4; br lab
 688    lt      <       jl  label                    jge +4; br lab
 689    ltu     <       jlo label                    lhs +4; br lab
 690    ge      >=      jge label                    jl  +4; br lab
 691    geu     >=      jhs label                    jlo +4; br lab
 692
 693    2. 4 words -> 1 word
 694
 695    ltn     <       jn                      jn  +2; jmp +4; br lab
 696
 697    3. 4 words -> 2 words
 698
 699    gt      >       jeq +2; jge label       jeq +6; jl  +4; br label
 700    gtu     >       jeq +2; jhs label       jeq +6; jlo +4; br label
 701
 702    4. 4 words -> 2 words and 2 labels
 703
 704    leu     <=      jeq label; jlo label    jeq +2; jhs +4; br label
 705    le      <=      jeq label; jl  label    jeq +2; jge +4; br label
 706    =================================================================
 707
 708    codemap for first cases is (labels masked ):
 709               eq:       0x2002,0x4010,0x0000 -> 0x2400
 710               ne:       0x2402,0x4010,0x0000 -> 0x2000
 711               lt:       0x3402,0x4010,0x0000 -> 0x3800
 712               ltu:      0x2c02,0x4010,0x0000 -> 0x2800
 713               ge:       0x3802,0x4010,0x0000 -> 0x3400
 714               geu:      0x2802,0x4010,0x0000 -> 0x2c00
 715
 716   second case:
 717               ltn:      0x3001,0x3c02,0x4010,0x0000 -> 0x3000
 718
 719   third case:
 720               gt:       0x2403,0x3802,0x4010,0x0000 -> 0x2401,0x3400
 721               gtu:      0x2403,0x2802,0x4010,0x0000 -> 0x2401,0x2c00
 722
 723   fourth case:
 724               leu:      0x2401,0x2c02,0x4010,0x0000 -> 0x2400,0x2800
 725               le:       0x2401,0x3402,0x4010,0x0000 -> 0x2400,0x3800
 726
 727   Unspecified case :)
 728               jump:     0x4010,0x0000 -> 0x3c00.  */
 729
 730 #define NUMB_RELAX_CODES        12
 731 static struct rcodes_s
 732 {
 733   int f0, f1;                   /* From code.  */
 734   int t0, t1;                   /* To code.  */
 735   int labels;                   /* Position of labels: 1 - one label at first
 736                                    word, 2 - one at second word, 3 - two
 737                                    labels at both.  */
 738   int cdx;                      /* Words to match.  */
 739   int bs;                       /* Shrink bytes.  */
 740   int off;                      /* Offset from old label for new code.  */
 741   int ncl;                      /* New code length.  */
 742 } rcode[] =
 743 {/*                               lab,cdx,bs,off,ncl */
 744   { 0x0000, 0x0000, 0x3c00, 0x0000, 1, 0, 2, 2,  2},    /* jump */
 745   { 0x0000, 0x2002, 0x2400, 0x0000, 1, 1, 4, 4,  2},    /* eq */
 746   { 0x0000, 0x2402, 0x2000, 0x0000, 1, 1, 4, 4,  2},    /* ne */
 747   { 0x0000, 0x3402, 0x3800, 0x0000, 1, 1, 4, 4,  2},    /* lt */
 748   { 0x0000, 0x2c02, 0x2800, 0x0000, 1, 1, 4, 4,  2},    /* ltu */
 749   { 0x0000, 0x3802, 0x3400, 0x0000, 1, 1, 4, 4,  2},    /* ge */
 750   { 0x0000, 0x2802, 0x2c00, 0x0000, 1, 1, 4, 4,  2},    /* geu */
 751   { 0x3001, 0x3c02, 0x3000, 0x0000, 1, 2, 6, 6,  2},    /* ltn */
 752   { 0x2403, 0x3802, 0x2401, 0x3400, 2, 2, 4, 6,  4},    /* gt */
 753   { 0x2403, 0x2802, 0x2401, 0x2c00, 2, 2, 4, 6,  4},    /* gtu */
 754   { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6,  4},    /* leu , 2 labels */
 755   { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6,  4},    /* le  , 2 labels */
 756   { 0,      0,      0,      0,      0, 0, 0, 0,  0}
 757 };
 758
 759 /* Return TRUE if a symbol exists at the given address.  */
 760
 761 static bfd_boolean
 762 msp430_elf_symbol_address_p (bfd * abfd,
 763                              asection * sec,
 764                              Elf_Internal_Sym * isym,
 765                              bfd_vma addr)
 766 {
 767   Elf_Internal_Shdr *symtab_hdr;
 768   unsigned int sec_shndx;
 769   Elf_Internal_Sym *isymend;
 770   struct elf_link_hash_entry **sym_hashes;
 771   struct elf_link_hash_entry **end_hashes;
 772   unsigned int symcount;
 773
 774   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
 775
 776   /* Examine all the local symbols.  */
 777   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 778   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
 779     if (isym->st_shndx == sec_shndx && isym->st_value == addr)
 780       return TRUE;
 781
 782   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
 783               - symtab_hdr->sh_info);
 784   sym_hashes = elf_sym_hashes (abfd);
 785   end_hashes = sym_hashes + symcount;
 786   for (; sym_hashes < end_hashes; sym_hashes++)
 787     {
 788       struct elf_link_hash_entry *sym_hash = *sym_hashes;
 789
 790       if ((sym_hash->root.type == bfd_link_hash_defined
 791            || sym_hash->root.type == bfd_link_hash_defweak)
 792           && sym_hash->root.u.def.section == sec
 793           && sym_hash->root.u.def.value == addr)
 794         return TRUE;
 795     }
 796
 797   return FALSE;
 798 }
 799
 800 /* Adjust all local symbols defined as '.section + 0xXXXX' (.section has sec_shndx)
 801     referenced from current and other sections.  */
 802 static bfd_boolean
 803 msp430_elf_relax_adjust_locals(bfd * abfd, asection * sec, bfd_vma addr,
 804     int count, unsigned int sec_shndx, bfd_vma toaddr)
 805 {
 806   Elf_Internal_Shdr *symtab_hdr;
 807   Elf_Internal_Rela *irel;
 808   Elf_Internal_Rela *irelend;
 809   Elf_Internal_Sym *isym;
 810
 811   irel = elf_section_data (sec)->relocs;
 812   irelend = irel + sec->reloc_count;
 813   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 814   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
 815
 816   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
 817     {
 818       int sidx = ELF32_R_SYM(irel->r_info);
 819       Elf_Internal_Sym *lsym = isym + sidx;
 820
 821       /* Adjust symbols referenced by .sec+0xXX */
 822       if (irel->r_addend > addr && irel->r_addend < toaddr
 823           && lsym->st_shndx == sec_shndx)
 824         irel->r_addend -= count;
 825     }
 826
 827   return TRUE;
 828 }
 829
 830 /* Delete some bytes from a section while relaxing.  */
 831
 832 static bfd_boolean
 833 msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
 834                                int count)
 835 {
 836   Elf_Internal_Shdr *symtab_hdr;
 837   unsigned int sec_shndx;
 838   bfd_byte *contents;
 839   Elf_Internal_Rela *irel;
 840   Elf_Internal_Rela *irelend;
 841   bfd_vma toaddr;
 842   Elf_Internal_Sym *isym;
 843   Elf_Internal_Sym *isymend;
 844   struct elf_link_hash_entry **sym_hashes;
 845   struct elf_link_hash_entry **end_hashes;
 846   unsigned int symcount;
 847   asection *p;
 848
 849   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
 850
 851   contents = elf_section_data (sec)->this_hdr.contents;
 852
 853   toaddr = sec->size;
 854
 855   irel = elf_section_data (sec)->relocs;
 856   irelend = irel + sec->reloc_count;
 857
 858   /* Actually delete the bytes.  */
 859   memmove (contents + addr, contents + addr + count,
 860            (size_t) (toaddr - addr - count));
 861   sec->size -= count;
 862
 863   /* Adjust all the relocs.  */
 864   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 865   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
 866   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
 867     {
 868       /* Get the new reloc address.  */
 869       if ((irel->r_offset > addr && irel->r_offset < toaddr))
 870         irel->r_offset -= count;
 871     }
 872
 873   for (p = abfd->sections; p != NULL; p = p->next)
 874     msp430_elf_relax_adjust_locals(abfd,p,addr,count,sec_shndx,toaddr);
 875
 876   /* Adjust the local symbols defined in this section.  */
 877   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 878   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
 879   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
 880     if (isym->st_shndx == sec_shndx
 881         && isym->st_value > addr && isym->st_value < toaddr)
 882       isym->st_value -= count;
 883
 884   /* Now adjust the global symbols defined in this section.  */
 885   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
 886               - symtab_hdr->sh_info);
 887   sym_hashes = elf_sym_hashes (abfd);
 888   end_hashes = sym_hashes + symcount;
 889   for (; sym_hashes < end_hashes; sym_hashes++)
 890     {
 891       struct elf_link_hash_entry *sym_hash = *sym_hashes;
 892
 893       if ((sym_hash->root.type == bfd_link_hash_defined
 894            || sym_hash->root.type == bfd_link_hash_defweak)
 895           && sym_hash->root.u.def.section == sec
 896           && sym_hash->root.u.def.value > addr
 897           && sym_hash->root.u.def.value < toaddr)
 898         sym_hash->root.u.def.value -= count;
 899     }
 900
 901   return TRUE;
 902 }
 903
 904 static bfd_boolean
 905 msp430_elf_relax_section (bfd * abfd, asection * sec,
 906                           struct bfd_link_info * link_info,
 907                           bfd_boolean * again)
 908 {
 909   Elf_Internal_Shdr * symtab_hdr;
 910   Elf_Internal_Rela * internal_relocs;
 911   Elf_Internal_Rela * irel;
 912   Elf_Internal_Rela * irelend;
 913   bfd_byte *          contents = NULL;
 914   Elf_Internal_Sym *  isymbuf = NULL;
 915
 916   /* Assume nothing changes.  */
 917   *again = FALSE;
 918
 919   /* We don't have to do anything for a relocatable link, if
 920      this section does not have relocs, or if this is not a
 921      code section.  */
 922   if (link_info->relocatable
 923       || (sec->flags & SEC_RELOC) == 0
 924       || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
 925     return TRUE;
 926
 927   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 928
 929   /* Get a copy of the native relocations.  */
 930   internal_relocs =
 931     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
 932   if (internal_relocs == NULL)
 933     goto error_return;
 934
 935   /* Walk through them looking for relaxing opportunities.  */
 936   irelend = internal_relocs + sec->reloc_count;
 937   for (irel = internal_relocs; irel < irelend; irel++)
 938     {
 939       bfd_vma symval;
 940
 941       /* If this isn't something that can be relaxed, then ignore
 942          this reloc.  */
 943       if (ELF32_R_TYPE (irel->r_info) != (int) R_MSP430_RL_PCREL)
 944         continue;
 945
 946       /* Get the section contents if we haven't done so already.  */
 947       if (contents == NULL)
 948         {
 949           /* Get cached copy if it exists.  */
 950           if (elf_section_data (sec)->this_hdr.contents != NULL)
 951             contents = elf_section_data (sec)->this_hdr.contents;
 952           else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
 953             goto error_return;
 954         }
 955
 956       /* Read this BFD's local symbols if we haven't done so already.  */
 957       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 958         {
 959           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 960           if (isymbuf == NULL)
 961             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 962                                             symtab_hdr->sh_info, 0,
 963                                             NULL, NULL, NULL);
 964           if (isymbuf == NULL)
 965             goto error_return;
 966         }
 967
 968       /* Get the value of the symbol referred to by the reloc.  */
 969       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 970         {
 971           /* A local symbol.  */
 972           Elf_Internal_Sym *isym;
 973           asection *sym_sec;
 974
 975           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 976           if (isym->st_shndx == SHN_UNDEF)
 977             sym_sec = bfd_und_section_ptr;
 978           else if (isym->st_shndx == SHN_ABS)
 979             sym_sec = bfd_abs_section_ptr;
 980           else if (isym->st_shndx == SHN_COMMON)
 981             sym_sec = bfd_com_section_ptr;
 982           else
 983             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 984           symval = (isym->st_value
 985                     + sym_sec->output_section->vma + sym_sec->output_offset);
 986         }
 987       else
 988         {
 989           unsigned long indx;
 990           struct elf_link_hash_entry *h;
 991
 992           /* An external symbol.  */
 993           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 994           h = elf_sym_hashes (abfd)[indx];
 995           BFD_ASSERT (h != NULL);
 996
 997           if (h->root.type != bfd_link_hash_defined
 998               && h->root.type != bfd_link_hash_defweak)
 999             /* This appears to be a reference to an undefined
1000                symbol.  Just ignore it--it will be caught by the
1001                regular reloc processing.  */
1002             continue;
1003
1004           symval = (h->root.u.def.value
1005                     + h->root.u.def.section->output_section->vma
1006                     + h->root.u.def.section->output_offset);
1007         }
1008
1009       /* For simplicity of coding, we are going to modify the section
1010          contents, the section relocs, and the BFD symbol table.  We
1011          must tell the rest of the code not to free up this
1012          information.  It would be possible to instead create a table
1013          of changes which have to be made, as is done in coff-mips.c;
1014          that would be more work, but would require less memory when
1015          the linker is run.  */
1016
1017       /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
1018          branch.  */
1019       /* Paranoia? paranoia...  */
1020       if (ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
1021         {
1022           bfd_vma value = symval;
1023
1024           /* Deal with pc-relative gunk.  */
1025           value -= (sec->output_section->vma + sec->output_offset);
1026           value -= irel->r_offset;
1027           value += irel->r_addend;
1028
1029           /* See if the value will fit in 10 bits, note the high value is
1030              1016 as the target will be two bytes closer if we are
1031              able to relax. */
1032           if ((long) value < 1016 && (long) value > -1016)
1033             {
1034               int code0 = 0, code1 = 0, code2 = 0;
1035               int i;
1036               struct rcodes_s *rx;
1037
1038               /* Get the opcode.  */
1039               if (irel->r_offset >= 6)
1040                 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
1041
1042               if (irel->r_offset >= 4)
1043                 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
1044
1045               code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
1046
1047               if (code2 != 0x4010)
1048                 continue;
1049
1050               /* Check r4 and r3.  */
1051               for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
1052                 {
1053                   rx = &rcode[i];
1054                   if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
1055                     break;
1056                   else if (rx->cdx == 1 && rx->f1 == code1)
1057                     break;
1058                   else if (rx->cdx == 0)        /* This is an unconditional jump.  */
1059                     break;
1060                 }
1061
1062               /* Check labels:
1063                    .Label0:       ; we do not care about this label
1064                       jeq    +6
1065                    .Label1:       ; make sure there is no label here
1066                       jl     +4
1067                    .Label2:       ; make sure there is no label here
1068                       br .Label_dst
1069
1070                  So, if there is .Label1 or .Label2 we cannot relax this code.
1071                  This actually should not happen, cause for relaxable
1072                  instructions we use RL_PCREL reloc instead of 16_PCREL.
1073                  Will change this in the future. */
1074
1075               if (rx->cdx > 0
1076                   && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1077                                                   irel->r_offset - 2))
1078                 continue;
1079               if (rx->cdx > 1
1080                   && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1081                                                   irel->r_offset - 4))
1082                 continue;
1083
1084               /* Note that we've changed the relocs, section contents, etc.  */
1085               elf_section_data (sec)->relocs = internal_relocs;
1086               elf_section_data (sec)->this_hdr.contents = contents;
1087               symtab_hdr->contents = (unsigned char *) isymbuf;
1088
1089               /* Fix the relocation's type.  */
1090               if (rx->labels == 3)      /* Handle special cases.  */
1091                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1092                                            R_MSP430_2X_PCREL);
1093               else
1094                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1095                                            R_MSP430_10_PCREL);
1096
1097               /* Fix the opcode right way.  */
1098               bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
1099               if (rx->t1)
1100                 bfd_put_16 (abfd, rx->t1,
1101                             contents + irel->r_offset - rx->off + 2);
1102
1103               /* Delete bytes. */
1104               if (!msp430_elf_relax_delete_bytes (abfd, sec,
1105                                                   irel->r_offset - rx->off +
1106                                                   rx->ncl, rx->bs))
1107                 goto error_return;
1108
1109               /* Handle unconditional jumps.  */
1110               if (rx->cdx == 0)
1111                 irel->r_offset -= 2;
1112
1113               /* That will change things, so, we should relax again.
1114                  Note that this is not required, and it may be slow.  */
1115               *again = TRUE;
1116             }
1117         }
1118     }
1119
1120   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1121     {
1122       if (!link_info->keep_memory)
1123         free (isymbuf);
1124       else
1125         {
1126           /* Cache the symbols for elf_link_input_bfd.  */
1127           symtab_hdr->contents = (unsigned char *) isymbuf;
1128         }
1129     }
1130
1131   if (contents != NULL
1132       && elf_section_data (sec)->this_hdr.contents != contents)
1133     {
1134       if (!link_info->keep_memory)
1135         free (contents);
1136       else
1137         {
1138           /* Cache the section contents for elf_link_input_bfd.  */
1139           elf_section_data (sec)->this_hdr.contents = contents;
1140         }
1141     }
1142
1143   if (internal_relocs != NULL
1144       && elf_section_data (sec)->relocs != internal_relocs)
1145     free (internal_relocs);
1146
1147   return TRUE;
1148
1149 error_return:
1150   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1151     free (isymbuf);
1152   if (contents != NULL
1153       && elf_section_data (sec)->this_hdr.contents != contents)
1154     free (contents);
1155   if (internal_relocs != NULL
1156       && elf_section_data (sec)->relocs != internal_relocs)
1157     free (internal_relocs);
1158
1159   return FALSE;
1160 }
1161
1162
1163 #define ELF_ARCH                bfd_arch_msp430
1164 #define ELF_MACHINE_CODE        EM_MSP430
1165 #define ELF_MACHINE_ALT1        EM_MSP430_OLD
1166 #define ELF_MAXPAGESIZE         1
1167 #define ELF_OSABI               ELFOSABI_STANDALONE
1168
1169 #define TARGET_LITTLE_SYM       bfd_elf32_msp430_vec
1170 #define TARGET_LITTLE_NAME      "elf32-msp430"
1171
1172 #define elf_info_to_howto                    msp430_info_to_howto_rela
1173 #define elf_info_to_howto_rel                NULL
1174 #define elf_backend_relocate_section         elf32_msp430_relocate_section
1175 #define elf_backend_check_relocs             elf32_msp430_check_relocs
1176 #define elf_backend_can_gc_sections          1
1177 #define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
1178 #define elf_backend_object_p                 elf32_msp430_object_p
1179 #define elf_backend_post_process_headers     _bfd_elf_set_osabi
1180 #define bfd_elf32_bfd_relax_section          msp430_elf_relax_section
1181
1182 #include "elf32-target.h"