bfd/elf32-msp430.c

   1 /*  MSP430-specific support for 32-bit ELF
   2     Copyright (C) 2002-2013 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 3 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,
  20     MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libiberty.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/msp430.h"
  28
  29 static reloc_howto_type elf_msp430_howto_table[] =
  30 {
  31   HOWTO (R_MSP430_NONE,         /* type */
  32          0,                     /* rightshift */
  33          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  34          32,                    /* bitsize */
  35          FALSE,                 /* pc_relative */
  36          0,                     /* bitpos */
  37          complain_overflow_bitfield,/* complain_on_overflow */
  38          bfd_elf_generic_reloc, /* special_function */
  39          "R_MSP430_NONE",       /* name */
  40          FALSE,                 /* partial_inplace */
  41          0,                     /* src_mask */
  42          0,                     /* dst_mask */
  43          FALSE),                /* pcrel_offset */
  44
  45   HOWTO (R_MSP430_32,           /* type */
  46          0,                     /* rightshift */
  47          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  48          32,                    /* bitsize */
  49          FALSE,                 /* pc_relative */
  50          0,                     /* bitpos */
  51          complain_overflow_bitfield,/* complain_on_overflow */
  52          bfd_elf_generic_reloc, /* special_function */
  53          "R_MSP430_32",         /* name */
  54          FALSE,                 /* partial_inplace */
  55          0xffffffff,            /* src_mask */
  56          0xffffffff,            /* dst_mask */
  57          FALSE),                /* pcrel_offset */
  58
  59   /* A 10 bit PC relative relocation.  */
  60   HOWTO (R_MSP430_10_PCREL,     /* type */
  61          1,                     /* rightshift */
  62          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  63          10,                    /* bitsize */
  64          TRUE,                  /* pc_relative */
  65          0,                     /* bitpos */
  66          complain_overflow_bitfield,/* complain_on_overflow */
  67          bfd_elf_generic_reloc, /* special_function */
  68          "R_MSP430_10_PCREL",   /* name */
  69          FALSE,                 /* partial_inplace */
  70          0x3ff,                 /* src_mask */
  71          0x3ff,                 /* dst_mask */
  72          TRUE),                 /* pcrel_offset */
  73
  74   /* A 16 bit absolute relocation.  */
  75   HOWTO (R_MSP430_16,           /* type */
  76          0,                     /* rightshift */
  77          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  78          16,                    /* bitsize */
  79          FALSE,                 /* pc_relative */
  80          0,                     /* bitpos */
  81          complain_overflow_dont,/* complain_on_overflow */
  82          bfd_elf_generic_reloc, /* special_function */
  83          "R_MSP430_16",         /* name */
  84          FALSE,                 /* partial_inplace */
  85          0,                     /* src_mask */
  86          0xffff,                /* dst_mask */
  87          FALSE),                /* pcrel_offset */
  88
  89   /* A 16 bit PC relative relocation for command address.  */
  90   HOWTO (R_MSP430_16_PCREL,     /* type */
  91          1,                     /* rightshift */
  92          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  93          16,                    /* bitsize */
  94          TRUE,                  /* pc_relative */
  95          0,                     /* bitpos */
  96          complain_overflow_dont,/* complain_on_overflow */
  97          bfd_elf_generic_reloc, /* special_function */
  98          "R_MSP430_16_PCREL",   /* name */
  99          FALSE,                 /* partial_inplace */
 100          0,                     /* src_mask */
 101          0xffff,                /* dst_mask */
 102          TRUE),                 /* pcrel_offset */
 103
 104   /* A 16 bit absolute relocation, byte operations.  */
 105   HOWTO (R_MSP430_16_BYTE,      /* type */
 106          0,                     /* rightshift */
 107          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 108          16,                    /* bitsize */
 109          FALSE,                 /* pc_relative */
 110          0,                     /* bitpos */
 111          complain_overflow_dont,/* complain_on_overflow */
 112          bfd_elf_generic_reloc, /* special_function */
 113          "R_MSP430_16_BYTE",    /* name */
 114          FALSE,                 /* partial_inplace */
 115          0xffff,                /* src_mask */
 116          0xffff,                /* dst_mask */
 117          FALSE),                /* pcrel_offset */
 118
 119   /* A 16 bit absolute relocation for command address.  */
 120   HOWTO (R_MSP430_16_PCREL_BYTE,/* type */
 121          1,                     /* rightshift */
 122          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 123          16,                    /* bitsize */
 124          TRUE,                  /* pc_relative */
 125          0,                     /* bitpos */
 126          complain_overflow_dont,/* complain_on_overflow */
 127          bfd_elf_generic_reloc, /* special_function */
 128          "R_MSP430_16_PCREL_BYTE",/* name */
 129          FALSE,                 /* partial_inplace */
 130          0xffff,                /* src_mask */
 131          0xffff,                /* dst_mask */
 132          TRUE),                 /* pcrel_offset */
 133
 134   /* A 10 bit PC relative relocation for complicated polymorphs.  */
 135   HOWTO (R_MSP430_2X_PCREL,     /* type */
 136          1,                     /* rightshift */
 137          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 138          10,                    /* bitsize */
 139          TRUE,                  /* pc_relative */
 140          0,                     /* bitpos */
 141          complain_overflow_bitfield,/* complain_on_overflow */
 142          bfd_elf_generic_reloc, /* special_function */
 143          "R_MSP430_2X_PCREL",   /* name */
 144          FALSE,                 /* partial_inplace */
 145          0x3ff,                 /* src_mask */
 146          0x3ff,                 /* dst_mask */
 147          TRUE),                 /* pcrel_offset */
 148
 149   /* A 16 bit relaxable relocation for command address.  */
 150   HOWTO (R_MSP430_RL_PCREL,     /* type */
 151          1,                     /* rightshift */
 152          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          16,                    /* bitsize */
 154          TRUE,                  /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_dont,/* complain_on_overflow */
 157          bfd_elf_generic_reloc, /* special_function */
 158          "R_MSP430_RL_PCREL",   /* name */
 159          FALSE,                 /* partial_inplace */
 160          0,                     /* src_mask */
 161          0xffff,                /* dst_mask */
 162          TRUE)                  /* pcrel_offset */
 163
 164   /* A 8-bit absolute relocation.  */
 165   , HOWTO (R_MSP430_8,          /* type */
 166          0,                     /* rightshift */
 167          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 168          8,                     /* bitsize */
 169          FALSE,                 /* pc_relative */
 170          0,                     /* bitpos */
 171          complain_overflow_dont,/* complain_on_overflow */
 172          bfd_elf_generic_reloc, /* special_function */
 173          "R_MSP430_8",          /* name */
 174          FALSE,                 /* partial_inplace */
 175          0,                     /* src_mask */
 176          0xffff,                /* dst_mask */
 177          FALSE),                /* pcrel_offset */
 178
 179   /* Together with a following reloc, allows for the difference
 180      between two symbols to be the real addend of the second reloc.  */
 181   HOWTO (R_MSP430_SYM_DIFF,     /* type */
 182          0,                     /* rightshift */
 183          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 184          32,                    /* bitsize */
 185          FALSE,                 /* pc_relative */
 186          0,                     /* bitpos */
 187          complain_overflow_dont,/* complain_on_overflow */
 188          NULL,                  /* special handler.  */
 189          "R_MSP430_SYM_DIFF",   /* name */
 190          FALSE,                 /* partial_inplace */
 191          0xffffffff,            /* src_mask */
 192          0xffffffff,            /* dst_mask */
 193          FALSE)                 /* pcrel_offset */
 194 };
 195
 196 static reloc_howto_type elf_msp430x_howto_table[] =
 197 {
 198   HOWTO (R_MSP430_NONE,         /* type */
 199          0,                     /* rightshift */
 200          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 201          32,                    /* bitsize */
 202          FALSE,                 /* pc_relative */
 203          0,                     /* bitpos */
 204          complain_overflow_bitfield,/* complain_on_overflow */
 205          bfd_elf_generic_reloc, /* special_function */
 206          "R_MSP430_NONE",       /* name */
 207          FALSE,                 /* partial_inplace */
 208          0,                     /* src_mask */
 209          0,                     /* dst_mask */
 210          FALSE),                /* pcrel_offset */
 211
 212   HOWTO (R_MSP430_ABS32,        /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          32,                    /* bitsize */
 216          FALSE,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_bitfield,/* complain_on_overflow */
 219          bfd_elf_generic_reloc, /* special_function */
 220          "R_MSP430_ABS32",      /* name */
 221          FALSE,                 /* partial_inplace */
 222          0xffffffff,            /* src_mask */
 223          0xffffffff,            /* dst_mask */
 224          FALSE),                /* pcrel_offset */
 225
 226   HOWTO (R_MSP430_ABS16,        /* type */
 227          0,                     /* rightshift */
 228          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          16,                    /* bitsize */
 230          FALSE,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_dont,/* complain_on_overflow */
 233          bfd_elf_generic_reloc, /* special_function */
 234          "R_MSP430_ABS16",      /* name */
 235          FALSE,                 /* partial_inplace */
 236          0,                     /* src_mask */
 237          0xffff,                /* dst_mask */
 238          FALSE),                /* pcrel_offset */
 239
 240   HOWTO (R_MSP430_ABS8,         /* type */
 241          0,                     /* rightshift */
 242          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          8,                     /* bitsize */
 244          FALSE,                 /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_bitfield,/* complain_on_overflow */
 247          bfd_elf_generic_reloc, /* special_function */
 248          "R_MSP430_ABS8",       /* name */
 249          FALSE,                 /* partial_inplace */
 250          0xff,                  /* src_mask */
 251          0xff,                  /* dst_mask */
 252          FALSE),                /* pcrel_offset */
 253
 254   HOWTO (R_MSP430_PCR16,        /* type */
 255          1,                     /* rightshift */
 256          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 257          16,                    /* bitsize */
 258          TRUE,                  /* pc_relative */
 259          0,                     /* bitpos */
 260          complain_overflow_dont,/* complain_on_overflow */
 261          bfd_elf_generic_reloc, /* special_function */
 262          "R_MSP430_PCR16",      /* name */
 263          FALSE,                 /* partial_inplace */
 264          0,                     /* src_mask */
 265          0xffff,                /* dst_mask */
 266          TRUE),                 /* pcrel_offset */
 267
 268   HOWTO (R_MSP430X_PCR20_EXT_SRC,/* type */
 269          0,                     /* rightshift */
 270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          32,                    /* bitsize */
 272          TRUE,                  /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_dont,/* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_MSP430X_PCR20_EXT_SRC",/* name */
 277          FALSE,                 /* partial_inplace */
 278          0,                     /* src_mask */
 279          0xffff,                /* dst_mask */
 280          TRUE),                 /* pcrel_offset */
 281
 282   HOWTO (R_MSP430X_PCR20_EXT_DST,/* type */
 283          0,                     /* rightshift */
 284          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 285          32,                    /* bitsize */
 286          TRUE,                  /* pc_relative */
 287          0,                     /* bitpos */
 288          complain_overflow_dont,/* complain_on_overflow */
 289          bfd_elf_generic_reloc, /* special_function */
 290          "R_MSP430X_PCR20_EXT_DST",/* name */
 291          FALSE,                 /* partial_inplace */
 292          0,                     /* src_mask */
 293          0xffff,                /* dst_mask */
 294          TRUE),                 /* pcrel_offset */
 295
 296   HOWTO (R_MSP430X_PCR20_EXT_ODST,/* type */
 297          0,                     /* rightshift */
 298          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 299          32,                    /* bitsize */
 300          TRUE,                  /* pc_relative */
 301          0,                     /* bitpos */
 302          complain_overflow_dont,/* complain_on_overflow */
 303          bfd_elf_generic_reloc, /* special_function */
 304          "R_MSP430X_PCR20_EXT_ODST",/* name */
 305          FALSE,                 /* partial_inplace */
 306          0,                     /* src_mask */
 307          0xffff,                /* dst_mask */
 308          TRUE),                 /* pcrel_offset */
 309
 310   HOWTO (R_MSP430X_ABS20_EXT_SRC,/* type */
 311          0,                     /* rightshift */
 312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 313          32,                    /* bitsize */
 314          TRUE,                  /* pc_relative */
 315          0,                     /* bitpos */
 316          complain_overflow_dont,/* complain_on_overflow */
 317          bfd_elf_generic_reloc, /* special_function */
 318          "R_MSP430X_ABS20_EXT_SRC",/* name */
 319          FALSE,                 /* partial_inplace */
 320          0,                     /* src_mask */
 321          0xffff,                /* dst_mask */
 322          TRUE),                 /* pcrel_offset */
 323
 324   HOWTO (R_MSP430X_ABS20_EXT_DST,/* type */
 325          0,                     /* rightshift */
 326          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          32,                    /* bitsize */
 328          TRUE,                  /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_dont,/* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* special_function */
 332          "R_MSP430X_ABS20_EXT_DST",/* name */
 333          FALSE,                 /* partial_inplace */
 334          0,                     /* src_mask */
 335          0xffff,                /* dst_mask */
 336          TRUE),                 /* pcrel_offset */
 337
 338   HOWTO (R_MSP430X_ABS20_EXT_ODST,/* type */
 339          0,                     /* rightshift */
 340          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          32,                    /* bitsize */
 342          TRUE,                  /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_dont,/* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* special_function */
 346          "R_MSP430X_ABS20_EXT_ODST",/* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0xffff,                /* dst_mask */
 350          TRUE),                 /* pcrel_offset */
 351
 352   HOWTO (R_MSP430X_ABS20_ADR_SRC,/* type */
 353          0,                     /* rightshift */
 354          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          32,                    /* bitsize */
 356          TRUE,                  /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_dont,/* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* special_function */
 360          "R_MSP430X_ABS20_ADR_SRC",/* name */
 361          FALSE,                 /* partial_inplace */
 362          0,                     /* src_mask */
 363          0xffff,                /* dst_mask */
 364          TRUE),                 /* pcrel_offset */
 365
 366   HOWTO (R_MSP430X_ABS20_ADR_DST,/* type */
 367          0,                     /* rightshift */
 368          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 369          32,                    /* bitsize */
 370          TRUE,                  /* pc_relative */
 371          0,                     /* bitpos */
 372          complain_overflow_dont,/* complain_on_overflow */
 373          bfd_elf_generic_reloc, /* special_function */
 374          "R_MSP430X_ABS20_ADR_DST",/* name */
 375          FALSE,                 /* partial_inplace */
 376          0,                     /* src_mask */
 377          0xffff,                /* dst_mask */
 378          TRUE),                 /* pcrel_offset */
 379
 380   HOWTO (R_MSP430X_PCR16,       /* type */
 381          0,                     /* rightshift */
 382          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 383          32,                    /* bitsize */
 384          TRUE,                  /* pc_relative */
 385          0,                     /* bitpos */
 386          complain_overflow_dont,/* complain_on_overflow */
 387          bfd_elf_generic_reloc, /* special_function */
 388          "R_MSP430X_PCR16",     /* name */
 389          FALSE,                 /* partial_inplace */
 390          0,                     /* src_mask */
 391          0xffff,                /* dst_mask */
 392          TRUE),                 /* pcrel_offset */
 393
 394   HOWTO (R_MSP430X_PCR20_CALL,  /* type */
 395          0,                     /* rightshift */
 396          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 397          32,                    /* bitsize */
 398          TRUE,                  /* pc_relative */
 399          0,                     /* bitpos */
 400          complain_overflow_dont,/* complain_on_overflow */
 401          bfd_elf_generic_reloc, /* special_function */
 402          "R_MSP430X_PCR20_CALL",/* name */
 403          FALSE,                 /* partial_inplace */
 404          0,                     /* src_mask */
 405          0xffff,                /* dst_mask */
 406          TRUE),                 /* pcrel_offset */
 407
 408   HOWTO (R_MSP430X_ABS16,       /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          32,                    /* bitsize */
 412          TRUE,                  /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_dont,/* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* special_function */
 416          "R_MSP430X_ABS16",     /* name */
 417          FALSE,                 /* partial_inplace */
 418          0,                     /* src_mask */
 419          0xffff,                /* dst_mask */
 420          TRUE),                 /* pcrel_offset */
 421
 422   HOWTO (R_MSP430_ABS_HI16,     /* type */
 423          0,                     /* rightshift */
 424          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 425          32,                    /* bitsize */
 426          TRUE,                  /* pc_relative */
 427          0,                     /* bitpos */
 428          complain_overflow_dont,/* complain_on_overflow */
 429          bfd_elf_generic_reloc, /* special_function */
 430          "R_MSP430_ABS_HI16",   /* name */
 431          FALSE,                 /* partial_inplace */
 432          0,                     /* src_mask */
 433          0xffff,                /* dst_mask */
 434          TRUE),                 /* pcrel_offset */
 435
 436   HOWTO (R_MSP430_PREL31,       /* type */
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          32,                    /* bitsize */
 440          TRUE,                  /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_dont,/* complain_on_overflow */
 443          bfd_elf_generic_reloc, /* special_function */
 444          "R_MSP430_PREL31",     /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0xffff,                /* dst_mask */
 448          TRUE),                 /* pcrel_offset */
 449
 450   EMPTY_HOWTO (R_MSP430_EHTYPE),
 451
 452   /* A 10 bit PC relative relocation.  */
 453   HOWTO (R_MSP430X_10_PCREL,    /* type */
 454          1,                     /* rightshift */
 455          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          10,                    /* bitsize */
 457          TRUE,                  /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_bitfield,/* complain_on_overflow */
 460          bfd_elf_generic_reloc, /* special_function */
 461          "R_MSP430X_10_PCREL",  /* name */
 462          FALSE,                 /* partial_inplace */
 463          0x3ff,                 /* src_mask */
 464          0x3ff,                 /* dst_mask */
 465          TRUE),                 /* pcrel_offset */
 466
 467   /* A 10 bit PC relative relocation for complicated polymorphs.  */
 468   HOWTO (R_MSP430X_2X_PCREL,    /* type */
 469          1,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          10,                    /* bitsize */
 472          TRUE,                  /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_bitfield,/* complain_on_overflow */
 475          bfd_elf_generic_reloc, /* special_function */
 476          "R_MSP430X_2X_PCREL",  /* name */
 477          FALSE,                 /* partial_inplace */
 478          0x3ff,                 /* src_mask */
 479          0x3ff,                 /* dst_mask */
 480          TRUE),                 /* pcrel_offset */
 481
 482   /* Together with a following reloc, allows for the difference
 483      between two symbols to be the real addend of the second reloc.  */
 484   HOWTO (R_MSP430X_SYM_DIFF,    /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          32,                    /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont,/* complain_on_overflow */
 491          NULL,                  /* special handler.  */
 492          "R_MSP430X_SYM_DIFF",  /* name */
 493          FALSE,                 /* partial_inplace */
 494          0xffffffff,            /* src_mask */
 495          0xffffffff,            /* dst_mask */
 496          FALSE)                 /* pcrel_offset */
 497 };
 498
 499 /* Map BFD reloc types to MSP430 ELF reloc types.  */
 500
 501 struct msp430_reloc_map
 502 {
 503   bfd_reloc_code_real_type bfd_reloc_val;
 504   unsigned int elf_reloc_val;
 505 };
 506
 507 static const struct msp430_reloc_map msp430_reloc_map[] =
 508 {
 509   {BFD_RELOC_NONE,                 R_MSP430_NONE},
 510   {BFD_RELOC_32,                   R_MSP430_32},
 511   {BFD_RELOC_MSP430_10_PCREL,      R_MSP430_10_PCREL},
 512   {BFD_RELOC_16,                   R_MSP430_16_BYTE},
 513   {BFD_RELOC_MSP430_16_PCREL,      R_MSP430_16_PCREL},
 514   {BFD_RELOC_MSP430_16,            R_MSP430_16},
 515   {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE},
 516   {BFD_RELOC_MSP430_16_BYTE,       R_MSP430_16_BYTE},
 517   {BFD_RELOC_MSP430_2X_PCREL,      R_MSP430_2X_PCREL},
 518   {BFD_RELOC_MSP430_RL_PCREL,      R_MSP430_RL_PCREL},
 519   {BFD_RELOC_8,                    R_MSP430_8},
 520   {BFD_RELOC_MSP430_SYM_DIFF,      R_MSP430_SYM_DIFF}
 521 };
 522
 523 static const struct msp430_reloc_map msp430x_reloc_map[] =
 524 {
 525   {BFD_RELOC_NONE,                    R_MSP430_NONE},
 526   {BFD_RELOC_32,                      R_MSP430_ABS32},
 527   {BFD_RELOC_16,                      R_MSP430_ABS16},
 528   {BFD_RELOC_8,                       R_MSP430_ABS8},
 529   {BFD_RELOC_MSP430_ABS8,             R_MSP430_ABS8},
 530   {BFD_RELOC_MSP430X_PCR20_EXT_SRC,   R_MSP430X_PCR20_EXT_SRC},
 531   {BFD_RELOC_MSP430X_PCR20_EXT_DST,   R_MSP430X_PCR20_EXT_DST},
 532   {BFD_RELOC_MSP430X_PCR20_EXT_ODST,  R_MSP430X_PCR20_EXT_ODST},
 533   {BFD_RELOC_MSP430X_ABS20_EXT_SRC,   R_MSP430X_ABS20_EXT_SRC},
 534   {BFD_RELOC_MSP430X_ABS20_EXT_DST,   R_MSP430X_ABS20_EXT_DST},
 535   {BFD_RELOC_MSP430X_ABS20_EXT_ODST,  R_MSP430X_ABS20_EXT_ODST},
 536   {BFD_RELOC_MSP430X_ABS20_ADR_SRC,   R_MSP430X_ABS20_ADR_SRC},
 537   {BFD_RELOC_MSP430X_ABS20_ADR_DST,   R_MSP430X_ABS20_ADR_DST},
 538   {BFD_RELOC_MSP430X_PCR16,           R_MSP430X_PCR16},
 539   {BFD_RELOC_MSP430X_PCR20_CALL,      R_MSP430X_PCR20_CALL},
 540   {BFD_RELOC_MSP430X_ABS16,           R_MSP430X_ABS16},
 541   {BFD_RELOC_MSP430_ABS_HI16,         R_MSP430_ABS_HI16},
 542   {BFD_RELOC_MSP430_PREL31,           R_MSP430_PREL31},
 543   {BFD_RELOC_MSP430_10_PCREL,         R_MSP430X_10_PCREL},
 544   {BFD_RELOC_MSP430_2X_PCREL,         R_MSP430X_2X_PCREL},
 545   {BFD_RELOC_MSP430_RL_PCREL,         R_MSP430X_PCR16},
 546   {BFD_RELOC_MSP430_SYM_DIFF,         R_MSP430X_SYM_DIFF}
 547 };
 548
 549 static inline bfd_boolean
 550 uses_msp430x_relocs (bfd * abfd)
 551 {
 552   extern const bfd_target bfd_elf32_msp430_ti_vec;
 553
 554   return bfd_get_mach (abfd) == bfd_mach_msp430x
 555     || abfd->xvec == & bfd_elf32_msp430_ti_vec;
 556 }
 557
 558 static reloc_howto_type *
 559 bfd_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 560                                  bfd_reloc_code_real_type code)
 561 {
 562   unsigned int i;
 563
 564   if (uses_msp430x_relocs (abfd))
 565     {
 566       for (i = ARRAY_SIZE (msp430x_reloc_map); i--;)
 567         if (msp430x_reloc_map[i].bfd_reloc_val == code)
 568           return elf_msp430x_howto_table + msp430x_reloc_map[i].elf_reloc_val;
 569     }
 570   else
 571     {
 572       for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++)
 573         if (msp430_reloc_map[i].bfd_reloc_val == code)
 574           return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val];
 575     }
 576
 577   return NULL;
 578 }
 579
 580 static reloc_howto_type *
 581 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 582                                  const char *r_name)
 583 {
 584   unsigned int i;
 585
 586   if (uses_msp430x_relocs (abfd))
 587     {
 588       for (i = ARRAY_SIZE (elf_msp430x_howto_table); i--;)
 589         if (elf_msp430x_howto_table[i].name != NULL
 590             && strcasecmp (elf_msp430x_howto_table[i].name, r_name) == 0)
 591           return elf_msp430x_howto_table + i;
 592     }
 593   else
 594     {
 595       for (i = 0;
 596            i < (sizeof (elf_msp430_howto_table)
 597                 / sizeof (elf_msp430_howto_table[0]));
 598            i++)
 599         if (elf_msp430_howto_table[i].name != NULL
 600             && strcasecmp (elf_msp430_howto_table[i].name, r_name) == 0)
 601           return &elf_msp430_howto_table[i];
 602     }
 603
 604   return NULL;
 605 }
 606
 607 /* Set the howto pointer for an MSP430 ELF reloc.  */
 608
 609 static void
 610 msp430_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 611                            arelent * cache_ptr,
 612                            Elf_Internal_Rela * dst)
 613 {
 614   unsigned int r_type;
 615
 616   r_type = ELF32_R_TYPE (dst->r_info);
 617
 618   if (uses_msp430x_relocs (abfd))
 619     {
 620       BFD_ASSERT (r_type < (unsigned int) R_MSP430x_max);
 621       cache_ptr->howto = elf_msp430x_howto_table + r_type;
 622       return;
 623     }
 624
 625   BFD_ASSERT (r_type < (unsigned int) R_MSP430_max);
 626   cache_ptr->howto = &elf_msp430_howto_table[r_type];
 627 }
 628
 629 /* Look through the relocs for a section during the first phase.
 630    Since we don't do .gots or .plts, we just need to consider the
 631    virtual table relocs for gc.  */
 632
 633 static bfd_boolean
 634 elf32_msp430_check_relocs (bfd * abfd, struct bfd_link_info * info,
 635                            asection * sec, const Elf_Internal_Rela * relocs)
 636 {
 637   Elf_Internal_Shdr *symtab_hdr;
 638   struct elf_link_hash_entry **sym_hashes;
 639   const Elf_Internal_Rela *rel;
 640   const Elf_Internal_Rela *rel_end;
 641
 642   if (info->relocatable)
 643     return TRUE;
 644
 645   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 646   sym_hashes = elf_sym_hashes (abfd);
 647
 648   rel_end = relocs + sec->reloc_count;
 649   for (rel = relocs; rel < rel_end; rel++)
 650     {
 651       struct elf_link_hash_entry *h;
 652       unsigned long r_symndx;
 653
 654       r_symndx = ELF32_R_SYM (rel->r_info);
 655       if (r_symndx < symtab_hdr->sh_info)
 656         h = NULL;
 657       else
 658         {
 659           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 660           while (h->root.type == bfd_link_hash_indirect
 661                  || h->root.type == bfd_link_hash_warning)
 662             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 663
 664           /* PR15323, ref flags aren't set for references in the same
 665              object.  */
 666           h->root.non_ir_ref = 1;
 667         }
 668     }
 669
 670   return TRUE;
 671 }
 672
 673 /* Perform a single relocation.  By default we use the standard BFD
 674    routines, but a few relocs, we have to do them ourselves.  */
 675
 676 static bfd_reloc_status_type
 677 msp430_final_link_relocate (reloc_howto_type *     howto,
 678                             bfd *                  input_bfd,
 679                             asection *             input_section,
 680                             bfd_byte *             contents,
 681                             Elf_Internal_Rela *    rel,
 682                             bfd_vma                relocation,
 683                             struct bfd_link_info * info)
 684 {
 685   static asection *  sym_diff_section;
 686   static bfd_vma     sym_diff_value;
 687
 688   struct bfd_elf_section_data * esd = elf_section_data (input_section);
 689   bfd_reloc_status_type r = bfd_reloc_ok;
 690   bfd_vma x;
 691   bfd_signed_vma srel;
 692   bfd_boolean is_rel_reloc = FALSE;
 693
 694   if (uses_msp430x_relocs (input_bfd))
 695     {
 696       /* See if we have a REL type relocation.  */
 697       is_rel_reloc = (esd->rel.hdr != NULL);
 698       /* Sanity check - only one type of relocation per section.
 699          FIXME: Theoretically it is possible to have both types,
 700          but if that happens how can we distinguish between the two ?  */
 701       BFD_ASSERT (! is_rel_reloc || ! esd->rela.hdr);
 702       /* If we are using a REL relocation then the addend should be empty.  */
 703       BFD_ASSERT (! is_rel_reloc || rel->r_addend == 0);
 704     }
 705
 706   if (sym_diff_section != NULL)
 707     {
 708       BFD_ASSERT (sym_diff_section == input_section);
 709
 710      if (uses_msp430x_relocs (input_bfd))
 711        switch (howto->type)
 712          {
 713          case R_MSP430_ABS32:
 714           /* If we are computing a 32-bit value for the location lists
 715              and the result is 0 then we add one to the value.  A zero
 716              value can result because of linker relaxation deleteing
 717              prologue instructions and using a value of 1 (for the begin
 718              and end offsets in the location list entry) results in a
 719              nul entry which does not prevent the following entries from
 720              being parsed.  */
 721            if (relocation == sym_diff_value
 722                && strcmp (input_section->name, ".debug_loc") == 0)
 723              ++ relocation;
 724            /* Fall through.  */
 725          case R_MSP430_ABS16:
 726          case R_MSP430X_ABS16:
 727          case R_MSP430_ABS8:
 728            BFD_ASSERT (! is_rel_reloc);
 729            relocation -= sym_diff_value;
 730           break;
 731
 732          default:
 733            return bfd_reloc_dangerous;
 734          }
 735      else
 736        switch (howto->type)
 737          {
 738          case R_MSP430_32:
 739          case R_MSP430_16:
 740          case R_MSP430_16_BYTE:
 741          case R_MSP430_8:
 742            relocation -= sym_diff_value;
 743           break;
 744
 745          default:
 746            return bfd_reloc_dangerous;
 747          }
 748
 749       sym_diff_section = NULL;
 750     }
 751
 752   if (uses_msp430x_relocs (input_bfd))
 753     switch (howto->type)
 754       {
 755       case R_MSP430X_SYM_DIFF:
 756         /* Cache the input section and value.
 757            The offset is unreliable, since relaxation may
 758            have reduced the following reloc's offset.  */
 759         BFD_ASSERT (! is_rel_reloc);
 760         sym_diff_section = input_section;
 761         sym_diff_value = relocation;
 762         return bfd_reloc_ok;
 763
 764       case R_MSP430_ABS16:
 765         contents += rel->r_offset;
 766         srel = (bfd_signed_vma) relocation;
 767         if (is_rel_reloc)
 768           srel += bfd_get_16 (input_bfd, contents);
 769         else
 770           srel += rel->r_addend;
 771         bfd_put_16 (input_bfd, srel & 0xffff, contents);
 772         break;
 773
 774       case R_MSP430X_10_PCREL:
 775         contents += rel->r_offset;
 776         srel = (bfd_signed_vma) relocation;
 777         if (is_rel_reloc)
 778           srel += bfd_get_16 (input_bfd, contents) & 0x3ff;
 779         else
 780           srel += rel->r_addend;
 781         srel -= rel->r_offset;
 782         srel -= 2;              /* Branch instructions add 2 to the PC...  */
 783         srel -= (input_section->output_section->vma +
 784                  input_section->output_offset);
 785         if (srel & 1)
 786           return bfd_reloc_outofrange;
 787
 788         /* MSP430 addresses commands as words.  */
 789         srel >>= 1;
 790
 791         /* Check for an overflow.  */
 792         if (srel < -512 || srel > 511)
 793           {
 794             if (info->disable_target_specific_optimizations < 0)
 795               {
 796                 static bfd_boolean warned = FALSE;
 797                 if (! warned)
 798                   {
 799                     info->callbacks->warning
 800                       (info,
 801                        _("Try enabling relaxation to avoid relocation truncations"),
 802                        NULL, input_bfd, input_section, relocation);
 803                     warned = TRUE;
 804                   }
 805               }
 806             return bfd_reloc_overflow;
 807           }
 808
 809         x = bfd_get_16 (input_bfd, contents);
 810         x = (x & 0xfc00) | (srel & 0x3ff);
 811         bfd_put_16 (input_bfd, x, contents);
 812         break;
 813
 814       case R_MSP430X_PCR20_EXT_ODST:
 815         /* [0,4]+[48,16] = ---F ---- FFFF */
 816         contents += rel->r_offset;
 817         srel = (bfd_signed_vma) relocation;
 818         if (is_rel_reloc)
 819           {
 820             bfd_vma addend;
 821             addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
 822             addend |= bfd_get_16 (input_bfd, contents+4);
 823             srel += addend;
 824
 825           }
 826         else
 827           srel += rel->r_addend;
 828         srel -= rel->r_offset;
 829         srel -= (input_section->output_section->vma +
 830                  input_section->output_offset);
 831         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
 832         x = bfd_get_16 (input_bfd, contents);
 833         x = (x & 0xfff0) | ((srel >> 16) & 0xf);
 834         bfd_put_16 (input_bfd, x, contents);
 835         break;
 836
 837       case R_MSP430X_ABS20_EXT_SRC:
 838         /* [7,4]+[32,16] = -78- FFFF */
 839         contents += rel->r_offset;
 840         srel = (bfd_signed_vma) relocation;
 841         if (is_rel_reloc)
 842           {
 843             bfd_vma addend;
 844             addend = (bfd_get_16 (input_bfd, contents) & 0x0780) << 9;
 845             addend |= bfd_get_16 (input_bfd, contents+2);
 846             srel += addend;
 847           }
 848         else
 849           srel += rel->r_addend;
 850         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
 851         srel >>= 16;
 852         x = bfd_get_16 (input_bfd, contents);
 853         x = (x & 0xf87f) | ((srel << 7) & 0x0780);
 854         bfd_put_16 (input_bfd, x, contents);
 855         break;
 856
 857       case R_MSP430_16_PCREL:
 858         contents += rel->r_offset;
 859         srel = (bfd_signed_vma) relocation;
 860         if (is_rel_reloc)
 861           srel += bfd_get_16 (input_bfd, contents);
 862         else
 863           srel += rel->r_addend;
 864         srel -= rel->r_offset;
 865         /* Only branch instructions add 2 to the PC...  */
 866         srel -= (input_section->output_section->vma +
 867                  input_section->output_offset);
 868         if (srel & 1)
 869           return bfd_reloc_outofrange;
 870         bfd_put_16 (input_bfd, srel & 0xffff, contents);
 871         break;
 872
 873       case R_MSP430X_PCR20_EXT_DST:
 874         /* [0,4]+[32,16] = ---F FFFF */
 875         contents += rel->r_offset;
 876         srel = (bfd_signed_vma) relocation;
 877         if (is_rel_reloc)
 878           {
 879             bfd_vma addend;
 880             addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
 881             addend |= bfd_get_16 (input_bfd, contents+2);
 882             srel += addend;
 883           }
 884         else
 885           srel += rel->r_addend;
 886         srel -= rel->r_offset;
 887         srel -= (input_section->output_section->vma +
 888                  input_section->output_offset);
 889         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
 890         srel >>= 16;
 891         x = bfd_get_16 (input_bfd, contents);
 892         x = (x & 0xfff0) | (srel & 0xf);
 893         bfd_put_16 (input_bfd, x, contents);
 894         break;
 895
 896       case R_MSP430X_PCR20_EXT_SRC:
 897         /* [7,4]+32,16] = -78- FFFF */
 898         contents += rel->r_offset;
 899         srel = (bfd_signed_vma) relocation;
 900         if (is_rel_reloc)
 901           {
 902             bfd_vma addend;
 903             addend = ((bfd_get_16 (input_bfd, contents) & 0x0780) << 9);
 904             addend |= bfd_get_16 (input_bfd, contents+2);
 905             srel += addend;;
 906           }
 907         else
 908           srel += rel->r_addend;
 909         srel -= rel->r_offset;
 910         /* Only branch instructions add 2 to the PC...  */
 911         srel -= (input_section->output_section->vma +
 912                  input_section->output_offset);
 913         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
 914         srel >>= 16;
 915         x = bfd_get_16 (input_bfd, contents);
 916         x = (x & 0xf87f) | ((srel << 7) & 0x0780);
 917         bfd_put_16 (input_bfd, x, contents);
 918         break;
 919
 920       case R_MSP430_ABS8:
 921         contents += rel->r_offset;
 922         srel = (bfd_signed_vma) relocation;
 923         if (is_rel_reloc)
 924           srel += bfd_get_8 (input_bfd, contents);
 925         else
 926           srel += rel->r_addend;
 927         bfd_put_8 (input_bfd, srel & 0xff, contents);
 928         break;
 929
 930       case R_MSP430X_ABS20_EXT_DST:
 931         contents += rel->r_offset;
 932         srel = (bfd_signed_vma) relocation;
 933         if (is_rel_reloc)
 934           srel += bfd_get_16 (input_bfd, contents) & 0xf;
 935         else
 936           srel += rel->r_addend;
 937         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
 938         srel >>= 16;
 939         x = bfd_get_16 (input_bfd, contents);
 940         x = (x & 0xfff0) | (srel & 0xf);
 941         bfd_put_16 (input_bfd, x, contents);
 942         break;
 943
 944       case R_MSP430X_ABS20_EXT_ODST:
 945         /* [0,4]+[48,16] = ---F ---- FFFF */
 946         contents += rel->r_offset;
 947         srel = (bfd_signed_vma) relocation;
 948         if (is_rel_reloc)
 949           {
 950             bfd_vma addend;
 951             addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
 952             addend |= bfd_get_16 (input_bfd, contents+4);
 953             srel += addend;
 954           }
 955         else
 956           srel += rel->r_addend;
 957         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
 958         srel >>= 16;
 959         x = bfd_get_16 (input_bfd, contents);
 960         x = (x & 0xfff0) | (srel & 0xf);
 961         bfd_put_16 (input_bfd, x, contents);
 962         break;
 963
 964       case R_MSP430X_ABS20_ADR_SRC:
 965         /* [8,4]+[32,16] = -F-- FFFF */
 966         contents += rel->r_offset;
 967         srel = (bfd_signed_vma) relocation;
 968         if (is_rel_reloc)
 969           {
 970             bfd_vma addend;
 971
 972             addend = ((bfd_get_16 (input_bfd, contents) & 0xf00) << 8);
 973             addend |= bfd_get_16 (input_bfd, contents+2);
 974             srel += addend;
 975           }
 976         else
 977           srel += rel->r_addend;
 978         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
 979         srel >>= 16;
 980         x = bfd_get_16 (input_bfd, contents);
 981         x = (x & 0xf0ff) | ((srel << 8) & 0x0f00);
 982         bfd_put_16 (input_bfd, x, contents);
 983         break;
 984
 985       case R_MSP430X_ABS20_ADR_DST:
 986         /* [0,4]+[32,16] = ---F FFFF */
 987         contents += rel->r_offset;
 988         srel = (bfd_signed_vma) relocation;
 989         if (is_rel_reloc)
 990           {
 991             bfd_vma addend;
 992             addend = ((bfd_get_16 (input_bfd, contents) & 0xf) << 16);
 993             addend |= bfd_get_16 (input_bfd, contents+2);
 994             srel += addend;
 995           }
 996         else
 997           srel += rel->r_addend;
 998         bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
 999         srel >>= 16;
1000         x = bfd_get_16 (input_bfd, contents);
1001         x = (x & 0xfff0) | (srel & 0xf);
1002         bfd_put_16 (input_bfd, x, contents);
1003         break;
1004
1005       case R_MSP430X_ABS16:
1006         contents += rel->r_offset;
1007         srel = (bfd_signed_vma) relocation;
1008         if (is_rel_reloc)
1009           srel += bfd_get_16 (input_bfd, contents);
1010         else
1011           srel += rel->r_addend;
1012         x = srel;
1013         if (x > 0xffff)
1014           return bfd_reloc_overflow;
1015         bfd_put_16 (input_bfd, srel & 0xffff, contents);
1016         break;
1017
1018       case R_MSP430_ABS_HI16:
1019         /* The EABI specifies that this must be a RELA reloc.  */
1020         BFD_ASSERT (! is_rel_reloc);
1021         contents += rel->r_offset;
1022         srel = (bfd_signed_vma) relocation;
1023         srel += rel->r_addend;
1024         bfd_put_16 (input_bfd, (srel >> 16) & 0xffff, contents);
1025         break;
1026
1027       case R_MSP430X_PCR20_CALL:
1028         /* [0,4]+[32,16] = ---F FFFF*/
1029         contents += rel->r_offset;
1030         srel = (bfd_signed_vma) relocation;
1031         if (is_rel_reloc)
1032           {
1033             bfd_vma addend;
1034             addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
1035             addend |= bfd_get_16 (input_bfd, contents+2);
1036             srel += addend;
1037           }
1038         else
1039           srel += rel->r_addend;
1040         srel -= rel->r_offset;
1041         srel -= (input_section->output_section->vma +
1042                  input_section->output_offset);
1043         bfd_put_16 (input_bfd, srel & 0xffff, contents + 2);
1044         srel >>= 16;
1045         x = bfd_get_16 (input_bfd, contents);
1046         x = (x & 0xfff0) | (srel & 0xf);
1047         bfd_put_16 (input_bfd, x, contents);
1048         break;
1049
1050       case R_MSP430X_PCR16:
1051         contents += rel->r_offset;
1052         srel = (bfd_signed_vma) relocation;
1053         if (is_rel_reloc)
1054           srel += bfd_get_16 (input_bfd, contents);
1055         else
1056           srel += rel->r_addend;
1057         srel -= rel->r_offset;
1058         srel -= (input_section->output_section->vma +
1059                  input_section->output_offset);
1060         bfd_put_16 (input_bfd, srel & 0xffff, contents);
1061         break;
1062
1063       case R_MSP430_PREL31:
1064         contents += rel->r_offset;
1065         srel = (bfd_signed_vma) relocation;
1066         if (is_rel_reloc)
1067           srel += (bfd_get_32 (input_bfd, contents) & 0x7fffffff);
1068         else
1069           srel += rel->r_addend;
1070         srel += rel->r_addend;
1071         x = bfd_get_32 (input_bfd, contents);
1072         x = (x & 0x80000000) | ((srel >> 31) & 0x7fffffff);
1073         bfd_put_32 (input_bfd, x, contents);
1074         break;
1075
1076       default:
1077         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1078                                       contents, rel->r_offset,
1079                                       relocation, rel->r_addend);
1080       }
1081   else
1082     switch (howto->type)
1083       {
1084     case R_MSP430_10_PCREL:
1085       contents += rel->r_offset;
1086       srel = (bfd_signed_vma) relocation;
1087       srel += rel->r_addend;
1088       srel -= rel->r_offset;
1089       srel -= 2;                /* Branch instructions add 2 to the PC...  */
1090       srel -= (input_section->output_section->vma +
1091                input_section->output_offset);
1092
1093       if (srel & 1)
1094         return bfd_reloc_outofrange;
1095
1096       /* MSP430 addresses commands as words.  */
1097       srel >>= 1;
1098
1099       /* Check for an overflow.  */
1100       if (srel < -512 || srel > 511)
1101         {
1102           if (info->disable_target_specific_optimizations < 0)
1103             {
1104               static bfd_boolean warned = FALSE;
1105               if (! warned)
1106                 {
1107                   info->callbacks->warning
1108                     (info,
1109                      _("Try enabling relaxation to avoid relocation truncations"),
1110                      NULL, input_bfd, input_section, relocation);
1111                   warned = TRUE;
1112                 }
1113             }
1114           return bfd_reloc_overflow;
1115         }
1116
1117       x = bfd_get_16 (input_bfd, contents);
1118       x = (x & 0xfc00) | (srel & 0x3ff);
1119       bfd_put_16 (input_bfd, x, contents);
1120       break;
1121
1122     case R_MSP430_2X_PCREL:
1123       contents += rel->r_offset;
1124       srel = (bfd_signed_vma) relocation;
1125       srel += rel->r_addend;
1126       srel -= rel->r_offset;
1127       srel -= 2;                /* Branch instructions add 2 to the PC...  */
1128       srel -= (input_section->output_section->vma +
1129                input_section->output_offset);
1130
1131       if (srel & 1)
1132         return bfd_reloc_outofrange;
1133
1134       /* MSP430 addresses commands as words.  */
1135       srel >>= 1;
1136
1137       /* Check for an overflow.  */
1138       if (srel < -512 || srel > 511)
1139         return bfd_reloc_overflow;
1140
1141       x = bfd_get_16 (input_bfd, contents);
1142       x = (x & 0xfc00) | (srel & 0x3ff);
1143       bfd_put_16 (input_bfd, x, contents);
1144       /* Handle second jump instruction.  */
1145       x = bfd_get_16 (input_bfd, contents - 2);
1146       srel += 1;
1147       x = (x & 0xfc00) | (srel & 0x3ff);
1148       bfd_put_16 (input_bfd, x, contents - 2);
1149       break;
1150
1151     case R_MSP430_RL_PCREL:
1152     case R_MSP430_16_PCREL:
1153       contents += rel->r_offset;
1154       srel = (bfd_signed_vma) relocation;
1155       srel += rel->r_addend;
1156       srel -= rel->r_offset;
1157       /* Only branch instructions add 2 to the PC...  */
1158       srel -= (input_section->output_section->vma +
1159                input_section->output_offset);
1160
1161       if (srel & 1)
1162         return bfd_reloc_outofrange;
1163
1164       bfd_put_16 (input_bfd, srel & 0xffff, contents);
1165       break;
1166
1167     case R_MSP430_16_PCREL_BYTE:
1168       contents += rel->r_offset;
1169       srel = (bfd_signed_vma) relocation;
1170       srel += rel->r_addend;
1171       srel -= rel->r_offset;
1172       /* Only branch instructions add 2 to the PC...  */
1173       srel -= (input_section->output_section->vma +
1174                input_section->output_offset);
1175
1176       bfd_put_16 (input_bfd, srel & 0xffff, contents);
1177       break;
1178
1179     case R_MSP430_16_BYTE:
1180       contents += rel->r_offset;
1181       srel = (bfd_signed_vma) relocation;
1182       srel += rel->r_addend;
1183       bfd_put_16 (input_bfd, srel & 0xffff, contents);
1184       break;
1185
1186     case R_MSP430_16:
1187       contents += rel->r_offset;
1188       srel = (bfd_signed_vma) relocation;
1189       srel += rel->r_addend;
1190
1191       if (srel & 1)
1192         return bfd_reloc_notsupported;
1193
1194       bfd_put_16 (input_bfd, srel & 0xffff, contents);
1195       break;
1196
1197     case R_MSP430_8:
1198       contents += rel->r_offset;
1199       srel = (bfd_signed_vma) relocation;
1200       srel += rel->r_addend;
1201
1202       bfd_put_8 (input_bfd, srel & 0xff, contents);
1203       break;
1204
1205     case R_MSP430_SYM_DIFF:
1206       /* Cache the input section and value.
1207          The offset is unreliable, since relaxation may
1208          have reduced the following reloc's offset.  */
1209       sym_diff_section = input_section;
1210       sym_diff_value = relocation;
1211       return bfd_reloc_ok;
1212
1213       default:
1214         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1215                                       contents, rel->r_offset,
1216                                       relocation, rel->r_addend);
1217       }
1218
1219   return r;
1220 }
1221
1222 /* Relocate an MSP430 ELF section.  */
1223
1224 static bfd_boolean
1225 elf32_msp430_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
1226                                struct bfd_link_info * info,
1227                                bfd * input_bfd,
1228                                asection * input_section,
1229                                bfd_byte * contents,
1230                                Elf_Internal_Rela * relocs,
1231                                Elf_Internal_Sym * local_syms,
1232                                asection ** local_sections)
1233 {
1234   Elf_Internal_Shdr *symtab_hdr;
1235   struct elf_link_hash_entry **sym_hashes;
1236   Elf_Internal_Rela *rel;
1237   Elf_Internal_Rela *relend;
1238
1239   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1240   sym_hashes = elf_sym_hashes (input_bfd);
1241   relend = relocs + input_section->reloc_count;
1242
1243   for (rel = relocs; rel < relend; rel++)
1244     {
1245       reloc_howto_type *howto;
1246       unsigned long r_symndx;
1247       Elf_Internal_Sym *sym;
1248       asection *sec;
1249       struct elf_link_hash_entry *h;
1250       bfd_vma relocation;
1251       bfd_reloc_status_type r;
1252       const char *name = NULL;
1253       int r_type;
1254
1255       r_type = ELF32_R_TYPE (rel->r_info);
1256       r_symndx = ELF32_R_SYM (rel->r_info);
1257
1258       if (uses_msp430x_relocs (input_bfd))
1259         howto = elf_msp430x_howto_table + r_type;
1260       else
1261         howto = elf_msp430_howto_table + r_type;
1262
1263       h = NULL;
1264       sym = NULL;
1265       sec = NULL;
1266
1267       if (r_symndx < symtab_hdr->sh_info)
1268         {
1269           sym = local_syms + r_symndx;
1270           sec = local_sections[r_symndx];
1271           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1272
1273           name = bfd_elf_string_from_elf_section
1274               (input_bfd, symtab_hdr->sh_link, sym->st_name);
1275           name = (name == NULL || * name == 0) ? bfd_section_name (input_bfd, sec) : name;
1276         }
1277       else
1278         {
1279           bfd_boolean unresolved_reloc, warned, ignored;
1280
1281           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1282                                    r_symndx, symtab_hdr, sym_hashes,
1283                                    h, sec, relocation,
1284                                    unresolved_reloc, warned, ignored);
1285           name = h->root.root.string;
1286         }
1287
1288       if (sec != NULL && discarded_section (sec))
1289         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1290                                          rel, 1, relend, howto, 0, contents);
1291
1292       if (info->relocatable)
1293         continue;
1294
1295       r = msp430_final_link_relocate (howto, input_bfd, input_section,
1296                                       contents, rel, relocation, info);
1297
1298       if (r != bfd_reloc_ok)
1299         {
1300           const char *msg = (const char *) NULL;
1301
1302           switch (r)
1303             {
1304             case bfd_reloc_overflow:
1305               r = info->callbacks->reloc_overflow
1306                 (info, (h ? &h->root : NULL), name, howto->name,
1307                    (bfd_vma) 0, input_bfd, input_section,
1308                    rel->r_offset);
1309               break;
1310
1311             case bfd_reloc_undefined:
1312               r = info->callbacks->undefined_symbol
1313                   (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1314               break;
1315
1316             case bfd_reloc_outofrange:
1317               msg = _("internal error: branch/jump to an odd address detected");
1318               break;
1319
1320             case bfd_reloc_notsupported:
1321               msg = _("internal error: unsupported relocation error");
1322               break;
1323
1324             case bfd_reloc_dangerous:
1325               msg = _("internal error: dangerous relocation");
1326               break;
1327
1328             default:
1329               msg = _("internal error: unknown error");
1330               break;
1331             }
1332
1333           if (msg)
1334             r = info->callbacks->warning
1335                 (info, msg, name, input_bfd, input_section, rel->r_offset);
1336
1337           if (!r)
1338             return FALSE;
1339         }
1340
1341     }
1342
1343   return TRUE;
1344 }
1345
1346 /* The final processing done just before writing out a MSP430 ELF object
1347    file.  This gets the MSP430 architecture right based on the machine
1348    number.  */
1349
1350 static void
1351 bfd_elf_msp430_final_write_processing (bfd * abfd,
1352                                        bfd_boolean linker ATTRIBUTE_UNUSED)
1353 {
1354   unsigned long val;
1355
1356   switch (bfd_get_mach (abfd))
1357     {
1358     default:
1359     case bfd_mach_msp110: val = E_MSP430_MACH_MSP430x11x1; break;
1360     case bfd_mach_msp11: val = E_MSP430_MACH_MSP430x11; break;
1361     case bfd_mach_msp12: val = E_MSP430_MACH_MSP430x12; break;
1362     case bfd_mach_msp13: val = E_MSP430_MACH_MSP430x13; break;
1363     case bfd_mach_msp14: val = E_MSP430_MACH_MSP430x14; break;
1364     case bfd_mach_msp15: val = E_MSP430_MACH_MSP430x15; break;
1365     case bfd_mach_msp16: val = E_MSP430_MACH_MSP430x16; break;
1366     case bfd_mach_msp31: val = E_MSP430_MACH_MSP430x31; break;
1367     case bfd_mach_msp32: val = E_MSP430_MACH_MSP430x32; break;
1368     case bfd_mach_msp33: val = E_MSP430_MACH_MSP430x33; break;
1369     case bfd_mach_msp41: val = E_MSP430_MACH_MSP430x41; break;
1370     case bfd_mach_msp42: val = E_MSP430_MACH_MSP430x42; break;
1371     case bfd_mach_msp43: val = E_MSP430_MACH_MSP430x43; break;
1372     case bfd_mach_msp44: val = E_MSP430_MACH_MSP430x44; break;
1373     case bfd_mach_msp20: val = E_MSP430_MACH_MSP430x20; break;
1374     case bfd_mach_msp22: val = E_MSP430_MACH_MSP430x22; break;
1375     case bfd_mach_msp23: val = E_MSP430_MACH_MSP430x23; break;
1376     case bfd_mach_msp24: val = E_MSP430_MACH_MSP430x24; break;
1377     case bfd_mach_msp26: val = E_MSP430_MACH_MSP430x26; break;
1378     case bfd_mach_msp46: val = E_MSP430_MACH_MSP430x46; break;
1379     case bfd_mach_msp47: val = E_MSP430_MACH_MSP430x47; break;
1380     case bfd_mach_msp54: val = E_MSP430_MACH_MSP430x54; break;
1381     case bfd_mach_msp430x: val = E_MSP430_MACH_MSP430X; break;
1382     }
1383
1384   elf_elfheader (abfd)->e_machine = EM_MSP430;
1385   elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
1386   elf_elfheader (abfd)->e_flags |= val;
1387 }
1388
1389 /* Set the right machine number.  */
1390
1391 static bfd_boolean
1392 elf32_msp430_object_p (bfd * abfd)
1393 {
1394   int e_set = bfd_mach_msp14;
1395
1396   if (elf_elfheader (abfd)->e_machine == EM_MSP430
1397       || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
1398     {
1399       int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
1400
1401       switch (e_mach)
1402         {
1403         default:
1404         case E_MSP430_MACH_MSP430x11: e_set = bfd_mach_msp11; break;
1405         case E_MSP430_MACH_MSP430x11x1: e_set = bfd_mach_msp110; break;
1406         case E_MSP430_MACH_MSP430x12: e_set = bfd_mach_msp12; break;
1407         case E_MSP430_MACH_MSP430x13: e_set = bfd_mach_msp13; break;
1408         case E_MSP430_MACH_MSP430x14: e_set = bfd_mach_msp14; break;
1409         case E_MSP430_MACH_MSP430x15: e_set = bfd_mach_msp15; break;
1410         case E_MSP430_MACH_MSP430x16: e_set = bfd_mach_msp16; break;
1411         case E_MSP430_MACH_MSP430x31: e_set = bfd_mach_msp31; break;
1412         case E_MSP430_MACH_MSP430x32: e_set = bfd_mach_msp32; break;
1413         case E_MSP430_MACH_MSP430x33: e_set = bfd_mach_msp33; break;
1414         case E_MSP430_MACH_MSP430x41: e_set = bfd_mach_msp41; break;
1415         case E_MSP430_MACH_MSP430x42: e_set = bfd_mach_msp42; break;
1416         case E_MSP430_MACH_MSP430x43: e_set = bfd_mach_msp43; break;
1417         case E_MSP430_MACH_MSP430x44: e_set = bfd_mach_msp44; break;
1418         case E_MSP430_MACH_MSP430x20: e_set = bfd_mach_msp20; break;
1419         case E_MSP430_MACH_MSP430x22: e_set = bfd_mach_msp22; break;
1420         case E_MSP430_MACH_MSP430x23: e_set = bfd_mach_msp23; break;
1421         case E_MSP430_MACH_MSP430x24: e_set = bfd_mach_msp24; break;
1422         case E_MSP430_MACH_MSP430x26: e_set = bfd_mach_msp26; break;
1423         case E_MSP430_MACH_MSP430x46: e_set = bfd_mach_msp46; break;
1424         case E_MSP430_MACH_MSP430x47: e_set = bfd_mach_msp47; break;
1425         case E_MSP430_MACH_MSP430x54: e_set = bfd_mach_msp54; break;
1426         case E_MSP430_MACH_MSP430X: e_set = bfd_mach_msp430x; break;
1427         }
1428     }
1429
1430   return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
1431 }
1432
1433 /* These functions handle relaxing for the msp430.
1434    Relaxation required only in two cases:
1435     - Bad hand coding like jumps from one section to another or
1436       from file to file.
1437     - Sibling calls. This will affect only 'jump label' polymorph. Without
1438       relaxing this enlarges code by 2 bytes. Sibcalls implemented but
1439       do not work in gcc's port by the reason I do not know.
1440     - To convert out of range conditional jump instructions (found inside
1441       a function) into inverted jumps over an unconditional branch instruction.
1442    Anyway, if a relaxation required, user should pass -relax option to the
1443    linker.
1444
1445    There are quite a few relaxing opportunities available on the msp430:
1446
1447    ================================================================
1448
1449    1. 3 words -> 1 word
1450
1451    eq      ==      jeq label                    jne +4; br lab
1452    ne      !=      jne label                    jeq +4; br lab
1453    lt      <       jl  label                    jge +4; br lab
1454    ltu     <       jlo label                    lhs +4; br lab
1455    ge      >=      jge label                    jl  +4; br lab
1456    geu     >=      jhs label                    jlo +4; br lab
1457
1458    2. 4 words -> 1 word
1459
1460    ltn     <       jn                      jn  +2; jmp +4; br lab
1461
1462    3. 4 words -> 2 words
1463
1464    gt      >       jeq +2; jge label       jeq +6; jl  +4; br label
1465    gtu     >       jeq +2; jhs label       jeq +6; jlo +4; br label
1466
1467    4. 4 words -> 2 words and 2 labels
1468
1469    leu     <=      jeq label; jlo label    jeq +2; jhs +4; br label
1470    le      <=      jeq label; jl  label    jeq +2; jge +4; br label
1471    =================================================================
1472
1473    codemap for first cases is (labels masked ):
1474               eq:       0x2002,0x4010,0x0000 -> 0x2400
1475               ne:       0x2402,0x4010,0x0000 -> 0x2000
1476               lt:       0x3402,0x4010,0x0000 -> 0x3800
1477               ltu:      0x2c02,0x4010,0x0000 -> 0x2800
1478               ge:       0x3802,0x4010,0x0000 -> 0x3400
1479               geu:      0x2802,0x4010,0x0000 -> 0x2c00
1480
1481   second case:
1482               ltn:      0x3001,0x3c02,0x4010,0x0000 -> 0x3000
1483
1484   third case:
1485               gt:       0x2403,0x3802,0x4010,0x0000 -> 0x2401,0x3400
1486               gtu:      0x2403,0x2802,0x4010,0x0000 -> 0x2401,0x2c00
1487
1488   fourth case:
1489               leu:      0x2401,0x2c02,0x4010,0x0000 -> 0x2400,0x2800
1490               le:       0x2401,0x3402,0x4010,0x0000 -> 0x2400,0x3800
1491
1492   Unspecified case :)
1493               jump:     0x4010,0x0000 -> 0x3c00.  */
1494
1495 #define NUMB_RELAX_CODES        12
1496 static struct rcodes_s
1497 {
1498   int f0, f1;                   /* From code.  */
1499   int t0, t1;                   /* To code.  */
1500   int labels;                   /* Position of labels: 1 - one label at first
1501                                    word, 2 - one at second word, 3 - two
1502                                    labels at both.  */
1503   int cdx;                      /* Words to match.  */
1504   int bs;                       /* Shrink bytes.  */
1505   int off;                      /* Offset from old label for new code.  */
1506   int ncl;                      /* New code length.  */
1507 } rcode[] =
1508 {/*                               lab,cdx,bs,off,ncl */
1509   { 0x0000, 0x0000, 0x3c00, 0x0000, 1, 0, 2, 2,  2},    /* jump */
1510   { 0x0000, 0x2002, 0x2400, 0x0000, 1, 1, 4, 4,  2},    /* eq */
1511   { 0x0000, 0x2402, 0x2000, 0x0000, 1, 1, 4, 4,  2},    /* ne */
1512   { 0x0000, 0x3402, 0x3800, 0x0000, 1, 1, 4, 4,  2},    /* lt */
1513   { 0x0000, 0x2c02, 0x2800, 0x0000, 1, 1, 4, 4,  2},    /* ltu */
1514   { 0x0000, 0x3802, 0x3400, 0x0000, 1, 1, 4, 4,  2},    /* ge */
1515   { 0x0000, 0x2802, 0x2c00, 0x0000, 1, 1, 4, 4,  2},    /* geu */
1516   { 0x3001, 0x3c02, 0x3000, 0x0000, 1, 2, 6, 6,  2},    /* ltn */
1517   { 0x2403, 0x3802, 0x2401, 0x3400, 2, 2, 4, 6,  4},    /* gt */
1518   { 0x2403, 0x2802, 0x2401, 0x2c00, 2, 2, 4, 6,  4},    /* gtu */
1519   { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6,  4},    /* leu , 2 labels */
1520   { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6,  4},    /* le  , 2 labels */
1521   { 0,      0,      0,      0,      0, 0, 0, 0,  0}
1522 };
1523
1524 /* Return TRUE if a symbol exists at the given address.  */
1525
1526 static bfd_boolean
1527 msp430_elf_symbol_address_p (bfd * abfd,
1528                              asection * sec,
1529                              Elf_Internal_Sym * isym,
1530                              bfd_vma addr)
1531 {
1532   Elf_Internal_Shdr *symtab_hdr;
1533   unsigned int sec_shndx;
1534   Elf_Internal_Sym *isymend;
1535   struct elf_link_hash_entry **sym_hashes;
1536   struct elf_link_hash_entry **end_hashes;
1537   unsigned int symcount;
1538
1539   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1540
1541   /* Examine all the local symbols.  */
1542   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1543   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1544     if (isym->st_shndx == sec_shndx && isym->st_value == addr)
1545       return TRUE;
1546
1547   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1548               - symtab_hdr->sh_info);
1549   sym_hashes = elf_sym_hashes (abfd);
1550   end_hashes = sym_hashes + symcount;
1551   for (; sym_hashes < end_hashes; sym_hashes++)
1552     {
1553       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1554
1555       if ((sym_hash->root.type == bfd_link_hash_defined
1556            || sym_hash->root.type == bfd_link_hash_defweak)
1557           && sym_hash->root.u.def.section == sec
1558           && sym_hash->root.u.def.value == addr)
1559         return TRUE;
1560     }
1561
1562   return FALSE;
1563 }
1564
1565 /* Adjust all local symbols defined as '.section + 0xXXXX' (.section has
1566    sec_shndx) referenced from current and other sections.  */
1567
1568 static bfd_boolean
1569 msp430_elf_relax_adjust_locals (bfd * abfd, asection * sec, bfd_vma addr,
1570                                 int count, unsigned int sec_shndx,
1571                                 bfd_vma toaddr)
1572 {
1573   Elf_Internal_Shdr *symtab_hdr;
1574   Elf_Internal_Rela *irel;
1575   Elf_Internal_Rela *irelend;
1576   Elf_Internal_Sym *isym;
1577
1578   irel = elf_section_data (sec)->relocs;
1579   if (irel == NULL)
1580     return TRUE;
1581
1582   irelend = irel + sec->reloc_count;
1583   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1584   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1585
1586   for (;irel < irelend; irel++)
1587     {
1588       int sidx = ELF32_R_SYM(irel->r_info);
1589       Elf_Internal_Sym *lsym = isym + sidx;
1590
1591       /* Adjust symbols referenced by .sec+0xXX */
1592       if (irel->r_addend > addr && irel->r_addend < toaddr
1593           && lsym->st_shndx == sec_shndx)
1594         irel->r_addend -= count;
1595     }
1596
1597   return TRUE;
1598 }
1599
1600 /* Delete some bytes from a section while relaxing.  */
1601
1602 static bfd_boolean
1603 msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
1604                                int count)
1605 {
1606   Elf_Internal_Shdr *symtab_hdr;
1607   unsigned int sec_shndx;
1608   bfd_byte *contents;
1609   Elf_Internal_Rela *irel;
1610   Elf_Internal_Rela *irelend;
1611   bfd_vma toaddr;
1612   Elf_Internal_Sym *isym;
1613   Elf_Internal_Sym *isymend;
1614   struct elf_link_hash_entry **sym_hashes;
1615   struct elf_link_hash_entry **end_hashes;
1616   unsigned int symcount;
1617   asection *p;
1618
1619   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1620
1621   contents = elf_section_data (sec)->this_hdr.contents;
1622
1623   toaddr = sec->size;
1624
1625   irel = elf_section_data (sec)->relocs;
1626   irelend = irel + sec->reloc_count;
1627
1628   /* Actually delete the bytes.  */
1629   memmove (contents + addr, contents + addr + count,
1630            (size_t) (toaddr - addr - count));
1631   sec->size -= count;
1632
1633   /* Adjust all the relocs.  */
1634   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1635   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1636   for (; irel < irelend; irel++)
1637     {
1638       /* Get the new reloc address.  */
1639       if ((irel->r_offset > addr && irel->r_offset < toaddr))
1640         irel->r_offset -= count;
1641     }
1642
1643   for (p = abfd->sections; p != NULL; p = p->next)
1644     msp430_elf_relax_adjust_locals (abfd,p,addr,count,sec_shndx,toaddr);
1645
1646   /* Adjust the local symbols defined in this section.  */
1647   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1648   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1649   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1650     if (isym->st_shndx == sec_shndx
1651         && isym->st_value > addr && isym->st_value < toaddr)
1652       isym->st_value -= count;
1653
1654   /* Now adjust the global symbols defined in this section.  */
1655   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1656               - symtab_hdr->sh_info);
1657   sym_hashes = elf_sym_hashes (abfd);
1658   end_hashes = sym_hashes + symcount;
1659   for (; sym_hashes < end_hashes; sym_hashes++)
1660     {
1661       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1662
1663       if ((sym_hash->root.type == bfd_link_hash_defined
1664            || sym_hash->root.type == bfd_link_hash_defweak)
1665           && sym_hash->root.u.def.section == sec
1666           && sym_hash->root.u.def.value > addr
1667           && sym_hash->root.u.def.value < toaddr)
1668         sym_hash->root.u.def.value -= count;
1669     }
1670
1671   return TRUE;
1672 }
1673
1674 /* Insert two words into a section whilst relaxing.  */
1675
1676 static bfd_byte *
1677 msp430_elf_relax_add_two_words (bfd * abfd, asection * sec, bfd_vma addr,
1678                                 int word1, int word2)
1679 {
1680   Elf_Internal_Shdr *symtab_hdr;
1681   unsigned int sec_shndx;
1682   bfd_byte *contents;
1683   Elf_Internal_Rela *irel;
1684   Elf_Internal_Rela *irelend;
1685   Elf_Internal_Sym *isym;
1686   Elf_Internal_Sym *isymend;
1687   struct elf_link_hash_entry **sym_hashes;
1688   struct elf_link_hash_entry **end_hashes;
1689   unsigned int symcount;
1690   bfd_vma sec_end;
1691   asection *p;
1692
1693   contents = elf_section_data (sec)->this_hdr.contents;
1694   sec_end = sec->size;
1695
1696   /* Make space for the new words.  */
1697   contents = bfd_realloc (contents, sec_end + 4);
1698   memmove (contents + addr + 4, contents + addr, sec_end - addr);
1699
1700   /* Insert the new words.  */
1701   bfd_put_16 (abfd, word1, contents + addr);
1702   bfd_put_16 (abfd, word2, contents + addr + 2);
1703
1704   /* Update the section information.  */
1705   sec->size += 4;
1706   elf_section_data (sec)->this_hdr.contents = contents;
1707
1708   /* Adjust all the relocs.  */
1709   irel = elf_section_data (sec)->relocs;
1710   irelend = irel + sec->reloc_count;
1711
1712   for (; irel < irelend; irel++)
1713     if ((irel->r_offset >= addr && irel->r_offset < sec_end))
1714       irel->r_offset += 4;
1715
1716   /* Adjust the local symbols defined in this section.  */
1717   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1718   for (p = abfd->sections; p != NULL; p = p->next)
1719     msp430_elf_relax_adjust_locals (abfd, p, addr, -4,
1720                                     sec_shndx, sec_end);
1721
1722   /* Adjust the global symbols affected by the move.  */
1723   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1724   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1725   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1726     if (isym->st_shndx == sec_shndx
1727         && isym->st_value >= addr && isym->st_value < sec_end)
1728       isym->st_value += 4;
1729
1730   /* Now adjust the global symbols defined in this section.  */
1731   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1732               - symtab_hdr->sh_info);
1733   sym_hashes = elf_sym_hashes (abfd);
1734   end_hashes = sym_hashes + symcount;
1735   for (; sym_hashes < end_hashes; sym_hashes++)
1736     {
1737       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1738
1739       if ((sym_hash->root.type == bfd_link_hash_defined
1740            || sym_hash->root.type == bfd_link_hash_defweak)
1741           && sym_hash->root.u.def.section == sec
1742           && sym_hash->root.u.def.value >= addr
1743           && sym_hash->root.u.def.value < sec_end)
1744         sym_hash->root.u.def.value += 4;
1745     }
1746
1747   return contents;
1748 }
1749
1750 static bfd_boolean
1751 msp430_elf_relax_section (bfd * abfd, asection * sec,
1752                           struct bfd_link_info * link_info,
1753                           bfd_boolean * again)
1754 {
1755   Elf_Internal_Shdr * symtab_hdr;
1756   Elf_Internal_Rela * internal_relocs;
1757   Elf_Internal_Rela * irel;
1758   Elf_Internal_Rela * irelend;
1759   bfd_byte *          contents = NULL;
1760   Elf_Internal_Sym *  isymbuf = NULL;
1761
1762
1763   /* Assume nothing changes.  */
1764   *again = FALSE;
1765
1766   /* We don't have to do anything for a relocatable link, if
1767      this section does not have relocs, or if this is not a
1768      code section.  */
1769   if (link_info->relocatable
1770     || (sec->flags & SEC_RELOC) == 0
1771     || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
1772     return TRUE;
1773
1774   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1775
1776   /* Get a copy of the native relocations.  */
1777   internal_relocs =
1778     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1779   if (internal_relocs == NULL)
1780     goto error_return;
1781
1782   /* Walk through them looking for relaxing opportunities.  */
1783   irelend = internal_relocs + sec->reloc_count;
1784
1785   /* Do code size growing relocs first.  */
1786   for (irel = internal_relocs; irel < irelend; irel++)
1787     {
1788       bfd_vma symval;
1789
1790       /* If this isn't something that can be relaxed, then ignore
1791          this reloc.  */
1792       if (uses_msp430x_relocs (abfd)
1793           && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430X_10_PCREL)
1794         ;
1795       else if (! uses_msp430x_relocs (abfd)
1796                && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_10_PCREL)
1797         ;
1798       else
1799         continue;
1800
1801       /* Get the section contents if we haven't done so already.  */
1802       if (contents == NULL)
1803         {
1804           /* Get cached copy if it exists.  */
1805           if (elf_section_data (sec)->this_hdr.contents != NULL)
1806             contents = elf_section_data (sec)->this_hdr.contents;
1807           else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1808             goto error_return;
1809         }
1810
1811       /* Read this BFD's local symbols if we haven't done so already.  */
1812       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1813         {
1814           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1815           if (isymbuf == NULL)
1816             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1817                                             symtab_hdr->sh_info, 0,
1818                                             NULL, NULL, NULL);
1819           if (isymbuf == NULL)
1820             goto error_return;
1821         }
1822
1823       /* Get the value of the symbol referred to by the reloc.  */
1824       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1825         {
1826           /* A local symbol.  */
1827           Elf_Internal_Sym *isym;
1828           asection *sym_sec;
1829
1830           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1831           if (isym->st_shndx == SHN_UNDEF)
1832             sym_sec = bfd_und_section_ptr;
1833           else if (isym->st_shndx == SHN_ABS)
1834             sym_sec = bfd_abs_section_ptr;
1835           else if (isym->st_shndx == SHN_COMMON)
1836             sym_sec = bfd_com_section_ptr;
1837           else
1838             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1839           symval = (isym->st_value
1840                     + sym_sec->output_section->vma + sym_sec->output_offset);
1841         }
1842       else
1843         {
1844           unsigned long indx;
1845           struct elf_link_hash_entry *h;
1846
1847           /* An external symbol.  */
1848           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1849           h = elf_sym_hashes (abfd)[indx];
1850           BFD_ASSERT (h != NULL);
1851
1852           if (h->root.type != bfd_link_hash_defined
1853               && h->root.type != bfd_link_hash_defweak)
1854             /* This appears to be a reference to an undefined
1855                symbol.  Just ignore it--it will be caught by the
1856                regular reloc processing.  */
1857             continue;
1858
1859           symval = (h->root.u.def.value
1860                     + h->root.u.def.section->output_section->vma
1861                     + h->root.u.def.section->output_offset);
1862         }
1863
1864       /* For simplicity of coding, we are going to modify the section
1865          contents, the section relocs, and the BFD symbol table.  We
1866          must tell the rest of the code not to free up this
1867          information.  It would be possible to instead create a table
1868          of changes which have to be made, as is done in coff-mips.c;
1869          that would be more work, but would require less memory when
1870          the linker is run.  */
1871
1872       bfd_signed_vma value = symval;
1873       int opcode;
1874
1875       /* Compute the value that will be relocated.  */
1876       value += irel->r_addend;
1877       /* Convert to PC relative.  */
1878       value -= (sec->output_section->vma + sec->output_offset);
1879       value -= irel->r_offset;
1880       value -= 2;
1881       /* Scale.  */
1882       value >>= 1;
1883
1884       /* If it is in range then no modifications are needed.  */
1885       if (value >= -512 && value <= 511)
1886         continue;
1887
1888       /* Get the opcode.  */
1889       opcode = bfd_get_16 (abfd, contents + irel->r_offset);
1890
1891       /* Compute the new opcode.  We are going to convert:
1892          J<cond> label
1893          into:
1894          J<inv-cond> 1f
1895          BR[A] #label
1896          1:                     */
1897       switch (opcode & 0xfc00)
1898         {
1899         case 0x3800: opcode = 0x3402; break; /* Jl  -> Jge +2 */
1900         case 0x3400: opcode = 0x3802; break; /* Jge -> Jl  +2 */
1901         case 0x2c00: opcode = 0x2802; break; /* Jhs -> Jlo +2 */
1902         case 0x2800: opcode = 0x2c02; break; /* Jlo -> Jhs +2 */
1903         case 0x2400: opcode = 0x2002; break; /* Jeq -> Jne +2 */
1904         case 0x2000: opcode = 0x2402; break; /* jne -> Jeq +2 */
1905         case 0x3000: /* jn    */
1906           /* There is no direct inverse of the Jn insn.
1907              FIXME: we could do this as:
1908                 Jn 1f
1909                 br 2f
1910              1: br label
1911              2:                */
1912           continue;
1913         default:
1914           /* Not a conditional branch instruction.  */
1915           /* fprintf (stderr, "unrecog: %x\n", opcode); */
1916           goto error_return;
1917         }
1918
1919       /* Note that we've changed the relocs, section contents, etc.  */
1920       elf_section_data (sec)->relocs = internal_relocs;
1921       elf_section_data (sec)->this_hdr.contents = contents;
1922       symtab_hdr->contents = (unsigned char *) isymbuf;
1923
1924       /* Install the new opcode.  */
1925       bfd_put_16 (abfd, opcode, contents + irel->r_offset);
1926
1927       /* Insert the new branch instruction.  */
1928       if (uses_msp430x_relocs (abfd))
1929         {
1930           /* Insert an absolute branch (aka MOVA) instruction.  */
1931           contents = msp430_elf_relax_add_two_words
1932             (abfd, sec, irel->r_offset + 2, 0x0080, 0x0000);
1933
1934           /* Update the relocation to point to the inserted branch
1935              instruction.  Note - we are changing a PC-relative reloc
1936              into an absolute reloc, but this is OK because we have
1937              arranged with the assembler to have the reloc's value be
1938              a (local) symbol, not a section+offset value.  */
1939           irel->r_offset += 2;
1940           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1941                                        R_MSP430X_ABS20_ADR_SRC);
1942         }
1943       else
1944         {
1945           contents = msp430_elf_relax_add_two_words
1946             (abfd, sec, irel->r_offset + 2, 0x4030, 0x0000);
1947
1948           /* See comment above about converting a 10-bit PC-rel
1949              relocation into a 16-bit absolute relocation.  */
1950           irel->r_offset += 4;
1951           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1952                                        R_MSP430_16);
1953         }
1954
1955       /* Growing the section may mean that other
1956          conditional branches need to be fixed.  */
1957       *again = TRUE;
1958     }
1959
1960   if (! uses_msp430x_relocs (abfd))
1961     /* Now perform the relocations that shrink the code size.
1962        We only do this for non msp430x as gas only generates the RL
1963        reloc for the msp430.  */
1964     for (irel = internal_relocs; irel < irelend; irel++)
1965       {
1966         bfd_vma symval;
1967
1968         /* Get the section contents if we haven't done so already.  */
1969         if (contents == NULL)
1970           {
1971             /* Get cached copy if it exists.  */
1972             if (elf_section_data (sec)->this_hdr.contents != NULL)
1973               contents = elf_section_data (sec)->this_hdr.contents;
1974             else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1975               goto error_return;
1976           }
1977
1978         /* Read this BFD's local symbols if we haven't done so already.  */
1979         if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1980           {
1981             isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1982             if (isymbuf == NULL)
1983               isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1984                                               symtab_hdr->sh_info, 0,
1985                                               NULL, NULL, NULL);
1986             if (isymbuf == NULL)
1987               goto error_return;
1988           }
1989
1990         /* Get the value of the symbol referred to by the reloc.  */
1991         if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1992           {
1993             /* A local symbol.  */
1994             Elf_Internal_Sym *isym;
1995             asection *sym_sec;
1996
1997             isym = isymbuf + ELF32_R_SYM (irel->r_info);
1998             if (isym->st_shndx == SHN_UNDEF)
1999               sym_sec = bfd_und_section_ptr;
2000             else if (isym->st_shndx == SHN_ABS)
2001               sym_sec = bfd_abs_section_ptr;
2002             else if (isym->st_shndx == SHN_COMMON)
2003               sym_sec = bfd_com_section_ptr;
2004             else
2005               sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2006             symval = (isym->st_value
2007                       + sym_sec->output_section->vma + sym_sec->output_offset);
2008           }
2009         else
2010           {
2011             unsigned long indx;
2012             struct elf_link_hash_entry *h;
2013
2014             /* An external symbol.  */
2015             indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2016             h = elf_sym_hashes (abfd)[indx];
2017             BFD_ASSERT (h != NULL);
2018
2019             if (h->root.type != bfd_link_hash_defined
2020                 && h->root.type != bfd_link_hash_defweak)
2021               /* This appears to be a reference to an undefined
2022                  symbol.  Just ignore it--it will be caught by the
2023                  regular reloc processing.  */
2024               continue;
2025
2026             symval = (h->root.u.def.value
2027                       + h->root.u.def.section->output_section->vma
2028                       + h->root.u.def.section->output_offset);
2029           }
2030
2031         /* For simplicity of coding, we are going to modify the section
2032            contents, the section relocs, and the BFD symbol table.  We
2033            must tell the rest of the code not to free up this
2034            information.  It would be possible to instead create a table
2035            of changes which have to be made, as is done in coff-mips.c;
2036            that would be more work, but would require less memory when
2037            the linker is run.  */
2038
2039         /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
2040            branch.  */
2041         /* Paranoia? paranoia...  */
2042         if (ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
2043           {
2044             bfd_vma value = symval;
2045
2046             /* Deal with pc-relative gunk.  */
2047             value -= (sec->output_section->vma + sec->output_offset);
2048             value -= irel->r_offset;
2049             value += irel->r_addend;
2050
2051             /* See if the value will fit in 10 bits, note the high value is
2052                1016 as the target will be two bytes closer if we are
2053                able to relax.  */
2054             if ((long) value < 1016 && (long) value > -1016)
2055               {
2056                 int code0 = 0, code1 = 0, code2 = 0;
2057                 int i;
2058                 struct rcodes_s *rx;
2059
2060                 /* Get the opcode.  */
2061                 if (irel->r_offset >= 6)
2062                   code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
2063
2064                 if (irel->r_offset >= 4)
2065                   code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
2066
2067                 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2068
2069                 if (code2 != 0x4010)
2070                   continue;
2071
2072                 /* Check r4 and r3.  */
2073                 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
2074                   {
2075                     rx = &rcode[i];
2076                     if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
2077                       break;
2078                     else if (rx->cdx == 1 && rx->f1 == code1)
2079                       break;
2080                     else if (rx->cdx == 0)      /* This is an unconditional jump.  */
2081                       break;
2082                   }
2083
2084                 /* Check labels:
2085                    .Label0:       ; we do not care about this label
2086                    jeq    +6
2087                    .Label1:       ; make sure there is no label here
2088                    jl     +4
2089                    .Label2:       ; make sure there is no label here
2090                    br .Label_dst
2091
2092                    So, if there is .Label1 or .Label2 we cannot relax this code.
2093                    This actually should not happen, cause for relaxable
2094                    instructions we use RL_PCREL reloc instead of 16_PCREL.
2095                    Will change this in the future. */
2096
2097                 if (rx->cdx > 0
2098                     && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2099                                                     irel->r_offset - 2))
2100                   continue;
2101                 if (rx->cdx > 1
2102                     && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2103                                                     irel->r_offset - 4))
2104                   continue;
2105
2106                 /* Note that we've changed the relocs, section contents, etc.  */
2107                 elf_section_data (sec)->relocs = internal_relocs;
2108                 elf_section_data (sec)->this_hdr.contents = contents;
2109                 symtab_hdr->contents = (unsigned char *) isymbuf;
2110
2111                 /* Fix the relocation's type.  */
2112                 if (uses_msp430x_relocs (abfd))
2113                   {
2114                     if (rx->labels == 3)        /* Handle special cases.  */
2115                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2116                                                    R_MSP430X_2X_PCREL);
2117                     else
2118                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2119                                                    R_MSP430X_10_PCREL);
2120                   }
2121                 else
2122                   {
2123                     if (rx->labels == 3)        /* Handle special cases.  */
2124                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2125                                                    R_MSP430_2X_PCREL);
2126                     else
2127                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2128                                                    R_MSP430_10_PCREL);
2129                   }
2130
2131                 /* Fix the opcode right way.  */
2132                 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
2133                 if (rx->t1)
2134                   bfd_put_16 (abfd, rx->t1,
2135                               contents + irel->r_offset - rx->off + 2);
2136
2137                 /* Delete bytes. */
2138                 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2139                                                     irel->r_offset - rx->off +
2140                                                     rx->ncl, rx->bs))
2141                   goto error_return;
2142
2143                 /* Handle unconditional jumps.  */
2144                 if (rx->cdx == 0)
2145                   irel->r_offset -= 2;
2146
2147                 /* That will change things, so, we should relax again.
2148                    Note that this is not required, and it may be slow.  */
2149                 *again = TRUE;
2150               }
2151           }
2152       }
2153
2154   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2155     {
2156       if (!link_info->keep_memory)
2157         free (isymbuf);
2158       else
2159         {
2160           /* Cache the symbols for elf_link_input_bfd.  */
2161           symtab_hdr->contents = (unsigned char *) isymbuf;
2162         }
2163     }
2164
2165   if (contents != NULL
2166       && elf_section_data (sec)->this_hdr.contents != contents)
2167     {
2168       if (!link_info->keep_memory)
2169         free (contents);
2170       else
2171         {
2172           /* Cache the section contents for elf_link_input_bfd.  */
2173           elf_section_data (sec)->this_hdr.contents = contents;
2174         }
2175     }
2176
2177   if (internal_relocs != NULL
2178       && elf_section_data (sec)->relocs != internal_relocs)
2179     free (internal_relocs);
2180
2181   return TRUE;
2182
2183 error_return:
2184   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2185     free (isymbuf);
2186   if (contents != NULL
2187       && elf_section_data (sec)->this_hdr.contents != contents)
2188     free (contents);
2189   if (internal_relocs != NULL
2190       && elf_section_data (sec)->relocs != internal_relocs)
2191     free (internal_relocs);
2192
2193   return FALSE;
2194 }
2195
2196 /* Handle an MSP430 specific section when reading an object file.
2197    This is called when bfd_section_from_shdr finds a section with
2198    an unknown type.  */
2199
2200 static bfd_boolean
2201 elf32_msp430_section_from_shdr (bfd *abfd,
2202                                 Elf_Internal_Shdr * hdr,
2203                                 const char *name,
2204                                 int shindex)
2205 {
2206   switch (hdr->sh_type)
2207     {
2208     case SHT_MSP430_SEC_FLAGS:
2209     case SHT_MSP430_SYM_ALIASES:
2210     case SHT_MSP430_ATTRIBUTES:
2211       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2212     default:
2213       return FALSE;
2214     }
2215 }
2216
2217 static bfd_boolean
2218 elf32_msp430_obj_attrs_handle_unknown (bfd *abfd, int tag)
2219 {
2220   _bfd_error_handler
2221     (_("Warning: %B: Unknown MSPABI object attribute %d"),
2222      abfd, tag);
2223   return TRUE;
2224 }
2225
2226 /* Determine whether an object attribute tag takes an integer, a
2227    string or both.  */
2228
2229 static int
2230 elf32_msp430_obj_attrs_arg_type (int tag)
2231 {
2232   if (tag == Tag_compatibility)
2233     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
2234
2235   if (tag < 32)
2236     return ATTR_TYPE_FLAG_INT_VAL;
2237
2238   return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
2239 }
2240
2241 static inline const char *
2242 isa_type (int isa)
2243 {
2244   switch (isa)
2245     {
2246     case 1: return "MSP430";
2247     case 2: return "MSP430X";
2248     default: return "unknown";
2249     }
2250 }
2251
2252 static inline const char *
2253 code_model (int model)
2254 {
2255   switch (model)
2256     {
2257     case 1: return "small";
2258     case 2: return "large";
2259     default: return "unknown";
2260     }
2261 }
2262
2263 static inline const char *
2264 data_model (int model)
2265 {
2266   switch (model)
2267     {
2268     case 1: return "small";
2269     case 2: return "large";
2270     case 3: return "restricted large";
2271     default: return "unknown";
2272     }
2273 }
2274
2275 /* Merge MSPABI object attributes from IBFD into OBFD.
2276    Raise an error if there are conflicting attributes.  */
2277
2278 static bfd_boolean
2279 elf32_msp430_merge_mspabi_attributes (bfd *ibfd, bfd *obfd)
2280 {
2281   obj_attribute *in_attr;
2282   obj_attribute *out_attr;
2283   bfd_boolean result = TRUE;
2284   static bfd * first_input_bfd = NULL;
2285
2286   /* Skip linker created files.  */
2287   if (ibfd->flags & BFD_LINKER_CREATED)
2288     return TRUE;
2289
2290   /* If this is the first real object just copy the attributes.  */
2291   if (!elf_known_obj_attributes_proc (obfd)[0].i)
2292     {
2293       _bfd_elf_copy_obj_attributes (ibfd, obfd);
2294
2295       out_attr = elf_known_obj_attributes_proc (obfd);
2296
2297       /* Use the Tag_null value to indicate that
2298          the attributes have been initialized.  */
2299       out_attr[0].i = 1;
2300
2301       first_input_bfd = ibfd;
2302       return TRUE;
2303     }
2304
2305   in_attr = elf_known_obj_attributes_proc (ibfd);
2306   out_attr = elf_known_obj_attributes_proc (obfd);
2307
2308   /* The ISAs must be the same.  */
2309   if (in_attr[OFBA_MSPABI_Tag_ISA].i != out_attr[OFBA_MSPABI_Tag_ISA].i)
2310     {
2311       _bfd_error_handler
2312         (_("error: %B uses %s instructions but %B uses %s"),
2313          ibfd, first_input_bfd,
2314          isa_type (in_attr[OFBA_MSPABI_Tag_ISA].i),
2315          isa_type (out_attr[OFBA_MSPABI_Tag_ISA].i));
2316       result = FALSE;
2317     }
2318
2319   /* The code models must be the same.  */
2320   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i !=
2321       out_attr[OFBA_MSPABI_Tag_Code_Model].i)
2322     {
2323       _bfd_error_handler
2324         (_("error: %B uses the %s code model whereas %B uses the %s code model"),
2325          ibfd, first_input_bfd,
2326          code_model (in_attr[OFBA_MSPABI_Tag_Code_Model].i),
2327          code_model (out_attr[OFBA_MSPABI_Tag_Code_Model].i));
2328       result = FALSE;
2329     }
2330
2331   /* The large code model is only supported by the MSP430X.  */
2332   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 2
2333       && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2334     {
2335       _bfd_error_handler
2336         (_("error: %B uses the large code model but %B uses MSP430 instructions"),
2337          ibfd, first_input_bfd);
2338       result = FALSE;
2339     }
2340
2341   /* The data models must be the same.  */
2342   if (in_attr[OFBA_MSPABI_Tag_Data_Model].i !=
2343       out_attr[OFBA_MSPABI_Tag_Data_Model].i)
2344     {
2345       _bfd_error_handler
2346         (_("error: %B uses the %s data model whereas %B uses the %s data model"),
2347          ibfd, first_input_bfd,
2348          data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
2349          data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2350       result = FALSE;
2351     }
2352
2353   /* The small code model requires the use of the small data model.  */
2354   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 1
2355       && out_attr[OFBA_MSPABI_Tag_Data_Model].i != 1)
2356     {
2357       _bfd_error_handler
2358         (_("error: %B uses the small code model but %B uses the %s data model"),
2359          ibfd, first_input_bfd,
2360          data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2361       result = FALSE;
2362     }
2363
2364   /* The large data models are only supported by the MSP430X.  */
2365   if (in_attr[OFBA_MSPABI_Tag_Data_Model].i > 1
2366       && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2367     {
2368       _bfd_error_handler
2369         (_("error: %B uses the %s data model but %B only uses MSP430 instructions"),
2370          ibfd, first_input_bfd,
2371          data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i));
2372       result = FALSE;
2373     }
2374
2375   return result;
2376 }
2377
2378 /* Merge backend specific data from an object file to the output
2379    object file when linking.  */
2380
2381 static bfd_boolean
2382 elf32_msp430_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
2383 {
2384   /* Make sure that the machine number reflects the most
2385      advanced version of the MSP architecture required.  */
2386 #define max(a,b) ((a) > (b) ? (a) : (b))
2387   if (bfd_get_mach (ibfd) != bfd_get_mach (obfd))
2388     bfd_default_set_arch_mach (obfd, bfd_get_arch (obfd),
2389                                max (bfd_get_mach (ibfd), bfd_get_mach (obfd)));
2390 #undef max
2391
2392   return elf32_msp430_merge_mspabi_attributes (ibfd, obfd);
2393 }
2394
2395 /* Copy backend specific data from one object module to another.  */
2396
2397 static bfd_boolean
2398 elf32_msp430_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2399 {
2400   /* Copy object attributes.  */
2401   _bfd_elf_copy_obj_attributes (ibfd, obfd);
2402
2403   return TRUE;
2404 }
2405
2406 static bfd_boolean
2407 msp430_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
2408 {
2409   return _bfd_elf_is_local_label_name (abfd, sym->name);
2410 }
2411
2412 /* This is gross.  The MSP430 EABI says that (sec 11.5):
2413
2414      "An implementation may choose to use Rel or Rela
2415       type relocations for other relocations."
2416
2417    But it also says that:
2418
2419      "Certain relocations are identified as Rela only. [snip]
2420       Where Rela is specified, an implementation must honor
2421       this requirement."
2422
2423   There is one relocation marked as requiring RELA - R_MSP430_ABS_HI16 - but
2424   to keep things simple we choose to use RELA relocations throughout.  The
2425   problem is that the TI compiler generates REL relocations, so we have to
2426   be able to accept those as well.  */
2427
2428 #define elf_backend_may_use_rel_p  1
2429 #define elf_backend_may_use_rela_p 1
2430 #define elf_backend_default_use_rela_p 1
2431
2432 #undef  elf_backend_obj_attrs_vendor
2433 #define elf_backend_obj_attrs_vendor            "mspabi"
2434 #undef  elf_backend_obj_attrs_section
2435 #define elf_backend_obj_attrs_section           ".MSP430.attributes"
2436 #undef  elf_backend_obj_attrs_section_type
2437 #define elf_backend_obj_attrs_section_type      SHT_MSP430_ATTRIBUTES
2438 #define elf_backend_section_from_shdr           elf32_msp430_section_from_shdr
2439 #define elf_backend_obj_attrs_handle_unknown    elf32_msp430_obj_attrs_handle_unknown
2440 #undef  elf_backend_obj_attrs_arg_type
2441 #define elf_backend_obj_attrs_arg_type          elf32_msp430_obj_attrs_arg_type
2442 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_msp430_copy_private_bfd_data
2443 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_msp430_merge_private_bfd_data
2444
2445 #define ELF_ARCH                bfd_arch_msp430
2446 #define ELF_MACHINE_CODE        EM_MSP430
2447 #define ELF_MACHINE_ALT1        EM_MSP430_OLD
2448 #define ELF_MAXPAGESIZE         4
2449 #define ELF_OSABI               ELFOSABI_STANDALONE
2450
2451 #define TARGET_LITTLE_SYM       bfd_elf32_msp430_vec
2452 #define TARGET_LITTLE_NAME      "elf32-msp430"
2453
2454 #define elf_info_to_howto                    msp430_info_to_howto_rela
2455 #define elf_info_to_howto_rel                NULL
2456 #define elf_backend_relocate_section         elf32_msp430_relocate_section
2457 #define elf_backend_check_relocs             elf32_msp430_check_relocs
2458 #define elf_backend_can_gc_sections          1
2459 #define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
2460 #define elf_backend_object_p                 elf32_msp430_object_p
2461 #define elf_backend_post_process_headers     _bfd_elf_set_osabi
2462 #define bfd_elf32_bfd_relax_section          msp430_elf_relax_section
2463 #define bfd_elf32_bfd_is_target_special_symbol  msp430_elf_is_target_special_symbol
2464
2465 #undef  elf32_bed
2466 #define elf32_bed               elf32_msp430_bed
2467
2468 #include "elf32-target.h"
2469
2470 /* The TI compiler sets the OSABI field to ELFOSABI_NONE.  */
2471 #undef  TARGET_LITTLE_SYM
2472 #define TARGET_LITTLE_SYM       bfd_elf32_msp430_ti_vec
2473
2474 #undef  elf32_bed
2475 #define elf32_bed               elf32_msp430_ti_bed
2476
2477 #undef  ELF_OSABI
2478 #define ELF_OSABI               ELFOSABI_NONE
2479
2480 static const struct bfd_elf_special_section msp430_ti_elf_special_sections[] =
2481 {
2482   /* prefix, prefix_length,        suffix_len, type,               attributes.  */
2483   { STRING_COMMA_LEN (".TI.symbol.alias"),  0, SHT_MSP430_SYM_ALIASES, 0 },
2484   { STRING_COMMA_LEN (".TI.section.flags"), 0, SHT_MSP430_SEC_FLAGS,   0 },
2485   { STRING_COMMA_LEN ("_TI_build_attrib"),  0, SHT_MSP430_ATTRIBUTES,  0 },
2486   { NULL, 0,                                0, 0,                      0 }
2487 };
2488
2489 #include "elf32-target.h"