bfd/elf32-msp430.c

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