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