bfd/elf32-tilepro.c

   1 /* TILEPro-specific support for 32-bit ELF.
   2    Copyright 2011, 2012 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/tilepro.h"
  26 #include "opcode/tilepro.h"
  27 #include "libiberty.h"
  28 #include "elf32-tilepro.h"
  29
  30 #define TILEPRO_BYTES_PER_WORD 4
  31
  32 static reloc_howto_type tilepro_elf_howto_table [] =
  33 {
  34   /* This reloc does nothing.  */
  35   HOWTO (R_TILEPRO_NONE,        /* type */
  36          0,                     /* rightshift */
  37          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  38          32,                    /* bitsize */
  39          FALSE,                 /* pc_relative */
  40          0,                     /* bitpos */
  41          complain_overflow_bitfield, /* complain_on_overflow */
  42          bfd_elf_generic_reloc, /* special_function */
  43          "R_TILEPRO_NONE",      /* name */
  44          FALSE,                 /* partial_inplace */
  45          0,                     /* src_mask */
  46          0,                     /* dst_mask */
  47          FALSE),                /* pcrel_offset */
  48
  49   /* A 32 bit absolute relocation.  */
  50   HOWTO (R_TILEPRO_32,  /* type */
  51          0,                     /* rightshift */
  52          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  53          32,                    /* bitsize */
  54          FALSE,                 /* pc_relative */
  55          0,                     /* bitpos */
  56          complain_overflow_dont, /* complain_on_overflow */
  57          bfd_elf_generic_reloc, /* special_function */
  58          "R_TILEPRO_32",        /* name */
  59          FALSE,                 /* partial_inplace */
  60          0,                     /* src_mask */
  61          0xffffffff,            /* dst_mask */
  62          FALSE),                /* pcrel_offset */
  63
  64   /* A 16 bit absolute relocation.  */
  65   HOWTO (R_TILEPRO_16,  /* type */
  66          0,                     /* rightshift */
  67          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  68          16,                    /* bitsize */
  69          FALSE,                 /* pc_relative */
  70          0,                     /* bitpos */
  71          complain_overflow_bitfield, /* complain_on_overflow */
  72          bfd_elf_generic_reloc, /* special_function */
  73          "R_TILEPRO_16",        /* name */
  74          FALSE,                 /* partial_inplace */
  75          0,                     /* src_mask */
  76          0xffff,                /* dst_mask */
  77          FALSE),                /* pcrel_offset */
  78
  79   /* An 8 bit absolute relocation.  */
  80   HOWTO (R_TILEPRO_8,   /* type */
  81          0,                     /* rightshift */
  82          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          8,                     /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_unsigned, /* complain_on_overflow */
  87          bfd_elf_generic_reloc, /* special_function */
  88          "R_TILEPRO_8", /* name */
  89          FALSE,                 /* partial_inplace */
  90          0,                     /* src_mask */
  91          0xff,                  /* dst_mask */
  92          FALSE),                /* pcrel_offset */
  93
  94   /* A 32 bit pc-relative relocation.  */
  95   HOWTO (R_TILEPRO_32_PCREL,/* type */
  96          0,                     /* rightshift */
  97          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  98          32,                    /* bitsize */
  99          TRUE,                  /* pc_relative */
 100          0,                     /* bitpos */
 101          complain_overflow_dont, /* complain_on_overflow */
 102          bfd_elf_generic_reloc, /* special_function */
 103          "R_TILEPRO_32_PCREL", /* name */
 104          FALSE,                 /* partial_inplace */
 105          0,                     /* src_mask */
 106          0xffffffff,            /* dst_mask */
 107          TRUE),                 /* pcrel_offset */
 108
 109   /* A 16 bit pc-relative relocation.  */
 110   HOWTO (R_TILEPRO_16_PCREL,/* type */
 111          0,                     /* rightshift */
 112          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 113          16,                    /* bitsize */
 114          TRUE,                  /* pc_relative */
 115          0,                     /* bitpos */
 116          complain_overflow_signed, /* complain_on_overflow */
 117          bfd_elf_generic_reloc, /* special_function */
 118          "R_TILEPRO_16_PCREL",  /* name */
 119          FALSE,                 /* partial_inplace */
 120          0,                     /* src_mask */
 121          0xffff,                /* dst_mask */
 122          TRUE),                 /* pcrel_offset */
 123
 124   /* An 8 bit pc-relative relocation.  */
 125   HOWTO (R_TILEPRO_8_PCREL,     /* type */
 126          0,                     /* rightshift */
 127          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 128          8,                     /* bitsize */
 129          TRUE,                  /* pc_relative */
 130          0,                     /* bitpos */
 131          complain_overflow_signed, /* complain_on_overflow */
 132          bfd_elf_generic_reloc, /* special_function */
 133          "R_TILEPRO_8_PCREL",/* name */
 134          FALSE,                 /* partial_inplace */
 135          0,                     /* src_mask */
 136          0xff,                  /* dst_mask */
 137          TRUE),                 /* pcrel_offset */
 138
 139   /* A 16 bit relocation without overflow.  */
 140   HOWTO (R_TILEPRO_LO16,        /* type */
 141          0,                     /* rightshift */
 142          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 143          16,                    /* bitsize */
 144          FALSE,                 /* pc_relative */
 145          0,                     /* bitpos */
 146          complain_overflow_dont,/* complain_on_overflow */
 147          bfd_elf_generic_reloc, /* special_function */
 148          "R_TILEPRO_LO16",      /* name */
 149          FALSE,                 /* partial_inplace */
 150          0,                     /* src_mask */
 151          0xffff,                /* dst_mask */
 152          FALSE),                /* pcrel_offset */
 153
 154   /* The high order 16 bits of an address.  */
 155   HOWTO (R_TILEPRO_HI16,        /* type */
 156          16,                    /* rightshift */
 157          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 158          16,                    /* bitsize */
 159          FALSE,                 /* pc_relative */
 160          0,                     /* bitpos */
 161          complain_overflow_dont, /* complain_on_overflow */
 162          bfd_elf_generic_reloc, /* special_function */
 163          "R_TILEPRO_HI16",      /* name */
 164          FALSE,                 /* partial_inplace */
 165          0,                     /* src_mask */
 166          0xffff,                /* dst_mask */
 167          FALSE),                /* pcrel_offset */
 168
 169   /* The high order 16 bits of an address, plus 1 if the contents of
 170      the low 16 bits, treated as a signed number, is negative.  */
 171   HOWTO (R_TILEPRO_HA16,        /* type */
 172          16,                    /* rightshift */
 173          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 174          16,                    /* bitsize */
 175          FALSE,                 /* pc_relative */
 176          0,                     /* bitpos */
 177          complain_overflow_dont, /* complain_on_overflow */
 178          bfd_elf_generic_reloc, /* special_function */
 179          "R_TILEPRO_HA16",  /* name */
 180          FALSE,                 /* partial_inplace */
 181          0,                     /* src_mask */
 182          0xffff,                /* dst_mask */
 183          FALSE),                /* pcrel_offset */
 184
 185   HOWTO (R_TILEPRO_COPY,                /* type */
 186          0,                     /* rightshift */
 187          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 188          0,                     /* bitsize */
 189          FALSE,                 /* pc_relative */
 190          0,                     /* bitpos */
 191          complain_overflow_dont, /* complain_on_overflow */
 192          bfd_elf_generic_reloc, /* special_function */
 193          "R_TILEPRO_COPY",              /* name */
 194          FALSE,                 /* partial_inplace */
 195          0,                     /* src_mask */
 196          0,                     /* dst_mask */
 197          TRUE),                 /* pcrel_offset */
 198
 199   HOWTO (R_TILEPRO_GLOB_DAT,    /* type */
 200          0,                     /* rightshift */
 201          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 202          0,                     /* bitsize */
 203          FALSE,                 /* pc_relative */
 204          0,                     /* bitpos */
 205          complain_overflow_dont, /* complain_on_overflow */
 206          bfd_elf_generic_reloc, /* special_function */
 207          "R_TILEPRO_GLOB_DAT",  /* name */
 208          FALSE,                 /* partial_inplace */
 209          0,                     /* src_mask */
 210          0,                     /* dst_mask */
 211          TRUE),                 /* pcrel_offset */
 212
 213   HOWTO (R_TILEPRO_JMP_SLOT,    /* type */
 214          0,                     /* rightshift */
 215          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 216          0,                     /* bitsize */
 217          FALSE,                 /* pc_relative */
 218          0,                     /* bitpos */
 219          complain_overflow_dont, /* complain_on_overflow */
 220          bfd_elf_generic_reloc, /* special_function */
 221          "R_TILEPRO_JMP_SLOT",  /* name */
 222          FALSE,                 /* partial_inplace */
 223          0,                     /* src_mask */
 224          0,                     /* dst_mask */
 225          TRUE),                 /* pcrel_offset */
 226
 227   HOWTO (R_TILEPRO_RELATIVE,    /* type */
 228          0,                     /* rightshift */
 229          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          0,                     /* bitsize */
 231          FALSE,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_dont, /* complain_on_overflow */
 234          bfd_elf_generic_reloc, /* special_function */
 235          "R_TILEPRO_RELATIVE",  /* name */
 236          FALSE,                 /* partial_inplace */
 237          0,                     /* src_mask */
 238          0,                     /* dst_mask */
 239          TRUE),                 /* pcrel_offset */
 240
 241   HOWTO (R_TILEPRO_BROFF_X1, /* type */
 242          TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
 243          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 244          17,                    /* bitsize */
 245          TRUE,                  /* pc_relative */
 246          0,                     /* bitpos */
 247          complain_overflow_signed, /* complain_on_overflow */
 248          bfd_elf_generic_reloc, /* special_function */
 249          "R_TILEPRO_BROFF_X1", /* name */
 250          FALSE,                 /* partial_inplace */
 251          0,                     /* src_mask */
 252          -1,                    /* dst_mask */
 253          TRUE),                 /* pcrel_offset */
 254
 255   HOWTO (R_TILEPRO_JOFFLONG_X1, /* type */
 256          TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
 257          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 258          29,                    /* bitsize */
 259          TRUE,                  /* pc_relative */
 260          0,                     /* bitpos */
 261          complain_overflow_signed,/* complain_on_overflow */
 262          bfd_elf_generic_reloc, /* special_function */
 263          "R_TILEPRO_JOFFLONG_X1", /* name */
 264          FALSE,                 /* partial_inplace */
 265          0,                     /* src_mask */
 266          -1,                    /* dst_mask */
 267          TRUE),                 /* pcrel_offset */
 268
 269   HOWTO (R_TILEPRO_JOFFLONG_X1_PLT, /* type */
 270          TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
 271          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 272          29,                    /* bitsize */
 273          TRUE,                  /* pc_relative */
 274          0,                     /* bitpos */
 275          complain_overflow_signed,/* complain_on_overflow */
 276          bfd_elf_generic_reloc, /* special_function */
 277          "R_TILEPRO_JOFFLONG_X1_PLT", /* name */
 278          FALSE,                 /* partial_inplace */
 279          0,                     /* src_mask */
 280          -1,                    /* dst_mask */
 281          TRUE),                 /* pcrel_offset */
 282
 283 #define TILEPRO_IMM_HOWTO(name, size, bitsize) \
 284   HOWTO (name, 0, size, bitsize, FALSE, 0, \
 285          complain_overflow_signed, bfd_elf_generic_reloc, \
 286          #name, FALSE, 0, -1, FALSE)
 287
 288 #define TILEPRO_UIMM_HOWTO(name, size, bitsize) \
 289   HOWTO (name, 0, size, bitsize, FALSE, 0, \
 290          complain_overflow_unsigned, bfd_elf_generic_reloc, \
 291          #name, FALSE, 0, -1, FALSE)
 292
 293   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X0,  0,  8),
 294   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y0,  0,  8),
 295   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X1,  0,  8),
 296   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y1,  0,  8),
 297   TILEPRO_UIMM_HOWTO(R_TILEPRO_MT_IMM15_X1, 1,  15),
 298   TILEPRO_UIMM_HOWTO(R_TILEPRO_MF_IMM15_X1, 1,  15),
 299   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X0, 1, 16),
 300   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X1, 1, 16),
 301
 302 #define TILEPRO_IMM16_HOWTO(name, rshift) \
 303   HOWTO (name, rshift, 1, 16, FALSE, 0, \
 304          complain_overflow_dont, bfd_elf_generic_reloc, \
 305          #name, FALSE, 0, 0xffff, FALSE)
 306
 307   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_LO,  0),
 308   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_LO,  0),
 309   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_HI, 16),
 310   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_HI, 16),
 311   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_HA, 16),
 312   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_HA, 16),
 313
 314   /* PC-relative offsets. */
 315
 316   HOWTO (R_TILEPRO_IMM16_X0_PCREL,      /* type */
 317          0,                     /* rightshift */
 318          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          16,                    /* bitsize */
 320          TRUE,                  /* pc_relative */
 321          0,                     /* bitpos */
 322          complain_overflow_signed, /* complain_on_overflow */
 323          bfd_elf_generic_reloc, /* special_function */
 324          "R_TILEPRO_IMM16_X0_PCREL",/* name */
 325          FALSE,                 /* partial_inplace */
 326          0,                     /* src_mask */
 327          -1,                    /* dst_mask */
 328          TRUE),                 /* pcrel_offset */
 329
 330   HOWTO (R_TILEPRO_IMM16_X1_PCREL,      /* type */
 331          0,                     /* rightshift */
 332          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 333          16,                    /* bitsize */
 334          TRUE,                  /* pc_relative */
 335          0,                     /* bitpos */
 336          complain_overflow_signed, /* complain_on_overflow */
 337          bfd_elf_generic_reloc, /* special_function */
 338          "R_TILEPRO_IMM16_X1_PCREL",/* name */
 339          FALSE,                 /* partial_inplace */
 340          0,                     /* src_mask */
 341          -1,                    /* dst_mask */
 342          TRUE),                 /* pcrel_offset */
 343
 344 #define TILEPRO_IMM16_HOWTO_PCREL(name, rshift) \
 345   HOWTO (name, rshift, 1, 16, TRUE, 0, \
 346          complain_overflow_dont, bfd_elf_generic_reloc, \
 347          #name, FALSE, 0, 0xffff, TRUE)
 348
 349   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_LO_PCREL,  0),
 350   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_LO_PCREL,  0),
 351   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_HI_PCREL, 16),
 352   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_HI_PCREL, 16),
 353   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X0_HA_PCREL, 16),
 354   TILEPRO_IMM16_HOWTO_PCREL (R_TILEPRO_IMM16_X1_HA_PCREL, 16),
 355
 356   /* Byte offset into GOT for a particular symbol. */
 357   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X0_GOT, 1, 16),
 358   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM16_X1_GOT, 1, 16),
 359   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_LO,  0),
 360   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_LO,  0),
 361   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_HI, 16),
 362   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_HI, 16),
 363   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_GOT_HA, 16),
 364   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_GOT_HA, 16),
 365
 366   TILEPRO_UIMM_HOWTO(R_TILEPRO_MMSTART_X0, 0, 5),
 367   TILEPRO_UIMM_HOWTO(R_TILEPRO_MMEND_X0,   0, 5),
 368   TILEPRO_UIMM_HOWTO(R_TILEPRO_MMSTART_X1, 0, 5),
 369   TILEPRO_UIMM_HOWTO(R_TILEPRO_MMEND_X1,   0, 5),
 370
 371   TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_X0, 0, 5),
 372   TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_X1, 0, 5),
 373   TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_Y0, 0, 5),
 374   TILEPRO_UIMM_HOWTO(R_TILEPRO_SHAMT_Y1, 0, 5),
 375
 376   TILEPRO_IMM_HOWTO(R_TILEPRO_DEST_IMM8_X1, 0, 8),
 377
 378   /* These relocs are currently not defined.  */
 379   EMPTY_HOWTO (56),
 380   EMPTY_HOWTO (57),
 381   EMPTY_HOWTO (58),
 382   EMPTY_HOWTO (59),
 383
 384   HOWTO (R_TILEPRO_TLS_GD_CALL, /* type */
 385          TILEPRO_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          29,                    /* bitsize */
 388          TRUE,                  /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_signed,/* complain_on_overflow */
 391          bfd_elf_generic_reloc, /* special_function */
 392          "R_TILEPRO_TLS_GD_CALL", /* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          -1,                    /* dst_mask */
 396          TRUE),                 /* pcrel_offset */
 397
 398   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X0_TLS_GD_ADD,  0,  8),
 399   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_X1_TLS_GD_ADD,  0,  8),
 400   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y0_TLS_GD_ADD,  0,  8),
 401   TILEPRO_IMM_HOWTO(R_TILEPRO_IMM8_Y1_TLS_GD_ADD,  0,  8),
 402   TILEPRO_IMM_HOWTO(R_TILEPRO_TLS_IE_LOAD,  0,  8),
 403
 404   /* Offsets into the GOT of TLS Descriptors. */
 405
 406   HOWTO (R_TILEPRO_IMM16_X0_TLS_GD,/* type */
 407          0,                     /* rightshift */
 408          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 409          16,                    /* bitsize */
 410          FALSE,                 /* pc_relative */
 411          0,                     /* bitpos */
 412          complain_overflow_signed, /* complain_on_overflow */
 413          bfd_elf_generic_reloc, /* special_function */
 414          "R_TILEPRO_IMM16_X0_TLS_GD",/* name */
 415          FALSE,                 /* partial_inplace */
 416          0,                     /* src_mask */
 417          0xffff,                /* dst_mask */
 418          FALSE),                /* pcrel_offset */
 419
 420   HOWTO (R_TILEPRO_IMM16_X1_TLS_GD,/* type */
 421          0,                     /* rightshift */
 422          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 423          16,                    /* bitsize */
 424          FALSE,                 /* pc_relative */
 425          0,                     /* bitpos */
 426          complain_overflow_signed, /* complain_on_overflow */
 427          bfd_elf_generic_reloc, /* special_function */
 428          "R_TILEPRO_IMM16_X1_TLS_GD",/* name */
 429          FALSE,                 /* partial_inplace */
 430          0,                     /* src_mask */
 431          0xffff,                /* dst_mask */
 432          FALSE),                /* pcrel_offset */
 433
 434   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_LO,  0),
 435   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_LO,  0),
 436   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_HI, 16),
 437   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_HI, 16),
 438   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_GD_HA, 16),
 439   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_GD_HA, 16),
 440
 441   /* Offsets into the GOT of TLS Descriptors. */
 442
 443   HOWTO (R_TILEPRO_IMM16_X0_TLS_IE,/* type */
 444          0,                     /* rightshift */
 445          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          16,                    /* bitsize */
 447          FALSE,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_signed, /* complain_on_overflow */
 450          bfd_elf_generic_reloc, /* special_function */
 451          "R_TILEPRO_IMM16_X0_TLS_IE",/* name */
 452          FALSE,                 /* partial_inplace */
 453          0,                     /* src_mask */
 454          -1,                    /* dst_mask */
 455          TRUE),                 /* pcrel_offset */
 456
 457   HOWTO (R_TILEPRO_IMM16_X1_TLS_IE,/* type */
 458          0,                     /* rightshift */
 459          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_signed, /* complain_on_overflow */
 464          bfd_elf_generic_reloc, /* special_function */
 465          "R_TILEPRO_IMM16_X1_TLS_IE",/* name */
 466          FALSE,                 /* partial_inplace */
 467          0,                     /* src_mask */
 468          -1,                    /* dst_mask */
 469          TRUE),                 /* pcrel_offset */
 470
 471   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_LO,  0),
 472   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_LO,  0),
 473   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_HI, 16),
 474   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_HI, 16),
 475   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_IE_HA, 16),
 476   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_IE_HA, 16),
 477
 478   /* These are common with the Solaris TLS implementation. */
 479   HOWTO(R_TILEPRO_TLS_DTPMOD32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 480         bfd_elf_generic_reloc, "R_TILEPRO_TLS_DTPMOD32",
 481         FALSE, 0, 0, TRUE),
 482   HOWTO(R_TILEPRO_TLS_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 483         bfd_elf_generic_reloc, "R_TILEPRO_TLS_DTPOFF32",
 484         FALSE, 0, 0xFFFFFFFF, TRUE),
 485   HOWTO(R_TILEPRO_TLS_TPOFF32, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 486         bfd_elf_generic_reloc, "R_TILEPRO_TLS_TPOFF32",
 487         FALSE, 0, 0, TRUE),
 488
 489   HOWTO (R_TILEPRO_IMM16_X0_TLS_LE,/* type */
 490          0,                     /* rightshift */
 491          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 492          16,                    /* bitsize */
 493          FALSE,                 /* pc_relative */
 494          0,                     /* bitpos */
 495          complain_overflow_signed, /* complain_on_overflow */
 496          bfd_elf_generic_reloc, /* special_function */
 497          "R_TILEPRO_IMM16_X0_TLS_LE",/* name */
 498          FALSE,                 /* partial_inplace */
 499          0,                     /* src_mask */
 500          -1,                    /* dst_mask */
 501          TRUE),                 /* pcrel_offset */
 502
 503   HOWTO (R_TILEPRO_IMM16_X1_TLS_LE,/* type */
 504          0,                     /* rightshift */
 505          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 506          16,                    /* bitsize */
 507          FALSE,                 /* pc_relative */
 508          0,                     /* bitpos */
 509          complain_overflow_signed, /* complain_on_overflow */
 510          bfd_elf_generic_reloc, /* special_function */
 511          "R_TILEPRO_IMM16_X1_TLS_LE",/* name */
 512          FALSE,                 /* partial_inplace */
 513          0,                     /* src_mask */
 514          -1,                    /* dst_mask */
 515          TRUE),                 /* pcrel_offset */
 516
 517   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_LO,  0),
 518   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_LO,  0),
 519   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_HI, 16),
 520   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_HI, 16),
 521   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X0_TLS_LE_HA, 16),
 522   TILEPRO_IMM16_HOWTO (R_TILEPRO_IMM16_X1_TLS_LE_HA, 16),
 523 };
 524
 525 static reloc_howto_type tilepro_elf_howto_table2 [] =
 526 {
 527   /* GNU extension to record C++ vtable hierarchy */
 528   HOWTO (R_TILEPRO_GNU_VTINHERIT, /* type */
 529          0,                     /* rightshift */
 530          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 531          0,                     /* bitsize */
 532          FALSE,                 /* pc_relative */
 533          0,                     /* bitpos */
 534          complain_overflow_dont, /* complain_on_overflow */
 535          NULL,                  /* special_function */
 536          "R_TILEPRO_GNU_VTINHERIT", /* name */
 537          FALSE,                 /* partial_inplace */
 538          0,                     /* src_mask */
 539          0,                     /* dst_mask */
 540          FALSE),                /* pcrel_offset */
 541
 542   /* GNU extension to record C++ vtable member usage */
 543   HOWTO (R_TILEPRO_GNU_VTENTRY,     /* type */
 544          0,                     /* rightshift */
 545          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 546          0,                     /* bitsize */
 547          FALSE,                 /* pc_relative */
 548          0,                     /* bitpos */
 549          complain_overflow_dont, /* complain_on_overflow */
 550          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 551          "R_TILEPRO_GNU_VTENTRY",   /* name */
 552          FALSE,                 /* partial_inplace */
 553          0,                     /* src_mask */
 554          0,                     /* dst_mask */
 555          FALSE),                /* pcrel_offset */
 556
 557 };
 558 \f
 559 /* Map BFD reloc types to TILEPRO ELF reloc types.  */
 560
 561 typedef struct tilepro_reloc_map
 562 {
 563   bfd_reloc_code_real_type  bfd_reloc_val;
 564   unsigned int              tilepro_reloc_val;
 565   reloc_howto_type *        table;
 566 } reloc_map;
 567
 568 static const reloc_map tilepro_reloc_map [] =
 569 {
 570 #define TH_REMAP(bfd, tilepro) \
 571   { bfd, tilepro, tilepro_elf_howto_table },
 572
 573   /* Standard relocations. */
 574   TH_REMAP (BFD_RELOC_NONE,                    R_TILEPRO_NONE)
 575   TH_REMAP (BFD_RELOC_32,                      R_TILEPRO_32)
 576   TH_REMAP (BFD_RELOC_16,                      R_TILEPRO_16)
 577   TH_REMAP (BFD_RELOC_8,                       R_TILEPRO_8)
 578   TH_REMAP (BFD_RELOC_32_PCREL,                R_TILEPRO_32_PCREL)
 579   TH_REMAP (BFD_RELOC_16_PCREL,                R_TILEPRO_16_PCREL)
 580   TH_REMAP (BFD_RELOC_8_PCREL,                 R_TILEPRO_8_PCREL)
 581   TH_REMAP (BFD_RELOC_LO16,                    R_TILEPRO_LO16)
 582   TH_REMAP (BFD_RELOC_HI16,                    R_TILEPRO_HI16)
 583   TH_REMAP (BFD_RELOC_HI16_S,                  R_TILEPRO_HA16)
 584
 585   /* Custom relocations. */
 586   TH_REMAP (BFD_RELOC_TILEPRO_COPY,            R_TILEPRO_COPY)
 587   TH_REMAP (BFD_RELOC_TILEPRO_GLOB_DAT,        R_TILEPRO_GLOB_DAT)
 588   TH_REMAP (BFD_RELOC_TILEPRO_JMP_SLOT,        R_TILEPRO_JMP_SLOT)
 589   TH_REMAP (BFD_RELOC_TILEPRO_RELATIVE,        R_TILEPRO_RELATIVE)
 590   TH_REMAP (BFD_RELOC_TILEPRO_BROFF_X1,        R_TILEPRO_BROFF_X1)
 591   TH_REMAP (BFD_RELOC_TILEPRO_JOFFLONG_X1,     R_TILEPRO_JOFFLONG_X1)
 592   TH_REMAP (BFD_RELOC_TILEPRO_JOFFLONG_X1_PLT, R_TILEPRO_JOFFLONG_X1_PLT)
 593   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X0,         R_TILEPRO_IMM8_X0)
 594   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y0,         R_TILEPRO_IMM8_Y0)
 595   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X1,         R_TILEPRO_IMM8_X1)
 596   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y1,         R_TILEPRO_IMM8_Y1)
 597   TH_REMAP (BFD_RELOC_TILEPRO_DEST_IMM8_X1,    R_TILEPRO_DEST_IMM8_X1)
 598   TH_REMAP (BFD_RELOC_TILEPRO_MT_IMM15_X1,     R_TILEPRO_MT_IMM15_X1)
 599   TH_REMAP (BFD_RELOC_TILEPRO_MF_IMM15_X1,     R_TILEPRO_MF_IMM15_X1)
 600   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0,        R_TILEPRO_IMM16_X0)
 601   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1,        R_TILEPRO_IMM16_X1)
 602   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_LO,     R_TILEPRO_IMM16_X0_LO)
 603   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_LO,     R_TILEPRO_IMM16_X1_LO)
 604   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HI,     R_TILEPRO_IMM16_X0_HI)
 605   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HI,     R_TILEPRO_IMM16_X1_HI)
 606   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HA,     R_TILEPRO_IMM16_X0_HA)
 607   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HA,     R_TILEPRO_IMM16_X1_HA)
 608
 609   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_PCREL,    R_TILEPRO_IMM16_X0_PCREL)
 610   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_PCREL,    R_TILEPRO_IMM16_X1_PCREL)
 611   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_LO_PCREL, R_TILEPRO_IMM16_X0_LO_PCREL)
 612   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_LO_PCREL, R_TILEPRO_IMM16_X1_LO_PCREL)
 613   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HI_PCREL, R_TILEPRO_IMM16_X0_HI_PCREL)
 614   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HI_PCREL, R_TILEPRO_IMM16_X1_HI_PCREL)
 615   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_HA_PCREL, R_TILEPRO_IMM16_X0_HA_PCREL)
 616   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_HA_PCREL, R_TILEPRO_IMM16_X1_HA_PCREL)
 617
 618   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT, R_TILEPRO_IMM16_X0_GOT)
 619   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT, R_TILEPRO_IMM16_X1_GOT)
 620   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_LO, R_TILEPRO_IMM16_X0_GOT_LO)
 621   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_LO, R_TILEPRO_IMM16_X1_GOT_LO)
 622   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_HI, R_TILEPRO_IMM16_X0_GOT_HI)
 623   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_HI, R_TILEPRO_IMM16_X1_GOT_HI)
 624   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_GOT_HA, R_TILEPRO_IMM16_X0_GOT_HA)
 625   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_GOT_HA, R_TILEPRO_IMM16_X1_GOT_HA)
 626
 627   TH_REMAP (BFD_RELOC_TILEPRO_MMSTART_X0,  R_TILEPRO_MMSTART_X0)
 628   TH_REMAP (BFD_RELOC_TILEPRO_MMEND_X0,    R_TILEPRO_MMEND_X0)
 629   TH_REMAP (BFD_RELOC_TILEPRO_MMSTART_X1,  R_TILEPRO_MMSTART_X1)
 630   TH_REMAP (BFD_RELOC_TILEPRO_MMEND_X1,    R_TILEPRO_MMEND_X1)
 631   TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_X0,    R_TILEPRO_SHAMT_X0)
 632   TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_X1,    R_TILEPRO_SHAMT_X1)
 633   TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y0,    R_TILEPRO_SHAMT_Y0)
 634   TH_REMAP (BFD_RELOC_TILEPRO_SHAMT_Y1,    R_TILEPRO_SHAMT_Y1)
 635
 636   TH_REMAP (BFD_RELOC_TILEPRO_TLS_GD_CALL,        R_TILEPRO_TLS_GD_CALL)
 637   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X0_TLS_GD_ADD, R_TILEPRO_IMM8_X0_TLS_GD_ADD)
 638   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_X1_TLS_GD_ADD, R_TILEPRO_IMM8_X1_TLS_GD_ADD)
 639   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y0_TLS_GD_ADD, R_TILEPRO_IMM8_Y0_TLS_GD_ADD)
 640   TH_REMAP (BFD_RELOC_TILEPRO_IMM8_Y1_TLS_GD_ADD, R_TILEPRO_IMM8_Y1_TLS_GD_ADD)
 641   TH_REMAP (BFD_RELOC_TILEPRO_TLS_IE_LOAD,        R_TILEPRO_TLS_IE_LOAD)
 642
 643   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD,    R_TILEPRO_IMM16_X0_TLS_GD)
 644   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD,    R_TILEPRO_IMM16_X1_TLS_GD)
 645   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_LO, R_TILEPRO_IMM16_X0_TLS_GD_LO)
 646   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_LO, R_TILEPRO_IMM16_X1_TLS_GD_LO)
 647   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HI, R_TILEPRO_IMM16_X0_TLS_GD_HI)
 648   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HI, R_TILEPRO_IMM16_X1_TLS_GD_HI)
 649   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_GD_HA, R_TILEPRO_IMM16_X0_TLS_GD_HA)
 650   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_GD_HA, R_TILEPRO_IMM16_X1_TLS_GD_HA)
 651
 652   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE,    R_TILEPRO_IMM16_X0_TLS_IE)
 653   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE,    R_TILEPRO_IMM16_X1_TLS_IE)
 654   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_LO, R_TILEPRO_IMM16_X0_TLS_IE_LO)
 655   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_LO, R_TILEPRO_IMM16_X1_TLS_IE_LO)
 656   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HI, R_TILEPRO_IMM16_X0_TLS_IE_HI)
 657   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HI, R_TILEPRO_IMM16_X1_TLS_IE_HI)
 658   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_IE_HA, R_TILEPRO_IMM16_X0_TLS_IE_HA)
 659   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_IE_HA, R_TILEPRO_IMM16_X1_TLS_IE_HA)
 660
 661   TH_REMAP (BFD_RELOC_TILEPRO_TLS_DTPMOD32, R_TILEPRO_TLS_DTPMOD32)
 662   TH_REMAP (BFD_RELOC_TILEPRO_TLS_DTPOFF32, R_TILEPRO_TLS_DTPOFF32)
 663   TH_REMAP (BFD_RELOC_TILEPRO_TLS_TPOFF32,  R_TILEPRO_TLS_TPOFF32)
 664
 665   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE,    R_TILEPRO_IMM16_X0_TLS_LE)
 666   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE,    R_TILEPRO_IMM16_X1_TLS_LE)
 667   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_LO, R_TILEPRO_IMM16_X0_TLS_LE_LO)
 668   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_LO, R_TILEPRO_IMM16_X1_TLS_LE_LO)
 669   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HI, R_TILEPRO_IMM16_X0_TLS_LE_HI)
 670   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HI, R_TILEPRO_IMM16_X1_TLS_LE_HI)
 671   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X0_TLS_LE_HA, R_TILEPRO_IMM16_X0_TLS_LE_HA)
 672   TH_REMAP (BFD_RELOC_TILEPRO_IMM16_X1_TLS_LE_HA, R_TILEPRO_IMM16_X1_TLS_LE_HA)
 673
 674 #undef TH_REMAP
 675
 676   { BFD_RELOC_VTABLE_INHERIT, R_TILEPRO_GNU_VTINHERIT, tilepro_elf_howto_table2 },
 677   { BFD_RELOC_VTABLE_ENTRY,   R_TILEPRO_GNU_VTENTRY,   tilepro_elf_howto_table2 },
 678 };
 679
 680
 681
 682 /* The TILEPro linker needs to keep track of the number of relocs that it
 683    decides to copy as dynamic relocs in check_relocs for each symbol.
 684    This is so that it can later discard them if they are found to be
 685    unnecessary.  We store the information in a field extending the
 686    regular ELF linker hash table.  */
 687
 688 struct tilepro_elf_dyn_relocs
 689 {
 690   struct tilepro_elf_dyn_relocs *next;
 691
 692   /* The input section of the reloc.  */
 693   asection *sec;
 694
 695   /* Total number of relocs copied for the input section.  */
 696   bfd_size_type count;
 697
 698   /* Number of pc-relative relocs copied for the input section.  */
 699   bfd_size_type pc_count;
 700 };
 701
 702 /* TILEPRO ELF linker hash entry.  */
 703
 704 struct tilepro_elf_link_hash_entry
 705 {
 706   struct elf_link_hash_entry elf;
 707
 708   /* Track dynamic relocs copied for this symbol.  */
 709   struct tilepro_elf_dyn_relocs *dyn_relocs;
 710
 711 #define GOT_UNKNOWN     0
 712 #define GOT_NORMAL      1
 713 #define GOT_TLS_GD      2
 714 #define GOT_TLS_IE      4
 715   unsigned char tls_type;
 716 };
 717
 718 #define tilepro_elf_hash_entry(ent) \
 719   ((struct tilepro_elf_link_hash_entry *)(ent))
 720
 721 struct _bfd_tilepro_elf_obj_tdata
 722 {
 723   struct elf_obj_tdata root;
 724
 725   /* tls_type for each local got entry.  */
 726   char *local_got_tls_type;
 727 };
 728
 729 #define _bfd_tilepro_elf_tdata(abfd) \
 730   ((struct _bfd_tilepro_elf_obj_tdata *) (abfd)->tdata.any)
 731
 732 #define _bfd_tilepro_elf_local_got_tls_type(abfd) \
 733   (_bfd_tilepro_elf_tdata (abfd)->local_got_tls_type)
 734
 735 #define is_tilepro_elf(bfd)                             \
 736   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 737    && elf_tdata (bfd) != NULL                           \
 738    && elf_object_id (bfd) == TILEPRO_ELF_DATA)
 739
 740 #include "elf/common.h"
 741 #include "elf/internal.h"
 742
 743 struct tilepro_elf_link_hash_table
 744 {
 745   struct elf_link_hash_table elf;
 746
 747   /* Short-cuts to get to dynamic linker sections.  */
 748   asection *sdynbss;
 749   asection *srelbss;
 750
 751   /* Small local sym to section mapping cache.  */
 752   struct sym_cache sym_cache;
 753 };
 754
 755 /* Get the Tilepro ELF linker hash table from a link_info structure.  */
 756 #define tilepro_elf_hash_table(p) \
 757   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 758   == TILEPRO_ELF_DATA \
 759   ? ((struct tilepro_elf_link_hash_table *) ((p)->hash)) : NULL)
 760
 761 static reloc_howto_type *
 762 tilepro_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 763                            bfd_reloc_code_real_type code)
 764 {
 765   unsigned int i;
 766
 767   for (i = ARRAY_SIZE (tilepro_reloc_map); --i;)
 768     {
 769       const reloc_map * entry;
 770
 771       entry = tilepro_reloc_map + i;
 772
 773       if (entry->bfd_reloc_val == code)
 774         return entry->table + (entry->tilepro_reloc_val
 775                                - entry->table[0].type);
 776     }
 777
 778   return NULL;
 779 }
 780
 781 static reloc_howto_type *
 782 tilepro_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 783                            const char *r_name)
 784 {
 785   unsigned int i;
 786
 787   for (i = 0;
 788        i < (sizeof (tilepro_elf_howto_table)
 789             / sizeof (tilepro_elf_howto_table[0]));
 790        i++)
 791     if (tilepro_elf_howto_table[i].name != NULL
 792         && strcasecmp (tilepro_elf_howto_table[i].name, r_name) == 0)
 793       return &tilepro_elf_howto_table[i];
 794
 795   return NULL;
 796 }
 797
 798 /* Set the howto pointer for an TILEPro ELF reloc.  */
 799
 800 static void
 801 tilepro_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 802                             arelent * cache_ptr,
 803                             Elf_Internal_Rela * dst)
 804 {
 805   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 806
 807   if (r_type <= (unsigned int) R_TILEPRO_IMM16_X1_TLS_LE_HA)
 808     cache_ptr->howto = &tilepro_elf_howto_table [r_type];
 809   else if (r_type - R_TILEPRO_GNU_VTINHERIT
 810            <= (unsigned int) R_TILEPRO_GNU_VTENTRY)
 811     cache_ptr->howto
 812       = &tilepro_elf_howto_table2 [r_type - R_TILEPRO_GNU_VTINHERIT];
 813   else
 814     abort ();
 815 }
 816
 817 typedef tilepro_bundle_bits (*tilepro_create_func)(int);
 818
 819 static const tilepro_create_func reloc_to_create_func[] =
 820 {
 821   /* The first fourteen relocation types don't correspond to operands */
 822   NULL,
 823   NULL,
 824   NULL,
 825   NULL,
 826   NULL,
 827   NULL,
 828   NULL,
 829   NULL,
 830   NULL,
 831   NULL,
 832   NULL,
 833   NULL,
 834   NULL,
 835   NULL,
 836
 837   /* The remaining relocations are used for immediate operands */
 838   create_BrOff_X1,
 839   create_JOffLong_X1,
 840   create_JOffLong_X1,
 841   create_Imm8_X0,
 842   create_Imm8_Y0,
 843   create_Imm8_X1,
 844   create_Imm8_Y1,
 845   create_MT_Imm15_X1,
 846   create_MF_Imm15_X1,
 847   create_Imm16_X0,
 848   create_Imm16_X1,
 849   create_Imm16_X0,
 850   create_Imm16_X1,
 851   create_Imm16_X0,
 852   create_Imm16_X1,
 853   create_Imm16_X0,
 854   create_Imm16_X1,
 855   create_Imm16_X0,
 856   create_Imm16_X1,
 857   create_Imm16_X0,
 858   create_Imm16_X1,
 859   create_Imm16_X0,
 860   create_Imm16_X1,
 861   create_Imm16_X0,
 862   create_Imm16_X1,
 863   create_Imm16_X0,
 864   create_Imm16_X1,
 865   create_Imm16_X0,
 866   create_Imm16_X1,
 867   create_Imm16_X0,
 868   create_Imm16_X1,
 869   create_Imm16_X0,
 870   create_Imm16_X1,
 871   create_MMStart_X0,
 872   create_MMEnd_X0,
 873   create_MMStart_X1,
 874   create_MMEnd_X1,
 875   create_ShAmt_X0,
 876   create_ShAmt_X1,
 877   create_ShAmt_Y0,
 878   create_ShAmt_Y1,
 879
 880   create_Dest_Imm8_X1,
 881   NULL,
 882   NULL,
 883   NULL,
 884   NULL,
 885   NULL,
 886   NULL,
 887   NULL,
 888   NULL,
 889   NULL,
 890   NULL,
 891
 892   create_Imm16_X0,
 893   create_Imm16_X1,
 894   create_Imm16_X0,
 895   create_Imm16_X1,
 896   create_Imm16_X0,
 897   create_Imm16_X1,
 898   create_Imm16_X0,
 899   create_Imm16_X1,
 900   create_Imm16_X0,
 901   create_Imm16_X1,
 902   create_Imm16_X0,
 903   create_Imm16_X1,
 904   create_Imm16_X0,
 905   create_Imm16_X1,
 906   create_Imm16_X0,
 907   create_Imm16_X1,
 908
 909   NULL,
 910   NULL,
 911   NULL,
 912
 913   create_Imm16_X0,
 914   create_Imm16_X1,
 915   create_Imm16_X0,
 916   create_Imm16_X1,
 917   create_Imm16_X0,
 918   create_Imm16_X1,
 919   create_Imm16_X0,
 920   create_Imm16_X1,
 921 };
 922
 923 #define NELEMS(a)       ((int) (sizeof (a) / sizeof ((a)[0])))
 924
 925 /* Support for core dump NOTE sections.  */
 926
 927 static bfd_boolean
 928 tilepro_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 929 {
 930   int offset;
 931   size_t size;
 932
 933   if (note->descsz != TILEPRO_PRSTATUS_SIZEOF)
 934     return FALSE;
 935
 936   /* pr_cursig */
 937   elf_tdata (abfd)->core_signal =
 938     bfd_get_16 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_CURSIG);
 939
 940   /* pr_pid */
 941   elf_tdata (abfd)->core_pid =
 942     bfd_get_32 (abfd, note->descdata + TILEPRO_PRSTATUS_OFFSET_PR_PID);
 943
 944   /* pr_reg */
 945   offset = TILEPRO_PRSTATUS_OFFSET_PR_REG;
 946   size   = TILEPRO_GREGSET_T_SIZE;
 947
 948   /* Make a ".reg/999" section.  */
 949   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 950                                           size, note->descpos + offset);
 951 }
 952
 953 static bfd_boolean
 954 tilepro_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 955 {
 956   if (note->descsz != TILEPRO_PRPSINFO_SIZEOF)
 957     return FALSE;
 958
 959   elf_tdata (abfd)->core_program
 960     = _bfd_elfcore_strndup (abfd,
 961                             note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_FNAME,
 962                             16);
 963   elf_tdata (abfd)->core_command
 964     = _bfd_elfcore_strndup (abfd,
 965                             note->descdata + TILEPRO_PRPSINFO_OFFSET_PR_PSARGS,
 966                             ELF_PR_PSARGS_SIZE);
 967
 968
 969   /* Note that for some reason, a spurious space is tacked
 970      onto the end of the args in some (at least one anyway)
 971      implementations, so strip it off if it exists.  */
 972   {
 973     char *command = elf_tdata (abfd)->core_command;
 974     int n = strlen (command);
 975
 976     if (0 < n && command[n - 1] == ' ')
 977       command[n - 1] = '\0';
 978   }
 979
 980   return TRUE;
 981 }
 982
 983
 984 static void
 985 tilepro_elf_append_rela_32 (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
 986 {
 987   Elf32_External_Rela *loc32;
 988
 989   loc32 = (Elf32_External_Rela *) s->contents;
 990   loc32 += s->reloc_count++;
 991   bfd_elf32_swap_reloca_out (abfd, rel, (bfd_byte *) loc32);
 992 }
 993
 994 /* PLT/GOT stuff */
 995
 996 /* The procedure linkage table starts with the following header:
 997
 998    {
 999     rli     r29, r29, 16
1000     lwadd   r28, r27, 4
1001    }
1002     lw      r27, r27
1003    {
1004     info    10            ## SP not offset, return PC in LR
1005     jr      r27
1006    }
1007
1008    Subsequent entries are the following, jumping to the header at the end:
1009
1010    lnk     r28
1011 1:
1012    {
1013     auli    r28, r28, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET>
1014     auli    r27, r28, <_GLOBAL_OFFSET_TABLE_ - 1b>
1015    }
1016    {
1017     addli   r28, r28, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET>
1018     addli   r27, r27, <_GLOBAL_OFFSET_TABLE_ - 1b>
1019    }
1020    {
1021     auli    r29, zero, MY_PLT_INDEX
1022     lw      r28, r28
1023    }
1024    {
1025     info    10            ## SP not offset, return PC in LR
1026     jr      r28
1027    }
1028
1029    We initially store MY_PLT_INDEX in the high bits so that we can use the all
1030    16 bits as an unsigned offset; if we use the low bits we would get an
1031    unwanted sign extension.  The PLT header then rotates the index to get the
1032    right value, before calling the resolution routine.  This computation can
1033    fit in unused bundle slots so it's free.
1034
1035    This code sequence lets the code at at the start of the PLT determine
1036    which PLT entry was executed by examining 'r29'.
1037
1038    Note that MY_PLT_INDEX skips over the header entries, so the first
1039    actual jump table entry has index zero.
1040 */
1041
1042 #define PLT_HEADER_SIZE_IN_BUNDLES 3
1043 #define PLT_ENTRY_SIZE_IN_BUNDLES  5
1044
1045 #define PLT_HEADER_SIZE \
1046   (PLT_HEADER_SIZE_IN_BUNDLES * TILEPRO_BUNDLE_SIZE_IN_BYTES)
1047 #define PLT_ENTRY_SIZE \
1048   (PLT_ENTRY_SIZE_IN_BUNDLES * TILEPRO_BUNDLE_SIZE_IN_BYTES)
1049
1050 /* The size in bytes of an entry in the global offset table.  */
1051
1052 #define GOT_ENTRY_SIZE TILEPRO_BYTES_PER_WORD
1053
1054 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
1055
1056
1057 static const bfd_byte
1058 tilepro_plt0_entry[PLT_HEADER_SIZE] =
1059 {
1060   0x5d, 0x07, 0x03, 0x70,
1061   0x6e, 0x23, 0xd0, 0x30, /* { rli r29, r29, 16 ; lwadd r28, r27, 4 } */
1062   0x00, 0x50, 0xba, 0x6d,
1063   0x00, 0x08, 0x6d, 0xdc, /* { lw r27, r27 } */
1064   0xff, 0xaf, 0x10, 0x50,
1065   0x60, 0x03, 0x18, 0x08, /* { info 10 ; jr r27 } */
1066 };
1067
1068 static const bfd_byte
1069 tilepro_short_plt_entry[PLT_ENTRY_SIZE] =
1070 {
1071   0x00, 0x50, 0x16, 0x70,
1072   0x0e, 0x00, 0x1a, 0x08, /* { lnk r28 } */
1073   0x1c, 0x07, 0x00, 0xa0,
1074   0x8d, 0x03, 0x00, 0x18, /* { addli r28, r28, 0 ; addli r27, r28, 0 } */
1075   0xdd, 0x0f, 0x00, 0x30,
1076   0x8e, 0x73, 0x0b, 0x40, /* { auli r29, zero, 0 ; lw r28, r28 } */
1077   0xff, 0xaf, 0x10, 0x50,
1078   0x80, 0x03, 0x18, 0x08, /* { info 10 ; jr r28 } */
1079   0x00, 0x00, 0x00, 0x00,
1080   0x00, 0x00, 0x00, 0x00,
1081 };
1082
1083 static const bfd_byte
1084 tilepro_long_plt_entry[PLT_ENTRY_SIZE] =
1085 {
1086   0x00, 0x50, 0x16, 0x70,
1087   0x0e, 0x00, 0x1a, 0x08, /* { lnk r28 } */
1088   0x1c, 0x07, 0x00, 0xb0,
1089   0x8d, 0x03, 0x00, 0x20, /* { auli r28, r28, 0 ; auli r27, r28, 0 } */
1090   0x1c, 0x07, 0x00, 0xa0,
1091   0x6d, 0x03, 0x00, 0x18, /* { addli r28, r28, 0 ; addli r27, r27, 0 } */
1092   0xdd, 0x0f, 0x00, 0x30,
1093   0x8e, 0x73, 0x0b, 0x40, /* { auli r29, zero, 0 ; lw r28, r28 } */
1094   0xff, 0xaf, 0x10, 0x50,
1095   0x80, 0x03, 0x18, 0x08, /* { info 10 ; jr r28 } */
1096 };
1097
1098 static bfd_vma
1099 tilepro_ha16(bfd_vma vma)
1100 {
1101   return ((vma >> 16) + ((vma >> 15) & 1)) & 0xffff;
1102 }
1103
1104 static int
1105 tilepro_plt_entry_build (asection *splt, asection *sgotplt, bfd_vma offset,
1106                       bfd_vma *r_offset)
1107 {
1108   int plt_index = (offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
1109   int got_offset = plt_index * GOT_ENTRY_SIZE + GOTPLT_HEADER_SIZE;
1110   tilepro_bundle_bits *pc;
1111
1112   /* Compute the distance from the got entry to the lnk.  */
1113   bfd_signed_vma dist_got_entry = sgotplt->output_section->vma
1114     + sgotplt->output_offset
1115     + got_offset
1116     - splt->output_section->vma
1117     - splt->output_offset
1118     - offset
1119     - TILEPRO_BUNDLE_SIZE_IN_BYTES;
1120
1121   /* Compute the distance to GOTPLT[0].  */
1122   bfd_signed_vma dist_got0 = dist_got_entry - got_offset;
1123
1124   /* Check whether we can use the short plt entry with 16-bit offset.  */
1125   bfd_boolean short_plt_entry =
1126     (dist_got_entry <= 0x7fff && dist_got0 >= -0x8000);
1127
1128   /* Copy the plt entry template.  */
1129   memcpy (splt->contents + offset,
1130           short_plt_entry ? tilepro_short_plt_entry : tilepro_long_plt_entry,
1131           PLT_ENTRY_SIZE);
1132
1133   /* Write the immediate offsets.  */
1134   pc = (tilepro_bundle_bits *)(splt->contents + offset);
1135   pc++;
1136
1137   if (!short_plt_entry)
1138     {
1139       /* { auli r28, r28, &GOTPLT[MY_GOT_INDEX] ; auli r27, r28, &GOTPLT[0] } */
1140       *pc++ |= create_Imm16_X0 (tilepro_ha16 (dist_got_entry))
1141         | create_Imm16_X1 (tilepro_ha16 (dist_got0));
1142     }
1143
1144   /* { addli r28, r28, &GOTPLT[MY_GOT_INDEX] ; addli r27, r28, &GOTPLT[0] } or
1145      { addli r28, r28, &GOTPLT[MY_GOT_INDEX] ; addli r27, r27, &GOTPLT[0] } */
1146   *pc++ |= create_Imm16_X0 (dist_got_entry)
1147     | create_Imm16_X1 (dist_got0);
1148
1149   /* { auli r29, zero, MY_PLT_INDEX ; lw r28, r28 } */
1150   *pc |= create_Imm16_X0 (plt_index);
1151
1152   /* Set the relocation offset.  */
1153   *r_offset = got_offset;
1154
1155   return plt_index;
1156 }
1157
1158 #define TILEPRO_ELF_RELA_BYTES (sizeof(Elf32_External_Rela))
1159
1160
1161 /* Create an entry in an TILEPro ELF linker hash table.  */
1162
1163 static struct bfd_hash_entry *
1164 link_hash_newfunc (struct bfd_hash_entry *entry,
1165                    struct bfd_hash_table *table, const char *string)
1166 {
1167   /* Allocate the structure if it has not already been allocated by a
1168      subclass.  */
1169   if (entry == NULL)
1170     {
1171       entry =
1172         bfd_hash_allocate (table,
1173                            sizeof (struct tilepro_elf_link_hash_entry));
1174       if (entry == NULL)
1175         return entry;
1176     }
1177
1178   /* Call the allocation method of the superclass.  */
1179   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1180   if (entry != NULL)
1181     {
1182       struct tilepro_elf_link_hash_entry *eh;
1183
1184       eh = (struct tilepro_elf_link_hash_entry *) entry;
1185       eh->dyn_relocs = NULL;
1186       eh->tls_type = GOT_UNKNOWN;
1187     }
1188
1189   return entry;
1190 }
1191
1192 /* Create a TILEPRO ELF linker hash table.  */
1193
1194 static struct bfd_link_hash_table *
1195 tilepro_elf_link_hash_table_create (bfd *abfd)
1196 {
1197   struct tilepro_elf_link_hash_table *ret;
1198   bfd_size_type amt = sizeof (struct tilepro_elf_link_hash_table);
1199
1200   ret = (struct tilepro_elf_link_hash_table *) bfd_zmalloc (amt);
1201   if (ret == NULL)
1202     return NULL;
1203
1204   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
1205                                       sizeof (struct tilepro_elf_link_hash_entry),
1206                                       TILEPRO_ELF_DATA))
1207     {
1208       free (ret);
1209       return NULL;
1210     }
1211
1212   return &ret->elf.root;
1213 }
1214
1215 /* Create the .got section.  */
1216
1217 static bfd_boolean
1218 tilepro_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
1219 {
1220   flagword flags;
1221   asection *s, *s_got;
1222   struct elf_link_hash_entry *h;
1223   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1224   struct elf_link_hash_table *htab = elf_hash_table (info);
1225
1226   /* This function may be called more than once.  */
1227   s = bfd_get_linker_section (abfd, ".got");
1228   if (s != NULL)
1229     return TRUE;
1230
1231   flags = bed->dynamic_sec_flags;
1232
1233   s = bfd_make_section_with_flags (abfd,
1234                                    (bed->rela_plts_and_copies_p
1235                                     ? ".rela.got" : ".rel.got"),
1236                                    (bed->dynamic_sec_flags
1237                                     | SEC_READONLY));
1238   if (s == NULL
1239       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
1240     return FALSE;
1241   htab->srelgot = s;
1242
1243   s = s_got = bfd_make_section_with_flags (abfd, ".got", flags);
1244   if (s == NULL
1245       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
1246     return FALSE;
1247   htab->sgot = s;
1248
1249   /* The first bit of the global offset table is the header.  */
1250   s->size += bed->got_header_size;
1251
1252   if (bed->want_got_plt)
1253     {
1254       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
1255       if (s == NULL
1256           || !bfd_set_section_alignment (abfd, s,
1257                                          bed->s->log_file_align))
1258         return FALSE;
1259       htab->sgotplt = s;
1260
1261       /* Reserve room for the header.  */
1262       s->size += GOTPLT_HEADER_SIZE;
1263     }
1264
1265   if (bed->want_got_sym)
1266     {
1267       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
1268          section.  We don't do this in the linker script because we don't want
1269          to define the symbol if we are not creating a global offset
1270          table.  */
1271       h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
1272                                        "_GLOBAL_OFFSET_TABLE_");
1273       elf_hash_table (info)->hgot = h;
1274       if (h == NULL)
1275         return FALSE;
1276     }
1277
1278   return TRUE;
1279 }
1280
1281 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
1282    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
1283    hash table.  */
1284
1285 static bfd_boolean
1286 tilepro_elf_create_dynamic_sections (bfd *dynobj,
1287                                      struct bfd_link_info *info)
1288 {
1289   struct tilepro_elf_link_hash_table *htab;
1290
1291   htab = tilepro_elf_hash_table (info);
1292   BFD_ASSERT (htab != NULL);
1293
1294   if (!tilepro_elf_create_got_section (dynobj, info))
1295     return FALSE;
1296
1297   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1298     return FALSE;
1299
1300   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
1301   if (!info->shared)
1302     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
1303
1304   if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
1305       || (!info->shared && !htab->srelbss))
1306     abort ();
1307
1308   return TRUE;
1309 }
1310
1311 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1312
1313 static void
1314 tilepro_elf_copy_indirect_symbol (struct bfd_link_info *info,
1315                                   struct elf_link_hash_entry *dir,
1316                                   struct elf_link_hash_entry *ind)
1317 {
1318   struct tilepro_elf_link_hash_entry *edir, *eind;
1319
1320   edir = (struct tilepro_elf_link_hash_entry *) dir;
1321   eind = (struct tilepro_elf_link_hash_entry *) ind;
1322
1323   if (eind->dyn_relocs != NULL)
1324     {
1325       if (edir->dyn_relocs != NULL)
1326         {
1327           struct tilepro_elf_dyn_relocs **pp;
1328           struct tilepro_elf_dyn_relocs *p;
1329
1330           /* Add reloc counts against the indirect sym to the direct sym
1331              list.  Merge any entries against the same section.  */
1332           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1333             {
1334               struct tilepro_elf_dyn_relocs *q;
1335
1336               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1337                 if (q->sec == p->sec)
1338                   {
1339                     q->pc_count += p->pc_count;
1340                     q->count += p->count;
1341                     *pp = p->next;
1342                     break;
1343                   }
1344               if (q == NULL)
1345                 pp = &p->next;
1346             }
1347           *pp = edir->dyn_relocs;
1348         }
1349
1350       edir->dyn_relocs = eind->dyn_relocs;
1351       eind->dyn_relocs = NULL;
1352     }
1353
1354   if (ind->root.type == bfd_link_hash_indirect
1355       && dir->got.refcount <= 0)
1356     {
1357       edir->tls_type = eind->tls_type;
1358       eind->tls_type = GOT_UNKNOWN;
1359     }
1360   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1361 }
1362
1363 static int
1364 tilepro_tls_translate_to_le (int r_type)
1365 {
1366   switch (r_type)
1367     {
1368     case R_TILEPRO_IMM16_X0_TLS_GD:
1369     case R_TILEPRO_IMM16_X0_TLS_IE:
1370       return R_TILEPRO_IMM16_X0_TLS_LE;
1371
1372     case R_TILEPRO_IMM16_X1_TLS_GD:
1373     case R_TILEPRO_IMM16_X1_TLS_IE:
1374       return R_TILEPRO_IMM16_X1_TLS_LE;
1375
1376     case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1377     case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1378       return R_TILEPRO_IMM16_X0_TLS_LE_LO;
1379
1380     case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1381     case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1382       return R_TILEPRO_IMM16_X1_TLS_LE_LO;
1383
1384     case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1385     case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1386       return R_TILEPRO_IMM16_X0_TLS_LE_HI;
1387
1388     case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1389     case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1390       return R_TILEPRO_IMM16_X1_TLS_LE_HI;
1391
1392     case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1393     case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1394       return R_TILEPRO_IMM16_X0_TLS_LE_HA;
1395
1396     case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1397     case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1398       return R_TILEPRO_IMM16_X1_TLS_LE_HA;
1399     }
1400   return r_type;
1401 }
1402
1403 static int
1404 tilepro_tls_translate_to_ie (int r_type)
1405 {
1406   switch (r_type)
1407     {
1408     case R_TILEPRO_IMM16_X0_TLS_GD:
1409     case R_TILEPRO_IMM16_X0_TLS_IE:
1410       return R_TILEPRO_IMM16_X0_TLS_IE;
1411
1412     case R_TILEPRO_IMM16_X1_TLS_GD:
1413     case R_TILEPRO_IMM16_X1_TLS_IE:
1414       return R_TILEPRO_IMM16_X1_TLS_IE;
1415
1416     case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1417     case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1418       return R_TILEPRO_IMM16_X0_TLS_IE_LO;
1419
1420     case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1421     case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1422       return R_TILEPRO_IMM16_X1_TLS_IE_LO;
1423
1424     case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1425     case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1426       return R_TILEPRO_IMM16_X0_TLS_IE_HI;
1427
1428     case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1429     case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1430       return R_TILEPRO_IMM16_X1_TLS_IE_HI;
1431
1432     case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1433     case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1434       return R_TILEPRO_IMM16_X0_TLS_IE_HA;
1435
1436     case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1437     case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1438       return R_TILEPRO_IMM16_X1_TLS_IE_HA;
1439     }
1440   return r_type;
1441 }
1442
1443 static int
1444 tilepro_elf_tls_transition (struct bfd_link_info *info, int r_type,
1445                             int is_local)
1446 {
1447   if (info->shared)
1448     return r_type;
1449
1450   if (is_local)
1451     return tilepro_tls_translate_to_le (r_type);
1452   else
1453     return tilepro_tls_translate_to_ie (r_type);
1454 }
1455
1456 /* Look through the relocs for a section during the first phase, and
1457    allocate space in the global offset table or procedure linkage
1458    table.  */
1459
1460 static bfd_boolean
1461 tilepro_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
1462                           asection *sec, const Elf_Internal_Rela *relocs)
1463 {
1464   struct tilepro_elf_link_hash_table *htab;
1465   Elf_Internal_Shdr *symtab_hdr;
1466   struct elf_link_hash_entry **sym_hashes;
1467   const Elf_Internal_Rela *rel;
1468   const Elf_Internal_Rela *rel_end;
1469   asection *sreloc;
1470   int num_relocs;
1471
1472   if (info->relocatable)
1473     return TRUE;
1474
1475   htab = tilepro_elf_hash_table (info);
1476   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1477   sym_hashes = elf_sym_hashes (abfd);
1478
1479   sreloc = NULL;
1480
1481   num_relocs = sec->reloc_count;
1482
1483   BFD_ASSERT (is_tilepro_elf (abfd) || num_relocs == 0);
1484
1485   if (htab->elf.dynobj == NULL)
1486     htab->elf.dynobj = abfd;
1487
1488   rel_end = relocs + num_relocs;
1489   for (rel = relocs; rel < rel_end; rel++)
1490     {
1491       unsigned int r_type;
1492       unsigned long r_symndx;
1493       struct elf_link_hash_entry *h;
1494       int tls_type;
1495
1496       r_symndx = ELF32_R_SYM (rel->r_info);
1497       r_type = ELF32_R_TYPE (rel->r_info);
1498
1499       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1500         {
1501           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1502                                  abfd, r_symndx);
1503           return FALSE;
1504         }
1505
1506       if (r_symndx < symtab_hdr->sh_info)
1507         h = NULL;
1508       else
1509         {
1510           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1511           while (h->root.type == bfd_link_hash_indirect
1512                  || h->root.type == bfd_link_hash_warning)
1513             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1514         }
1515
1516       r_type = tilepro_elf_tls_transition (info, r_type, h == NULL);
1517       switch (r_type)
1518         {
1519         case R_TILEPRO_IMM16_X0_TLS_LE:
1520         case R_TILEPRO_IMM16_X1_TLS_LE:
1521         case R_TILEPRO_IMM16_X0_TLS_LE_LO:
1522         case R_TILEPRO_IMM16_X1_TLS_LE_LO:
1523         case R_TILEPRO_IMM16_X0_TLS_LE_HI:
1524         case R_TILEPRO_IMM16_X1_TLS_LE_HI:
1525         case R_TILEPRO_IMM16_X0_TLS_LE_HA:
1526         case R_TILEPRO_IMM16_X1_TLS_LE_HA:
1527           if (info->shared)
1528             goto r_tilepro_plt32;
1529           break;
1530
1531         case R_TILEPRO_IMM16_X0_TLS_GD:
1532         case R_TILEPRO_IMM16_X1_TLS_GD:
1533         case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1534         case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1535         case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1536         case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1537         case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1538         case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1539           BFD_ASSERT (info->shared);
1540           tls_type = GOT_TLS_GD;
1541           goto have_got_reference;
1542
1543         case R_TILEPRO_IMM16_X0_TLS_IE:
1544         case R_TILEPRO_IMM16_X1_TLS_IE:
1545         case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1546         case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1547         case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1548         case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1549         case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1550         case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1551           tls_type = GOT_TLS_IE;
1552           if (info->shared)
1553             info->flags |= DF_STATIC_TLS;
1554           goto have_got_reference;
1555
1556         case R_TILEPRO_IMM16_X0_GOT:
1557         case R_TILEPRO_IMM16_X1_GOT:
1558         case R_TILEPRO_IMM16_X0_GOT_LO:
1559         case R_TILEPRO_IMM16_X1_GOT_LO:
1560         case R_TILEPRO_IMM16_X0_GOT_HI:
1561         case R_TILEPRO_IMM16_X1_GOT_HI:
1562         case R_TILEPRO_IMM16_X0_GOT_HA:
1563         case R_TILEPRO_IMM16_X1_GOT_HA:
1564            tls_type = GOT_NORMAL;
1565            /* Fall Through */
1566
1567         have_got_reference:
1568           /* This symbol requires a global offset table entry.  */
1569           {
1570             int old_tls_type;
1571
1572             if (h != NULL)
1573               {
1574                 h->got.refcount += 1;
1575                 old_tls_type = tilepro_elf_hash_entry(h)->tls_type;
1576               }
1577             else
1578               {
1579                 bfd_signed_vma *local_got_refcounts;
1580
1581                 /* This is a global offset table entry for a local symbol.  */
1582                 local_got_refcounts = elf_local_got_refcounts (abfd);
1583                 if (local_got_refcounts == NULL)
1584                   {
1585                     bfd_size_type size;
1586
1587                     size = symtab_hdr->sh_info;
1588                     size *= (sizeof (bfd_signed_vma) + sizeof(char));
1589                     local_got_refcounts = ((bfd_signed_vma *)
1590                                            bfd_zalloc (abfd, size));
1591                     if (local_got_refcounts == NULL)
1592                       return FALSE;
1593                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1594                     _bfd_tilepro_elf_local_got_tls_type (abfd)
1595                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1596                   }
1597                 local_got_refcounts[r_symndx] += 1;
1598                 old_tls_type =
1599                   _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx];
1600               }
1601
1602             /* If a TLS symbol is accessed using IE at least once,
1603                there is no point to use dynamic model for it.  */
1604             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1605                 && (old_tls_type != GOT_TLS_GD
1606                     || tls_type != GOT_TLS_IE))
1607               {
1608                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
1609                   tls_type = old_tls_type;
1610                 else
1611                   {
1612                     (*_bfd_error_handler)
1613                       (_("%B: `%s' accessed both as normal and thread local symbol"),
1614                        abfd, h ? h->root.root.string : "<local>");
1615                     return FALSE;
1616                   }
1617               }
1618
1619             if (old_tls_type != tls_type)
1620               {
1621                 if (h != NULL)
1622                   tilepro_elf_hash_entry (h)->tls_type = tls_type;
1623                 else
1624                   _bfd_tilepro_elf_local_got_tls_type (abfd) [r_symndx] =
1625                     tls_type;
1626               }
1627           }
1628
1629           if (htab->elf.sgot == NULL)
1630             {
1631               if (!tilepro_elf_create_got_section (htab->elf.dynobj, info))
1632                 return FALSE;
1633             }
1634           break;
1635
1636         case R_TILEPRO_TLS_GD_CALL:
1637           if (info->shared)
1638             {
1639               /* These are basically R_TILEPRO_JOFFLONG_X1_PLT relocs
1640                  against __tls_get_addr.  */
1641               struct bfd_link_hash_entry *bh = NULL;
1642               if (! _bfd_generic_link_add_one_symbol (info, abfd,
1643                                                       "__tls_get_addr", 0,
1644                                                       bfd_und_section_ptr, 0,
1645                                                       NULL, FALSE, FALSE,
1646                                                       &bh))
1647                 return FALSE;
1648               h = (struct elf_link_hash_entry *) bh;
1649             }
1650           else
1651             break;
1652           /* Fall through */
1653
1654         case R_TILEPRO_JOFFLONG_X1_PLT:
1655           /* This symbol requires a procedure linkage table entry.  We
1656              actually build the entry in adjust_dynamic_symbol,
1657              because this might be a case of linking PIC code without
1658              linking in any dynamic objects, in which case we don't
1659              need to generate a procedure linkage table after all.  */
1660
1661           if (h != NULL)
1662             {
1663               h->needs_plt = 1;
1664               h->plt.refcount += 1;
1665             }
1666           break;
1667
1668         case R_TILEPRO_32_PCREL:
1669         case R_TILEPRO_16_PCREL:
1670         case R_TILEPRO_8_PCREL:
1671         case R_TILEPRO_IMM16_X0_PCREL:
1672         case R_TILEPRO_IMM16_X1_PCREL:
1673         case R_TILEPRO_IMM16_X0_LO_PCREL:
1674         case R_TILEPRO_IMM16_X1_LO_PCREL:
1675         case R_TILEPRO_IMM16_X0_HI_PCREL:
1676         case R_TILEPRO_IMM16_X1_HI_PCREL:
1677         case R_TILEPRO_IMM16_X0_HA_PCREL:
1678         case R_TILEPRO_IMM16_X1_HA_PCREL:
1679           if (h != NULL)
1680             h->non_got_ref = 1;
1681
1682           if (h != NULL
1683               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1684             break;
1685           /* Fall through.  */
1686
1687         case R_TILEPRO_32:
1688         case R_TILEPRO_16:
1689         case R_TILEPRO_8:
1690         case R_TILEPRO_LO16:
1691         case R_TILEPRO_HI16:
1692         case R_TILEPRO_HA16:
1693         case R_TILEPRO_COPY:
1694         case R_TILEPRO_GLOB_DAT:
1695         case R_TILEPRO_JMP_SLOT:
1696         case R_TILEPRO_RELATIVE:
1697         case R_TILEPRO_BROFF_X1:
1698         case R_TILEPRO_JOFFLONG_X1:
1699         case R_TILEPRO_IMM8_X0:
1700         case R_TILEPRO_IMM8_Y0:
1701         case R_TILEPRO_IMM8_X1:
1702         case R_TILEPRO_IMM8_Y1:
1703         case R_TILEPRO_DEST_IMM8_X1:
1704         case R_TILEPRO_MT_IMM15_X1:
1705         case R_TILEPRO_MF_IMM15_X1:
1706         case R_TILEPRO_IMM16_X0:
1707         case R_TILEPRO_IMM16_X1:
1708         case R_TILEPRO_IMM16_X0_LO:
1709         case R_TILEPRO_IMM16_X1_LO:
1710         case R_TILEPRO_IMM16_X0_HI:
1711         case R_TILEPRO_IMM16_X1_HI:
1712         case R_TILEPRO_IMM16_X0_HA:
1713         case R_TILEPRO_IMM16_X1_HA:
1714         case R_TILEPRO_MMSTART_X0:
1715         case R_TILEPRO_MMEND_X0:
1716         case R_TILEPRO_MMSTART_X1:
1717         case R_TILEPRO_MMEND_X1:
1718         case R_TILEPRO_SHAMT_X0:
1719         case R_TILEPRO_SHAMT_X1:
1720         case R_TILEPRO_SHAMT_Y0:
1721         case R_TILEPRO_SHAMT_Y1:
1722           if (h != NULL)
1723               h->non_got_ref = 1;
1724
1725         r_tilepro_plt32:
1726           if (h != NULL && !info->shared)
1727             {
1728               /* We may need a .plt entry if the function this reloc
1729                  refers to is in a shared lib.  */
1730               h->plt.refcount += 1;
1731             }
1732
1733           /* If we are creating a shared library, and this is a reloc
1734              against a global symbol, or a non PC relative reloc
1735              against a local symbol, then we need to copy the reloc
1736              into the shared library.  However, if we are linking with
1737              -Bsymbolic, we do not need to copy a reloc against a
1738              global symbol which is defined in an object we are
1739              including in the link (i.e., DEF_REGULAR is set).  At
1740              this point we have not seen all the input files, so it is
1741              possible that DEF_REGULAR is not set now but will be set
1742              later (it is never cleared).  In case of a weak definition,
1743              DEF_REGULAR may be cleared later by a strong definition in
1744              a shared library.  We account for that possibility below by
1745              storing information in the relocs_copied field of the hash
1746              table entry.  A similar situation occurs when creating
1747              shared libraries and symbol visibility changes render the
1748              symbol local.
1749
1750              If on the other hand, we are creating an executable, we
1751              may need to keep relocations for symbols satisfied by a
1752              dynamic library if we manage to avoid copy relocs for the
1753              symbol.  */
1754           if ((info->shared
1755                && (sec->flags & SEC_ALLOC) != 0
1756                && (! tilepro_elf_howto_table[r_type].pc_relative
1757                    || (h != NULL
1758                        && (! info->symbolic
1759                            || h->root.type == bfd_link_hash_defweak
1760                            || !h->def_regular))))
1761               || (!info->shared
1762                   && (sec->flags & SEC_ALLOC) != 0
1763                   && h != NULL
1764                   && (h->root.type == bfd_link_hash_defweak
1765                       || !h->def_regular)))
1766             {
1767               struct tilepro_elf_dyn_relocs *p;
1768               struct tilepro_elf_dyn_relocs **head;
1769
1770               /* When creating a shared object, we must copy these
1771                  relocs into the output file.  We create a reloc
1772                  section in dynobj and make room for the reloc.  */
1773               if (sreloc == NULL)
1774                 {
1775                   sreloc = _bfd_elf_make_dynamic_reloc_section
1776                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1777
1778                   if (sreloc == NULL)
1779                     return FALSE;
1780                 }
1781
1782               /* If this is a global symbol, we count the number of
1783                  relocations we need for this symbol.  */
1784               if (h != NULL)
1785                 head =
1786                   &((struct tilepro_elf_link_hash_entry *) h)->dyn_relocs;
1787               else
1788                 {
1789                   /* Track dynamic relocs needed for local syms too.
1790                      We really need local syms available to do this
1791                      easily.  Oh well.  */
1792
1793                   asection *s;
1794                   void *vpp;
1795                   Elf_Internal_Sym *isym;
1796
1797                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1798                                                 abfd, r_symndx);
1799                   if (isym == NULL)
1800                     return FALSE;
1801
1802                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1803                   if (s == NULL)
1804                     s = sec;
1805
1806                   vpp = &elf_section_data (s)->local_dynrel;
1807                   head = (struct tilepro_elf_dyn_relocs **) vpp;
1808                 }
1809
1810               p = *head;
1811               if (p == NULL || p->sec != sec)
1812                 {
1813                   bfd_size_type amt = sizeof *p;
1814                   p = ((struct tilepro_elf_dyn_relocs *)
1815                        bfd_alloc (htab->elf.dynobj, amt));
1816                   if (p == NULL)
1817                     return FALSE;
1818                   p->next = *head;
1819                   *head = p;
1820                   p->sec = sec;
1821                   p->count = 0;
1822                   p->pc_count = 0;
1823                 }
1824
1825               p->count += 1;
1826               if (tilepro_elf_howto_table[r_type].pc_relative)
1827                 p->pc_count += 1;
1828             }
1829
1830           break;
1831
1832         case R_TILEPRO_GNU_VTINHERIT:
1833           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1834             return FALSE;
1835           break;
1836
1837         case R_TILEPRO_GNU_VTENTRY:
1838           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1839             return FALSE;
1840           break;
1841
1842         default:
1843           break;
1844         }
1845     }
1846
1847   return TRUE;
1848 }
1849
1850 \f
1851 static asection *
1852 tilepro_elf_gc_mark_hook (asection *sec,
1853                           struct bfd_link_info *info,
1854                           Elf_Internal_Rela *rel,
1855                           struct elf_link_hash_entry *h,
1856                           Elf_Internal_Sym *sym)
1857 {
1858   if (h != NULL)
1859     {
1860       switch (ELF32_R_TYPE (rel->r_info))
1861       {
1862       case R_TILEPRO_GNU_VTINHERIT:
1863       case R_TILEPRO_GNU_VTENTRY:
1864         break;
1865       }
1866     }
1867
1868   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1869 }
1870
1871 /* Update the got entry reference counts for the section being removed.  */
1872 static bfd_boolean
1873 tilepro_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1874                            asection *sec, const Elf_Internal_Rela *relocs)
1875 {
1876   struct tilepro_elf_link_hash_table *htab;
1877   Elf_Internal_Shdr *symtab_hdr;
1878   struct elf_link_hash_entry **sym_hashes;
1879   bfd_signed_vma *local_got_refcounts;
1880   const Elf_Internal_Rela *rel, *relend;
1881
1882   if (info->relocatable)
1883     return TRUE;
1884
1885   BFD_ASSERT (is_tilepro_elf (abfd) || sec->reloc_count == 0);
1886
1887   elf_section_data (sec)->local_dynrel = NULL;
1888
1889   htab = tilepro_elf_hash_table (info);
1890   BFD_ASSERT (htab != NULL);
1891   symtab_hdr = &elf_symtab_hdr (abfd);
1892   sym_hashes = elf_sym_hashes (abfd);
1893   local_got_refcounts = elf_local_got_refcounts (abfd);
1894
1895   relend = relocs + sec->reloc_count;
1896   for (rel = relocs; rel < relend; rel++)
1897     {
1898       unsigned long r_symndx;
1899       unsigned int r_type;
1900       struct elf_link_hash_entry *h = NULL;
1901
1902       r_symndx = ELF32_R_SYM (rel->r_info);
1903       if (r_symndx >= symtab_hdr->sh_info)
1904         {
1905           struct tilepro_elf_link_hash_entry *eh;
1906           struct tilepro_elf_dyn_relocs **pp;
1907           struct tilepro_elf_dyn_relocs *p;
1908
1909           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1910           while (h->root.type == bfd_link_hash_indirect
1911                  || h->root.type == bfd_link_hash_warning)
1912             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1913           eh = (struct tilepro_elf_link_hash_entry *) h;
1914           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1915             if (p->sec == sec)
1916               {
1917                 /* Everything must go for SEC.  */
1918                 *pp = p->next;
1919                 break;
1920               }
1921         }
1922
1923       r_type = ELF32_R_TYPE (rel->r_info);
1924       r_type = tilepro_elf_tls_transition (info, r_type, h != NULL);
1925       switch (r_type)
1926         {
1927         case R_TILEPRO_IMM16_X0_GOT:
1928         case R_TILEPRO_IMM16_X1_GOT:
1929         case R_TILEPRO_IMM16_X0_GOT_LO:
1930         case R_TILEPRO_IMM16_X1_GOT_LO:
1931         case R_TILEPRO_IMM16_X0_GOT_HI:
1932         case R_TILEPRO_IMM16_X1_GOT_HI:
1933         case R_TILEPRO_IMM16_X0_GOT_HA:
1934         case R_TILEPRO_IMM16_X1_GOT_HA:
1935         case R_TILEPRO_IMM16_X0_TLS_GD:
1936         case R_TILEPRO_IMM16_X1_TLS_GD:
1937         case R_TILEPRO_IMM16_X0_TLS_GD_LO:
1938         case R_TILEPRO_IMM16_X1_TLS_GD_LO:
1939         case R_TILEPRO_IMM16_X0_TLS_GD_HI:
1940         case R_TILEPRO_IMM16_X1_TLS_GD_HI:
1941         case R_TILEPRO_IMM16_X0_TLS_GD_HA:
1942         case R_TILEPRO_IMM16_X1_TLS_GD_HA:
1943         case R_TILEPRO_IMM16_X0_TLS_IE:
1944         case R_TILEPRO_IMM16_X1_TLS_IE:
1945         case R_TILEPRO_IMM16_X0_TLS_IE_LO:
1946         case R_TILEPRO_IMM16_X1_TLS_IE_LO:
1947         case R_TILEPRO_IMM16_X0_TLS_IE_HI:
1948         case R_TILEPRO_IMM16_X1_TLS_IE_HI:
1949         case R_TILEPRO_IMM16_X0_TLS_IE_HA:
1950         case R_TILEPRO_IMM16_X1_TLS_IE_HA:
1951           if (h != NULL)
1952             {
1953               if (h->got.refcount > 0)
1954                 h->got.refcount--;
1955             }
1956           else
1957             {
1958               if (local_got_refcounts &&
1959                   local_got_refcounts[r_symndx] > 0)
1960                 local_got_refcounts[r_symndx]--;
1961             }
1962           break;
1963
1964         case R_TILEPRO_32_PCREL:
1965         case R_TILEPRO_16_PCREL:
1966         case R_TILEPRO_8_PCREL:
1967         case R_TILEPRO_IMM16_X0_PCREL:
1968         case R_TILEPRO_IMM16_X1_PCREL:
1969         case R_TILEPRO_IMM16_X0_LO_PCREL:
1970         case R_TILEPRO_IMM16_X1_LO_PCREL:
1971         case R_TILEPRO_IMM16_X0_HI_PCREL:
1972         case R_TILEPRO_IMM16_X1_HI_PCREL:
1973         case R_TILEPRO_IMM16_X0_HA_PCREL:
1974         case R_TILEPRO_IMM16_X1_HA_PCREL:
1975           if (h != NULL
1976               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1977             break;
1978           /* Fall through.  */
1979
1980         case R_TILEPRO_32:
1981         case R_TILEPRO_16:
1982         case R_TILEPRO_8:
1983         case R_TILEPRO_LO16:
1984         case R_TILEPRO_HI16:
1985         case R_TILEPRO_HA16:
1986         case R_TILEPRO_COPY:
1987         case R_TILEPRO_GLOB_DAT:
1988         case R_TILEPRO_JMP_SLOT:
1989         case R_TILEPRO_RELATIVE:
1990         case R_TILEPRO_BROFF_X1:
1991         case R_TILEPRO_JOFFLONG_X1:
1992         case R_TILEPRO_IMM8_X0:
1993         case R_TILEPRO_IMM8_Y0:
1994         case R_TILEPRO_IMM8_X1:
1995         case R_TILEPRO_IMM8_Y1:
1996         case R_TILEPRO_DEST_IMM8_X1:
1997         case R_TILEPRO_MT_IMM15_X1:
1998         case R_TILEPRO_MF_IMM15_X1:
1999         case R_TILEPRO_IMM16_X0:
2000         case R_TILEPRO_IMM16_X1:
2001         case R_TILEPRO_IMM16_X0_LO:
2002         case R_TILEPRO_IMM16_X1_LO:
2003         case R_TILEPRO_IMM16_X0_HI:
2004         case R_TILEPRO_IMM16_X1_HI:
2005         case R_TILEPRO_IMM16_X0_HA:
2006         case R_TILEPRO_IMM16_X1_HA:
2007         case R_TILEPRO_MMSTART_X0:
2008         case R_TILEPRO_MMEND_X0:
2009         case R_TILEPRO_MMSTART_X1:
2010         case R_TILEPRO_MMEND_X1:
2011         case R_TILEPRO_SHAMT_X0:
2012         case R_TILEPRO_SHAMT_X1:
2013         case R_TILEPRO_SHAMT_Y0:
2014         case R_TILEPRO_SHAMT_Y1:
2015           if (info->shared)
2016             break;
2017           /* Fall through.  */
2018
2019         case R_TILEPRO_JOFFLONG_X1_PLT:
2020           if (h != NULL)
2021             {
2022               if (h->plt.refcount > 0)
2023                 h->plt.refcount--;
2024             }
2025           break;
2026
2027         default:
2028           break;
2029         }
2030     }
2031
2032   return TRUE;
2033 }
2034
2035 /* Adjust a symbol defined by a dynamic object and referenced by a
2036    regular object.  The current definition is in some section of the
2037    dynamic object, but we're not including those sections.  We have to
2038    change the definition to something the rest of the link can
2039    understand.  */
2040
2041 static bfd_boolean
2042 tilepro_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2043                                    struct elf_link_hash_entry *h)
2044 {
2045   struct tilepro_elf_link_hash_table *htab;
2046   struct tilepro_elf_link_hash_entry * eh;
2047   struct tilepro_elf_dyn_relocs *p;
2048   asection *s;
2049
2050   htab = tilepro_elf_hash_table (info);
2051   BFD_ASSERT (htab != NULL);
2052
2053   /* Make sure we know what is going on here.  */
2054   BFD_ASSERT (htab->elf.dynobj != NULL
2055               && (h->needs_plt
2056                   || h->u.weakdef != NULL
2057                   || (h->def_dynamic
2058                       && h->ref_regular
2059                       && !h->def_regular)));
2060
2061   /* If this is a function, put it in the procedure linkage table.  We
2062      will fill in the contents of the procedure linkage table later
2063      (although we could actually do it here). */
2064   if (h->type == STT_FUNC || h->needs_plt)
2065     {
2066       if (h->plt.refcount <= 0
2067           || SYMBOL_CALLS_LOCAL (info, h)
2068           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2069               && h->root.type == bfd_link_hash_undefweak))
2070         {
2071           /* This case can occur if we saw a R_TILEPRO_JOFFLONG_X1_PLT
2072              reloc in an input file, but the symbol was never referred
2073              to by a dynamic object, or if all references were garbage
2074              collected.  In such a case, we don't actually need to build
2075              a procedure linkage table, and we can just do a
2076              R_TILEPRO_JOFFLONG_X1 relocation instead. */
2077           h->plt.offset = (bfd_vma) -1;
2078           h->needs_plt = 0;
2079         }
2080
2081       return TRUE;
2082     }
2083   else
2084     h->plt.offset = (bfd_vma) -1;
2085
2086   /* If this is a weak symbol, and there is a real definition, the
2087      processor independent code will have arranged for us to see the
2088      real definition first, and we can just use the same value.  */
2089   if (h->u.weakdef != NULL)
2090     {
2091       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2092                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2093       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2094       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2095       return TRUE;
2096     }
2097
2098   /* This is a reference to a symbol defined by a dynamic object which
2099      is not a function.  */
2100
2101   /* If we are creating a shared library, we must presume that the
2102      only references to the symbol are via the global offset table.
2103      For such cases we need not do anything here; the relocations will
2104      be handled correctly by relocate_section.  */
2105   if (info->shared)
2106     return TRUE;
2107
2108   /* If there are no references to this symbol that do not use the
2109      GOT, we don't need to generate a copy reloc.  */
2110   if (!h->non_got_ref)
2111     return TRUE;
2112
2113   /* If -z nocopyreloc was given, we won't generate them either.  */
2114   if (info->nocopyreloc)
2115     {
2116       h->non_got_ref = 0;
2117       return TRUE;
2118     }
2119
2120   eh = (struct tilepro_elf_link_hash_entry *) h;
2121   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2122     {
2123       s = p->sec->output_section;
2124       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2125         break;
2126     }
2127
2128   /* If we didn't find any dynamic relocs in read-only sections, then
2129      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2130   if (p == NULL)
2131     {
2132       h->non_got_ref = 0;
2133       return TRUE;
2134     }
2135
2136   /* We must allocate the symbol in our .dynbss section, which will
2137      become part of the .bss section of the executable.  There will be
2138      an entry for this symbol in the .dynsym section.  The dynamic
2139      object will contain position independent code, so all references
2140      from the dynamic object to this symbol will go through the global
2141      offset table.  The dynamic linker will use the .dynsym entry to
2142      determine the address it must put in the global offset table, so
2143      both the dynamic object and the regular object will refer to the
2144      same memory location for the variable.  */
2145
2146   /* We must generate a R_TILEPRO_COPY reloc to tell the dynamic linker
2147      to copy the initial value out of the dynamic object and into the
2148      runtime process image.  We need to remember the offset into the
2149      .rel.bss section we are going to use.  */
2150   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2151     {
2152       htab->srelbss->size += TILEPRO_ELF_RELA_BYTES;
2153       h->needs_copy = 1;
2154     }
2155
2156   return _bfd_elf_adjust_dynamic_copy (h, htab->sdynbss);
2157 }
2158
2159 /* Allocate space in .plt, .got and associated reloc sections for
2160    dynamic relocs.  */
2161
2162 static bfd_boolean
2163 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2164 {
2165   struct bfd_link_info *info;
2166   struct tilepro_elf_link_hash_table *htab;
2167   struct tilepro_elf_link_hash_entry *eh;
2168   struct tilepro_elf_dyn_relocs *p;
2169
2170   if (h->root.type == bfd_link_hash_indirect)
2171     return TRUE;
2172
2173   info = (struct bfd_link_info *) inf;
2174   htab = tilepro_elf_hash_table (info);
2175   BFD_ASSERT (htab != NULL);
2176
2177   if (htab->elf.dynamic_sections_created
2178       && h->plt.refcount > 0)
2179     {
2180       /* Make sure this symbol is output as a dynamic symbol.
2181          Undefined weak syms won't yet be marked as dynamic.  */
2182       if (h->dynindx == -1
2183           && !h->forced_local)
2184         {
2185           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2186             return FALSE;
2187         }
2188
2189       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
2190         {
2191           asection *s = htab->elf.splt;
2192
2193           /* Allocate room for the header.  */
2194           if (s->size == 0)
2195             {
2196               s->size = PLT_HEADER_SIZE;
2197             }
2198
2199           h->plt.offset = s->size;
2200
2201           /* If this symbol is not defined in a regular file, and we are
2202              not generating a shared library, then set the symbol to this
2203              location in the .plt.  This is required to make function
2204              pointers compare as equal between the normal executable and
2205              the shared library.  */
2206           if (! info->shared
2207               && !h->def_regular)
2208             {
2209               h->root.u.def.section = s;
2210               h->root.u.def.value = h->plt.offset;
2211             }
2212
2213           /* Make room for this entry.  */
2214           s->size += PLT_ENTRY_SIZE;
2215
2216           /* We also need to make an entry in the .got.plt section.  */
2217           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2218
2219           /* We also need to make an entry in the .rela.plt section.  */
2220           htab->elf.srelplt->size += TILEPRO_ELF_RELA_BYTES;
2221         }
2222       else
2223         {
2224           h->plt.offset = (bfd_vma) -1;
2225           h->needs_plt = 0;
2226         }
2227     }
2228   else
2229     {
2230       h->plt.offset = (bfd_vma) -1;
2231       h->needs_plt = 0;
2232     }
2233
2234   /* If a TLS_IE symbol is now local to the binary, make it a TLS_LE
2235      requiring no TLS entry.  */
2236   if (h->got.refcount > 0
2237       && !info->shared
2238       && h->dynindx == -1
2239       && tilepro_elf_hash_entry(h)->tls_type == GOT_TLS_IE)
2240     h->got.offset = (bfd_vma) -1;
2241   else if (h->got.refcount > 0)
2242     {
2243       asection *s;
2244       bfd_boolean dyn;
2245       int tls_type = tilepro_elf_hash_entry(h)->tls_type;
2246
2247       /* Make sure this symbol is output as a dynamic symbol.
2248          Undefined weak syms won't yet be marked as dynamic.  */
2249       if (h->dynindx == -1
2250           && !h->forced_local)
2251         {
2252           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2253             return FALSE;
2254         }
2255
2256       s = htab->elf.sgot;
2257       h->got.offset = s->size;
2258       s->size += TILEPRO_BYTES_PER_WORD;
2259       /* R_TILEPRO_IMM16_Xn_TLS_GD entries need 2 consecutive GOT slots. */
2260       if (tls_type == GOT_TLS_GD)
2261         s->size += TILEPRO_BYTES_PER_WORD;
2262       dyn = htab->elf.dynamic_sections_created;
2263       /* R_TILEPRO_IMM16_Xn_TLS_IE_xxx needs one dynamic relocation,
2264          R_TILEPRO_IMM16_Xn_TLS_GD_xxx needs two if local symbol and two if
2265          global.  */
2266       if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE)
2267         htab->elf.srelgot->size += 2 * TILEPRO_ELF_RELA_BYTES;
2268       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2269         htab->elf.srelgot->size += TILEPRO_ELF_RELA_BYTES;
2270     }
2271   else
2272     h->got.offset = (bfd_vma) -1;
2273
2274   eh = (struct tilepro_elf_link_hash_entry *) h;
2275   if (eh->dyn_relocs == NULL)
2276     return TRUE;
2277
2278   /* In the shared -Bsymbolic case, discard space allocated for
2279      dynamic pc-relative relocs against symbols which turn out to be
2280      defined in regular objects.  For the normal shared case, discard
2281      space for pc-relative relocs that have become local due to symbol
2282      visibility changes.  */
2283
2284   if (info->shared)
2285     {
2286       if (SYMBOL_CALLS_LOCAL (info, h))
2287         {
2288           struct tilepro_elf_dyn_relocs **pp;
2289
2290           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2291             {
2292               p->count -= p->pc_count;
2293               p->pc_count = 0;
2294               if (p->count == 0)
2295                 *pp = p->next;
2296               else
2297                 pp = &p->next;
2298             }
2299         }
2300
2301       /* Also discard relocs on undefined weak syms with non-default
2302          visibility.  */
2303       if (eh->dyn_relocs != NULL
2304           && h->root.type == bfd_link_hash_undefweak)
2305         {
2306           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2307             eh->dyn_relocs = NULL;
2308
2309           /* Make sure undefined weak symbols are output as a dynamic
2310              symbol in PIEs.  */
2311           else if (h->dynindx == -1
2312                    && !h->forced_local)
2313             {
2314               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2315                 return FALSE;
2316             }
2317         }
2318     }
2319   else
2320     {
2321       /* For the non-shared case, discard space for relocs against
2322          symbols which turn out to need copy relocs or are not
2323          dynamic.  */
2324
2325       if (!h->non_got_ref
2326           && ((h->def_dynamic
2327                && !h->def_regular)
2328               || (htab->elf.dynamic_sections_created
2329                   && (h->root.type == bfd_link_hash_undefweak
2330                       || h->root.type == bfd_link_hash_undefined))))
2331         {
2332           /* Make sure this symbol is output as a dynamic symbol.
2333              Undefined weak syms won't yet be marked as dynamic.  */
2334           if (h->dynindx == -1
2335               && !h->forced_local)
2336             {
2337               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2338                 return FALSE;
2339             }
2340
2341           /* If that succeeded, we know we'll be keeping all the
2342              relocs.  */
2343           if (h->dynindx != -1)
2344             goto keep;
2345         }
2346
2347       eh->dyn_relocs = NULL;
2348
2349     keep: ;
2350     }
2351
2352   /* Finally, allocate space.  */
2353   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2354     {
2355       asection *sreloc = elf_section_data (p->sec)->sreloc;
2356       sreloc->size += p->count * TILEPRO_ELF_RELA_BYTES;
2357     }
2358
2359   return TRUE;
2360 }
2361
2362 /* Find any dynamic relocs that apply to read-only sections.  */
2363
2364 static bfd_boolean
2365 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
2366 {
2367   struct tilepro_elf_link_hash_entry *eh;
2368   struct tilepro_elf_dyn_relocs *p;
2369
2370   eh = (struct tilepro_elf_link_hash_entry *) h;
2371   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2372     {
2373       asection *s = p->sec->output_section;
2374
2375       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2376         {
2377           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2378
2379           info->flags |= DF_TEXTREL;
2380
2381           /* Not an error, just cut short the traversal.  */
2382           return FALSE;
2383         }
2384     }
2385   return TRUE;
2386 }
2387
2388 /* Return true if the dynamic symbol for a given section should be
2389    omitted when creating a shared library.  */
2390
2391 static bfd_boolean
2392 tilepro_elf_omit_section_dynsym (bfd *output_bfd,
2393                                     struct bfd_link_info *info,
2394                                     asection *p)
2395 {
2396   /* We keep the .got section symbol so that explicit relocations
2397      against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode
2398      can be turned into relocations against the .got symbol.  */
2399   if (strcmp (p->name, ".got") == 0)
2400     return FALSE;
2401
2402   return _bfd_elf_link_omit_section_dynsym (output_bfd, info, p);
2403 }
2404
2405 /* Set the sizes of the dynamic sections.  */
2406
2407 #define ELF32_DYNAMIC_INTERPRETER "/lib/ld.so.1"
2408
2409 static bfd_boolean
2410 tilepro_elf_size_dynamic_sections (bfd *output_bfd,
2411                                       struct bfd_link_info *info)
2412 {
2413   (void)output_bfd;
2414
2415   struct tilepro_elf_link_hash_table *htab;
2416   bfd *dynobj;
2417   asection *s;
2418   bfd *ibfd;
2419
2420   htab = tilepro_elf_hash_table (info);
2421   BFD_ASSERT (htab != NULL);
2422   dynobj = htab->elf.dynobj;
2423   BFD_ASSERT (dynobj != NULL);
2424
2425   if (elf_hash_table (info)->dynamic_sections_created)
2426     {
2427       /* Set the contents of the .interp section to the interpreter.  */
2428       if (info->executable)
2429         {
2430           s = bfd_get_linker_section (dynobj, ".interp");
2431           BFD_ASSERT (s != NULL);
2432           s->size = sizeof ELF32_DYNAMIC_INTERPRETER;
2433           s->contents = (unsigned char *) ELF32_DYNAMIC_INTERPRETER;
2434         }
2435     }
2436
2437   /* Set up .got offsets for local syms, and space for local dynamic
2438      relocs.  */
2439   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2440     {
2441       bfd_signed_vma *local_got;
2442       bfd_signed_vma *end_local_got;
2443       char *local_tls_type;
2444       bfd_size_type locsymcount;
2445       Elf_Internal_Shdr *symtab_hdr;
2446       asection *srel;
2447
2448       if (! is_tilepro_elf (ibfd))
2449         continue;
2450
2451       for (s = ibfd->sections; s != NULL; s = s->next)
2452         {
2453           struct tilepro_elf_dyn_relocs *p;
2454
2455           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2456             {
2457               if (!bfd_is_abs_section (p->sec)
2458                   && bfd_is_abs_section (p->sec->output_section))
2459                 {
2460                   /* Input section has been discarded, either because
2461                      it is a copy of a linkonce section or due to
2462                      linker script /DISCARD/, so we'll be discarding
2463                      the relocs too.  */
2464                 }
2465               else if (p->count != 0)
2466                 {
2467                   srel = elf_section_data (p->sec)->sreloc;
2468                   srel->size += p->count * TILEPRO_ELF_RELA_BYTES;
2469                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2470                     info->flags |= DF_TEXTREL;
2471                 }
2472             }
2473         }
2474
2475       local_got = elf_local_got_refcounts (ibfd);
2476       if (!local_got)
2477         continue;
2478
2479       symtab_hdr = &elf_symtab_hdr (ibfd);
2480       locsymcount = symtab_hdr->sh_info;
2481       end_local_got = local_got + locsymcount;
2482       local_tls_type = _bfd_tilepro_elf_local_got_tls_type (ibfd);
2483       s = htab->elf.sgot;
2484       srel = htab->elf.srelgot;
2485       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2486         {
2487           if (*local_got > 0)
2488             {
2489               *local_got = s->size;
2490               s->size += TILEPRO_BYTES_PER_WORD;
2491               if (*local_tls_type == GOT_TLS_GD)
2492                 s->size += TILEPRO_BYTES_PER_WORD;
2493               if (info->shared
2494                   || *local_tls_type == GOT_TLS_GD
2495                   || *local_tls_type == GOT_TLS_IE)
2496                 srel->size += TILEPRO_ELF_RELA_BYTES;
2497             }
2498           else
2499             *local_got = (bfd_vma) -1;
2500         }
2501     }
2502
2503   /* Allocate global sym .plt and .got entries, and space for global
2504      sym dynamic relocs.  */
2505   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2506
2507   if (elf_hash_table (info)->dynamic_sections_created)
2508     {
2509       /* If the .got section is more than 0x8000 bytes, we add
2510          0x8000 to the value of _GLOBAL_OFFSET_TABLE_, so that 16
2511          bit relocations have a greater chance of working. */
2512       if (htab->elf.sgot->size >= 0x8000
2513           && elf_hash_table (info)->hgot->root.u.def.value == 0)
2514         elf_hash_table (info)->hgot->root.u.def.value = 0x8000;
2515     }
2516
2517   if (htab->elf.sgotplt)
2518     {
2519       struct elf_link_hash_entry *got;
2520       got = elf_link_hash_lookup (elf_hash_table (info),
2521                                   "_GLOBAL_OFFSET_TABLE_",
2522                                   FALSE, FALSE, FALSE);
2523
2524       /* Don't allocate .got.plt section if there are no GOT nor PLT
2525          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2526       if ((got == NULL
2527            || !got->ref_regular_nonweak)
2528           && (htab->elf.sgotplt->size
2529               == GOTPLT_HEADER_SIZE)
2530           && (htab->elf.splt == NULL
2531               || htab->elf.splt->size == 0)
2532           && (htab->elf.sgot == NULL
2533               || (htab->elf.sgot->size
2534                   == get_elf_backend_data (output_bfd)->got_header_size)))
2535         htab->elf.sgotplt->size = 0;
2536     }
2537
2538   /* The check_relocs and adjust_dynamic_symbol entry points have
2539      determined the sizes of the various dynamic sections.  Allocate
2540      memory for them.  */
2541   for (s = dynobj->sections; s != NULL; s = s->next)
2542     {
2543       if ((s->flags & SEC_LINKER_CREATED) == 0)
2544         continue;
2545
2546       if (s == htab->elf.splt
2547           || s == htab->elf.sgot
2548           || s == htab->elf.sgotplt
2549           || s == htab->sdynbss)
2550         {
2551           /* Strip this section if we don't need it; see the
2552              comment below.  */
2553         }
2554       else if (strncmp (s->name, ".rela", 5) == 0)
2555         {
2556           if (s->size != 0)
2557             {
2558               /* We use the reloc_count field as a counter if we need
2559                  to copy relocs into the output file.  */
2560               s->reloc_count = 0;
2561             }
2562         }
2563       else
2564         {
2565           /* It's not one of our sections.  */
2566           continue;
2567         }
2568
2569       if (s->size == 0)
2570         {
2571           /* If we don't need this section, strip it from the
2572              output file.  This is mostly to handle .rela.bss and
2573              .rela.plt.  We must create both sections in
2574              create_dynamic_sections, because they must be created
2575              before the linker maps input sections to output
2576              sections.  The linker does that before
2577              adjust_dynamic_symbol is called, and it is that
2578              function which decides whether anything needs to go
2579              into these sections.  */
2580           s->flags |= SEC_EXCLUDE;
2581           continue;
2582         }
2583
2584       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2585         continue;
2586
2587       /* Allocate memory for the section contents.  Zero the memory
2588          for the benefit of .rela.plt, which has 4 unused entries
2589          at the beginning, and we don't want garbage.  */
2590       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2591       if (s->contents == NULL)
2592         return FALSE;
2593     }
2594
2595   if (elf_hash_table (info)->dynamic_sections_created)
2596     {
2597       /* Add some entries to the .dynamic section.  We fill in the
2598          values later, in tilepro_elf_finish_dynamic_sections, but we
2599          must add the entries now so that we get the correct size for
2600          the .dynamic section.  The DT_DEBUG entry is filled in by the
2601          dynamic linker and used by the debugger.  */
2602 #define add_dynamic_entry(TAG, VAL) \
2603   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2604
2605       if (info->executable)
2606         {
2607           if (!add_dynamic_entry (DT_DEBUG, 0))
2608             return FALSE;
2609         }
2610
2611       if (htab->elf.srelplt->size != 0)
2612         {
2613           if (!add_dynamic_entry (DT_PLTGOT, 0)
2614               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2615               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2616               || !add_dynamic_entry (DT_JMPREL, 0))
2617             return FALSE;
2618         }
2619
2620       if (!add_dynamic_entry (DT_RELA, 0)
2621           || !add_dynamic_entry (DT_RELASZ, 0)
2622           || !add_dynamic_entry (DT_RELAENT, TILEPRO_ELF_RELA_BYTES))
2623         return FALSE;
2624
2625       /* If any dynamic relocs apply to a read-only section,
2626          then we need a DT_TEXTREL entry.  */
2627       if ((info->flags & DF_TEXTREL) == 0)
2628         elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2629
2630       if (info->flags & DF_TEXTREL)
2631         {
2632           if (!add_dynamic_entry (DT_TEXTREL, 0))
2633             return FALSE;
2634         }
2635     }
2636 #undef add_dynamic_entry
2637
2638   return TRUE;
2639 }
2640 \f
2641 /* Return the base VMA address which should be subtracted from real addresses
2642    when resolving @dtpoff relocation.
2643    This is PT_TLS segment p_vaddr.  */
2644
2645 static bfd_vma
2646 dtpoff_base (struct bfd_link_info *info)
2647 {
2648   /* If tls_sec is NULL, we should have signalled an error already.  */
2649   if (elf_hash_table (info)->tls_sec == NULL)
2650     return 0;
2651   return elf_hash_table (info)->tls_sec->vma;
2652 }
2653
2654 /* Return the relocation value for R_TILEPRO_TLS_TPOFF32. */
2655
2656 static bfd_vma
2657 tpoff (struct bfd_link_info *info, bfd_vma address)
2658 {
2659   struct elf_link_hash_table *htab = elf_hash_table (info);
2660
2661   /* If tls_sec is NULL, we should have signalled an error already.  */
2662   if (htab->tls_sec == NULL)
2663     return 0;
2664
2665   return (address - htab->tls_sec->vma);
2666 }
2667
2668 /* Replace the MASK bits in ADDR with those in INSN, for the next
2669    TILEPRO_BUNDLE_SIZE_IN_BYTES bytes.  */
2670
2671 static void
2672 tilepro_replace_insn (bfd_byte *addr, const bfd_byte *mask,
2673                       const bfd_byte *insn)
2674 {
2675   int i;
2676   for (i = 0; i < TILEPRO_BUNDLE_SIZE_IN_BYTES; i++)
2677     {
2678       addr[i] = (addr[i] & ~mask[i]) | (insn[i] & mask[i]);
2679     }
2680 }
2681
2682 /* Mask to extract the bits corresponding to an instruction in a
2683    specific pipe of a bundle.  */
2684 static const bfd_byte insn_mask_X1[] = {
2685   0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x7f
2686 };
2687
2688 /* Mask to extract the bits corresponding to an instruction in a
2689    specific pipe of a bundle, minus the destination operand and the
2690    first source operand.  */
2691 static const bfd_byte insn_mask_X0_no_dest_no_srca[] = {
2692   0x00, 0xf0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00
2693 };
2694
2695 static const bfd_byte insn_mask_X1_no_dest_no_srca[] = {
2696   0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x7f
2697 };
2698
2699 static const bfd_byte insn_mask_Y0_no_dest_no_srca[] = {
2700   0x00, 0xf0, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00
2701 };
2702
2703 static const bfd_byte insn_mask_Y1_no_dest_no_srca[] = {
2704   0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0x78
2705 };
2706
2707 /* Mask to extract the first source operand of an instruction.  */
2708 static const bfd_byte srca_mask_X0[] = {
2709   0xc0, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2710 };
2711
2712 static const bfd_byte srca_mask_X1[] = {
2713   0x00, 0x00, 0x00, 0x00, 0xe0, 0x07, 0x00, 0x00
2714 };
2715
2716 /* Various instructions synthesized to support tls references.  */
2717
2718 /* move r0, r0 in the X1 pipe, used for tls le.  */
2719 static const bfd_byte insn_tls_le_move_X1[] = {
2720   0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x33, 0x08
2721 };
2722
2723 /* move r0, zero in the X0 and X1 pipe, used for tls le.  */
2724 static const bfd_byte insn_tls_le_move_zero_X0X1[] = {
2725   0xc0, 0xff, 0xcf, 0x00, 0xe0, 0xff, 0x33, 0x08
2726 };
2727
2728 /* lw r0, r0 in the X1 pipe, used for tls ie.  */
2729 static const bfd_byte insn_tls_ie_lw_X1[] = {
2730   0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x0b, 0x40
2731 };
2732
2733 /* add r0, r0, tp in various pipes, used for tls ie.  */
2734 static const bfd_byte insn_tls_ie_add_X0X1[] = {
2735   0x00, 0x50, 0x0f, 0x00, 0x00, 0xa8, 0x07, 0x08
2736 };
2737 static const bfd_byte insn_tls_ie_add_Y0Y1[] = {
2738   0x00, 0x50, 0x03, 0x08, 0x00, 0xa8, 0x01, 0x8c
2739 };
2740
2741 /* move r0, r0 in various pipes, used for tls gd.  */
2742 static const bfd_byte insn_tls_gd_add_X0X1[] = {
2743   0x00, 0xf0, 0xcf, 0x00, 0x00, 0xf8, 0x33, 0x08
2744 };
2745 static const bfd_byte insn_tls_gd_add_Y0Y1[] = {
2746   0x00, 0xf0, 0x0b, 0x18, 0x00, 0xf8, 0x05, 0x9c
2747 };
2748
2749 /* Relocate an TILEPRO ELF section.
2750
2751    The RELOCATE_SECTION function is called by the new ELF backend linker
2752    to handle the relocations for a section.
2753
2754    The relocs are always passed as Rela structures.
2755
2756    This function is responsible for adjusting the section contents as
2757    necessary, and (if generating a relocatable output file) adjusting
2758    the reloc addend as necessary.
2759
2760    This function does not have to worry about setting the reloc
2761    address or the reloc symbol index.
2762
2763    LOCAL_SYMS is a pointer to the swapped in local symbols.
2764
2765    LOCAL_SECTIONS is an array giving the section in the input file
2766    corresponding to the st_shndx field of each local symbol.
2767
2768    The global hash table entry for the global symbols can be found
2769    via elf_sym_hashes (input_bfd).
2770
2771    When generating relocatable output, this function must handle
2772    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2773    going to be the section symbol corresponding to the output
2774    section, which means that the addend must be adjusted
2775    accordingly.  */
2776
2777 static bfd_boolean
2778 tilepro_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2779                               bfd *input_bfd, asection *input_section,
2780                               bfd_byte *contents, Elf_Internal_Rela *relocs,
2781                               Elf_Internal_Sym *local_syms,
2782                               asection **local_sections)
2783 {
2784   struct tilepro_elf_link_hash_table *htab;
2785   Elf_Internal_Shdr *symtab_hdr;
2786   struct elf_link_hash_entry **sym_hashes;
2787   bfd_vma *local_got_offsets;
2788   bfd_vma got_base;
2789   asection *sreloc;
2790   Elf_Internal_Rela *rel;
2791   Elf_Internal_Rela *relend;
2792   int num_relocs;
2793
2794   htab = tilepro_elf_hash_table (info);
2795   BFD_ASSERT (htab != NULL);
2796   symtab_hdr = &elf_symtab_hdr (input_bfd);
2797   sym_hashes = elf_sym_hashes (input_bfd);
2798   local_got_offsets = elf_local_got_offsets (input_bfd);
2799
2800   if (elf_hash_table (info)->hgot == NULL)
2801     got_base = 0;
2802   else
2803     got_base = elf_hash_table (info)->hgot->root.u.def.value;
2804
2805   sreloc = elf_section_data (input_section)->sreloc;
2806
2807   rel = relocs;
2808   num_relocs = input_section->reloc_count;
2809   relend = relocs + num_relocs;
2810   for (; rel < relend; rel++)
2811     {
2812       int r_type, tls_type;
2813       bfd_boolean is_tls_iele, is_tls_le;
2814       reloc_howto_type *howto;
2815       unsigned long r_symndx;
2816       struct elf_link_hash_entry *h;
2817       Elf_Internal_Sym *sym;
2818       tilepro_create_func create_func;
2819       asection *sec;
2820       bfd_vma relocation;
2821       bfd_reloc_status_type r;
2822       const char *name;
2823       bfd_vma off;
2824       bfd_boolean is_plt = FALSE;
2825
2826       bfd_boolean unresolved_reloc;
2827
2828       r_type = ELF32_R_TYPE (rel->r_info);
2829       if (r_type == R_TILEPRO_GNU_VTINHERIT
2830           || r_type == R_TILEPRO_GNU_VTENTRY)
2831         continue;
2832
2833       if ((unsigned int)r_type >= NELEMS(tilepro_elf_howto_table))
2834         {
2835           /* Not clear if we need to check here, but just be paranoid. */
2836           (*_bfd_error_handler)
2837             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
2838              input_bfd, r_type, input_section);
2839           bfd_set_error (bfd_error_bad_value);
2840           return FALSE;
2841         }
2842
2843       howto = tilepro_elf_howto_table + r_type;
2844
2845       /* This is a final link.  */
2846       r_symndx = ELF32_R_SYM (rel->r_info);
2847       h = NULL;
2848       sym = NULL;
2849       sec = NULL;
2850       unresolved_reloc = FALSE;
2851       if (r_symndx < symtab_hdr->sh_info)
2852         {
2853           sym = local_syms + r_symndx;
2854           sec = local_sections[r_symndx];
2855           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2856         }
2857       else
2858         {
2859           bfd_boolean warned;
2860
2861           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2862                                    r_symndx, symtab_hdr, sym_hashes,
2863                                    h, sec, relocation,
2864                                    unresolved_reloc, warned);
2865           if (warned)
2866             {
2867               /* To avoid generating warning messages about truncated
2868                  relocations, set the relocation's address to be the same as
2869                  the start of this section.  */
2870               if (input_section->output_section != NULL)
2871                 relocation = input_section->output_section->vma;
2872               else
2873                 relocation = 0;
2874             }
2875         }
2876
2877       if (sec != NULL && discarded_section (sec))
2878         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2879                                          rel, 1, relend, howto, 0, contents);
2880
2881       if (info->relocatable)
2882         continue;
2883
2884       if (h != NULL)
2885         name = h->root.root.string;
2886       else
2887         {
2888           name = (bfd_elf_string_from_elf_section
2889                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
2890           if (name == NULL || *name == '\0')
2891             name = bfd_section_name (input_bfd, sec);
2892         }
2893
2894       switch (r_type)
2895         {
2896         case R_TILEPRO_TLS_GD_CALL:
2897         case R_TILEPRO_IMM8_X0_TLS_GD_ADD:
2898         case R_TILEPRO_IMM8_Y0_TLS_GD_ADD:
2899         case R_TILEPRO_IMM8_X1_TLS_GD_ADD:
2900         case R_TILEPRO_IMM8_Y1_TLS_GD_ADD:
2901         case R_TILEPRO_IMM16_X0_TLS_GD_HA:
2902         case R_TILEPRO_IMM16_X1_TLS_GD_HA:
2903         case R_TILEPRO_IMM16_X0_TLS_IE_HA:
2904         case R_TILEPRO_IMM16_X1_TLS_IE_HA:
2905           tls_type = GOT_UNKNOWN;
2906           if (h == NULL && local_got_offsets)
2907             tls_type =
2908               _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
2909           else if (h != NULL)
2910             tls_type = tilepro_elf_hash_entry(h)->tls_type;
2911
2912           is_tls_iele = (! info->shared || tls_type == GOT_TLS_IE);
2913           is_tls_le = is_tls_iele && (!info->shared
2914                                       && (h == NULL || h->dynindx == -1));
2915
2916           if (r_type == R_TILEPRO_TLS_GD_CALL)
2917             {
2918               if (is_tls_le)
2919                 {
2920                   /* GD -> LE */
2921                   tilepro_replace_insn (contents + rel->r_offset,
2922                                         insn_mask_X1, insn_tls_le_move_X1);
2923                   continue;
2924                 }
2925               else if (is_tls_iele)
2926                 {
2927                   /* GD -> IE */
2928                   tilepro_replace_insn (contents + rel->r_offset,
2929                                         insn_mask_X1, insn_tls_ie_lw_X1);
2930                   continue;
2931                 }
2932
2933               /* GD -> GD */
2934               h = (struct elf_link_hash_entry *)
2935                 bfd_link_hash_lookup (info->hash, "__tls_get_addr", FALSE,
2936                                       FALSE, TRUE);
2937               BFD_ASSERT (h != NULL);
2938               r_type = R_TILEPRO_JOFFLONG_X1_PLT;
2939               howto = tilepro_elf_howto_table + r_type;
2940             }
2941           else if (r_type == R_TILEPRO_IMM16_X0_TLS_GD_HA
2942                    || r_type == R_TILEPRO_IMM16_X0_TLS_IE_HA)
2943             {
2944               if (is_tls_le)
2945                 tilepro_replace_insn (contents + rel->r_offset, srca_mask_X0,
2946                                       insn_tls_le_move_zero_X0X1);
2947             }
2948           else if (r_type == R_TILEPRO_IMM16_X1_TLS_GD_HA
2949                    || r_type == R_TILEPRO_IMM16_X1_TLS_IE_HA)
2950             {
2951               if (is_tls_le)
2952                 tilepro_replace_insn (contents + rel->r_offset, srca_mask_X1,
2953                                       insn_tls_le_move_zero_X0X1);
2954             }
2955           else
2956             {
2957               const bfd_byte *mask = NULL;
2958               const bfd_byte *add_insn = NULL;
2959
2960               switch (r_type)
2961                 {
2962                 case R_TILEPRO_IMM8_X0_TLS_GD_ADD:
2963                   add_insn = is_tls_iele ? insn_tls_ie_add_X0X1
2964                     : insn_tls_gd_add_X0X1;
2965                   mask = insn_mask_X0_no_dest_no_srca;
2966                   break;
2967                 case R_TILEPRO_IMM8_X1_TLS_GD_ADD:
2968                   add_insn = is_tls_iele ? insn_tls_ie_add_X0X1
2969                     : insn_tls_gd_add_X0X1;
2970                   mask = insn_mask_X1_no_dest_no_srca;
2971                   break;
2972                 case R_TILEPRO_IMM8_Y0_TLS_GD_ADD:
2973                   add_insn = is_tls_iele ? insn_tls_ie_add_Y0Y1
2974                     : insn_tls_gd_add_Y0Y1;
2975                   mask = insn_mask_Y0_no_dest_no_srca;
2976                   break;
2977                 case R_TILEPRO_IMM8_Y1_TLS_GD_ADD:
2978                   add_insn = is_tls_iele ? insn_tls_ie_add_Y0Y1
2979                     : insn_tls_gd_add_Y0Y1;
2980                   mask = insn_mask_Y1_no_dest_no_srca;
2981                   break;
2982                 }
2983
2984               tilepro_replace_insn (contents + rel->r_offset, mask, add_insn);
2985
2986               continue;
2987             }
2988           break;
2989         case R_TILEPRO_TLS_IE_LOAD:
2990           if (!info->shared && (h == NULL || h->dynindx == -1))
2991             /* IE -> LE */
2992             tilepro_replace_insn (contents + rel->r_offset,
2993                                   insn_mask_X1_no_dest_no_srca,
2994                                   insn_tls_le_move_X1);
2995           else
2996             /* IE -> IE */
2997             tilepro_replace_insn (contents + rel->r_offset,
2998                                   insn_mask_X1_no_dest_no_srca,
2999                                   insn_tls_ie_lw_X1);
3000           continue;
3001           break;
3002         default:
3003           break;
3004         }
3005
3006       switch (r_type)
3007         {
3008         case R_TILEPRO_IMM16_X0_GOT:
3009         case R_TILEPRO_IMM16_X1_GOT:
3010         case R_TILEPRO_IMM16_X0_GOT_LO:
3011         case R_TILEPRO_IMM16_X1_GOT_LO:
3012         case R_TILEPRO_IMM16_X0_GOT_HI:
3013         case R_TILEPRO_IMM16_X1_GOT_HI:
3014         case R_TILEPRO_IMM16_X0_GOT_HA:
3015         case R_TILEPRO_IMM16_X1_GOT_HA:
3016           /* Relocation is to the entry for this symbol in the global
3017              offset table.  */
3018           if (htab->elf.sgot == NULL)
3019             abort ();
3020
3021           if (h != NULL)
3022             {
3023               bfd_boolean dyn;
3024
3025               off = h->got.offset;
3026               BFD_ASSERT (off != (bfd_vma) -1);
3027               dyn = elf_hash_table (info)->dynamic_sections_created;
3028
3029               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3030                   || (info->shared
3031                       && SYMBOL_REFERENCES_LOCAL (info, h)))
3032                 {
3033                   /* This is actually a static link, or it is a
3034                      -Bsymbolic link and the symbol is defined
3035                      locally, or the symbol was forced to be local
3036                      because of a version file.  We must initialize
3037                      this entry in the global offset table.  Since the
3038                      offset must always be a multiple
3039                      of 4 for 32-bit, we use the least significant bit
3040                      to record whether we have initialized it already.
3041
3042                      When doing a dynamic link, we create a .rela.got
3043                      relocation entry to initialize the value.  This
3044                      is done in the finish_dynamic_symbol routine.  */
3045                   if ((off & 1) != 0)
3046                     off &= ~1;
3047                   else
3048                     {
3049                       bfd_put_32 (output_bfd, relocation,
3050                                           htab->elf.sgot->contents + off);
3051                       h->got.offset |= 1;
3052                     }
3053                 }
3054               else
3055                 unresolved_reloc = FALSE;
3056             }
3057           else
3058             {
3059               BFD_ASSERT (local_got_offsets != NULL
3060                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
3061
3062               off = local_got_offsets[r_symndx];
3063
3064               /* The offset must always be a multiple of 4 on 32-bit.
3065                  We use the least significant bit to record
3066                  whether we have already processed this entry.  */
3067               if ((off & 1) != 0)
3068                 off &= ~1;
3069               else
3070                 {
3071                   if (info->shared)
3072                     {
3073                       asection *s;
3074                       Elf_Internal_Rela outrel;
3075
3076                       /* We need to generate a R_TILEPRO_RELATIVE reloc
3077                          for the dynamic linker.  */
3078                       s = htab->elf.srelgot;
3079                       BFD_ASSERT (s != NULL);
3080
3081                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3082                                          + htab->elf.sgot->output_offset
3083                                          + off);
3084                       outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
3085                       outrel.r_addend = relocation;
3086                       relocation = 0;
3087                       tilepro_elf_append_rela_32 (output_bfd, s, &outrel);
3088                     }
3089
3090                   bfd_put_32 (output_bfd, relocation,
3091                                       htab->elf.sgot->contents + off);
3092                   local_got_offsets[r_symndx] |= 1;
3093                 }
3094             }
3095           relocation = htab->elf.sgot->output_offset + off - got_base;
3096           break;
3097
3098         case R_TILEPRO_JOFFLONG_X1_PLT:
3099           /* Relocation is to the entry for this symbol in the
3100              procedure linkage table.  */
3101           BFD_ASSERT (h != NULL);
3102
3103           if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL)
3104             {
3105               /* We didn't make a PLT entry for this symbol.  This
3106                  happens when statically linking PIC code, or when
3107                  using -Bsymbolic.  */
3108               break;
3109             }
3110
3111           relocation = (htab->elf.splt->output_section->vma
3112                         + htab->elf.splt->output_offset
3113                         + h->plt.offset);
3114           unresolved_reloc = FALSE;
3115           break;
3116
3117         case R_TILEPRO_32_PCREL:
3118         case R_TILEPRO_16_PCREL:
3119         case R_TILEPRO_8_PCREL:
3120         case R_TILEPRO_IMM16_X0_PCREL:
3121         case R_TILEPRO_IMM16_X1_PCREL:
3122         case R_TILEPRO_IMM16_X0_LO_PCREL:
3123         case R_TILEPRO_IMM16_X1_LO_PCREL:
3124         case R_TILEPRO_IMM16_X0_HI_PCREL:
3125         case R_TILEPRO_IMM16_X1_HI_PCREL:
3126         case R_TILEPRO_IMM16_X0_HA_PCREL:
3127         case R_TILEPRO_IMM16_X1_HA_PCREL:
3128           if (h != NULL
3129               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3130             break;
3131           /* Fall through.  */
3132         case R_TILEPRO_32:
3133         case R_TILEPRO_16:
3134         case R_TILEPRO_8:
3135         case R_TILEPRO_LO16:
3136         case R_TILEPRO_HI16:
3137         case R_TILEPRO_HA16:
3138         case R_TILEPRO_COPY:
3139         case R_TILEPRO_GLOB_DAT:
3140         case R_TILEPRO_JMP_SLOT:
3141         case R_TILEPRO_RELATIVE:
3142         case R_TILEPRO_BROFF_X1:
3143         case R_TILEPRO_JOFFLONG_X1:
3144         case R_TILEPRO_IMM8_X0:
3145         case R_TILEPRO_IMM8_Y0:
3146         case R_TILEPRO_IMM8_X1:
3147         case R_TILEPRO_IMM8_Y1:
3148         case R_TILEPRO_DEST_IMM8_X1:
3149         case R_TILEPRO_MT_IMM15_X1:
3150         case R_TILEPRO_MF_IMM15_X1:
3151         case R_TILEPRO_IMM16_X0:
3152         case R_TILEPRO_IMM16_X1:
3153         case R_TILEPRO_IMM16_X0_LO:
3154         case R_TILEPRO_IMM16_X1_LO:
3155         case R_TILEPRO_IMM16_X0_HI:
3156         case R_TILEPRO_IMM16_X1_HI:
3157         case R_TILEPRO_IMM16_X0_HA:
3158         case R_TILEPRO_IMM16_X1_HA:
3159         case R_TILEPRO_MMSTART_X0:
3160         case R_TILEPRO_MMEND_X0:
3161         case R_TILEPRO_MMSTART_X1:
3162         case R_TILEPRO_MMEND_X1:
3163         case R_TILEPRO_SHAMT_X0:
3164         case R_TILEPRO_SHAMT_X1:
3165         case R_TILEPRO_SHAMT_Y0:
3166         case R_TILEPRO_SHAMT_Y1:
3167           if ((input_section->flags & SEC_ALLOC) == 0)
3168             break;
3169
3170           if ((info->shared
3171                && (h == NULL
3172                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3173                    || h->root.type != bfd_link_hash_undefweak)
3174                && (! howto->pc_relative
3175                    || !SYMBOL_CALLS_LOCAL (info, h)))
3176               || (!info->shared
3177                   && h != NULL
3178                   && h->dynindx != -1
3179                   && !h->non_got_ref
3180                   && ((h->def_dynamic
3181                        && !h->def_regular)
3182                       || h->root.type == bfd_link_hash_undefweak
3183                       || h->root.type == bfd_link_hash_undefined)))
3184             {
3185               Elf_Internal_Rela outrel;
3186               bfd_boolean skip, relocate = FALSE;
3187
3188               /* When generating a shared object, these relocations
3189                  are copied into the output file to be resolved at run
3190                  time.  */
3191
3192               BFD_ASSERT (sreloc != NULL);
3193
3194               skip = FALSE;
3195
3196               outrel.r_offset =
3197                 _bfd_elf_section_offset (output_bfd, info, input_section,
3198                                          rel->r_offset);
3199               if (outrel.r_offset == (bfd_vma) -1)
3200                 skip = TRUE;
3201               else if (outrel.r_offset == (bfd_vma) -2)
3202                 skip = TRUE, relocate = TRUE;
3203               outrel.r_offset += (input_section->output_section->vma
3204                                   + input_section->output_offset);
3205
3206               switch (r_type)
3207                 {
3208                 case R_TILEPRO_32_PCREL:
3209                 case R_TILEPRO_16_PCREL:
3210                 case R_TILEPRO_8_PCREL:
3211                   /* If the symbol is not dynamic, we should not keep
3212                      a dynamic relocation.  But an .rela.* slot has been
3213                      allocated for it, output R_TILEPRO_NONE.
3214                      FIXME: Add code tracking needed dynamic relocs as
3215                      e.g. i386 has.  */
3216                   if (h->dynindx == -1)
3217                     skip = TRUE, relocate = TRUE;
3218                   break;
3219                 }
3220
3221               if (skip)
3222                 memset (&outrel, 0, sizeof outrel);
3223               /* h->dynindx may be -1 if the symbol was marked to
3224                  become local.  */
3225               else if (h != NULL &&
3226                        h->dynindx != -1
3227                        && (! is_plt
3228                            || !info->shared
3229                            || !SYMBOLIC_BIND (info, h)
3230                            || !h->def_regular))
3231                 {
3232                   BFD_ASSERT (h->dynindx != -1);
3233                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
3234                   outrel.r_addend = rel->r_addend;
3235                 }
3236               else
3237                 {
3238                   if (r_type == R_TILEPRO_32)
3239                     {
3240                       outrel.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
3241                       outrel.r_addend = relocation + rel->r_addend;
3242                     }
3243                   else
3244                     {
3245                       long indx;
3246
3247                       outrel.r_addend = relocation + rel->r_addend;
3248
3249                       if (is_plt)
3250                         sec = htab->elf.splt;
3251
3252                       if (bfd_is_abs_section (sec))
3253                         indx = 0;
3254                       else if (sec == NULL || sec->owner == NULL)
3255                         {
3256                           bfd_set_error (bfd_error_bad_value);
3257                           return FALSE;
3258                         }
3259                       else
3260                         {
3261                           asection *osec;
3262
3263                           /* We are turning this relocation into one
3264                              against a section symbol.  It would be
3265                              proper to subtract the symbol's value,
3266                              osec->vma, from the emitted reloc addend,
3267                              but ld.so expects buggy relocs.  */
3268                           osec = sec->output_section;
3269                           indx = elf_section_data (osec)->dynindx;
3270
3271                           if (indx == 0)
3272                             {
3273                               osec = htab->elf.text_index_section;
3274                               indx = elf_section_data (osec)->dynindx;
3275                             }
3276
3277                           /* FIXME: we really should be able to link non-pic
3278                              shared libraries.  */
3279                           if (indx == 0)
3280                             {
3281                               BFD_FAIL ();
3282                               (*_bfd_error_handler)
3283                                 (_("%B: probably compiled without -fPIC?"),
3284                                  input_bfd);
3285                               bfd_set_error (bfd_error_bad_value);
3286                               return FALSE;
3287                             }
3288                         }
3289
3290                       outrel.r_info = ELF32_R_INFO (indx, r_type);
3291                     }
3292                 }
3293
3294               tilepro_elf_append_rela_32 (output_bfd, sreloc, &outrel);
3295
3296               /* This reloc will be computed at runtime, so there's no
3297                  need to do anything now.  */
3298               if (! relocate)
3299                 continue;
3300             }
3301           break;
3302
3303         case R_TILEPRO_IMM16_X0_TLS_LE:
3304         case R_TILEPRO_IMM16_X1_TLS_LE:
3305         case R_TILEPRO_IMM16_X0_TLS_LE_LO:
3306         case R_TILEPRO_IMM16_X1_TLS_LE_LO:
3307         case R_TILEPRO_IMM16_X0_TLS_LE_HI:
3308         case R_TILEPRO_IMM16_X1_TLS_LE_HI:
3309         case R_TILEPRO_IMM16_X0_TLS_LE_HA:
3310         case R_TILEPRO_IMM16_X1_TLS_LE_HA:
3311           if (info->shared)
3312             {
3313               Elf_Internal_Rela outrel;
3314               bfd_boolean skip;
3315
3316               BFD_ASSERT (sreloc != NULL);
3317               skip = FALSE;
3318               outrel.r_offset =
3319                 _bfd_elf_section_offset (output_bfd, info, input_section,
3320                                          rel->r_offset);
3321               if (outrel.r_offset == (bfd_vma) -1)
3322                 skip = TRUE;
3323               else if (outrel.r_offset == (bfd_vma) -2)
3324                 skip = TRUE;
3325               outrel.r_offset += (input_section->output_section->vma
3326                                   + input_section->output_offset);
3327               if (skip)
3328                 memset (&outrel, 0, sizeof outrel);
3329               else
3330                 {
3331                   outrel.r_info = ELF32_R_INFO (0, r_type);
3332                   outrel.r_addend = relocation - dtpoff_base (info)
3333                                     + rel->r_addend;
3334                 }
3335
3336               tilepro_elf_append_rela_32 (output_bfd, sreloc, &outrel);
3337               continue;
3338             }
3339           relocation = tpoff (info, relocation);
3340           break;
3341
3342         case R_TILEPRO_IMM16_X0_TLS_GD:
3343         case R_TILEPRO_IMM16_X1_TLS_GD:
3344         case R_TILEPRO_IMM16_X0_TLS_GD_LO:
3345         case R_TILEPRO_IMM16_X1_TLS_GD_LO:
3346         case R_TILEPRO_IMM16_X0_TLS_GD_HI:
3347         case R_TILEPRO_IMM16_X1_TLS_GD_HI:
3348         case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3349         case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3350         case R_TILEPRO_IMM16_X0_TLS_IE:
3351         case R_TILEPRO_IMM16_X1_TLS_IE:
3352         case R_TILEPRO_IMM16_X0_TLS_IE_LO:
3353         case R_TILEPRO_IMM16_X1_TLS_IE_LO:
3354         case R_TILEPRO_IMM16_X0_TLS_IE_HI:
3355         case R_TILEPRO_IMM16_X1_TLS_IE_HI:
3356         case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3357         case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3358           r_type = tilepro_elf_tls_transition (info, r_type, h == NULL);
3359           tls_type = GOT_UNKNOWN;
3360           if (h == NULL && local_got_offsets)
3361             tls_type
3362               = _bfd_tilepro_elf_local_got_tls_type (input_bfd) [r_symndx];
3363           else if (h != NULL)
3364             {
3365               tls_type = tilepro_elf_hash_entry(h)->tls_type;
3366               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
3367                 r_type = tilepro_tls_translate_to_le (r_type);
3368             }
3369           if (tls_type == GOT_TLS_IE)
3370             r_type = tilepro_tls_translate_to_ie (r_type);
3371
3372           if (r_type == R_TILEPRO_IMM16_X0_TLS_LE
3373               || r_type == R_TILEPRO_IMM16_X1_TLS_LE
3374               || r_type == R_TILEPRO_IMM16_X0_TLS_LE_LO
3375               || r_type == R_TILEPRO_IMM16_X1_TLS_LE_LO
3376               || r_type == R_TILEPRO_IMM16_X0_TLS_LE_HI
3377               || r_type == R_TILEPRO_IMM16_X1_TLS_LE_HI
3378               || r_type == R_TILEPRO_IMM16_X0_TLS_LE_HA
3379               || r_type == R_TILEPRO_IMM16_X1_TLS_LE_HA)
3380             {
3381               relocation = tpoff (info, relocation);
3382               break;
3383             }
3384
3385           if (h != NULL)
3386             {
3387               off = h->got.offset;
3388               h->got.offset |= 1;
3389             }
3390           else
3391             {
3392               BFD_ASSERT (local_got_offsets != NULL);
3393               off = local_got_offsets[r_symndx];
3394               local_got_offsets[r_symndx] |= 1;
3395             }
3396
3397           if (htab->elf.sgot == NULL)
3398             abort ();
3399
3400           if ((off & 1) != 0)
3401             off &= ~1;
3402           else
3403             {
3404               Elf_Internal_Rela outrel;
3405               int indx = 0;
3406               bfd_boolean need_relocs = FALSE;
3407
3408               if (htab->elf.srelgot == NULL)
3409                 abort ();
3410
3411               if (h != NULL)
3412               {
3413                 bfd_boolean dyn;
3414                 dyn = htab->elf.dynamic_sections_created;
3415
3416                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3417                     && (!info->shared
3418                         || !SYMBOL_REFERENCES_LOCAL (info, h)))
3419                   {
3420                     indx = h->dynindx;
3421                   }
3422               }
3423
3424               /* The GOT entries have not been initialized yet.  Do it
3425                  now, and emit any relocations. */
3426               if ((info->shared || indx != 0)
3427                   && (h == NULL
3428                       || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3429                       || h->root.type != bfd_link_hash_undefweak))
3430                     need_relocs = TRUE;
3431
3432               switch (r_type)
3433                 {
3434                   case R_TILEPRO_IMM16_X0_TLS_IE:
3435                   case R_TILEPRO_IMM16_X1_TLS_IE:
3436                   case R_TILEPRO_IMM16_X0_TLS_IE_LO:
3437                   case R_TILEPRO_IMM16_X1_TLS_IE_LO:
3438                   case R_TILEPRO_IMM16_X0_TLS_IE_HI:
3439                   case R_TILEPRO_IMM16_X1_TLS_IE_HI:
3440                   case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3441                   case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3442                     if (need_relocs) {
3443                       bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3444                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3445                                        + htab->elf.sgot->output_offset + off);
3446                       outrel.r_addend = 0;
3447                       if (indx == 0)
3448                         outrel.r_addend = relocation - dtpoff_base (info);
3449                       outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_TPOFF32);
3450                       tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3451                                                   &outrel);
3452                     } else {
3453                       bfd_put_32 (output_bfd, tpoff (info, relocation),
3454                                   htab->elf.sgot->contents + off);
3455                     }
3456                     break;
3457
3458                   case R_TILEPRO_IMM16_X0_TLS_GD:
3459                   case R_TILEPRO_IMM16_X1_TLS_GD:
3460                   case R_TILEPRO_IMM16_X0_TLS_GD_LO:
3461                   case R_TILEPRO_IMM16_X1_TLS_GD_LO:
3462                   case R_TILEPRO_IMM16_X0_TLS_GD_HI:
3463                   case R_TILEPRO_IMM16_X1_TLS_GD_HI:
3464                   case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3465                   case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3466                     if (need_relocs) {
3467                       outrel.r_offset = (htab->elf.sgot->output_section->vma
3468                                        + htab->elf.sgot->output_offset + off);
3469                       outrel.r_addend = 0;
3470                       outrel.r_info = ELF32_R_INFO (indx, R_TILEPRO_TLS_DTPMOD32);
3471                       bfd_put_32 (output_bfd, 0, htab->elf.sgot->contents + off);
3472                       tilepro_elf_append_rela_32 (output_bfd, htab->elf.srelgot,
3473                                                   &outrel);
3474                       if (indx == 0)
3475                         {
3476                           BFD_ASSERT (! unresolved_reloc);
3477                           bfd_put_32 (output_bfd,
3478                                       relocation - dtpoff_base (info),
3479                                       (htab->elf.sgot->contents + off +
3480                                        TILEPRO_BYTES_PER_WORD));
3481                         }
3482                       else
3483                         {
3484                           bfd_put_32 (output_bfd, 0,
3485                                       (htab->elf.sgot->contents + off +
3486                                        TILEPRO_BYTES_PER_WORD));
3487                           outrel.r_info = ELF32_R_INFO (indx,
3488                                                         R_TILEPRO_TLS_DTPOFF32);
3489                           outrel.r_offset += TILEPRO_BYTES_PER_WORD;
3490                           tilepro_elf_append_rela_32 (output_bfd,
3491                                                       htab->elf.srelgot, &outrel);
3492                         }
3493                     }
3494
3495                     else {
3496                       /* If we are not emitting relocations for a
3497                          general dynamic reference, then we must be in a
3498                          static link or an executable link with the
3499                          symbol binding locally.  Mark it as belonging
3500                          to module 1, the executable.  */
3501                       bfd_put_32 (output_bfd, 1,
3502                                   htab->elf.sgot->contents + off );
3503                       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
3504                                   htab->elf.sgot->contents + off +
3505                                   TILEPRO_BYTES_PER_WORD);
3506                    }
3507                    break;
3508                 }
3509             }
3510
3511           if (off >= (bfd_vma) -2)
3512             abort ();
3513
3514           relocation = htab->elf.sgot->output_offset + off - got_base;
3515           unresolved_reloc = FALSE;
3516           howto = tilepro_elf_howto_table + r_type;
3517           break;
3518
3519         default:
3520           break;
3521         }
3522
3523       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3524          because such sections are not SEC_ALLOC and thus ld.so will
3525          not process them.  */
3526       if (unresolved_reloc
3527           && !((input_section->flags & SEC_DEBUGGING) != 0
3528                && h->def_dynamic)
3529           && _bfd_elf_section_offset (output_bfd, info, input_section,
3530                                       rel->r_offset) != (bfd_vma) -1)
3531         (*_bfd_error_handler)
3532           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3533            input_bfd,
3534            input_section,
3535            (long) rel->r_offset,
3536            howto->name,
3537            h->root.root.string);
3538
3539       r = bfd_reloc_continue;
3540
3541       /* For the _HA types, we add 0x8000 so that if bit 15 is set,
3542        * we will increment bit 16.  The howto->rightshift takes care
3543        * of the rest for us. */
3544       switch (r_type)
3545       {
3546       case R_TILEPRO_HA16:
3547       case R_TILEPRO_IMM16_X0_HA:
3548       case R_TILEPRO_IMM16_X1_HA:
3549       case R_TILEPRO_IMM16_X0_HA_PCREL:
3550       case R_TILEPRO_IMM16_X1_HA_PCREL:
3551       case R_TILEPRO_IMM16_X0_GOT_HA:
3552       case R_TILEPRO_IMM16_X1_GOT_HA:
3553       case R_TILEPRO_IMM16_X0_TLS_GD_HA:
3554       case R_TILEPRO_IMM16_X1_TLS_GD_HA:
3555       case R_TILEPRO_IMM16_X0_TLS_IE_HA:
3556       case R_TILEPRO_IMM16_X1_TLS_IE_HA:
3557         relocation += 0x8000;
3558         break;
3559       }
3560
3561       /* Get the operand creation function, if any. */
3562       create_func = reloc_to_create_func[r_type];
3563       if (create_func == NULL)
3564       {
3565         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3566                                       contents, rel->r_offset,
3567                                       relocation, rel->r_addend);
3568       }
3569       else
3570       {
3571         if (howto->pc_relative)
3572         {
3573           relocation -=
3574             input_section->output_section->vma + input_section->output_offset;
3575           if (howto->pcrel_offset)
3576             relocation -= rel->r_offset;
3577         }
3578
3579         bfd_byte *data;
3580
3581         /* Add the relocation addend if any to the final target value */
3582         relocation += rel->r_addend;
3583
3584         /* Do basic range checking */
3585         r = bfd_check_overflow (howto->complain_on_overflow,
3586                                 howto->bitsize,
3587                                 howto->rightshift,
3588                                 32,
3589                                 relocation);
3590
3591         /*
3592          * Write the relocated value out into the raw section data.
3593          * Don't put a relocation out in the .rela section.
3594          */
3595         tilepro_bundle_bits mask = create_func(-1);
3596         tilepro_bundle_bits value = create_func(relocation >> howto->rightshift);
3597
3598         /* Only touch bytes while the mask is not 0, so we
3599            don't write to out of bounds memory if this is actually
3600            a 16-bit switch instruction. */
3601         for (data = contents + rel->r_offset; mask != 0; data++)
3602           {
3603             bfd_byte byte_mask = (bfd_byte)mask;
3604             *data = (*data & ~byte_mask) | ((bfd_byte)value & byte_mask);
3605             mask >>= 8;
3606             value >>= 8;
3607           }
3608       }
3609
3610       if (r != bfd_reloc_ok)
3611         {
3612           const char *msg = NULL;
3613
3614           switch (r)
3615             {
3616             case bfd_reloc_overflow:
3617               r = info->callbacks->reloc_overflow
3618                 (info, (h ? &h->root : NULL), name, howto->name,
3619                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3620               break;
3621
3622             case bfd_reloc_undefined:
3623               r = info->callbacks->undefined_symbol
3624                 (info, name, input_bfd, input_section, rel->r_offset,
3625                  TRUE);
3626               break;
3627
3628             case bfd_reloc_outofrange:
3629               msg = _("internal error: out of range error");
3630               break;
3631
3632             case bfd_reloc_notsupported:
3633               msg = _("internal error: unsupported relocation error");
3634               break;
3635
3636             case bfd_reloc_dangerous:
3637               msg = _("internal error: dangerous relocation");
3638               break;
3639
3640             default:
3641               msg = _("internal error: unknown error");
3642               break;
3643             }
3644
3645           if (msg)
3646             r = info->callbacks->warning
3647               (info, msg, name, input_bfd, input_section, rel->r_offset);
3648
3649           if (! r)
3650             return FALSE;
3651         }
3652     }
3653
3654   return TRUE;
3655 }
3656
3657 /* Finish up dynamic symbol handling.  We set the contents of various
3658    dynamic sections here.  */
3659
3660 static bfd_boolean
3661 tilepro_elf_finish_dynamic_symbol (bfd *output_bfd,
3662                                    struct bfd_link_info *info,
3663                                    struct elf_link_hash_entry *h,
3664                                    Elf_Internal_Sym *sym)
3665 {
3666   struct tilepro_elf_link_hash_table *htab;
3667
3668   htab = tilepro_elf_hash_table (info);
3669   BFD_ASSERT (htab != NULL);
3670
3671   if (h->plt.offset != (bfd_vma) -1)
3672     {
3673       asection *splt;
3674       asection *srela;
3675       asection *sgotplt;
3676       Elf_Internal_Rela rela;
3677       bfd_byte *loc;
3678       bfd_vma r_offset;
3679
3680       int rela_index;
3681
3682       /* This symbol has an entry in the PLT.  Set it up.  */
3683
3684       BFD_ASSERT (h->dynindx != -1);
3685
3686       splt = htab->elf.splt;
3687       srela = htab->elf.srelplt;
3688       sgotplt = htab->elf.sgotplt;
3689
3690       if (splt == NULL || srela == NULL)
3691        abort ();
3692
3693       /* Fill in the entry in the procedure linkage table.  */
3694       rela_index = tilepro_plt_entry_build (splt, sgotplt, h->plt.offset,
3695                                             &r_offset);
3696
3697       /* Fill in the entry in the global offset table, which initially points
3698          to the beginning of the plt.  */
3699       bfd_put_32 (output_bfd, splt->output_section->vma + splt->output_offset,
3700                   sgotplt->contents + r_offset);
3701
3702       /* Fill in the entry in the .rela.plt section.  */
3703       rela.r_offset = (sgotplt->output_section->vma
3704                        + sgotplt->output_offset
3705                        + r_offset);
3706       rela.r_addend = 0;
3707       rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_JMP_SLOT);
3708
3709       loc = srela->contents + rela_index * sizeof (Elf32_External_Rela);
3710       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3711
3712       if (!h->def_regular)
3713         {
3714           /* Mark the symbol as undefined, rather than as defined in
3715              the .plt section.  Leave the value alone.  */
3716           sym->st_shndx = SHN_UNDEF;
3717           /* If the symbol is weak, we do need to clear the value.
3718              Otherwise, the PLT entry would provide a definition for
3719              the symbol even if the symbol wasn't defined anywhere,
3720              and so the symbol would never be NULL.  */
3721           if (!h->ref_regular_nonweak)
3722             sym->st_value = 0;
3723         }
3724     }
3725
3726   if (h->got.offset != (bfd_vma) -1
3727       && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_GD
3728       && tilepro_elf_hash_entry(h)->tls_type != GOT_TLS_IE)
3729     {
3730       asection *sgot;
3731       asection *srela;
3732       Elf_Internal_Rela rela;
3733
3734       /* This symbol has an entry in the GOT.  Set it up.  */
3735
3736       sgot = htab->elf.sgot;
3737       srela = htab->elf.srelgot;
3738       BFD_ASSERT (sgot != NULL && srela != NULL);
3739
3740       rela.r_offset = (sgot->output_section->vma
3741                        + sgot->output_offset
3742                        + (h->got.offset &~ (bfd_vma) 1));
3743
3744       /* If this is a -Bsymbolic link, and the symbol is defined
3745          locally, we just want to emit a RELATIVE reloc.  Likewise if
3746          the symbol was forced to be local because of a version file.
3747          The entry in the global offset table will already have been
3748          initialized in the relocate_section function.  */
3749       if (info->shared
3750           && (info->symbolic || h->dynindx == -1)
3751           && h->def_regular)
3752         {
3753           asection *sec = h->root.u.def.section;
3754           rela.r_info = ELF32_R_INFO (0, R_TILEPRO_RELATIVE);
3755           rela.r_addend = (h->root.u.def.value
3756                            + sec->output_section->vma
3757                            + sec->output_offset);
3758         }
3759       else
3760         {
3761           rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_GLOB_DAT);
3762           rela.r_addend = 0;
3763         }
3764
3765       bfd_put_32 (output_bfd, 0,
3766                           sgot->contents + (h->got.offset & ~(bfd_vma) 1));
3767       tilepro_elf_append_rela_32 (output_bfd, srela, &rela);
3768     }
3769
3770   if (h->needs_copy)
3771     {
3772       asection *s;
3773       Elf_Internal_Rela rela;
3774
3775       /* This symbols needs a copy reloc.  Set it up.  */
3776       BFD_ASSERT (h->dynindx != -1);
3777
3778       s = htab->srelbss;
3779       BFD_ASSERT (s != NULL);
3780
3781       rela.r_offset = (h->root.u.def.value
3782                        + h->root.u.def.section->output_section->vma
3783                        + h->root.u.def.section->output_offset);
3784       rela.r_info = ELF32_R_INFO (h->dynindx, R_TILEPRO_COPY);
3785       rela.r_addend = 0;
3786       tilepro_elf_append_rela_32 (output_bfd, s, &rela);
3787     }
3788
3789   /* Mark some specially defined symbols as absolute. */
3790   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3791       || (h == htab->elf.hgot || h == htab->elf.hplt))
3792     sym->st_shndx = SHN_ABS;
3793
3794   return TRUE;
3795 }
3796
3797 /* Finish up the dynamic sections.  */
3798
3799 static bfd_boolean
3800 tilepro_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
3801                     bfd *dynobj, asection *sdyn,
3802                     asection *splt ATTRIBUTE_UNUSED)
3803 {
3804   Elf32_External_Dyn *dyncon, *dynconend;
3805   struct tilepro_elf_link_hash_table *htab;
3806
3807   htab = tilepro_elf_hash_table (info);
3808   BFD_ASSERT (htab != NULL);
3809   dyncon = (Elf32_External_Dyn *) sdyn->contents;
3810   dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3811   for (; dyncon < dynconend; dyncon++)
3812     {
3813       Elf_Internal_Dyn dyn;
3814       asection *s;
3815
3816       bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3817
3818       switch (dyn.d_tag)
3819         {
3820         case DT_PLTGOT:
3821           s = htab->elf.sgotplt;
3822           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3823           break;
3824         case DT_JMPREL:
3825           s = htab->elf.srelplt;
3826           dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3827           break;
3828         case DT_PLTRELSZ:
3829           s = htab->elf.srelplt;
3830           dyn.d_un.d_val = s->size;
3831           break;
3832         default:
3833           continue;
3834         }
3835
3836       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3837     }
3838   return TRUE;
3839 }
3840
3841 static bfd_boolean
3842 tilepro_elf_finish_dynamic_sections (bfd *output_bfd,
3843                                      struct bfd_link_info *info)
3844 {
3845   bfd *dynobj;
3846   asection *sdyn;
3847   struct tilepro_elf_link_hash_table *htab;
3848
3849   htab = tilepro_elf_hash_table (info);
3850   BFD_ASSERT (htab != NULL);
3851   dynobj = htab->elf.dynobj;
3852
3853   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3854
3855   if (elf_hash_table (info)->dynamic_sections_created)
3856     {
3857       asection *splt;
3858       bfd_boolean ret;
3859
3860       splt = htab->elf.splt;
3861       BFD_ASSERT (splt != NULL && sdyn != NULL);
3862
3863       ret = tilepro_finish_dyn (output_bfd, info, dynobj, sdyn, splt);
3864
3865       if (ret != TRUE)
3866         return ret;
3867
3868       /* Fill in the first entry in the procedure linkage table.  */
3869       if (splt->size > 0)
3870         memcpy (splt->contents, tilepro_plt0_entry, PLT_HEADER_SIZE);
3871
3872       elf_section_data (splt->output_section)->this_hdr.sh_entsize
3873         = PLT_ENTRY_SIZE;
3874     }
3875
3876   if (htab->elf.sgotplt)
3877     {
3878       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
3879         {
3880           (*_bfd_error_handler)
3881             (_("discarded output section: `%A'"), htab->elf.sgotplt);
3882           return FALSE;
3883         }
3884
3885       if (htab->elf.sgotplt->size > 0)
3886         {
3887           /* Write the first two entries in .got.plt, needed for the dynamic
3888              linker.  */
3889           bfd_put_32 (output_bfd, (bfd_vma) -1,
3890                       htab->elf.sgotplt->contents);
3891           bfd_put_32 (output_bfd, (bfd_vma) 0,
3892                       htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
3893         }
3894
3895       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
3896         = GOT_ENTRY_SIZE;
3897     }
3898
3899   if (htab->elf.sgot)
3900     {
3901       if (htab->elf.sgot->size > 0)
3902         {
3903           /* Set the first entry in the global offset table to the address of
3904              the dynamic section.  */
3905           bfd_vma val = (sdyn ?
3906                          sdyn->output_section->vma + sdyn->output_offset :
3907                          0);
3908           bfd_put_32 (output_bfd, val, htab->elf.sgot->contents);
3909         }
3910
3911       elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
3912         = GOT_ENTRY_SIZE;
3913     }
3914
3915   return TRUE;
3916 }
3917
3918 \f
3919
3920 /* Return address for Ith PLT stub in section PLT, for relocation REL
3921    or (bfd_vma) -1 if it should not be included.  */
3922
3923 static bfd_vma
3924 tilepro_elf_plt_sym_val (bfd_vma i, const asection *plt,
3925                       const arelent *rel ATTRIBUTE_UNUSED)
3926 {
3927   return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
3928 }
3929
3930 static enum elf_reloc_type_class
3931 tilepro_reloc_type_class (const Elf_Internal_Rela *rela)
3932 {
3933   switch ((int) ELF32_R_TYPE (rela->r_info))
3934     {
3935     case R_TILEPRO_RELATIVE:
3936       return reloc_class_relative;
3937     case R_TILEPRO_JMP_SLOT:
3938       return reloc_class_plt;
3939     case R_TILEPRO_COPY:
3940       return reloc_class_copy;
3941     default:
3942       return reloc_class_normal;
3943     }
3944 }
3945
3946 static int
3947 tilepro_additional_program_headers (bfd *abfd,
3948                                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
3949 {
3950   /* Each .intrpt section specified by the user adds another PT_LOAD
3951      header since the sections are discontiguous. */
3952   static const char intrpt_sections[4][9] =
3953     {
3954       ".intrpt0", ".intrpt1", ".intrpt2", ".intrpt3"
3955     };
3956   int count = 0;
3957   int i;
3958
3959   for (i = 0; i < 4; i++)
3960     {
3961       asection *sec = bfd_get_section_by_name (abfd, intrpt_sections[i]);
3962       if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
3963         ++count;
3964     }
3965
3966   /* Add four "padding" headers in to leave room in case a custom linker
3967      script does something fancy. Otherwise ld complains that it ran
3968      out of program headers and refuses to link. */
3969   count += 4;
3970
3971   return count;
3972 }
3973
3974 #define ELF_ARCH                bfd_arch_tilepro
3975 #define ELF_TARGET_ID           TILEPRO_ELF_DATA
3976 #define ELF_MACHINE_CODE        EM_TILEPRO
3977 #define ELF_MAXPAGESIZE         0x10000
3978 #define ELF_COMMONPAGESIZE      0x10000
3979
3980 #define TARGET_LITTLE_SYM       bfd_elf32_tilepro_vec
3981 #define TARGET_LITTLE_NAME      "elf32-tilepro"
3982
3983 #define elf_backend_reloc_type_class         tilepro_reloc_type_class
3984
3985 #define bfd_elf32_bfd_reloc_name_lookup      tilepro_reloc_name_lookup
3986 #define bfd_elf32_bfd_link_hash_table_create tilepro_elf_link_hash_table_create
3987 #define bfd_elf32_bfd_reloc_type_lookup      tilepro_reloc_type_lookup
3988
3989 #define elf_backend_copy_indirect_symbol     tilepro_elf_copy_indirect_symbol
3990 #define elf_backend_create_dynamic_sections  tilepro_elf_create_dynamic_sections
3991 #define elf_backend_check_relocs             tilepro_elf_check_relocs
3992 #define elf_backend_adjust_dynamic_symbol    tilepro_elf_adjust_dynamic_symbol
3993 #define elf_backend_omit_section_dynsym      tilepro_elf_omit_section_dynsym
3994 #define elf_backend_size_dynamic_sections    tilepro_elf_size_dynamic_sections
3995 #define elf_backend_relocate_section         tilepro_elf_relocate_section
3996 #define elf_backend_finish_dynamic_symbol    tilepro_elf_finish_dynamic_symbol
3997 #define elf_backend_finish_dynamic_sections  tilepro_elf_finish_dynamic_sections
3998 #define elf_backend_gc_mark_hook             tilepro_elf_gc_mark_hook
3999 #define elf_backend_gc_sweep_hook            tilepro_elf_gc_sweep_hook
4000 #define elf_backend_plt_sym_val              tilepro_elf_plt_sym_val
4001 #define elf_info_to_howto_rel                NULL
4002 #define elf_info_to_howto                    tilepro_info_to_howto_rela
4003 #define elf_backend_grok_prstatus            tilepro_elf_grok_prstatus
4004 #define elf_backend_grok_psinfo              tilepro_elf_grok_psinfo
4005 #define elf_backend_additional_program_headers tilepro_additional_program_headers
4006
4007 #define elf_backend_init_index_section  _bfd_elf_init_1_index_section
4008
4009 #define elf_backend_can_gc_sections 1
4010 #define elf_backend_can_refcount 1
4011 #define elf_backend_want_got_plt 1
4012 #define elf_backend_plt_readonly 1
4013 /* Align PLT mod 64 byte L2 line size. */
4014 #define elf_backend_plt_alignment 6
4015 #define elf_backend_want_plt_sym 1
4016 #define elf_backend_got_header_size GOT_ENTRY_SIZE
4017 #define elf_backend_rela_normal 1
4018 #define elf_backend_default_execstack 0
4019
4020 #include "elf32-target.h"