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   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 872   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
 873   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
 874     {
 875       int sidx = ELF32_R_SYM(irel->r_info);
 876       Elf_Internal_Sym *lsym = isym + sidx;
 877
 878       /* Get the new reloc address.  */
 879       if ((irel->r_offset > addr && irel->r_offset < toaddr))
 880         irel->r_offset -= count;
 881
 882       /* Adjust symbols referenced by .sec+0xXX */
 883       if (irel->r_addend > addr && irel->r_addend < toaddr
 884           && lsym->st_shndx == sec_shndx)
 885         irel->r_addend -= count;
 886     }
 887
 888   /* Adjust the local symbols defined in this section.  */
 889   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 890   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
 891   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
 892     if (isym->st_shndx == sec_shndx
 893         && isym->st_value > addr && isym->st_value < toaddr)
 894       isym->st_value -= count;
 895
 896   /* Now adjust the global symbols defined in this section.  */
 897   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
 898               - symtab_hdr->sh_info);
 899   sym_hashes = elf_sym_hashes (abfd);
 900   end_hashes = sym_hashes + symcount;
 901   for (; sym_hashes < end_hashes; sym_hashes++)
 902     {
 903       struct elf_link_hash_entry *sym_hash = *sym_hashes;
 904
 905       if ((sym_hash->root.type == bfd_link_hash_defined
 906            || sym_hash->root.type == bfd_link_hash_defweak)
 907           && sym_hash->root.u.def.section == sec
 908           && sym_hash->root.u.def.value > addr
 909           && sym_hash->root.u.def.value < toaddr)
 910         sym_hash->root.u.def.value -= count;
 911     }
 912
 913   return TRUE;
 914 }
 915
 916
 917 static bfd_boolean
 918 msp430_elf_relax_section (bfd * abfd, asection * sec,
 919                           struct bfd_link_info * link_info,
 920                           bfd_boolean * again)
 921 {
 922   Elf_Internal_Shdr * symtab_hdr;
 923   Elf_Internal_Rela * internal_relocs;
 924   Elf_Internal_Rela * irel;
 925   Elf_Internal_Rela * irelend;
 926   bfd_byte *          contents = NULL;
 927   Elf_Internal_Sym *  isymbuf = NULL;
 928
 929   /* Assume nothing changes.  */
 930   *again = FALSE;
 931
 932   /* We don't have to do anything for a relocatable link, if
 933      this section does not have relocs, or if this is not a
 934      code section.  */
 935   if (link_info->relocatable
 936       || (sec->flags & SEC_RELOC) == 0
 937       || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
 938     return TRUE;
 939
 940   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
 941
 942   /* Get a copy of the native relocations.  */
 943   internal_relocs =
 944     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
 945   if (internal_relocs == NULL)
 946     goto error_return;
 947
 948   /* Walk through them looking for relaxing opportunities.  */
 949   irelend = internal_relocs + sec->reloc_count;
 950   for (irel = internal_relocs; irel < irelend; irel++)
 951     {
 952       bfd_vma symval;
 953
 954       /* If this isn't something that can be relaxed, then ignore
 955          this reloc.  */
 956       if (ELF32_R_TYPE (irel->r_info) != (int) R_MSP430_RL_PCREL)
 957         continue;
 958
 959       /* Get the section contents if we haven't done so already.  */
 960       if (contents == NULL)
 961         {
 962           /* Get cached copy if it exists.  */
 963           if (elf_section_data (sec)->this_hdr.contents != NULL)
 964             contents = elf_section_data (sec)->this_hdr.contents;
 965           else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
 966             goto error_return;
 967         }
 968
 969       /* Read this BFD's local symbols if we haven't done so already.  */
 970       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 971         {
 972           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 973           if (isymbuf == NULL)
 974             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 975                                             symtab_hdr->sh_info, 0,
 976                                             NULL, NULL, NULL);
 977           if (isymbuf == NULL)
 978             goto error_return;
 979         }
 980
 981       /* Get the value of the symbol referred to by the reloc.  */
 982       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 983         {
 984           /* A local symbol.  */
 985           Elf_Internal_Sym *isym;
 986           asection *sym_sec;
 987
 988           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 989           if (isym->st_shndx == SHN_UNDEF)
 990             sym_sec = bfd_und_section_ptr;
 991           else if (isym->st_shndx == SHN_ABS)
 992             sym_sec = bfd_abs_section_ptr;
 993           else if (isym->st_shndx == SHN_COMMON)
 994             sym_sec = bfd_com_section_ptr;
 995           else
 996             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 997           symval = (isym->st_value
 998                     + sym_sec->output_section->vma + sym_sec->output_offset);
 999         }
1000       else
1001         {
1002           unsigned long indx;
1003           struct elf_link_hash_entry *h;
1004
1005           /* An external symbol.  */
1006           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1007           h = elf_sym_hashes (abfd)[indx];
1008           BFD_ASSERT (h != NULL);
1009
1010           if (h->root.type != bfd_link_hash_defined
1011               && h->root.type != bfd_link_hash_defweak)
1012             /* This appears to be a reference to an undefined
1013                symbol.  Just ignore it--it will be caught by the
1014                regular reloc processing.  */
1015             continue;
1016
1017           symval = (h->root.u.def.value
1018                     + h->root.u.def.section->output_section->vma
1019                     + h->root.u.def.section->output_offset);
1020         }
1021
1022       /* For simplicity of coding, we are going to modify the section
1023          contents, the section relocs, and the BFD symbol table.  We
1024          must tell the rest of the code not to free up this
1025          information.  It would be possible to instead create a table
1026          of changes which have to be made, as is done in coff-mips.c;
1027          that would be more work, but would require less memory when
1028          the linker is run.  */
1029
1030       /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
1031          branch.  */
1032       /* Paranoia? paranoia...  */
1033       if (ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
1034         {
1035           bfd_vma value = symval;
1036
1037           /* Deal with pc-relative gunk.  */
1038           value -= (sec->output_section->vma + sec->output_offset);
1039           value -= irel->r_offset;
1040           value += irel->r_addend;
1041
1042           /* See if the value will fit in 10 bits, note the high value is
1043              1016 as the target will be two bytes closer if we are
1044              able to relax. */
1045           if ((long) value < 1016 && (long) value > -1016)
1046             {
1047               int code0 = 0, code1 = 0, code2 = 0;
1048               int i;
1049               struct rcodes_s *rx;
1050
1051               /* Get the opcode.  */
1052               if (irel->r_offset >= 6)
1053                 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
1054
1055               if (irel->r_offset >= 4)
1056                 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
1057
1058               code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
1059
1060               if (code2 != 0x4010)
1061                 continue;
1062
1063               /* Check r4 and r3.  */
1064               for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
1065                 {
1066                   rx = &rcode[i];
1067                   if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
1068                     break;
1069                   else if (rx->cdx == 1 && rx->f1 == code1)
1070                     break;
1071                   else if (rx->cdx == 0)        /* This is an unconditional jump.  */
1072                     break;
1073                 }
1074
1075               /* Check labels:
1076                    .Label0:       ; we do not care about this label
1077                       jeq    +6
1078                    .Label1:       ; make sure there is no label here
1079                       jl     +4
1080                    .Label2:       ; make sure there is no label here
1081                       br .Label_dst
1082
1083                  So, if there is .Label1 or .Label2 we cannot relax this code.
1084                  This actually should not happen, cause for relaxable
1085                  instructions we use RL_PCREL reloc instead of 16_PCREL.
1086                  Will change this in the future. */
1087
1088               if (rx->cdx > 0
1089                   && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1090                                                   irel->r_offset - 2))
1091                 continue;
1092               if (rx->cdx > 1
1093                   && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1094                                                   irel->r_offset - 4))
1095                 continue;
1096
1097               /* Note that we've changed the relocs, section contents, etc.  */
1098               elf_section_data (sec)->relocs = internal_relocs;
1099               elf_section_data (sec)->this_hdr.contents = contents;
1100               symtab_hdr->contents = (unsigned char *) isymbuf;
1101
1102               /* Fix the relocation's type.  */
1103               if (rx->labels == 3)      /* Handle special cases.  */
1104                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1105                                            R_MSP430_2X_PCREL);
1106               else
1107                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1108                                            R_MSP430_10_PCREL);
1109
1110               /* Fix the opcode right way.  */
1111               bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
1112               if (rx->t1)
1113                 bfd_put_16 (abfd, rx->t1,
1114                             contents + irel->r_offset - rx->off + 2);
1115
1116               /* Delete bytes. */
1117               if (!msp430_elf_relax_delete_bytes (abfd, sec,
1118                                                   irel->r_offset - rx->off +
1119                                                   rx->ncl, rx->bs))
1120                 goto error_return;
1121
1122               /* Handle unconditional jumps.  */
1123               if (rx->cdx == 0)
1124                 irel->r_offset -= 2;
1125
1126               /* That will change things, so, we should relax again.
1127                  Note that this is not required, and it may be slow.  */
1128               *again = TRUE;
1129             }
1130         }
1131     }
1132
1133   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1134     {
1135       if (!link_info->keep_memory)
1136         free (isymbuf);
1137       else
1138         {
1139           /* Cache the symbols for elf_link_input_bfd.  */
1140           symtab_hdr->contents = (unsigned char *) isymbuf;
1141         }
1142     }
1143
1144   if (contents != NULL
1145       && elf_section_data (sec)->this_hdr.contents != contents)
1146     {
1147       if (!link_info->keep_memory)
1148         free (contents);
1149       else
1150         {
1151           /* Cache the section contents for elf_link_input_bfd.  */
1152           elf_section_data (sec)->this_hdr.contents = contents;
1153         }
1154     }
1155
1156   if (internal_relocs != NULL
1157       && elf_section_data (sec)->relocs != internal_relocs)
1158     free (internal_relocs);
1159
1160   return TRUE;
1161
1162 error_return:
1163   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1164     free (isymbuf);
1165   if (contents != NULL
1166       && elf_section_data (sec)->this_hdr.contents != contents)
1167     free (contents);
1168   if (internal_relocs != NULL
1169       && elf_section_data (sec)->relocs != internal_relocs)
1170     free (internal_relocs);
1171
1172   return FALSE;
1173 }
1174
1175
1176 #define ELF_ARCH                bfd_arch_msp430
1177 #define ELF_MACHINE_CODE        EM_MSP430
1178 #define ELF_MACHINE_ALT1        EM_MSP430_OLD
1179 #define ELF_MAXPAGESIZE         1
1180
1181 #define TARGET_LITTLE_SYM       bfd_elf32_msp430_vec
1182 #define TARGET_LITTLE_NAME      "elf32-msp430"
1183
1184 #define elf_info_to_howto                    msp430_info_to_howto_rela
1185 #define elf_info_to_howto_rel                NULL
1186 #define elf_backend_relocate_section         elf32_msp430_relocate_section
1187 #define elf_backend_gc_mark_hook             elf32_msp430_gc_mark_hook
1188 #define elf_backend_gc_sweep_hook            elf32_msp430_gc_sweep_hook
1189 #define elf_backend_check_relocs             elf32_msp430_check_relocs
1190 #define elf_backend_can_gc_sections          1
1191 #define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
1192 #define elf_backend_object_p                 elf32_msp430_object_p
1193 #define elf_backend_post_process_headers     elf32_msp430_post_process_headers
1194 #define bfd_elf32_bfd_relax_section          msp430_elf_relax_section
1195
1196 #include "elf32-target.h"