bfd/elf32-msp430.c

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