bfd/elf32-tilepro.c

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