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          3,                     /* size (0 = byte, 1 = short, 2 = long) */
  34          0,                     /* bitsize */
  35          FALSE,                 /* pc_relative */
  36          0,                     /* bitpos */
  37          complain_overflow_dont,/* 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          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 201          0,                     /* bitsize */
 202          FALSE,                 /* pc_relative */
 203          0,                     /* bitpos */
 204          complain_overflow_dont,/* 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 (_("%B: 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 (_("%B: 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     {
1660       const char * name;
1661
1662       name = bfd_elf_string_from_elf_section
1663         (abfd, symtab_hdr->sh_link, isym->st_name);
1664       name = (name == NULL || * name == 0) ? bfd_section_name (abfd, sec) : name;
1665
1666       if (isym->st_shndx != sec_shndx)
1667         continue;
1668
1669       if (isym->st_value > addr
1670           && (isym->st_value < toaddr
1671               /* We also adjust a symbol at the end of the section if its name is
1672                  on the list below.  These symbols are used for debug info
1673                  generation and they refer to the end of the current section, not
1674                  the start of the next section.  */
1675               || (isym->st_value == toaddr
1676                   && name != NULL
1677                   && (CONST_STRNEQ (name, ".Letext")
1678                       || CONST_STRNEQ (name, ".LFE")))))
1679         {
1680           if (isym->st_value < addr + count)
1681             isym->st_value = addr;
1682           else
1683             isym->st_value -= count;
1684         }
1685       /* Adjust the function symbol's size as well.  */
1686       else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC
1687                && isym->st_value + isym->st_size > addr
1688                && isym->st_value + isym->st_size < toaddr)
1689         isym->st_size -= count;
1690     }
1691
1692   /* Now adjust the global symbols defined in this section.  */
1693   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1694               - symtab_hdr->sh_info);
1695   sym_hashes = elf_sym_hashes (abfd);
1696   end_hashes = sym_hashes + symcount;
1697   for (; sym_hashes < end_hashes; sym_hashes++)
1698     {
1699       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1700
1701       if ((sym_hash->root.type == bfd_link_hash_defined
1702            || sym_hash->root.type == bfd_link_hash_defweak)
1703           && sym_hash->root.u.def.section == sec
1704           && sym_hash->root.u.def.value > addr
1705           && sym_hash->root.u.def.value < toaddr)
1706         {
1707           if (sym_hash->root.u.def.value < addr + count)
1708             sym_hash->root.u.def.value = addr;
1709           else
1710             sym_hash->root.u.def.value -= count;
1711         }
1712       /* Adjust the function symbol's size as well.  */
1713       else if (sym_hash->root.type == bfd_link_hash_defined
1714                && sym_hash->root.u.def.section == sec
1715                && sym_hash->type == STT_FUNC
1716                && sym_hash->root.u.def.value + sym_hash->size > addr
1717                && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1718         sym_hash->size -= count;
1719     }
1720
1721   return TRUE;
1722 }
1723
1724 /* Insert two words into a section whilst relaxing.  */
1725
1726 static bfd_byte *
1727 msp430_elf_relax_add_two_words (bfd * abfd, asection * sec, bfd_vma addr,
1728                                 int word1, int word2)
1729 {
1730   Elf_Internal_Shdr *symtab_hdr;
1731   unsigned int sec_shndx;
1732   bfd_byte *contents;
1733   Elf_Internal_Rela *irel;
1734   Elf_Internal_Rela *irelend;
1735   Elf_Internal_Sym *isym;
1736   Elf_Internal_Sym *isymend;
1737   struct elf_link_hash_entry **sym_hashes;
1738   struct elf_link_hash_entry **end_hashes;
1739   unsigned int symcount;
1740   bfd_vma sec_end;
1741   asection *p;
1742
1743   contents = elf_section_data (sec)->this_hdr.contents;
1744   sec_end = sec->size;
1745
1746   /* Make space for the new words.  */
1747   contents = bfd_realloc (contents, sec_end + 4);
1748   memmove (contents + addr + 4, contents + addr, sec_end - addr);
1749
1750   /* Insert the new words.  */
1751   bfd_put_16 (abfd, word1, contents + addr);
1752   bfd_put_16 (abfd, word2, contents + addr + 2);
1753
1754   /* Update the section information.  */
1755   sec->size += 4;
1756   elf_section_data (sec)->this_hdr.contents = contents;
1757
1758   /* Adjust all the relocs.  */
1759   irel = elf_section_data (sec)->relocs;
1760   irelend = irel + sec->reloc_count;
1761
1762   for (; irel < irelend; irel++)
1763     if ((irel->r_offset >= addr && irel->r_offset < sec_end))
1764       irel->r_offset += 4;
1765
1766   /* Adjust the local symbols defined in this section.  */
1767   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1768   for (p = abfd->sections; p != NULL; p = p->next)
1769     msp430_elf_relax_adjust_locals (abfd, p, addr, -4,
1770                                     sec_shndx, sec_end);
1771
1772   /* Adjust the global symbols affected by the move.  */
1773   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1774   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1775   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1776     if (isym->st_shndx == sec_shndx
1777         && isym->st_value >= addr && isym->st_value < sec_end)
1778       isym->st_value += 4;
1779
1780   /* Now adjust the global symbols defined in this section.  */
1781   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1782               - symtab_hdr->sh_info);
1783   sym_hashes = elf_sym_hashes (abfd);
1784   end_hashes = sym_hashes + symcount;
1785   for (; sym_hashes < end_hashes; sym_hashes++)
1786     {
1787       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1788
1789       if ((sym_hash->root.type == bfd_link_hash_defined
1790            || sym_hash->root.type == bfd_link_hash_defweak)
1791           && sym_hash->root.u.def.section == sec
1792           && sym_hash->root.u.def.value >= addr
1793           && sym_hash->root.u.def.value < sec_end)
1794         sym_hash->root.u.def.value += 4;
1795     }
1796
1797   return contents;
1798 }
1799
1800 static bfd_boolean
1801 msp430_elf_relax_section (bfd * abfd, asection * sec,
1802                           struct bfd_link_info * link_info,
1803                           bfd_boolean * again)
1804 {
1805   Elf_Internal_Shdr * symtab_hdr;
1806   Elf_Internal_Rela * internal_relocs;
1807   Elf_Internal_Rela * irel;
1808   Elf_Internal_Rela * irelend;
1809   bfd_byte *          contents = NULL;
1810   Elf_Internal_Sym *  isymbuf = NULL;
1811
1812   /* Assume nothing changes.  */
1813   *again = FALSE;
1814
1815   /* We don't have to do anything for a relocatable link, if
1816      this section does not have relocs, or if this is not a
1817      code section.  */
1818   if (link_info->relocatable
1819     || (sec->flags & SEC_RELOC) == 0
1820     || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
1821     return TRUE;
1822
1823   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1824
1825   /* Get a copy of the native relocations.  */
1826   internal_relocs =
1827     _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1828   if (internal_relocs == NULL)
1829     goto error_return;
1830
1831   /* Walk through them looking for relaxing opportunities.  */
1832   irelend = internal_relocs + sec->reloc_count;
1833
1834   /* Do code size growing relocs first.  */
1835   for (irel = internal_relocs; irel < irelend; irel++)
1836     {
1837       bfd_vma symval;
1838
1839       /* If this isn't something that can be relaxed, then ignore
1840          this reloc.  */
1841       if (uses_msp430x_relocs (abfd)
1842           && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430X_10_PCREL)
1843         ;
1844       else if (! uses_msp430x_relocs (abfd)
1845                && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_10_PCREL)
1846         ;
1847       else
1848         continue;
1849
1850       /* Get the section contents if we haven't done so already.  */
1851       if (contents == NULL)
1852         {
1853           /* Get cached copy if it exists.  */
1854           if (elf_section_data (sec)->this_hdr.contents != NULL)
1855             contents = elf_section_data (sec)->this_hdr.contents;
1856           else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1857             goto error_return;
1858         }
1859
1860       /* Read this BFD's local symbols if we haven't done so already.  */
1861       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1862         {
1863           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1864           if (isymbuf == NULL)
1865             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1866                                             symtab_hdr->sh_info, 0,
1867                                             NULL, NULL, NULL);
1868           if (isymbuf == NULL)
1869             goto error_return;
1870         }
1871
1872       /* Get the value of the symbol referred to by the reloc.  */
1873       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1874         {
1875           /* A local symbol.  */
1876           Elf_Internal_Sym *isym;
1877           asection *sym_sec;
1878
1879           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1880           if (isym->st_shndx == SHN_UNDEF)
1881             sym_sec = bfd_und_section_ptr;
1882           else if (isym->st_shndx == SHN_ABS)
1883             sym_sec = bfd_abs_section_ptr;
1884           else if (isym->st_shndx == SHN_COMMON)
1885             sym_sec = bfd_com_section_ptr;
1886           else
1887             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1888           symval = (isym->st_value
1889                     + sym_sec->output_section->vma + sym_sec->output_offset);
1890         }
1891       else
1892         {
1893           unsigned long indx;
1894           struct elf_link_hash_entry *h;
1895
1896           /* An external symbol.  */
1897           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1898           h = elf_sym_hashes (abfd)[indx];
1899           BFD_ASSERT (h != NULL);
1900
1901           if (h->root.type != bfd_link_hash_defined
1902               && h->root.type != bfd_link_hash_defweak)
1903             /* This appears to be a reference to an undefined
1904                symbol.  Just ignore it--it will be caught by the
1905                regular reloc processing.  */
1906             continue;
1907
1908           symval = (h->root.u.def.value
1909                     + h->root.u.def.section->output_section->vma
1910                     + h->root.u.def.section->output_offset);
1911         }
1912
1913       /* For simplicity of coding, we are going to modify the section
1914          contents, the section relocs, and the BFD symbol table.  We
1915          must tell the rest of the code not to free up this
1916          information.  It would be possible to instead create a table
1917          of changes which have to be made, as is done in coff-mips.c;
1918          that would be more work, but would require less memory when
1919          the linker is run.  */
1920
1921       bfd_signed_vma value = symval;
1922       int opcode;
1923
1924       /* Compute the value that will be relocated.  */
1925       value += irel->r_addend;
1926       /* Convert to PC relative.  */
1927       value -= (sec->output_section->vma + sec->output_offset);
1928       value -= irel->r_offset;
1929       value -= 2;
1930       /* Scale.  */
1931       value >>= 1;
1932
1933       /* If it is in range then no modifications are needed.  */
1934       if (value >= -512 && value <= 511)
1935         continue;
1936
1937       /* Get the opcode.  */
1938       opcode = bfd_get_16 (abfd, contents + irel->r_offset);
1939
1940       /* Compute the new opcode.  We are going to convert:
1941          J<cond> label
1942          into:
1943          J<inv-cond> 1f
1944          BR[A] #label
1945          1:                     */
1946       switch (opcode & 0xfc00)
1947         {
1948         case 0x3800: opcode = 0x3402; break; /* Jl  -> Jge +2 */
1949         case 0x3400: opcode = 0x3802; break; /* Jge -> Jl  +2 */
1950         case 0x2c00: opcode = 0x2802; break; /* Jhs -> Jlo +2 */
1951         case 0x2800: opcode = 0x2c02; break; /* Jlo -> Jhs +2 */
1952         case 0x2400: opcode = 0x2002; break; /* Jeq -> Jne +2 */
1953         case 0x2000: opcode = 0x2402; break; /* jne -> Jeq +2 */
1954         case 0x3000: /* jn    */
1955           /* There is no direct inverse of the Jn insn.
1956              FIXME: we could do this as:
1957                 Jn 1f
1958                 br 2f
1959              1: br label
1960              2:                */
1961           continue;
1962         default:
1963           /* Not a conditional branch instruction.  */
1964           /* fprintf (stderr, "unrecog: %x\n", opcode); */
1965           continue;
1966         }
1967
1968       /* Note that we've changed the relocs, section contents, etc.  */
1969       elf_section_data (sec)->relocs = internal_relocs;
1970       elf_section_data (sec)->this_hdr.contents = contents;
1971       symtab_hdr->contents = (unsigned char *) isymbuf;
1972
1973       /* Install the new opcode.  */
1974       bfd_put_16 (abfd, opcode, contents + irel->r_offset);
1975
1976       /* Insert the new branch instruction.  */
1977       if (uses_msp430x_relocs (abfd))
1978         {
1979           /* Insert an absolute branch (aka MOVA) instruction.  */
1980           contents = msp430_elf_relax_add_two_words
1981             (abfd, sec, irel->r_offset + 2, 0x0080, 0x0000);
1982
1983           /* Update the relocation to point to the inserted branch
1984              instruction.  Note - we are changing a PC-relative reloc
1985              into an absolute reloc, but this is OK because we have
1986              arranged with the assembler to have the reloc's value be
1987              a (local) symbol, not a section+offset value.  */
1988           irel->r_offset += 2;
1989           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1990                                        R_MSP430X_ABS20_ADR_SRC);
1991         }
1992       else
1993         {
1994           contents = msp430_elf_relax_add_two_words
1995             (abfd, sec, irel->r_offset + 2, 0x4030, 0x0000);
1996
1997           /* See comment above about converting a 10-bit PC-rel
1998              relocation into a 16-bit absolute relocation.  */
1999           irel->r_offset += 4;
2000           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2001                                        R_MSP430_16);
2002         }
2003
2004       /* Growing the section may mean that other
2005          conditional branches need to be fixed.  */
2006       *again = TRUE;
2007     }
2008
2009     for (irel = internal_relocs; irel < irelend; irel++)
2010       {
2011         bfd_vma symval;
2012
2013         /* Get the section contents if we haven't done so already.  */
2014         if (contents == NULL)
2015           {
2016             /* Get cached copy if it exists.  */
2017             if (elf_section_data (sec)->this_hdr.contents != NULL)
2018               contents = elf_section_data (sec)->this_hdr.contents;
2019             else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2020               goto error_return;
2021           }
2022
2023         /* Read this BFD's local symbols if we haven't done so already.  */
2024         if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2025           {
2026             isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2027             if (isymbuf == NULL)
2028               isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2029                                               symtab_hdr->sh_info, 0,
2030                                               NULL, NULL, NULL);
2031             if (isymbuf == NULL)
2032               goto error_return;
2033           }
2034
2035         /* Get the value of the symbol referred to by the reloc.  */
2036         if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2037           {
2038             /* A local symbol.  */
2039             Elf_Internal_Sym *isym;
2040             asection *sym_sec;
2041
2042             isym = isymbuf + ELF32_R_SYM (irel->r_info);
2043             if (isym->st_shndx == SHN_UNDEF)
2044               sym_sec = bfd_und_section_ptr;
2045             else if (isym->st_shndx == SHN_ABS)
2046               sym_sec = bfd_abs_section_ptr;
2047             else if (isym->st_shndx == SHN_COMMON)
2048               sym_sec = bfd_com_section_ptr;
2049             else
2050               sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2051             symval = (isym->st_value
2052                       + sym_sec->output_section->vma + sym_sec->output_offset);
2053           }
2054         else
2055           {
2056             unsigned long indx;
2057             struct elf_link_hash_entry *h;
2058
2059             /* An external symbol.  */
2060             indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2061             h = elf_sym_hashes (abfd)[indx];
2062             BFD_ASSERT (h != NULL);
2063
2064             if (h->root.type != bfd_link_hash_defined
2065                 && h->root.type != bfd_link_hash_defweak)
2066               /* This appears to be a reference to an undefined
2067                  symbol.  Just ignore it--it will be caught by the
2068                  regular reloc processing.  */
2069               continue;
2070
2071             symval = (h->root.u.def.value
2072                       + h->root.u.def.section->output_section->vma
2073                       + h->root.u.def.section->output_offset);
2074           }
2075
2076         /* For simplicity of coding, we are going to modify the section
2077            contents, the section relocs, and the BFD symbol table.  We
2078            must tell the rest of the code not to free up this
2079            information.  It would be possible to instead create a table
2080            of changes which have to be made, as is done in coff-mips.c;
2081            that would be more work, but would require less memory when
2082            the linker is run.  */
2083
2084         /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
2085            branch.  */
2086         /* Paranoia? paranoia...  */
2087         if (! uses_msp430x_relocs (abfd)
2088             && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
2089           {
2090             bfd_vma value = symval;
2091
2092             /* Deal with pc-relative gunk.  */
2093             value -= (sec->output_section->vma + sec->output_offset);
2094             value -= irel->r_offset;
2095             value += irel->r_addend;
2096
2097             /* See if the value will fit in 10 bits, note the high value is
2098                1016 as the target will be two bytes closer if we are
2099                able to relax.  */
2100             if ((long) value < 1016 && (long) value > -1016)
2101               {
2102                 int code0 = 0, code1 = 0, code2 = 0;
2103                 int i;
2104                 struct rcodes_s *rx;
2105
2106                 /* Get the opcode.  */
2107                 if (irel->r_offset >= 6)
2108                   code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
2109
2110                 if (irel->r_offset >= 4)
2111                   code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
2112
2113                 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2114
2115                 if (code2 != 0x4010)
2116                   continue;
2117
2118                 /* Check r4 and r3.  */
2119                 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
2120                   {
2121                     rx = &rcode[i];
2122                     if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
2123                       break;
2124                     else if (rx->cdx == 1 && rx->f1 == code1)
2125                       break;
2126                     else if (rx->cdx == 0)      /* This is an unconditional jump.  */
2127                       break;
2128                   }
2129
2130                 /* Check labels:
2131                    .Label0:       ; we do not care about this label
2132                    jeq    +6
2133                    .Label1:       ; make sure there is no label here
2134                    jl     +4
2135                    .Label2:       ; make sure there is no label here
2136                    br .Label_dst
2137
2138                    So, if there is .Label1 or .Label2 we cannot relax this code.
2139                    This actually should not happen, cause for relaxable
2140                    instructions we use RL_PCREL reloc instead of 16_PCREL.
2141                    Will change this in the future. */
2142
2143                 if (rx->cdx > 0
2144                     && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2145                                                     irel->r_offset - 2))
2146                   continue;
2147                 if (rx->cdx > 1
2148                     && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2149                                                     irel->r_offset - 4))
2150                   continue;
2151
2152                 /* Note that we've changed the relocs, section contents, etc.  */
2153                 elf_section_data (sec)->relocs = internal_relocs;
2154                 elf_section_data (sec)->this_hdr.contents = contents;
2155                 symtab_hdr->contents = (unsigned char *) isymbuf;
2156
2157                 /* Fix the relocation's type.  */
2158                 if (uses_msp430x_relocs (abfd))
2159                   {
2160                     if (rx->labels == 3)        /* Handle special cases.  */
2161                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2162                                                    R_MSP430X_2X_PCREL);
2163                     else
2164                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2165                                                    R_MSP430X_10_PCREL);
2166                   }
2167                 else
2168                   {
2169                     if (rx->labels == 3)        /* Handle special cases.  */
2170                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2171                                                    R_MSP430_2X_PCREL);
2172                     else
2173                       irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2174                                                    R_MSP430_10_PCREL);
2175                   }
2176
2177                 /* Fix the opcode right way.  */
2178                 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
2179                 if (rx->t1)
2180                   bfd_put_16 (abfd, rx->t1,
2181                               contents + irel->r_offset - rx->off + 2);
2182
2183                 /* Delete bytes. */
2184                 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2185                                                     irel->r_offset - rx->off +
2186                                                     rx->ncl, rx->bs))
2187                   goto error_return;
2188
2189                 /* Handle unconditional jumps.  */
2190                 if (rx->cdx == 0)
2191                   irel->r_offset -= 2;
2192
2193                 /* That will change things, so, we should relax again.
2194                    Note that this is not required, and it may be slow.  */
2195                 *again = TRUE;
2196               }
2197           }
2198
2199         /* Try to turn a 16-bit absolute branch into a 10-bit pc-relative
2200            branch.  */
2201         if (uses_msp430x_relocs (abfd)
2202             && ELF32_R_TYPE (irel->r_info) == R_MSP430X_ABS16)
2203           {
2204             bfd_vma value = symval;
2205
2206             value -= (sec->output_section->vma + sec->output_offset);
2207             value -= irel->r_offset;
2208             value += irel->r_addend;
2209
2210             /* See if the value will fit in 10 bits, note the high value is
2211                1016 as the target will be two bytes closer if we are
2212                able to relax.  */
2213             if ((long) value < 1016 && (long) value > -1016)
2214               {
2215                 int code2;
2216
2217                 /* Get the opcode.  */
2218                 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2219                 if (code2 != 0x4030)
2220                   continue;
2221                 /* FIXME: check r4 and r3 ? */
2222                 /* FIXME: Handle 0x4010 as well ?  */
2223
2224                 /* Note that we've changed the relocs, section contents, etc.  */
2225                 elf_section_data (sec)->relocs = internal_relocs;
2226                 elf_section_data (sec)->this_hdr.contents = contents;
2227                 symtab_hdr->contents = (unsigned char *) isymbuf;
2228
2229                 /* Fix the relocation's type.  */
2230                 if (uses_msp430x_relocs (abfd))
2231                   {
2232                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2233                                                  R_MSP430X_10_PCREL);
2234                   }
2235                 else
2236                   {
2237                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2238                                                  R_MSP430_10_PCREL);
2239                   }
2240
2241                 /* Fix the opcode right way.  */
2242                 bfd_put_16 (abfd, 0x3c00, contents + irel->r_offset - 2);
2243                 irel->r_offset -= 2;
2244
2245                 /* Delete bytes.  */
2246                 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2247                                                     irel->r_offset + 2, 2))
2248                   goto error_return;
2249
2250                 /* That will change things, so, we should relax again.
2251                    Note that this is not required, and it may be slow.  */
2252                 *again = TRUE;
2253               }
2254           }
2255       }
2256
2257   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2258     {
2259       if (!link_info->keep_memory)
2260         free (isymbuf);
2261       else
2262         {
2263           /* Cache the symbols for elf_link_input_bfd.  */
2264           symtab_hdr->contents = (unsigned char *) isymbuf;
2265         }
2266     }
2267
2268   if (contents != NULL
2269       && elf_section_data (sec)->this_hdr.contents != contents)
2270     {
2271       if (!link_info->keep_memory)
2272         free (contents);
2273       else
2274         {
2275           /* Cache the section contents for elf_link_input_bfd.  */
2276           elf_section_data (sec)->this_hdr.contents = contents;
2277         }
2278     }
2279
2280   if (internal_relocs != NULL
2281       && elf_section_data (sec)->relocs != internal_relocs)
2282     free (internal_relocs);
2283
2284   return TRUE;
2285
2286 error_return:
2287   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2288     free (isymbuf);
2289   if (contents != NULL
2290       && elf_section_data (sec)->this_hdr.contents != contents)
2291     free (contents);
2292   if (internal_relocs != NULL
2293       && elf_section_data (sec)->relocs != internal_relocs)
2294     free (internal_relocs);
2295
2296   return FALSE;
2297 }
2298
2299 /* Handle an MSP430 specific section when reading an object file.
2300    This is called when bfd_section_from_shdr finds a section with
2301    an unknown type.  */
2302
2303 static bfd_boolean
2304 elf32_msp430_section_from_shdr (bfd *abfd,
2305                                 Elf_Internal_Shdr * hdr,
2306                                 const char *name,
2307                                 int shindex)
2308 {
2309   switch (hdr->sh_type)
2310     {
2311     case SHT_MSP430_SEC_FLAGS:
2312     case SHT_MSP430_SYM_ALIASES:
2313     case SHT_MSP430_ATTRIBUTES:
2314       return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2315     default:
2316       return FALSE;
2317     }
2318 }
2319
2320 static bfd_boolean
2321 elf32_msp430_obj_attrs_handle_unknown (bfd *abfd, int tag)
2322 {
2323   _bfd_error_handler
2324     (_("Warning: %B: Unknown MSPABI object attribute %d"),
2325      abfd, tag);
2326   return TRUE;
2327 }
2328
2329 /* Determine whether an object attribute tag takes an integer, a
2330    string or both.  */
2331
2332 static int
2333 elf32_msp430_obj_attrs_arg_type (int tag)
2334 {
2335   if (tag == Tag_compatibility)
2336     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
2337
2338   if (tag < 32)
2339     return ATTR_TYPE_FLAG_INT_VAL;
2340
2341   return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
2342 }
2343
2344 static inline const char *
2345 isa_type (int isa)
2346 {
2347   switch (isa)
2348     {
2349     case 1: return "MSP430";
2350     case 2: return "MSP430X";
2351     default: return "unknown";
2352     }
2353 }
2354
2355 static inline const char *
2356 code_model (int model)
2357 {
2358   switch (model)
2359     {
2360     case 1: return "small";
2361     case 2: return "large";
2362     default: return "unknown";
2363     }
2364 }
2365
2366 static inline const char *
2367 data_model (int model)
2368 {
2369   switch (model)
2370     {
2371     case 1: return "small";
2372     case 2: return "large";
2373     case 3: return "restricted large";
2374     default: return "unknown";
2375     }
2376 }
2377
2378 /* Merge MSPABI object attributes from IBFD into OBFD.
2379    Raise an error if there are conflicting attributes.  */
2380
2381 static bfd_boolean
2382 elf32_msp430_merge_mspabi_attributes (bfd *ibfd, bfd *obfd)
2383 {
2384   obj_attribute *in_attr;
2385   obj_attribute *out_attr;
2386   bfd_boolean result = TRUE;
2387   static bfd * first_input_bfd = NULL;
2388
2389   /* Skip linker created files.  */
2390   if (ibfd->flags & BFD_LINKER_CREATED)
2391     return TRUE;
2392
2393   /* If this is the first real object just copy the attributes.  */
2394   if (!elf_known_obj_attributes_proc (obfd)[0].i)
2395     {
2396       _bfd_elf_copy_obj_attributes (ibfd, obfd);
2397
2398       out_attr = elf_known_obj_attributes_proc (obfd);
2399
2400       /* Use the Tag_null value to indicate that
2401          the attributes have been initialized.  */
2402       out_attr[0].i = 1;
2403
2404       first_input_bfd = ibfd;
2405       return TRUE;
2406     }
2407
2408   in_attr = elf_known_obj_attributes_proc (ibfd);
2409   out_attr = elf_known_obj_attributes_proc (obfd);
2410
2411   /* The ISAs must be the same.  */
2412   if (in_attr[OFBA_MSPABI_Tag_ISA].i != out_attr[OFBA_MSPABI_Tag_ISA].i)
2413     {
2414       _bfd_error_handler
2415         (_("error: %B uses %s instructions but %B uses %s"),
2416          ibfd, first_input_bfd,
2417          isa_type (in_attr[OFBA_MSPABI_Tag_ISA].i),
2418          isa_type (out_attr[OFBA_MSPABI_Tag_ISA].i));
2419       result = FALSE;
2420     }
2421
2422   /* The code models must be the same.  */
2423   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i !=
2424       out_attr[OFBA_MSPABI_Tag_Code_Model].i)
2425     {
2426       _bfd_error_handler
2427         (_("error: %B uses the %s code model whereas %B uses the %s code model"),
2428          ibfd, first_input_bfd,
2429          code_model (in_attr[OFBA_MSPABI_Tag_Code_Model].i),
2430          code_model (out_attr[OFBA_MSPABI_Tag_Code_Model].i));
2431       result = FALSE;
2432     }
2433
2434   /* The large code model is only supported by the MSP430X.  */
2435   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 2
2436       && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2437     {
2438       _bfd_error_handler
2439         (_("error: %B uses the large code model but %B uses MSP430 instructions"),
2440          ibfd, first_input_bfd);
2441       result = FALSE;
2442     }
2443
2444   /* The data models must be the same.  */
2445   if (in_attr[OFBA_MSPABI_Tag_Data_Model].i !=
2446       out_attr[OFBA_MSPABI_Tag_Data_Model].i)
2447     {
2448       _bfd_error_handler
2449         (_("error: %B uses the %s data model whereas %B uses the %s data model"),
2450          ibfd, first_input_bfd,
2451          data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
2452          data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2453       result = FALSE;
2454     }
2455
2456   /* The small code model requires the use of the small data model.  */
2457   if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 1
2458       && out_attr[OFBA_MSPABI_Tag_Data_Model].i != 1)
2459     {
2460       _bfd_error_handler
2461         (_("error: %B uses the small code model but %B uses the %s data model"),
2462          ibfd, first_input_bfd,
2463          data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2464       result = FALSE;
2465     }
2466
2467   /* The large data models are only supported by the MSP430X.  */
2468   if (in_attr[OFBA_MSPABI_Tag_Data_Model].i > 1
2469       && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2470     {
2471       _bfd_error_handler
2472         (_("error: %B uses the %s data model but %B only uses MSP430 instructions"),
2473          ibfd, first_input_bfd,
2474          data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i));
2475       result = FALSE;
2476     }
2477
2478   return result;
2479 }
2480
2481 /* Merge backend specific data from an object file to the output
2482    object file when linking.  */
2483
2484 static bfd_boolean
2485 elf32_msp430_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
2486 {
2487   /* Make sure that the machine number reflects the most
2488      advanced version of the MSP architecture required.  */
2489 #define max(a,b) ((a) > (b) ? (a) : (b))
2490   if (bfd_get_mach (ibfd) != bfd_get_mach (obfd))
2491     bfd_default_set_arch_mach (obfd, bfd_get_arch (obfd),
2492                                max (bfd_get_mach (ibfd), bfd_get_mach (obfd)));
2493 #undef max
2494
2495   return elf32_msp430_merge_mspabi_attributes (ibfd, obfd);
2496 }
2497
2498 static bfd_boolean
2499 msp430_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
2500 {
2501   return _bfd_elf_is_local_label_name (abfd, sym->name);
2502 }
2503
2504 /* This is gross.  The MSP430 EABI says that (sec 11.5):
2505
2506      "An implementation may choose to use Rel or Rela
2507       type relocations for other relocations."
2508
2509    But it also says that:
2510
2511      "Certain relocations are identified as Rela only. [snip]
2512       Where Rela is specified, an implementation must honor
2513       this requirement."
2514
2515   There is one relocation marked as requiring RELA - R_MSP430_ABS_HI16 - but
2516   to keep things simple we choose to use RELA relocations throughout.  The
2517   problem is that the TI compiler generates REL relocations, so we have to
2518   be able to accept those as well.  */
2519
2520 #define elf_backend_may_use_rel_p  1
2521 #define elf_backend_may_use_rela_p 1
2522 #define elf_backend_default_use_rela_p 1
2523
2524 #undef  elf_backend_obj_attrs_vendor
2525 #define elf_backend_obj_attrs_vendor            "mspabi"
2526 #undef  elf_backend_obj_attrs_section
2527 #define elf_backend_obj_attrs_section           ".MSP430.attributes"
2528 #undef  elf_backend_obj_attrs_section_type
2529 #define elf_backend_obj_attrs_section_type      SHT_MSP430_ATTRIBUTES
2530 #define elf_backend_section_from_shdr           elf32_msp430_section_from_shdr
2531 #define elf_backend_obj_attrs_handle_unknown    elf32_msp430_obj_attrs_handle_unknown
2532 #undef  elf_backend_obj_attrs_arg_type
2533 #define elf_backend_obj_attrs_arg_type          elf32_msp430_obj_attrs_arg_type
2534 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_msp430_merge_private_bfd_data
2535
2536 #define ELF_ARCH                bfd_arch_msp430
2537 #define ELF_MACHINE_CODE        EM_MSP430
2538 #define ELF_MACHINE_ALT1        EM_MSP430_OLD
2539 #define ELF_MAXPAGESIZE         4
2540 #define ELF_OSABI               ELFOSABI_STANDALONE
2541
2542 #define TARGET_LITTLE_SYM       msp430_elf32_vec
2543 #define TARGET_LITTLE_NAME      "elf32-msp430"
2544
2545 #define elf_info_to_howto                    msp430_info_to_howto_rela
2546 #define elf_info_to_howto_rel                NULL
2547 #define elf_backend_relocate_section         elf32_msp430_relocate_section
2548 #define elf_backend_check_relocs             elf32_msp430_check_relocs
2549 #define elf_backend_can_gc_sections          1
2550 #define elf_backend_final_write_processing   bfd_elf_msp430_final_write_processing
2551 #define elf_backend_object_p                 elf32_msp430_object_p
2552 #define bfd_elf32_bfd_relax_section          msp430_elf_relax_section
2553 #define bfd_elf32_bfd_is_target_special_symbol  msp430_elf_is_target_special_symbol
2554
2555 #undef  elf32_bed
2556 #define elf32_bed               elf32_msp430_bed
2557
2558 #include "elf32-target.h"
2559
2560 /* The TI compiler sets the OSABI field to ELFOSABI_NONE.  */
2561 #undef  TARGET_LITTLE_SYM
2562 #define TARGET_LITTLE_SYM       msp430_elf32_ti_vec
2563
2564 #undef  elf32_bed
2565 #define elf32_bed               elf32_msp430_ti_bed
2566
2567 #undef  ELF_OSABI
2568 #define ELF_OSABI               ELFOSABI_NONE
2569
2570 static const struct bfd_elf_special_section msp430_ti_elf_special_sections[] =
2571 {
2572   /* prefix, prefix_length,        suffix_len, type,               attributes.  */
2573   { STRING_COMMA_LEN (".TI.symbol.alias"),  0, SHT_MSP430_SYM_ALIASES, 0 },
2574   { STRING_COMMA_LEN (".TI.section.flags"), 0, SHT_MSP430_SEC_FLAGS,   0 },
2575   { STRING_COMMA_LEN ("_TI_build_attrib"),  0, SHT_MSP430_ATTRIBUTES,  0 },
2576   { NULL, 0,                                0, 0,                      0 }
2577 };
2578
2579 #include "elf32-target.h"