bfd/elf32-msp430.c

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