bfd/elf32-or1k.c

   1 /* Or1k-specific support for 32-bit ELF.
   2    Copyright (C) 2001-2016 Free Software Foundation, Inc.
   3    Contributed for OR32 by Johan Rydberg, jrydberg@opencores.org
   4
   5    PIC parts added by Stefan Kristiansson, stefan.kristiansson@saunalahti.fi,
   6    largely based on elf32-m32r.c and elf32-microblaze.c.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/or1k.h"
  28 #include "libiberty.h"
  29
  30 #define PLT_ENTRY_SIZE 20
  31
  32 #define PLT0_ENTRY_WORD0 0x19800000 /* l.movhi r12, 0 <- hi(.got+4) */
  33 #define PLT0_ENTRY_WORD1 0xa98c0000 /* l.ori r12, r12, 0 <- lo(.got+4) */
  34 #define PLT0_ENTRY_WORD2 0x85ec0004 /* l.lwz r15, 4(r12) <- *(.got+8)*/
  35 #define PLT0_ENTRY_WORD3 0x44007800 /* l.jr r15 */
  36 #define PLT0_ENTRY_WORD4 0x858c0000 /* l.lwz r12, 0(r12) */
  37
  38 #define PLT0_PIC_ENTRY_WORD0 0x85900004 /* l.lwz r12, 4(r16) */
  39 #define PLT0_PIC_ENTRY_WORD1 0x85f00008 /* l.lwz r15, 8(r16) */
  40 #define PLT0_PIC_ENTRY_WORD2 0x44007800 /* l.jr r15 */
  41 #define PLT0_PIC_ENTRY_WORD3 0x15000000 /* l.nop */
  42 #define PLT0_PIC_ENTRY_WORD4 0x15000000 /* l.nop */
  43
  44 #define PLT_ENTRY_WORD0 0x19800000 /* l.movhi r12, 0 <- hi(got idx addr) */
  45 #define PLT_ENTRY_WORD1 0xa98c0000 /* l.ori r12, r12, 0 <- lo(got idx addr) */
  46 #define PLT_ENTRY_WORD2 0x858c0000 /* l.lwz r12, 0(r12) */
  47 #define PLT_ENTRY_WORD3 0x44006000 /* l.jr r12 */
  48 #define PLT_ENTRY_WORD4 0xa9600000 /* l.ori r11, r0, 0 <- reloc offset */
  49
  50 #define PLT_PIC_ENTRY_WORD0 0x85900000 /* l.lwz r12, 0(r16) <- index in got */
  51 #define PLT_PIC_ENTRY_WORD1 0xa9600000 /* l.ori r11, r0, 0 <- reloc offset */
  52 #define PLT_PIC_ENTRY_WORD2 0x44006000 /* l.jr r12 */
  53 #define PLT_PIC_ENTRY_WORD3 0x15000000 /* l.nop */
  54 #define PLT_PIC_ENTRY_WORD4 0x15000000 /* l.nop */
  55
  56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
  57
  58 static reloc_howto_type or1k_elf_howto_table[] =
  59 {
  60   /* This reloc does nothing.  */
  61   HOWTO (R_OR1K_NONE,           /* type */
  62          0,                     /* rightshift */
  63          3,                     /* size (0 = byte, 1 = short, 2 = long) */
  64          0,                     /* bitsize */
  65          FALSE,                 /* pc_relative */
  66          0,                     /* bitpos */
  67          complain_overflow_dont, /* complain_on_overflow */
  68          bfd_elf_generic_reloc, /* special_function */
  69          "R_OR1K_NONE",         /* name */
  70          FALSE,                 /* partial_inplace */
  71          0,                     /* src_mask */
  72          0,                     /* dst_mask */
  73          FALSE),                /* pcrel_offset */
  74
  75   HOWTO (R_OR1K_32,
  76          0,                     /* rightshift */
  77          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  78          32,                    /* bitsize */
  79          FALSE,                 /* pc_relative */
  80          0,                     /* bitpos */
  81          complain_overflow_unsigned, /* complain_on_overflow */
  82          bfd_elf_generic_reloc, /* special_function */
  83          "R_OR1K_32",           /* name */
  84          FALSE,                 /* partial_inplace */
  85          0,                     /* src_mask */
  86          0xffffffff,            /* dst_mask */
  87          FALSE),                /* pcrel_offset */
  88
  89   HOWTO (R_OR1K_16,
  90          0,                     /* rightshift */
  91          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  92          16,                    /* bitsize */
  93          FALSE,                 /* pc_relative */
  94          0,                     /* bitpos */
  95          complain_overflow_unsigned, /* complain_on_overflow */
  96          bfd_elf_generic_reloc, /* special_function */
  97          "R_OR1K_16",           /* name */
  98          FALSE,                 /* partial_inplace */
  99          0,                     /* src_mask */
 100          0xffff,                /* dst_mask */
 101          FALSE),                /* pcrel_offset */
 102
 103   HOWTO (R_OR1K_8,
 104          0,                     /* rightshift */
 105          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 106          8,                     /* bitsize */
 107          FALSE,                 /* pc_relative */
 108          0,                     /* bitpos */
 109          complain_overflow_unsigned, /* complain_on_overflow */
 110          bfd_elf_generic_reloc, /* special_function */
 111          "R_OR1K_8",            /* name */
 112          FALSE,                 /* partial_inplace */
 113          0,                     /* src_mask */
 114          0xff,                  /* dst_mask */
 115          FALSE),                /* pcrel_offset */
 116
 117   HOWTO (R_OR1K_LO_16_IN_INSN, /* type */
 118          0,                     /* rightshift */
 119          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 120          16,                    /* bitsize */
 121          FALSE,                 /* pc_relative */
 122          0,                     /* bitpos */
 123          complain_overflow_dont, /* complain_on_overflow */
 124          bfd_elf_generic_reloc, /* special_function */
 125          "R_OR1K_LO_16_IN_INSN", /* name */
 126          FALSE,                 /* partial_inplace */
 127          0,                     /* src_mask */
 128          0x0000ffff,            /* dst_mask */
 129          FALSE),                /* pcrel_offset */
 130
 131   HOWTO (R_OR1K_HI_16_IN_INSN, /* type */
 132          16,                    /* rightshift */
 133          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 134          16,                    /* bitsize */
 135          FALSE,                 /* pc_relative */
 136          0,                     /* bitpos */
 137          complain_overflow_dont, /* complain_on_overflow */
 138          bfd_elf_generic_reloc, /* special_function */
 139          "R_OR1K_HI_16_IN_INSN", /* name */
 140          FALSE,                 /* partial_inplace */
 141          0,                     /* src_mask */
 142          0x0000ffff,            /* dst_mask */
 143          FALSE),                /* pcrel_offset */
 144
 145   /* A PC relative 26 bit relocation, right shifted by 2.  */
 146   HOWTO (R_OR1K_INSN_REL_26, /* type */
 147          2,                     /* rightshift */
 148          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 149          26,                    /* bitsize */
 150          TRUE,                  /* pc_relative */
 151          0,                     /* bitpos */
 152          complain_overflow_signed, /* complain_on_overflow */
 153          bfd_elf_generic_reloc, /* special_function */
 154          "R_OR1K_INSN_REL_26", /* name */
 155          FALSE,                 /* partial_inplace */
 156          0,                     /* src_mask */
 157          0x03ffffff,            /* dst_mask */
 158          TRUE),                 /* pcrel_offset */
 159
 160   /* GNU extension to record C++ vtable hierarchy.  */
 161   HOWTO (R_OR1K_GNU_VTINHERIT, /* type */
 162          0,                     /* rightshift */
 163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 164          0,                     /* bitsize */
 165          FALSE,                 /* pc_relative */
 166          0,                     /* bitpos */
 167          complain_overflow_dont, /* complain_on_overflow */
 168          NULL,                  /* special_function */
 169          "R_OR1K_GNU_VTINHERIT", /* name */
 170          FALSE,                 /* partial_inplace */
 171          0,                     /* src_mask */
 172          0,                     /* dst_mask */
 173          FALSE),                /* pcrel_offset */
 174
 175   /* GNU extension to record C++ vtable member usage.  */
 176   HOWTO (R_OR1K_GNU_VTENTRY, /* type */
 177          0,                     /* rightshift */
 178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          0,                     /* bitsize */
 180          FALSE,                 /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_dont, /* complain_on_overflow */
 183          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 184          "R_OR1K_GNU_VTENTRY", /* name */
 185          FALSE,                 /* partial_inplace */
 186          0,                     /* src_mask */
 187          0,                     /* dst_mask */
 188          FALSE),                /* pcrel_offset */
 189
 190   HOWTO (R_OR1K_32_PCREL,
 191          0,                     /* rightshift */
 192          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 193          32,                    /* bitsize */
 194          TRUE,                  /* pc_relative */
 195          0,                     /* bitpos */
 196          complain_overflow_signed, /* complain_on_overflow */
 197          bfd_elf_generic_reloc, /* special_function */
 198          "R_OR1K_32_PCREL",     /* name */
 199          FALSE,                 /* partial_inplace */
 200          0,                     /* src_mask */
 201          0xffffffff,            /* dst_mask */
 202          TRUE),                 /* pcrel_offset */
 203
 204   HOWTO (R_OR1K_16_PCREL,
 205          0,                     /* rightshift */
 206          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 207          16,                    /* bitsize */
 208          TRUE,                  /* pc_relative */
 209          0,                     /* bitpos */
 210          complain_overflow_signed, /* complain_on_overflow */
 211          bfd_elf_generic_reloc, /* special_function */
 212          "R_OR1K_16_PCREL",     /* name */
 213          FALSE,                 /* partial_inplace */
 214          0,                     /* src_mask */
 215          0xffff,                /* dst_mask */
 216          TRUE),                 /* pcrel_offset */
 217
 218   HOWTO (R_OR1K_8_PCREL,
 219          0,                     /* rightshift */
 220          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 221          8,                     /* bitsize */
 222          TRUE,                  /* pc_relative */
 223          0,                     /* bitpos */
 224          complain_overflow_signed, /* complain_on_overflow */
 225          bfd_elf_generic_reloc, /* special_function */
 226          "R_OR1K_8_PCREL",      /* name */
 227          FALSE,                 /* partial_inplace */
 228          0,                     /* src_mask */
 229          0xff,                  /* dst_mask */
 230          TRUE),                 /* pcrel_offset */
 231
 232    HOWTO (R_OR1K_GOTPC_HI16,    /* Type.  */
 233          16,                    /* Rightshift.  */
 234          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 235          16,                    /* Bitsize.  */
 236          TRUE,                  /* PC_relative.  */
 237          0,                     /* Bitpos.  */
 238          complain_overflow_dont, /* Complain on overflow.  */
 239          bfd_elf_generic_reloc, /* Special Function.  */
 240          "R_OR1K_GOTPC_HI16",   /* Name.  */
 241          FALSE,         /* Partial Inplace.  */
 242          0,                     /* Source Mask.  */
 243          0xffff,                /* Dest Mask.  */
 244          TRUE),                 /* PC relative offset?  */
 245
 246    HOWTO (R_OR1K_GOTPC_LO16,    /* Type.  */
 247          0,                     /* Rightshift.  */
 248          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 249          16,                    /* Bitsize.  */
 250          TRUE,                  /* PC_relative.  */
 251          0,                     /* Bitpos.  */
 252          complain_overflow_dont, /* Complain on overflow.  */
 253          bfd_elf_generic_reloc, /* Special Function.  */
 254          "R_OR1K_GOTPC_LO16",   /* Name.  */
 255          FALSE,         /* Partial Inplace.  */
 256          0,                     /* Source Mask.  */
 257          0xffff,                /* Dest Mask.  */
 258          TRUE),                 /* PC relative offset?  */
 259
 260   HOWTO (R_OR1K_GOT16,          /* type */
 261          0,                     /* rightshift */
 262          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 263          16,                    /* bitsize */
 264          FALSE,                 /* pc_relative */
 265          0,                     /* bitpos */
 266          complain_overflow_signed, /* complain_on_overflow */
 267          bfd_elf_generic_reloc, /* special_function */
 268          "R_OR1K_GOT16",        /* name */
 269          FALSE,                 /* partial_inplace */
 270          0,                     /* src_mask */
 271          0xffff,                /* dst_mask */
 272          FALSE),                /* pcrel_offset */
 273
 274   /* A 26 bit PLT relocation.  Shifted by 2.  */
 275   HOWTO (R_OR1K_PLT26,  /* Type.  */
 276          2,                     /* Rightshift.  */
 277          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 278          26,                    /* Bitsize.  */
 279          TRUE,                  /* PC_relative.  */
 280          0,                     /* Bitpos.  */
 281          complain_overflow_dont, /* Complain on overflow.  */
 282          bfd_elf_generic_reloc,/* Special Function.  */
 283          "R_OR1K_PLT26",        /* Name.  */
 284          FALSE,         /* Partial Inplace.  */
 285          0,                     /* Source Mask.  */
 286          0x03ffffff,            /* Dest Mask.  */
 287          TRUE),                 /* PC relative offset?  */
 288
 289   HOWTO (R_OR1K_GOTOFF_HI16,    /* type */
 290          16,                    /* rightshift */
 291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 292          16,                    /* bitsize */
 293          FALSE,                 /* pc_relative */
 294          0,                     /* bitpos */
 295          complain_overflow_dont, /* complain_on_overflow */
 296          bfd_elf_generic_reloc, /* special_function */
 297          "R_OR1K_GOTOFF_HI16",  /* name */
 298          FALSE,                 /* partial_inplace */
 299          0x0,                   /* src_mask */
 300          0xffff,                /* dst_mask */
 301          FALSE),                /* pcrel_offset */
 302
 303   HOWTO (R_OR1K_GOTOFF_LO16,    /* type */
 304          0,                     /* rightshift */
 305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 306          16,                    /* bitsize */
 307          FALSE,                 /* pc_relative */
 308          0,                     /* bitpos */
 309          complain_overflow_dont, /* complain_on_overflow */
 310          bfd_elf_generic_reloc, /* special_function */
 311          "R_OR1K_GOTOFF_LO16",  /* name */
 312          FALSE,                 /* partial_inplace */
 313          0x0,                   /* src_mask */
 314          0xffff,                /* dst_mask */
 315          FALSE),                /* pcrel_offset */
 316
 317   HOWTO (R_OR1K_COPY,           /* type */
 318          0,                     /* rightshift */
 319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 320          32,                    /* bitsize */
 321          FALSE,                 /* pc_relative */
 322          0,                     /* bitpos */
 323          complain_overflow_bitfield, /* complain_on_overflow */
 324          bfd_elf_generic_reloc, /* special_function */
 325          "R_OR1K_COPY",         /* name */
 326          FALSE,                 /* partial_inplace */
 327          0xffffffff,            /* src_mask */
 328          0xffffffff,            /* dst_mask */
 329          FALSE),                /* pcrel_offset */
 330
 331   HOWTO (R_OR1K_GLOB_DAT,       /* type */
 332          0,                     /* rightshift */
 333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 334          32,                    /* bitsize */
 335          FALSE,                 /* pc_relative */
 336          0,                     /* bitpos */
 337          complain_overflow_bitfield, /* complain_on_overflow */
 338          bfd_elf_generic_reloc, /* special_function */
 339          "R_OR1K_GLOB_DAT",     /* name */
 340          FALSE,                 /* partial_inplace */
 341          0xffffffff,            /* src_mask */
 342          0xffffffff,            /* dst_mask */
 343          FALSE),                /* pcrel_offset */
 344
 345   HOWTO (R_OR1K_JMP_SLOT,       /* type */
 346          0,                     /* rightshift */
 347          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 348          32,                    /* bitsize */
 349          FALSE,                 /* pc_relative */
 350          0,                     /* bitpos */
 351          complain_overflow_bitfield, /* complain_on_overflow */
 352          bfd_elf_generic_reloc, /* special_function */
 353          "R_OR1K_JMP_SLOT",     /* name */
 354          FALSE,                 /* partial_inplace */
 355          0xffffffff,            /* src_mask */
 356          0xffffffff,            /* dst_mask */
 357          FALSE),                /* pcrel_offset */
 358
 359   HOWTO (R_OR1K_RELATIVE,       /* type */
 360          0,                     /* rightshift */
 361          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 362          32,                    /* bitsize */
 363          FALSE,                 /* pc_relative */
 364          0,                     /* bitpos */
 365          complain_overflow_bitfield, /* complain_on_overflow */
 366          bfd_elf_generic_reloc, /* special_function */
 367          "R_OR1K_RELATIVE",     /* name */
 368          FALSE,                 /* partial_inplace */
 369          0xffffffff,            /* src_mask */
 370          0xffffffff,            /* dst_mask */
 371          FALSE),                /* pcrel_offset */
 372
 373   HOWTO (R_OR1K_TLS_GD_HI16,    /* type */
 374          16,                    /* rightshift */
 375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 376          16,                    /* bitsize */
 377          FALSE,                 /* pc_relative */
 378          0,                     /* bitpos */
 379          complain_overflow_dont, /* complain_on_overflow */
 380          bfd_elf_generic_reloc, /* special_function */
 381          "R_OR1K_TLS_GD_HI16",  /* name */
 382          FALSE,                 /* partial_inplace */
 383          0x0,                   /* src_mask */
 384          0xffff,                /* dst_mask */
 385          FALSE),                /* pcrel_offset */
 386
 387   HOWTO (R_OR1K_TLS_GD_LO16,    /* type */
 388          0,                     /* rightshift */
 389          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 390          16,                    /* bitsize */
 391          FALSE,                 /* pc_relative */
 392          0,                     /* bitpos */
 393          complain_overflow_dont, /* complain_on_overflow */
 394          bfd_elf_generic_reloc, /* special_function */
 395          "R_OR1K_TLS_GD_LO16",  /* name */
 396          FALSE,                 /* partial_inplace */
 397          0x0,                   /* src_mask */
 398          0xffff,                /* dst_mask */
 399          FALSE),                /* pcrel_offset */
 400
 401   HOWTO (R_OR1K_TLS_LDM_HI16,   /* type */
 402          16,                    /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                    /* bitsize */
 405          FALSE,                 /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_dont, /* complain_on_overflow */
 408          bfd_elf_generic_reloc, /* special_function */
 409          "R_OR1K_TLS_LDM_HI16", /* name */
 410          FALSE,                 /* partial_inplace */
 411          0x0,                   /* src_mask */
 412          0xffff,                /* dst_mask */
 413          FALSE),                /* pcrel_offset */
 414
 415   HOWTO (R_OR1K_TLS_LDM_LO16,   /* type */
 416          0,                     /* rightshift */
 417          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 418          16,                    /* bitsize */
 419          FALSE,                 /* pc_relative */
 420          0,                     /* bitpos */
 421          complain_overflow_dont, /* complain_on_overflow */
 422          bfd_elf_generic_reloc, /* special_function */
 423          "R_OR1K_TLS_LDM_LO16", /* name */
 424          FALSE,                 /* partial_inplace */
 425          0x0,                   /* src_mask */
 426          0xffff,                /* dst_mask */
 427          FALSE),                /* pcrel_offset */
 428
 429   HOWTO (R_OR1K_TLS_LDO_HI16,   /* type */
 430          16,                    /* rightshift */
 431          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 432          16,                    /* bitsize */
 433          FALSE,                 /* pc_relative */
 434          0,                     /* bitpos */
 435          complain_overflow_dont, /* complain_on_overflow */
 436          bfd_elf_generic_reloc, /* special_function */
 437          "R_OR1K_TLS_LDO_HI16", /* name */
 438          FALSE,                 /* partial_inplace */
 439          0x0,                   /* src_mask */
 440          0xffff,                /* dst_mask */
 441          FALSE),                /* pcrel_offset */
 442
 443   HOWTO (R_OR1K_TLS_LDO_LO16,   /* type */
 444          0,                     /* rightshift */
 445          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          16,                    /* bitsize */
 447          FALSE,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_dont, /* complain_on_overflow */
 450          bfd_elf_generic_reloc, /* special_function */
 451          "R_OR1K_TLS_LDO_LO16", /* name */
 452          FALSE,                 /* partial_inplace */
 453          0x0,                   /* src_mask */
 454          0xffff,                /* dst_mask */
 455          FALSE),                /* pcrel_offset */
 456
 457   HOWTO (R_OR1K_TLS_IE_HI16,    /* type */
 458          16,                    /* rightshift */
 459          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          16,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_dont, /* complain_on_overflow */
 464          bfd_elf_generic_reloc, /* special_function */
 465          "R_OR1K_TLS_IE_HI16",  /* name */
 466          FALSE,                 /* partial_inplace */
 467          0x0,                   /* src_mask */
 468          0xffff,                /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   HOWTO (R_OR1K_TLS_IE_LO16,    /* type */
 472          0,                     /* rightshift */
 473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 474          16,                    /* bitsize */
 475          FALSE,                 /* pc_relative */
 476          0,                     /* bitpos */
 477          complain_overflow_dont, /* complain_on_overflow */
 478          bfd_elf_generic_reloc, /* special_function */
 479          "R_OR1K_TLS_IE_LO16",  /* name */
 480          FALSE,                 /* partial_inplace */
 481          0x0,                   /* src_mask */
 482          0xffff,                /* dst_mask */
 483          FALSE),                /* pcrel_offset */
 484
 485   HOWTO (R_OR1K_TLS_LE_HI16,    /* type */
 486          16,                    /* rightshift */
 487          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          16,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          bfd_elf_generic_reloc, /* special_function */
 493          "R_OR1K_TLS_LE_HI16",  /* name */
 494          FALSE,                 /* partial_inplace */
 495          0x0,                   /* src_mask */
 496          0xffff,                /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499   HOWTO (R_OR1K_TLS_LE_LO16,    /* type */
 500          0,                     /* rightshift */
 501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          16,                    /* bitsize */
 503          FALSE,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_dont, /* complain_on_overflow */
 506          bfd_elf_generic_reloc, /* special_function */
 507          "R_OR1K_TLS_LE_LO16",  /* name */
 508          FALSE,                 /* partial_inplace */
 509          0x0,                   /* src_mask */
 510          0xffff,                /* dst_mask */
 511          FALSE),                /* pcrel_offset */
 512
 513 };
 514
 515 /* Map BFD reloc types to Or1k ELF reloc types.  */
 516
 517 struct or1k_reloc_map
 518 {
 519   bfd_reloc_code_real_type bfd_reloc_val;
 520   unsigned int or1k_reloc_val;
 521 };
 522
 523 static const struct or1k_reloc_map or1k_reloc_map[] =
 524 {
 525   { BFD_RELOC_NONE,             R_OR1K_NONE },
 526   { BFD_RELOC_32,               R_OR1K_32 },
 527   { BFD_RELOC_16,               R_OR1K_16 },
 528   { BFD_RELOC_8,                R_OR1K_8 },
 529   { BFD_RELOC_LO16,             R_OR1K_LO_16_IN_INSN },
 530   { BFD_RELOC_HI16,             R_OR1K_HI_16_IN_INSN },
 531   { BFD_RELOC_OR1K_REL_26,      R_OR1K_INSN_REL_26 },
 532   { BFD_RELOC_VTABLE_ENTRY,     R_OR1K_GNU_VTENTRY },
 533   { BFD_RELOC_VTABLE_INHERIT,   R_OR1K_GNU_VTINHERIT },
 534   { BFD_RELOC_32_PCREL,         R_OR1K_32_PCREL },
 535   { BFD_RELOC_16_PCREL,         R_OR1K_16_PCREL },
 536   { BFD_RELOC_8_PCREL,          R_OR1K_8_PCREL },
 537   { BFD_RELOC_OR1K_GOTPC_HI16,  R_OR1K_GOTPC_HI16 },
 538   { BFD_RELOC_OR1K_GOTPC_LO16,  R_OR1K_GOTPC_LO16 },
 539   { BFD_RELOC_OR1K_GOT16,       R_OR1K_GOT16 },
 540   { BFD_RELOC_OR1K_PLT26,       R_OR1K_PLT26 },
 541   { BFD_RELOC_OR1K_GOTOFF_HI16, R_OR1K_GOTOFF_HI16 },
 542   { BFD_RELOC_OR1K_GOTOFF_LO16, R_OR1K_GOTOFF_LO16 },
 543   { BFD_RELOC_OR1K_GLOB_DAT,    R_OR1K_GLOB_DAT },
 544   { BFD_RELOC_OR1K_COPY,        R_OR1K_COPY },
 545   { BFD_RELOC_OR1K_JMP_SLOT,    R_OR1K_JMP_SLOT },
 546   { BFD_RELOC_OR1K_RELATIVE,    R_OR1K_RELATIVE },
 547   { BFD_RELOC_OR1K_TLS_GD_HI16, R_OR1K_TLS_GD_HI16 },
 548   { BFD_RELOC_OR1K_TLS_GD_LO16, R_OR1K_TLS_GD_LO16 },
 549   { BFD_RELOC_OR1K_TLS_LDM_HI16,        R_OR1K_TLS_LDM_HI16 },
 550   { BFD_RELOC_OR1K_TLS_LDM_LO16,        R_OR1K_TLS_LDM_LO16 },
 551   { BFD_RELOC_OR1K_TLS_LDO_HI16,        R_OR1K_TLS_LDO_HI16 },
 552   { BFD_RELOC_OR1K_TLS_LDO_LO16,        R_OR1K_TLS_LDO_LO16 },
 553   { BFD_RELOC_OR1K_TLS_IE_HI16, R_OR1K_TLS_IE_HI16 },
 554   { BFD_RELOC_OR1K_TLS_IE_LO16, R_OR1K_TLS_IE_LO16 },
 555   { BFD_RELOC_OR1K_TLS_LE_HI16, R_OR1K_TLS_LE_HI16 },
 556   { BFD_RELOC_OR1K_TLS_LE_LO16, R_OR1K_TLS_LE_LO16 },
 557 };
 558
 559 /* The linker needs to keep track of the number of relocs that it
 560    decides to copy as dynamic relocs in check_relocs for each symbol.
 561    This is so that it can later discard them if they are found to be
 562    unnecessary.  We store the information in a field extending the
 563    regular ELF linker hash table.  */
 564
 565 struct elf_or1k_dyn_relocs
 566 {
 567   struct elf_or1k_dyn_relocs *next;
 568
 569   /* The input section of the reloc.  */
 570   asection *sec;
 571
 572   /* Total number of relocs copied for the input section.  */
 573   bfd_size_type count;
 574
 575   /* Number of pc-relative relocs copied for the input section.  */
 576   bfd_size_type pc_count;
 577 };
 578
 579 #define TLS_UNKNOWN    0
 580 #define TLS_NONE       1
 581 #define TLS_GD         2
 582 #define TLS_LD         3
 583 #define TLS_IE         4
 584 #define TLS_LE         5
 585
 586 /* ELF linker hash entry.  */
 587 struct elf_or1k_link_hash_entry
 588 {
 589   struct elf_link_hash_entry root;
 590
 591   /* Track dynamic relocs copied for this symbol.  */
 592   struct elf_or1k_dyn_relocs *dyn_relocs;
 593
 594   /* Track type of TLS access.  */
 595   unsigned char tls_type;
 596 };
 597
 598 /* ELF object data.  */
 599 struct elf_or1k_obj_tdata
 600 {
 601   struct elf_obj_tdata root;
 602
 603   /* tls_type for each local got entry.  */
 604   unsigned char *local_tls_type;
 605 };
 606
 607 #define elf_or1k_tdata(abfd) \
 608   ((struct elf_or1k_obj_tdata *) (abfd)->tdata.any)
 609
 610 #define elf_or1k_local_tls_type(abfd) \
 611   (elf_or1k_tdata (abfd)->local_tls_type)
 612
 613 /* ELF linker hash table.  */
 614 struct elf_or1k_link_hash_table
 615 {
 616   struct elf_link_hash_table root;
 617
 618   /* Short-cuts to get to dynamic linker sections.  */
 619   asection *sgot;
 620   asection *sgotplt;
 621   asection *srelgot;
 622   asection *splt;
 623   asection *srelplt;
 624   asection *sdynbss;
 625   asection *srelbss;
 626
 627   /* Small local sym to section mapping cache.  */
 628   struct sym_cache sym_sec;
 629 };
 630
 631 /* Get the ELF linker hash table from a link_info structure.  */
 632 #define or1k_elf_hash_table(p) \
 633   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 634    == OR1K_ELF_DATA ? ((struct elf_or1k_link_hash_table *) ((p)->hash)) : NULL)
 635
 636 static bfd_boolean
 637 elf_or1k_mkobject (bfd *abfd)
 638 {
 639   return bfd_elf_allocate_object (abfd, sizeof (struct elf_or1k_obj_tdata),
 640                                   OR1K_ELF_DATA);
 641 }
 642
 643 /* Create an entry in an or1k ELF linker hash table.  */
 644
 645 static struct bfd_hash_entry *
 646 or1k_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 647                             struct bfd_hash_table *table,
 648                             const char *string)
 649 {
 650   struct elf_or1k_link_hash_entry *ret =
 651     (struct elf_or1k_link_hash_entry *) entry;
 652
 653   /* Allocate the structure if it has not already been allocated by a
 654      subclass.  */
 655   if (ret == NULL)
 656     ret = bfd_hash_allocate (table,
 657                              sizeof (struct elf_or1k_link_hash_entry));
 658   if (ret == NULL)
 659     return NULL;
 660
 661   /* Call the allocation method of the superclass.  */
 662   ret = ((struct elf_or1k_link_hash_entry *)
 663          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 664                                      table, string));
 665   if (ret != NULL)
 666     {
 667       struct elf_or1k_link_hash_entry *eh;
 668
 669       eh = (struct elf_or1k_link_hash_entry *) ret;
 670       eh->dyn_relocs = NULL;
 671       eh->tls_type = TLS_UNKNOWN;
 672     }
 673
 674   return (struct bfd_hash_entry *) ret;
 675 }
 676
 677 /* Create an or1k ELF linker hash table.  */
 678
 679 static struct bfd_link_hash_table *
 680 or1k_elf_link_hash_table_create (bfd *abfd)
 681 {
 682   struct elf_or1k_link_hash_table *ret;
 683   bfd_size_type amt = sizeof (struct elf_or1k_link_hash_table);
 684
 685   ret = bfd_zmalloc (amt);
 686   if (ret == NULL)
 687     return NULL;
 688
 689   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 690                                       or1k_elf_link_hash_newfunc,
 691                                       sizeof (struct elf_or1k_link_hash_entry),
 692                                       OR1K_ELF_DATA))
 693     {
 694       free (ret);
 695       return NULL;
 696     }
 697
 698   return &ret->root.root;
 699 }
 700
 701 static reloc_howto_type *
 702 or1k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 703                         bfd_reloc_code_real_type code)
 704 {
 705   unsigned int i;
 706
 707   for (i = ARRAY_SIZE (or1k_reloc_map); i--;)
 708     if (or1k_reloc_map[i].bfd_reloc_val == code)
 709       return & or1k_elf_howto_table[or1k_reloc_map[i].or1k_reloc_val];
 710
 711   return NULL;
 712 }
 713
 714 static reloc_howto_type *
 715 or1k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 716                         const char *r_name)
 717 {
 718   unsigned int i;
 719
 720   for (i = 0;
 721        i < (sizeof (or1k_elf_howto_table)
 722             / sizeof (or1k_elf_howto_table[0]));
 723        i++)
 724     if (or1k_elf_howto_table[i].name != NULL
 725         && strcasecmp (or1k_elf_howto_table[i].name, r_name) == 0)
 726       return &or1k_elf_howto_table[i];
 727
 728   return NULL;
 729 }
 730
 731 /* Set the howto pointer for an Or1k ELF reloc.  */
 732
 733 static void
 734 or1k_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
 735                          arelent * cache_ptr,
 736                          Elf_Internal_Rela * dst)
 737 {
 738   unsigned int r_type;
 739
 740   r_type = ELF32_R_TYPE (dst->r_info);
 741   if (r_type >= (unsigned int) R_OR1K_max)
 742     {
 743       _bfd_error_handler (_("%B: invalid OR1K reloc number: %d"), abfd, r_type);
 744       r_type = 0;
 745     }
 746   cache_ptr->howto = & or1k_elf_howto_table[r_type];
 747 }
 748
 749
 750 /* Return the relocation value for @tpoff relocations..  */
 751 static bfd_vma
 752 tpoff (struct bfd_link_info *info, bfd_vma address)
 753 {
 754   /* If tls_sec is NULL, we should have signalled an error already.  */
 755   if (elf_hash_table (info)->tls_sec == NULL)
 756     return 0;
 757
 758   /* The thread pointer on or1k stores the address after the TCB where
 759      the data is, just compute the difference. No need to compensate
 760      for the size of TCB.  */
 761   return (address - elf_hash_table (info)->tls_sec->vma);
 762 }
 763
 764 /* Relocate an Or1k ELF section.
 765
 766    The RELOCATE_SECTION function is called by the new ELF backend linker
 767    to handle the relocations for a section.
 768
 769    The relocs are always passed as Rela structures; if the section
 770    actually uses Rel structures, the r_addend field will always be
 771    zero.
 772
 773    This function is responsible for adjusting the section contents as
 774    necessary, and (if using Rela relocs and generating a relocatable
 775    output file) adjusting the reloc addend as necessary.
 776
 777    This function does not have to worry about setting the reloc
 778    address or the reloc symbol index.
 779
 780    LOCAL_SYMS is a pointer to the swapped in local symbols.
 781
 782    LOCAL_SECTIONS is an array giving the section in the input file
 783    corresponding to the st_shndx field of each local symbol.
 784
 785    The global hash table entry for the global symbols can be found
 786    via elf_sym_hashes (input_bfd).
 787
 788    When generating relocatable output, this function must handle
 789    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 790    going to be the section symbol corresponding to the output
 791    section, which means that the addend must be adjusted
 792    accordingly.  */
 793
 794 static bfd_boolean
 795 or1k_elf_relocate_section (bfd *output_bfd,
 796                            struct bfd_link_info *info,
 797                            bfd *input_bfd,
 798                            asection *input_section,
 799                            bfd_byte *contents,
 800                            Elf_Internal_Rela *relocs,
 801                            Elf_Internal_Sym *local_syms,
 802                            asection **local_sections)
 803 {
 804   Elf_Internal_Shdr *symtab_hdr;
 805   struct elf_link_hash_entry **sym_hashes;
 806   Elf_Internal_Rela *rel;
 807   Elf_Internal_Rela *relend;
 808   struct elf_or1k_link_hash_table *htab = or1k_elf_hash_table (info);
 809   bfd *dynobj;
 810   asection *sreloc;
 811   bfd_vma *local_got_offsets;
 812   asection *sgot;
 813
 814   if (htab == NULL)
 815     return FALSE;
 816
 817   dynobj = htab->root.dynobj;
 818   local_got_offsets = elf_local_got_offsets (input_bfd);
 819
 820   sreloc = elf_section_data (input_section)->sreloc;
 821
 822   sgot = htab->sgot;
 823
 824   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 825   sym_hashes = elf_sym_hashes (input_bfd);
 826   relend = relocs + input_section->reloc_count;
 827
 828   for (rel = relocs; rel < relend; rel++)
 829     {
 830       reloc_howto_type *howto;
 831       unsigned long r_symndx;
 832       Elf_Internal_Sym *sym;
 833       asection *sec;
 834       struct elf_link_hash_entry *h;
 835       bfd_vma relocation;
 836       bfd_reloc_status_type r;
 837       const char *name = NULL;
 838       int r_type;
 839
 840       r_type = ELF32_R_TYPE (rel->r_info);
 841       r_symndx = ELF32_R_SYM (rel->r_info);
 842
 843       if (r_type == R_OR1K_GNU_VTINHERIT
 844           || r_type == R_OR1K_GNU_VTENTRY)
 845         continue;
 846
 847       if (r_type < 0 || r_type >= (int) R_OR1K_max)
 848         {
 849           bfd_set_error (bfd_error_bad_value);
 850           return FALSE;
 851         }
 852
 853       howto = or1k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 854       h = NULL;
 855       sym = NULL;
 856       sec = NULL;
 857
 858       if (r_symndx < symtab_hdr->sh_info)
 859         {
 860           sym = local_syms + r_symndx;
 861           sec = local_sections[r_symndx];
 862           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 863
 864           name = bfd_elf_string_from_elf_section
 865             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 866           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 867         }
 868       else
 869         {
 870           bfd_boolean unresolved_reloc, warned, ignored;
 871
 872           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 873                                    r_symndx, symtab_hdr, sym_hashes,
 874                                    h, sec, relocation,
 875                                    unresolved_reloc, warned, ignored);
 876         }
 877
 878       if (sec != NULL && discarded_section (sec))
 879         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 880                                          rel, 1, relend, howto, 0, contents);
 881
 882       if (bfd_link_relocatable (info))
 883         continue;
 884
 885       switch (howto->type)
 886         {
 887         case R_OR1K_PLT26:
 888           {
 889             if (htab->splt != NULL && h != NULL
 890                 && h->plt.offset != (bfd_vma) -1)
 891               {
 892                 relocation = (htab->splt->output_section->vma
 893                               + htab->splt->output_offset
 894                               + h->plt.offset);
 895               }
 896             break;
 897           }
 898
 899         case R_OR1K_GOT16:
 900           /* Relocation is to the entry for this symbol in the global
 901              offset table.  */
 902           BFD_ASSERT (sgot != NULL);
 903           if (h != NULL)
 904             {
 905               bfd_boolean dyn;
 906               bfd_vma off;
 907
 908               off = h->got.offset;
 909               BFD_ASSERT (off != (bfd_vma) -1);
 910
 911               dyn = htab->root.dynamic_sections_created;
 912               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
 913                                                      bfd_link_pic (info),
 914                                                      h)
 915                   || (bfd_link_pic (info)
 916                       && SYMBOL_REFERENCES_LOCAL (info, h)))
 917                 {
 918                   /* This is actually a static link, or it is a
 919                      -Bsymbolic link and the symbol is defined
 920                      locally, or the symbol was forced to be local
 921                      because of a version file.  We must initialize
 922                      this entry in the global offset table.  Since the
 923                      offset must always be a multiple of 4, we use the
 924                      least significant bit to record whether we have
 925                      initialized it already.
 926
 927                      When doing a dynamic link, we create a .rela.got
 928                      relocation entry to initialize the value.  This
 929                      is done in the finish_dynamic_symbol routine.  */
 930                   if ((off & 1) != 0)
 931                     off &= ~1;
 932                   else
 933                     {
 934                       /* Write entry in GOT.  */
 935                       bfd_put_32 (output_bfd, relocation,
 936                                   sgot->contents + off);
 937                       /* Mark GOT entry as having been written.  */
 938                       h->got.offset |= 1;
 939                     }
 940                 }
 941
 942               relocation = sgot->output_offset + off;
 943             }
 944           else
 945             {
 946               bfd_vma off;
 947               bfd_byte *loc;
 948
 949               BFD_ASSERT (local_got_offsets != NULL
 950                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
 951
 952               /* Get offset into GOT table.  */
 953               off = local_got_offsets[r_symndx];
 954
 955               /* The offset must always be a multiple of 4.  We use
 956                  the least significant bit to record whether we have
 957                  already processed this entry.  */
 958               if ((off & 1) != 0)
 959                 off &= ~1;
 960               else
 961                 {
 962                   /* Write entry in GOT.  */
 963                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
 964                   if (bfd_link_pic (info))
 965                     {
 966                       asection *srelgot;
 967                       Elf_Internal_Rela outrel;
 968
 969                       /* We need to generate a R_OR1K_RELATIVE reloc
 970                          for the dynamic linker.  */
 971                       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 972                       BFD_ASSERT (srelgot != NULL);
 973
 974                       outrel.r_offset = (sgot->output_section->vma
 975                                          + sgot->output_offset
 976                                          + off);
 977                       outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
 978                       outrel.r_addend = relocation;
 979                       loc = srelgot->contents;
 980                       loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
 981                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
 982                       ++srelgot->reloc_count;
 983                     }
 984
 985                   local_got_offsets[r_symndx] |= 1;
 986                 }
 987               relocation = sgot->output_offset + off;
 988             }
 989
 990           /* Addend should be zero.  */
 991           if (rel->r_addend != 0)
 992             (*_bfd_error_handler)
 993               (_("internal error: addend should be zero for R_OR1K_GOT16"));
 994
 995           break;
 996
 997         case R_OR1K_GOTOFF_LO16:
 998         case R_OR1K_GOTOFF_HI16:
 999           /* Relocation is offset from GOT.  */
1000           BFD_ASSERT (sgot != NULL);
1001           relocation
1002             -= (htab->root.hgot->root.u.def.value
1003                 + htab->root.hgot->root.u.def.section->output_offset
1004                 + htab->root.hgot->root.u.def.section->output_section->vma);
1005           break;
1006
1007         case R_OR1K_INSN_REL_26:
1008         case R_OR1K_HI_16_IN_INSN:
1009         case R_OR1K_LO_16_IN_INSN:
1010         case R_OR1K_32:
1011           /* R_OR1K_16? */
1012           {
1013             /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
1014                from removed linkonce sections, or sections discarded by
1015                a linker script.  */
1016             if (r_symndx == STN_UNDEF
1017                 || (input_section->flags & SEC_ALLOC) == 0)
1018               break;
1019
1020             if ((bfd_link_pic (info)
1021                  && (h == NULL
1022                      || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1023                      || h->root.type != bfd_link_hash_undefweak)
1024                  && (howto->type != R_OR1K_INSN_REL_26
1025                      || !SYMBOL_CALLS_LOCAL (info, h)))
1026                 || (!bfd_link_pic (info)
1027                     && h != NULL
1028                     && h->dynindx != -1
1029                     && !h->non_got_ref
1030                     && ((h->def_dynamic
1031                          && !h->def_regular)
1032                         || h->root.type == bfd_link_hash_undefweak
1033                         || h->root.type == bfd_link_hash_undefined)))
1034               {
1035                 Elf_Internal_Rela outrel;
1036                 bfd_byte *loc;
1037                 bfd_boolean skip;
1038
1039                 /* When generating a shared object, these relocations
1040                    are copied into the output file to be resolved at run
1041                    time.  */
1042
1043                 BFD_ASSERT (sreloc != NULL);
1044
1045                 skip = FALSE;
1046
1047                 outrel.r_offset =
1048                   _bfd_elf_section_offset (output_bfd, info, input_section,
1049                                            rel->r_offset);
1050                 if (outrel.r_offset == (bfd_vma) -1)
1051                   skip = TRUE;
1052                 else if (outrel.r_offset == (bfd_vma) -2)
1053                   skip = TRUE;
1054                 outrel.r_offset += (input_section->output_section->vma
1055                                     + input_section->output_offset);
1056
1057                 if (skip)
1058                   memset (&outrel, 0, sizeof outrel);
1059                 /* h->dynindx may be -1 if the symbol was marked to
1060                    become local.  */
1061                 else if (h != NULL
1062                          && ((! info->symbolic && h->dynindx != -1)
1063                              || !h->def_regular))
1064                   {
1065                     BFD_ASSERT (h->dynindx != -1);
1066                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1067                     outrel.r_addend = rel->r_addend;
1068                   }
1069                 else
1070                   {
1071                     if (r_type == R_OR1K_32)
1072                       {
1073                         outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1074                         outrel.r_addend = relocation + rel->r_addend;
1075                       }
1076                     else
1077                       {
1078                         BFD_FAIL ();
1079                         (*_bfd_error_handler)
1080                           (_("%B: probably compiled without -fPIC?"),
1081                            input_bfd);
1082                         bfd_set_error (bfd_error_bad_value);
1083                         return FALSE;
1084                       }
1085                   }
1086
1087                 loc = sreloc->contents;
1088                 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1089                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1090                 break;
1091               }
1092             break;
1093           }
1094
1095         case R_OR1K_TLS_LDM_HI16:
1096         case R_OR1K_TLS_LDM_LO16:
1097         case R_OR1K_TLS_LDO_HI16:
1098         case R_OR1K_TLS_LDO_LO16:
1099           /* TODO: implement support for local dynamic.  */
1100           BFD_FAIL ();
1101           (*_bfd_error_handler)
1102             (_("%B: support for local dynamic not implemented"),
1103              input_bfd);
1104           bfd_set_error (bfd_error_bad_value);
1105           return FALSE;
1106
1107
1108         case R_OR1K_TLS_GD_HI16:
1109         case R_OR1K_TLS_GD_LO16:
1110         case R_OR1K_TLS_IE_HI16:
1111         case R_OR1K_TLS_IE_LO16:
1112           {
1113             bfd_vma gotoff;
1114             Elf_Internal_Rela rela;
1115             bfd_byte *loc;
1116             int dynamic;
1117
1118             sreloc = bfd_get_section_by_name (dynobj, ".rela.got");
1119
1120             /* Mark as TLS related GOT entry by setting
1121                bit 2 as well as bit 1.  */
1122             if (h != NULL)
1123               {
1124                 gotoff = h->got.offset;
1125                 h->got.offset |= 3;
1126               }
1127             else
1128               {
1129                 gotoff = local_got_offsets[r_symndx];
1130                 local_got_offsets[r_symndx] |= 3;
1131               }
1132
1133             /* Only process the relocation once.  */
1134             if (gotoff & 1)
1135               {
1136                 relocation = sgot->output_offset + (gotoff  & ~3);
1137                 break;
1138               }
1139
1140             BFD_ASSERT (elf_hash_table (info)->hgot == NULL
1141                         || elf_hash_table (info)->hgot->root.u.def.value == 0);
1142
1143             /* Dynamic entries will require relocations. if we do not need
1144                them we will just use the default R_OR1K_NONE and
1145                not set anything.  */
1146             dynamic = bfd_link_pic (info)
1147               || (sec && (sec->flags & SEC_ALLOC) != 0
1148                   && h != NULL
1149                   && (h->root.type == bfd_link_hash_defweak || !h->def_regular));
1150
1151             /* Shared GD.  */
1152             if (dynamic && (howto->type == R_OR1K_TLS_GD_HI16
1153                             || howto->type == R_OR1K_TLS_GD_LO16))
1154               {
1155                 int i;
1156
1157                 /* Add DTPMOD and DTPOFF GOT and rela entries.  */
1158                 for (i = 0; i < 2; ++i)
1159                   {
1160                     rela.r_offset = sgot->output_section->vma +
1161                       sgot->output_offset + gotoff + i*4;
1162                     if (h != NULL && h->dynindx != -1)
1163                       {
1164                         rela.r_info = ELF32_R_INFO (h->dynindx,
1165                             (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1166                         rela.r_addend = 0;
1167                       }
1168                     else
1169                       {
1170                         rela.r_info = ELF32_R_INFO (0,
1171                             (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1172                         rela.r_addend = tpoff (info, relocation);
1173                       }
1174
1175                     loc = sreloc->contents;
1176                     loc += sreloc->reloc_count++ *
1177                       sizeof (Elf32_External_Rela);
1178
1179                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1180                     bfd_put_32 (output_bfd, 0, sgot->contents + gotoff + i*4);
1181                   }
1182               }
1183             /* Static GD.  */
1184             else if (howto->type == R_OR1K_TLS_GD_HI16
1185                      || howto->type == R_OR1K_TLS_GD_LO16)
1186               {
1187                 bfd_put_32 (output_bfd, 1, sgot->contents + gotoff);
1188                 bfd_put_32 (output_bfd, tpoff (info, relocation),
1189                     sgot->contents + gotoff + 4);
1190               }
1191             /* Shared IE.  */
1192             else if (dynamic)
1193               {
1194                 /* Add TPOFF GOT and rela entries.  */
1195                 rela.r_offset = sgot->output_section->vma +
1196                   sgot->output_offset + gotoff;
1197                 if (h != NULL && h->dynindx != -1)
1198                   {
1199                     rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_TLS_TPOFF);
1200                     rela.r_addend = 0;
1201                   }
1202                 else
1203                   {
1204                     rela.r_info = ELF32_R_INFO (0, R_OR1K_TLS_TPOFF);
1205                     rela.r_addend = tpoff (info, relocation);
1206                   }
1207
1208                 loc = sreloc->contents;
1209                 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1210
1211                 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1212                 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff);
1213               }
1214             /* Static IE.  */
1215             else
1216               {
1217                 bfd_put_32 (output_bfd, tpoff (info, relocation),
1218                             sgot->contents + gotoff);
1219               }
1220             relocation = sgot->output_offset + gotoff;
1221             break;
1222           }
1223         case R_OR1K_TLS_LE_HI16:
1224         case R_OR1K_TLS_LE_LO16:
1225
1226           /* Relocation is offset from TP.  */
1227           relocation = tpoff (info, relocation);
1228           break;
1229
1230         case R_OR1K_TLS_DTPMOD:
1231         case R_OR1K_TLS_DTPOFF:
1232         case R_OR1K_TLS_TPOFF:
1233           /* These are resolved dynamically on load and shouldn't
1234              be used as linker input.  */
1235           BFD_FAIL ();
1236           (*_bfd_error_handler)
1237             (_("%B: will not resolve runtime TLS relocation"),
1238              input_bfd);
1239           bfd_set_error (bfd_error_bad_value);
1240           return FALSE;
1241
1242         default:
1243           break;
1244         }
1245       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1246                                     rel->r_offset, relocation, rel->r_addend);
1247
1248       if (r != bfd_reloc_ok)
1249         {
1250           const char *msg = NULL;
1251
1252           switch (r)
1253             {
1254             case bfd_reloc_overflow:
1255               (*info->callbacks->reloc_overflow)
1256                 (info, (h ? &h->root : NULL), name, howto->name,
1257                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1258               break;
1259
1260             case bfd_reloc_undefined:
1261               (*info->callbacks->undefined_symbol)
1262                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1263               break;
1264
1265             case bfd_reloc_outofrange:
1266               msg = _("internal error: out of range error");
1267               break;
1268
1269             case bfd_reloc_notsupported:
1270               msg = _("internal error: unsupported relocation error");
1271               break;
1272
1273             case bfd_reloc_dangerous:
1274               msg = _("internal error: dangerous relocation");
1275               break;
1276
1277             default:
1278               msg = _("internal error: unknown error");
1279               break;
1280             }
1281
1282           if (msg)
1283             (*info->callbacks->warning) (info, msg, name, input_bfd,
1284                                          input_section, rel->r_offset);
1285         }
1286     }
1287
1288   return TRUE;
1289 }
1290
1291 /* Return the section that should be marked against GC for a given
1292    relocation.  */
1293
1294 static asection *
1295 or1k_elf_gc_mark_hook (asection *sec,
1296                        struct bfd_link_info *info,
1297                        Elf_Internal_Rela *rel,
1298                        struct elf_link_hash_entry *h,
1299                        Elf_Internal_Sym *sym)
1300 {
1301   if (h != NULL)
1302     switch (ELF32_R_TYPE (rel->r_info))
1303       {
1304       case R_OR1K_GNU_VTINHERIT:
1305       case R_OR1K_GNU_VTENTRY:
1306         return NULL;
1307       }
1308
1309   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1310 }
1311
1312 static bfd_boolean
1313 or1k_elf_gc_sweep_hook (bfd *abfd,
1314                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1315                         asection *sec,
1316                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1317 {
1318   /* Update the got entry reference counts for the section being removed.  */
1319   Elf_Internal_Shdr *symtab_hdr;
1320   struct elf_link_hash_entry **sym_hashes;
1321   bfd_signed_vma *local_got_refcounts;
1322   const Elf_Internal_Rela *rel, *relend;
1323
1324   elf_section_data (sec)->local_dynrel = NULL;
1325
1326   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1327   sym_hashes = elf_sym_hashes (abfd);
1328   local_got_refcounts = elf_local_got_refcounts (abfd);
1329
1330   relend = relocs + sec->reloc_count;
1331   for (rel = relocs; rel < relend; rel++)
1332     {
1333       unsigned long r_symndx;
1334       struct elf_link_hash_entry *h = NULL;
1335
1336       r_symndx = ELF32_R_SYM (rel->r_info);
1337       if (r_symndx >= symtab_hdr->sh_info)
1338         {
1339           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1340           while (h->root.type == bfd_link_hash_indirect
1341                  || h->root.type == bfd_link_hash_warning)
1342             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1343         }
1344
1345       switch (ELF32_R_TYPE (rel->r_info))
1346         {
1347         case R_OR1K_GOT16:
1348           if (h != NULL)
1349             {
1350               if (h->got.refcount > 0)
1351                 h->got.refcount--;
1352             }
1353           else
1354             {
1355               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1356                 local_got_refcounts[r_symndx]--;
1357             }
1358           break;
1359
1360         default:
1361           break;
1362         }
1363     }
1364   return TRUE;
1365 }
1366
1367 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1368    shortcuts to them in our hash table.  */
1369
1370 static bfd_boolean
1371 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1372 {
1373   struct elf_or1k_link_hash_table *htab;
1374   asection *s;
1375
1376   /* This function may be called more than once.  */
1377   s = bfd_get_section_by_name (dynobj, ".got");
1378   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
1379     return TRUE;
1380
1381   htab = or1k_elf_hash_table (info);
1382   if (htab == NULL)
1383     return FALSE;
1384
1385   if (! _bfd_elf_create_got_section (dynobj, info))
1386     return FALSE;
1387
1388   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1389   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1390   htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1391
1392   if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1393     abort ();
1394
1395   if (! bfd_set_section_flags (dynobj, htab->srelgot, SEC_ALLOC
1396                                | SEC_LOAD
1397                                | SEC_HAS_CONTENTS
1398                                | SEC_IN_MEMORY
1399                                | SEC_LINKER_CREATED
1400                                | SEC_READONLY)
1401       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1402     return FALSE;
1403
1404   return TRUE;
1405 }
1406
1407 /* Look through the relocs for a section during the first phase.  */
1408
1409 static bfd_boolean
1410 or1k_elf_check_relocs (bfd *abfd,
1411                        struct bfd_link_info *info,
1412                        asection *sec,
1413                        const Elf_Internal_Rela *relocs)
1414 {
1415   Elf_Internal_Shdr *symtab_hdr;
1416   struct elf_link_hash_entry **sym_hashes;
1417   const Elf_Internal_Rela *rel;
1418
1419   const Elf_Internal_Rela *rel_end;
1420   struct elf_or1k_link_hash_table *htab;
1421   bfd *dynobj;
1422   asection *sreloc = NULL;
1423
1424   if (bfd_link_relocatable (info))
1425     return TRUE;
1426
1427   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1428   sym_hashes = elf_sym_hashes (abfd);
1429
1430   htab = or1k_elf_hash_table (info);
1431   if (htab == NULL)
1432     return FALSE;
1433
1434   dynobj = htab->root.dynobj;
1435
1436   rel_end = relocs + sec->reloc_count;
1437   for (rel = relocs; rel < rel_end; rel++)
1438     {
1439       struct elf_link_hash_entry *h;
1440       unsigned long r_symndx;
1441       unsigned char tls_type;
1442
1443       r_symndx = ELF32_R_SYM (rel->r_info);
1444       if (r_symndx < symtab_hdr->sh_info)
1445         h = NULL;
1446       else
1447         {
1448           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1449           while (h->root.type == bfd_link_hash_indirect
1450                  || h->root.type == bfd_link_hash_warning)
1451             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1452
1453           /* PR15323, ref flags aren't set for references in the same
1454              object.  */
1455           h->root.non_ir_ref = 1;
1456         }
1457
1458       switch (ELF32_R_TYPE (rel->r_info))
1459         {
1460         case R_OR1K_TLS_GD_HI16:
1461         case R_OR1K_TLS_GD_LO16:
1462           tls_type = TLS_GD;
1463           break;
1464         case R_OR1K_TLS_LDM_HI16:
1465         case R_OR1K_TLS_LDM_LO16:
1466         case R_OR1K_TLS_LDO_HI16:
1467         case R_OR1K_TLS_LDO_LO16:
1468           tls_type = TLS_LD;
1469           break;
1470         case R_OR1K_TLS_IE_HI16:
1471         case R_OR1K_TLS_IE_LO16:
1472           tls_type = TLS_IE;
1473           break;
1474         case R_OR1K_TLS_LE_HI16:
1475         case R_OR1K_TLS_LE_LO16:
1476           tls_type = TLS_LE;
1477           break;
1478         default:
1479           tls_type = TLS_NONE;
1480         }
1481
1482       /* Record TLS type.  */
1483       if (h != NULL)
1484           ((struct elf_or1k_link_hash_entry *) h)->tls_type = tls_type;
1485       else
1486         {
1487           unsigned char *local_tls_type;
1488
1489           /* This is a TLS type record for a local symbol.  */
1490           local_tls_type = (unsigned char *) elf_or1k_local_tls_type (abfd);
1491           if (local_tls_type == NULL)
1492             {
1493               bfd_size_type size;
1494
1495               size = symtab_hdr->sh_info;
1496               local_tls_type = bfd_zalloc (abfd, size);
1497               if (local_tls_type == NULL)
1498                 return FALSE;
1499               elf_or1k_local_tls_type (abfd) = local_tls_type;
1500             }
1501           local_tls_type[r_symndx] = tls_type;
1502         }
1503
1504       switch (ELF32_R_TYPE (rel->r_info))
1505         {
1506           /* This relocation describes the C++ object vtable hierarchy.
1507              Reconstruct it for later use during GC.  */
1508         case R_OR1K_GNU_VTINHERIT:
1509           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1510             return FALSE;
1511           break;
1512
1513           /* This relocation describes which C++ vtable entries are actually
1514              used.  Record for later use during GC.  */
1515         case R_OR1K_GNU_VTENTRY:
1516           BFD_ASSERT (h != NULL);
1517           if (h != NULL
1518               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1519             return FALSE;
1520           break;
1521
1522           /* This relocation requires .plt entry.  */
1523         case R_OR1K_PLT26:
1524           if (h != NULL)
1525             {
1526               h->needs_plt = 1;
1527               h->plt.refcount += 1;
1528             }
1529           break;
1530
1531         case R_OR1K_GOT16:
1532         case R_OR1K_GOTOFF_HI16:
1533         case R_OR1K_GOTOFF_LO16:
1534         case R_OR1K_TLS_GD_HI16:
1535         case R_OR1K_TLS_GD_LO16:
1536         case R_OR1K_TLS_IE_HI16:
1537         case R_OR1K_TLS_IE_LO16:
1538           if (htab->sgot == NULL)
1539             {
1540               if (dynobj == NULL)
1541                 htab->root.dynobj = dynobj = abfd;
1542               if (! create_got_section (dynobj, info))
1543                 return FALSE;
1544             }
1545
1546           if (ELF32_R_TYPE (rel->r_info) != R_OR1K_GOTOFF_HI16 &&
1547               ELF32_R_TYPE (rel->r_info) != R_OR1K_GOTOFF_LO16)
1548             {
1549               if (h != NULL)
1550                 h->got.refcount += 1;
1551               else
1552                 {
1553                   bfd_signed_vma *local_got_refcounts;
1554
1555                   /* This is a global offset table entry for a local symbol.  */
1556                   local_got_refcounts = elf_local_got_refcounts (abfd);
1557                   if (local_got_refcounts == NULL)
1558                     {
1559                       bfd_size_type size;
1560
1561                       size = symtab_hdr->sh_info;
1562                       size *= sizeof (bfd_signed_vma);
1563                       local_got_refcounts = bfd_zalloc (abfd, size);
1564                       if (local_got_refcounts == NULL)
1565                         return FALSE;
1566                       elf_local_got_refcounts (abfd) = local_got_refcounts;
1567                     }
1568                   local_got_refcounts[r_symndx] += 1;
1569                 }
1570             }
1571           break;
1572
1573         case R_OR1K_INSN_REL_26:
1574         case R_OR1K_HI_16_IN_INSN:
1575         case R_OR1K_LO_16_IN_INSN:
1576         case R_OR1K_32:
1577           /* R_OR1K_16? */
1578           {
1579             if (h != NULL && !bfd_link_pic (info))
1580               {
1581                 /* We may need a copy reloc.  */
1582                 h->non_got_ref = 1;
1583
1584                 /* We may also need a .plt entry.  */
1585                 h->plt.refcount += 1;
1586                 if (ELF32_R_TYPE (rel->r_info) != R_OR1K_INSN_REL_26)
1587                   h->pointer_equality_needed = 1;
1588               }
1589
1590             /* If we are creating a shared library, and this is a reloc
1591                against a global symbol, or a non PC relative reloc
1592                against a local symbol, then we need to copy the reloc
1593                into the shared library.  However, if we are linking with
1594                -Bsymbolic, we do not need to copy a reloc against a
1595                global symbol which is defined in an object we are
1596                including in the link (i.e., DEF_REGULAR is set).  At
1597                this point we have not seen all the input files, so it is
1598                possible that DEF_REGULAR is not set now but will be set
1599                later (it is never cleared).  In case of a weak definition,
1600                DEF_REGULAR may be cleared later by a strong definition in
1601                a shared library.  We account for that possibility below by
1602                storing information in the relocs_copied field of the hash
1603                table entry.  A similar situation occurs when creating
1604                shared libraries and symbol visibility changes render the
1605                symbol local.
1606
1607                If on the other hand, we are creating an executable, we
1608                may need to keep relocations for symbols satisfied by a
1609                dynamic library if we manage to avoid copy relocs for the
1610                symbol.  */
1611
1612             if ((bfd_link_pic (info)
1613                  && (sec->flags & SEC_ALLOC) != 0
1614                  && (ELF32_R_TYPE (rel->r_info) != R_OR1K_INSN_REL_26
1615                      || (h != NULL
1616                          && (!SYMBOLIC_BIND (info, h)
1617                              || h->root.type == bfd_link_hash_defweak
1618                              || !h->def_regular))))
1619                 || (!bfd_link_pic (info)
1620                     && (sec->flags & SEC_ALLOC) != 0
1621                     && h != NULL
1622                     && (h->root.type == bfd_link_hash_defweak
1623                         || !h->def_regular)))
1624               {
1625                 struct elf_or1k_dyn_relocs *p;
1626                 struct elf_or1k_dyn_relocs **head;
1627
1628                 /* When creating a shared object, we must copy these
1629                    relocs into the output file.  We create a reloc
1630                    section in dynobj and make room for the reloc.  */
1631                 if (sreloc == NULL)
1632                   {
1633                     const char *name;
1634                     unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1635                     unsigned int shnam = _bfd_elf_single_rel_hdr (sec)->sh_name;
1636
1637                     name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1638                     if (name == NULL)
1639                       return FALSE;
1640
1641                     if (strncmp (name, ".rela", 5) != 0
1642                         || strcmp (bfd_get_section_name (abfd, sec),
1643                                    name + 5) != 0)
1644                       {
1645                         (*_bfd_error_handler)
1646                           (_("%B: bad relocation section name `%s\'"),
1647                            abfd, name);
1648                       }
1649
1650                     if (htab->root.dynobj == NULL)
1651                       htab->root.dynobj = abfd;
1652                     dynobj = htab->root.dynobj;
1653
1654                     sreloc = bfd_get_section_by_name (dynobj, name);
1655                     if (sreloc == NULL)
1656                       {
1657                         sreloc = _bfd_elf_make_dynamic_reloc_section
1658                           (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
1659
1660                         if (sreloc == NULL)
1661                           return FALSE;
1662                       }
1663                     elf_section_data (sec)->sreloc = sreloc;
1664                   }
1665
1666                 /* If this is a global symbol, we count the number of
1667                    relocations we need for this symbol.  */
1668                 if (h != NULL)
1669                   head = &((struct elf_or1k_link_hash_entry *) h)->dyn_relocs;
1670                 else
1671                   {
1672                     /* Track dynamic relocs needed for local syms too.
1673                        We really need local syms available to do this
1674                        easily.  Oh well.  */
1675
1676                     asection *s;
1677                     Elf_Internal_Sym *isym;
1678                     void *vpp;
1679
1680                     isym = bfd_sym_from_r_symndx (&htab->sym_sec,
1681                                                   abfd, r_symndx);
1682                     if (isym == NULL)
1683                       return FALSE;
1684
1685                     s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1686                     if (s == NULL)
1687                       return FALSE;
1688
1689                     vpp = &elf_section_data (s)->local_dynrel;
1690                     head = (struct elf_or1k_dyn_relocs **) vpp;
1691                   }
1692
1693                 p = *head;
1694                 if (p == NULL || p->sec != sec)
1695                   {
1696                     bfd_size_type amt = sizeof *p;
1697                     p = ((struct elf_or1k_dyn_relocs *)
1698                          bfd_alloc (htab->root.dynobj, amt));
1699                     if (p == NULL)
1700                       return FALSE;
1701                     p->next = *head;
1702                     *head = p;
1703                     p->sec = sec;
1704                     p->count = 0;
1705                     p->pc_count = 0;
1706                   }
1707
1708                 p->count += 1;
1709                 if (ELF32_R_TYPE (rel->r_info) == R_OR1K_INSN_REL_26)
1710                   p->pc_count += 1;
1711               }
1712           }
1713           break;
1714         }
1715     }
1716
1717   return TRUE;
1718 }
1719
1720 /* Finish up the dynamic sections.  */
1721
1722 static bfd_boolean
1723 or1k_elf_finish_dynamic_sections (bfd *output_bfd,
1724                                   struct bfd_link_info *info)
1725 {
1726   bfd *dynobj;
1727   asection *sdyn, *sgot;
1728   struct elf_or1k_link_hash_table *htab;
1729
1730   htab = or1k_elf_hash_table (info);
1731   if (htab == NULL)
1732     return FALSE;
1733
1734   dynobj = htab->root.dynobj;
1735
1736   sgot = htab->sgotplt;
1737   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1738
1739   if (htab->root.dynamic_sections_created)
1740     {
1741       asection *splt;
1742       Elf32_External_Dyn *dyncon, *dynconend;
1743
1744       BFD_ASSERT (sgot != NULL && sdyn != NULL);
1745
1746       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1747       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1748
1749       for (; dyncon < dynconend; dyncon++)
1750         {
1751           Elf_Internal_Dyn dyn;
1752           asection *s;
1753
1754           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1755
1756           switch (dyn.d_tag)
1757             {
1758             default:
1759               continue;
1760
1761             case DT_PLTGOT:
1762               s = htab->sgotplt;
1763               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1764               break;
1765
1766             case DT_JMPREL:
1767               s = htab->srelplt;
1768               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1769               break;
1770
1771             case DT_PLTRELSZ:
1772               s = htab->srelplt;
1773               dyn.d_un.d_val = s->size;
1774               break;
1775
1776             case DT_RELASZ:
1777               /* My reading of the SVR4 ABI indicates that the
1778                  procedure linkage table relocs (DT_JMPREL) should be
1779                  included in the overall relocs (DT_RELA).  This is
1780                  what Solaris does.  However, UnixWare can not handle
1781                  that case.  Therefore, we override the DT_RELASZ entry
1782                  here to make it not include the JMPREL relocs.  Since
1783                  the linker script arranges for .rela.plt to follow all
1784                  other relocation sections, we don't have to worry
1785                  about changing the DT_RELA entry.  */
1786               if (htab->srelplt != NULL)
1787                 {
1788                   s = htab->srelplt;
1789                   dyn.d_un.d_val -= s->size;
1790                 }
1791               break;
1792             }
1793           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1794         }
1795
1796
1797       /* Fill in the first entry in the procedure linkage table.  */
1798       splt = htab->splt;
1799       if (splt && splt->size > 0)
1800         {
1801           if (bfd_link_pic (info))
1802             {
1803               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0,
1804                           splt->contents);
1805               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1,
1806                           splt->contents + 4);
1807               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2,
1808                           splt->contents + 8);
1809               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3,
1810                           splt->contents + 12);
1811               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4,
1812                           splt->contents + 16);
1813             }
1814           else
1815             {
1816               unsigned long addr;
1817               /* addr = .got + 4 */
1818               addr = sgot->output_section->vma + sgot->output_offset + 4;
1819               bfd_put_32 (output_bfd,
1820                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1821                           splt->contents);
1822               bfd_put_32 (output_bfd,
1823                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1824                           splt->contents + 4);
1825               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1826               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1827               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1828             }
1829
1830           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1831         }
1832     }
1833
1834   /* Set the first entry in the global offset table to the address of
1835      the dynamic section.  */
1836   if (sgot && sgot->size > 0)
1837     {
1838       if (sdyn == NULL)
1839         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1840       else
1841         bfd_put_32 (output_bfd,
1842                     sdyn->output_section->vma + sdyn->output_offset,
1843                     sgot->contents);
1844       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1845     }
1846
1847   if (htab->sgot && htab->sgot->size > 0)
1848     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize = 4;
1849
1850   return TRUE;
1851 }
1852
1853 /* Finish up dynamic symbol handling.  We set the contents of various
1854    dynamic sections here.  */
1855
1856 static bfd_boolean
1857 or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
1858                                 struct bfd_link_info *info,
1859                                 struct elf_link_hash_entry *h,
1860                                 Elf_Internal_Sym *sym)
1861 {
1862   struct elf_or1k_link_hash_table *htab;
1863   bfd_byte *loc;
1864
1865   htab = or1k_elf_hash_table (info);
1866   if (htab == NULL)
1867     return FALSE;
1868
1869   if (h->plt.offset != (bfd_vma) -1)
1870     {
1871       asection *splt;
1872       asection *sgot;
1873       asection *srela;
1874
1875       bfd_vma plt_index;
1876       bfd_vma got_offset;
1877       bfd_vma got_addr;
1878       Elf_Internal_Rela rela;
1879
1880       /* This symbol has an entry in the procedure linkage table.  Set
1881          it up.  */
1882       BFD_ASSERT (h->dynindx != -1);
1883
1884       splt = htab->splt;
1885       sgot = htab->sgotplt;
1886       srela = htab->srelplt;
1887       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1888
1889       /* Get the index in the procedure linkage table which
1890          corresponds to this symbol.  This is the index of this symbol
1891          in all the symbols for which we are making plt entries.  The
1892          first entry in the procedure linkage table is reserved.  */
1893       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1894
1895       /* Get the offset into the .got table of the entry that
1896         corresponds to this function.  Each .got entry is 4 bytes.
1897         The first three are reserved.  */
1898       got_offset = (plt_index + 3) * 4;
1899       got_addr = got_offset;
1900
1901       /* Fill in the entry in the procedure linkage table.  */
1902       if (! bfd_link_pic (info))
1903         {
1904           got_addr += htab->sgotplt->output_section->vma
1905             + htab->sgotplt->output_offset;
1906           bfd_put_32 (output_bfd, PLT_ENTRY_WORD0 | ((got_addr >> 16) & 0xffff),
1907                       splt->contents + h->plt.offset);
1908           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1 | (got_addr & 0xffff),
1909                       splt->contents + h->plt.offset + 4);
1910           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
1911                       splt->contents + h->plt.offset + 8);
1912           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
1913                       splt->contents + h->plt.offset + 12);
1914           bfd_put_32 (output_bfd, PLT_ENTRY_WORD4
1915                       | plt_index * sizeof (Elf32_External_Rela),
1916                       splt->contents + h->plt.offset + 16);
1917         }
1918       else
1919         {
1920           bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD0 | (got_addr & 0xffff),
1921                       splt->contents + h->plt.offset);
1922           bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD1
1923                       | plt_index * sizeof (Elf32_External_Rela),
1924                       splt->contents + h->plt.offset + 4);
1925           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
1926                       splt->contents + h->plt.offset + 8);
1927           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
1928                       splt->contents + h->plt.offset + 12);
1929           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
1930                       splt->contents + h->plt.offset + 16);
1931         }
1932
1933       /* Fill in the entry in the global offset table.  */
1934       bfd_put_32 (output_bfd,
1935                   (splt->output_section->vma
1936                    + splt->output_offset), /* Same offset.  */
1937                   sgot->contents + got_offset);
1938
1939       /* Fill in the entry in the .rela.plt section.  */
1940       rela.r_offset = (sgot->output_section->vma
1941                        + sgot->output_offset
1942                        + got_offset);
1943       rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_JMP_SLOT);
1944       rela.r_addend = 0;
1945       loc = srela->contents;
1946       loc += plt_index * sizeof (Elf32_External_Rela);
1947       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1948
1949       if (!h->def_regular)
1950         {
1951           /* Mark the symbol as undefined, rather than as defined in
1952              the .plt section.  Leave the value alone.  */
1953           sym->st_shndx = SHN_UNDEF;
1954         }
1955
1956     }
1957
1958   if (h->got.offset != (bfd_vma) -1
1959       && (h->got.offset & 2) == 0) /* Homemade TLS check.  */
1960     {
1961       asection *sgot;
1962       asection *srela;
1963       Elf_Internal_Rela rela;
1964
1965       /* This symbol has an entry in the global offset table.  Set it
1966          up.  */
1967       sgot = htab->sgot;
1968       srela = htab->srelgot;
1969       BFD_ASSERT (sgot != NULL && srela != NULL);
1970
1971       rela.r_offset = (sgot->output_section->vma
1972                        + sgot->output_offset
1973                        + (h->got.offset &~ 1));
1974
1975       /* If this is a -Bsymbolic link, and the symbol is defined
1976          locally, we just want to emit a RELATIVE reloc.  Likewise if
1977          the symbol was forced to be local because of a version file.
1978          The entry in the global offset table will already have been
1979          initialized in the relocate_section function.  */
1980       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
1981         {
1982           rela.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1983           rela.r_addend = (h->root.u.def.value
1984                            + h->root.u.def.section->output_section->vma
1985                            + h->root.u.def.section->output_offset);
1986         }
1987       else
1988         {
1989           BFD_ASSERT ((h->got.offset & 1) == 0);
1990           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1991           rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_GLOB_DAT);
1992           rela.r_addend = 0;
1993         }
1994
1995       loc = srela->contents;
1996       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1997       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1998       ++srela->reloc_count;
1999     }
2000
2001   if (h->needs_copy)
2002     {
2003       asection *s;
2004       Elf_Internal_Rela rela;
2005
2006       /* This symbols needs a copy reloc.  Set it up.  */
2007       BFD_ASSERT (h->dynindx != -1
2008                   && (h->root.type == bfd_link_hash_defined
2009                       || h->root.type == bfd_link_hash_defweak));
2010
2011       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2012                                    ".rela.bss");
2013       BFD_ASSERT (s != NULL);
2014
2015       rela.r_offset = (h->root.u.def.value
2016                        + h->root.u.def.section->output_section->vma
2017                        + h->root.u.def.section->output_offset);
2018       rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_COPY);
2019       rela.r_addend = 0;
2020       loc = s->contents;
2021       loc += s->reloc_count * sizeof (Elf32_External_Rela);
2022       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2023       ++s->reloc_count;
2024     }
2025
2026   /* Mark some specially defined symbols as absolute.  */
2027   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2028       || h == htab->root.hgot)
2029     sym->st_shndx = SHN_ABS;
2030
2031   return TRUE;
2032 }
2033
2034 static enum elf_reloc_type_class
2035 or1k_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2036                            const asection *rel_sec ATTRIBUTE_UNUSED,
2037                            const Elf_Internal_Rela *rela)
2038 {
2039   switch ((int) ELF32_R_TYPE (rela->r_info))
2040     {
2041     case R_OR1K_RELATIVE:  return reloc_class_relative;
2042     case R_OR1K_JMP_SLOT:  return reloc_class_plt;
2043     case R_OR1K_COPY:      return reloc_class_copy;
2044     default:               return reloc_class_normal;
2045     }
2046 }
2047
2048 /* Adjust a symbol defined by a dynamic object and referenced by a
2049    regular object.  The current definition is in some section of the
2050    dynamic object, but we're not including those sections.  We have to
2051    change the definition to something the rest of the link can
2052    understand.  */
2053
2054 static bfd_boolean
2055 or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2056                                 struct elf_link_hash_entry *h)
2057 {
2058   struct elf_or1k_link_hash_table *htab;
2059   struct elf_or1k_link_hash_entry *eh;
2060   struct elf_or1k_dyn_relocs *p;
2061   bfd *dynobj;
2062   asection *s;
2063
2064   dynobj = elf_hash_table (info)->dynobj;
2065
2066   /* Make sure we know what is going on here.  */
2067   BFD_ASSERT (dynobj != NULL
2068               && (h->needs_plt
2069                   || h->u.weakdef != NULL
2070                   || (h->def_dynamic
2071                       && h->ref_regular
2072                       && !h->def_regular)));
2073
2074   /* If this is a function, put it in the procedure linkage table.  We
2075      will fill in the contents of the procedure linkage table later,
2076      when we know the address of the .got section.  */
2077   if (h->type == STT_FUNC
2078       || h->needs_plt)
2079     {
2080       if (! bfd_link_pic (info)
2081           && !h->def_dynamic
2082           && !h->ref_dynamic
2083           && h->root.type != bfd_link_hash_undefweak
2084           && h->root.type != bfd_link_hash_undefined)
2085         {
2086           /* This case can occur if we saw a PLT reloc in an input
2087              file, but the symbol was never referred to by a dynamic
2088              object.  In such a case, we don't actually need to build
2089              a procedure linkage table, and we can just do a PCREL
2090              reloc instead.  */
2091           h->plt.offset = (bfd_vma) -1;
2092           h->needs_plt = 0;
2093         }
2094
2095       return TRUE;
2096     }
2097   else
2098     h->plt.offset = (bfd_vma) -1;
2099
2100   /* If this is a weak symbol, and there is a real definition, the
2101      processor independent code will have arranged for us to see the
2102      real definition first, and we can just use the same value.  */
2103   if (h->u.weakdef != NULL)
2104     {
2105       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2106                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2107       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2108       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2109       return TRUE;
2110     }
2111
2112   /* This is a reference to a symbol defined by a dynamic object which
2113      is not a function.  */
2114
2115   /* If we are creating a shared library, we must presume that the
2116      only references to the symbol are via the global offset table.
2117      For such cases we need not do anything here; the relocations will
2118      be handled correctly by relocate_section.  */
2119   if (bfd_link_pic (info))
2120     return TRUE;
2121
2122   /* If there are no references to this symbol that do not use the
2123      GOT, we don't need to generate a copy reloc.  */
2124   if (!h->non_got_ref)
2125     return TRUE;
2126
2127   /* If -z nocopyreloc was given, we won't generate them either.  */
2128   if (info->nocopyreloc)
2129     {
2130       h->non_got_ref = 0;
2131       return TRUE;
2132     }
2133
2134   eh = (struct elf_or1k_link_hash_entry *) h;
2135   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2136     {
2137       s = p->sec->output_section;
2138       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
2139         break;
2140     }
2141
2142   /* If we didn't find any dynamic relocs in sections which needs the
2143      copy reloc, then we'll be keeping the dynamic relocs and avoiding
2144      the copy reloc.  */
2145   if (p == NULL)
2146     {
2147       h->non_got_ref = 0;
2148       return TRUE;
2149     }
2150
2151   /* We must allocate the symbol in our .dynbss section, which will
2152      become part of the .bss section of the executable.  There will be
2153      an entry for this symbol in the .dynsym section.  The dynamic
2154      object will contain position independent code, so all references
2155      from the dynamic object to this symbol will go through the global
2156      offset table.  The dynamic linker will use the .dynsym entry to
2157      determine the address it must put in the global offset table, so
2158      both the dynamic object and the regular object will refer to the
2159      same memory location for the variable.  */
2160
2161   htab = or1k_elf_hash_table (info);
2162   if (htab == NULL)
2163     return FALSE;
2164
2165   s = htab->sdynbss;
2166   BFD_ASSERT (s != NULL);
2167
2168   /* We must generate a R_OR1K_COPY reloc to tell the dynamic linker
2169      to copy the initial value out of the dynamic object and into the
2170      runtime process image.  We need to remember the offset into the
2171      .rela.bss section we are going to use.  */
2172   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2173     {
2174       asection *srel;
2175
2176       srel = htab->srelbss;
2177       BFD_ASSERT (srel != NULL);
2178       srel->size += sizeof (Elf32_External_Rela);
2179       h->needs_copy = 1;
2180     }
2181
2182   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2183 }
2184
2185 /* Allocate space in .plt, .got and associated reloc sections for
2186    dynamic relocs.  */
2187
2188 static bfd_boolean
2189 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2190 {
2191   struct bfd_link_info *info;
2192   struct elf_or1k_link_hash_table *htab;
2193   struct elf_or1k_link_hash_entry *eh;
2194   struct elf_or1k_dyn_relocs *p;
2195
2196   if (h->root.type == bfd_link_hash_indirect)
2197     return TRUE;
2198
2199   info = (struct bfd_link_info *) inf;
2200   htab = or1k_elf_hash_table (info);
2201   if (htab == NULL)
2202     return FALSE;
2203
2204   eh = (struct elf_or1k_link_hash_entry *) h;
2205
2206   if (htab->root.dynamic_sections_created
2207       && h->plt.refcount > 0)
2208     {
2209       /* Make sure this symbol is output as a dynamic symbol.
2210          Undefined weak syms won't yet be marked as dynamic.  */
2211       if (h->dynindx == -1
2212           && !h->forced_local)
2213         {
2214           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2215             return FALSE;
2216         }
2217
2218       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2219         {
2220           asection *s = htab->splt;
2221
2222           /* If this is the first .plt entry, make room for the special
2223              first entry.  */
2224           if (s->size == 0)
2225             s->size = PLT_ENTRY_SIZE;
2226
2227           h->plt.offset = s->size;
2228
2229           /* If this symbol is not defined in a regular file, and we are
2230              not generating a shared library, then set the symbol to this
2231              location in the .plt.  This is required to make function
2232              pointers compare as equal between the normal executable and
2233              the shared library.  */
2234           if (! bfd_link_pic (info)
2235               && !h->def_regular)
2236             {
2237               h->root.u.def.section = s;
2238               h->root.u.def.value = h->plt.offset;
2239             }
2240
2241           /* Make room for this entry.  */
2242           s->size += PLT_ENTRY_SIZE;
2243
2244           /* We also need to make an entry in the .got.plt section, which
2245              will be placed in the .got section by the linker script.  */
2246           htab->sgotplt->size += 4;
2247
2248           /* We also need to make an entry in the .rel.plt section.  */
2249           htab->srelplt->size += sizeof (Elf32_External_Rela);
2250         }
2251       else
2252         {
2253           h->plt.offset = (bfd_vma) -1;
2254           h->needs_plt = 0;
2255         }
2256     }
2257   else
2258     {
2259       h->plt.offset = (bfd_vma) -1;
2260       h->needs_plt = 0;
2261     }
2262
2263   if (h->got.refcount > 0)
2264     {
2265       asection *s;
2266       bfd_boolean dyn;
2267       unsigned char tls_type;
2268
2269       /* Make sure this symbol is output as a dynamic symbol.
2270          Undefined weak syms won't yet be marked as dynamic.  */
2271       if (h->dynindx == -1
2272           && !h->forced_local)
2273         {
2274           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2275             return FALSE;
2276         }
2277
2278       s = htab->sgot;
2279
2280       h->got.offset = s->size;
2281
2282       tls_type = ((struct elf_or1k_link_hash_entry *) h)->tls_type;
2283
2284       /* TLS GD requires two GOT and two relocs.  */
2285       if (tls_type == TLS_GD)
2286         s->size += 8;
2287       else
2288         s->size += 4;
2289       dyn = htab->root.dynamic_sections_created;
2290       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
2291         {
2292           if (tls_type == TLS_GD)
2293             htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
2294           else
2295             htab->srelgot->size += sizeof (Elf32_External_Rela);
2296         }
2297     }
2298   else
2299     h->got.offset = (bfd_vma) -1;
2300
2301   if (eh->dyn_relocs == NULL)
2302     return TRUE;
2303
2304   /* In the shared -Bsymbolic case, discard space allocated for
2305      dynamic pc-relative relocs against symbols which turn out to be
2306      defined in regular objects.  For the normal shared case, discard
2307      space for pc-relative relocs that have become local due to symbol
2308      visibility changes.  */
2309
2310   if (bfd_link_pic (info))
2311     {
2312       if (SYMBOL_CALLS_LOCAL (info, h))
2313         {
2314           struct elf_or1k_dyn_relocs **pp;
2315
2316           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2317             {
2318               p->count -= p->pc_count;
2319               p->pc_count = 0;
2320               if (p->count == 0)
2321                 *pp = p->next;
2322               else
2323                 pp = &p->next;
2324             }
2325         }
2326
2327       /* Also discard relocs on undefined weak syms with non-default
2328          visibility.  */
2329       if (eh->dyn_relocs != NULL
2330           && h->root.type == bfd_link_hash_undefweak)
2331         {
2332           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2333             eh->dyn_relocs = NULL;
2334
2335           /* Make sure undefined weak symbols are output as a dynamic
2336              symbol in PIEs.  */
2337           else if (h->dynindx == -1
2338                    && !h->forced_local)
2339             {
2340               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2341                 return FALSE;
2342             }
2343         }
2344     }
2345   else
2346     {
2347       /* For the non-shared case, discard space for relocs against
2348          symbols which turn out to need copy relocs or are not
2349          dynamic.  */
2350
2351       if (!h->non_got_ref
2352           && ((h->def_dynamic
2353                && !h->def_regular)
2354               || (htab->root.dynamic_sections_created
2355                   && (h->root.type == bfd_link_hash_undefweak
2356                       || h->root.type == bfd_link_hash_undefined))))
2357         {
2358           /* Make sure this symbol is output as a dynamic symbol.
2359              Undefined weak syms won't yet be marked as dynamic.  */
2360           if (h->dynindx == -1
2361               && !h->forced_local)
2362             {
2363               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2364                 return FALSE;
2365             }
2366
2367           /* If that succeeded, we know we'll be keeping all the
2368              relocs.  */
2369           if (h->dynindx != -1)
2370             goto keep;
2371         }
2372
2373       eh->dyn_relocs = NULL;
2374
2375     keep: ;
2376     }
2377
2378   /* Finally, allocate space.  */
2379   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2380     {
2381       asection *sreloc = elf_section_data (p->sec)->sreloc;
2382       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2383     }
2384
2385   return TRUE;
2386 }
2387
2388 /* Find any dynamic relocs that apply to read-only sections.  */
2389
2390 static bfd_boolean
2391 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2392 {
2393   struct elf_or1k_link_hash_entry *eh;
2394   struct elf_or1k_dyn_relocs *p;
2395
2396   eh = (struct elf_or1k_link_hash_entry *) h;
2397   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2398     {
2399       asection *s = p->sec->output_section;
2400
2401       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2402         {
2403           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2404
2405           info->flags |= DF_TEXTREL;
2406
2407           /* Not an error, just cut short the traversal.  */
2408           return FALSE;
2409         }
2410     }
2411   return TRUE;
2412 }
2413
2414 /* Set the sizes of the dynamic sections.  */
2415
2416 static bfd_boolean
2417 or1k_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2418                                 struct bfd_link_info *info)
2419 {
2420   struct elf_or1k_link_hash_table *htab;
2421   bfd *dynobj;
2422   asection *s;
2423   bfd_boolean relocs;
2424   bfd *ibfd;
2425
2426   htab = or1k_elf_hash_table (info);
2427   if (htab == NULL)
2428     return FALSE;
2429
2430   dynobj = htab->root.dynobj;
2431   BFD_ASSERT (dynobj != NULL);
2432
2433   if (htab->root.dynamic_sections_created)
2434     {
2435       /* Set the contents of the .interp section to the interpreter.  */
2436       if (bfd_link_executable (info) && !info->nointerp)
2437         {
2438           s = bfd_get_section_by_name (dynobj, ".interp");
2439           BFD_ASSERT (s != NULL);
2440           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2441           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2442         }
2443     }
2444
2445   /* Set up .got offsets for local syms, and space for local dynamic
2446      relocs.  */
2447   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2448     {
2449       bfd_signed_vma *local_got;
2450       bfd_signed_vma *end_local_got;
2451       bfd_size_type locsymcount;
2452       Elf_Internal_Shdr *symtab_hdr;
2453       unsigned char *local_tls_type;
2454       asection *srel;
2455
2456       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2457         continue;
2458
2459       for (s = ibfd->sections; s != NULL; s = s->next)
2460         {
2461           struct elf_or1k_dyn_relocs *p;
2462
2463           for (p = ((struct elf_or1k_dyn_relocs *)
2464                     elf_section_data (s)->local_dynrel);
2465                p != NULL;
2466                p = p->next)
2467             {
2468               if (! bfd_is_abs_section (p->sec)
2469                   && bfd_is_abs_section (p->sec->output_section))
2470                 {
2471                   /* Input section has been discarded, either because
2472                      it is a copy of a linkonce section or due to
2473                      linker script /DISCARD/, so we'll be discarding
2474                      the relocs too.  */
2475                 }
2476               else if (p->count != 0)
2477                 {
2478                   srel = elf_section_data (p->sec)->sreloc;
2479                   srel->size += p->count * sizeof (Elf32_External_Rela);
2480                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2481                     info->flags |= DF_TEXTREL;
2482                 }
2483             }
2484         }
2485
2486       local_got = elf_local_got_refcounts (ibfd);
2487       if (!local_got)
2488         continue;
2489
2490       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2491       locsymcount = symtab_hdr->sh_info;
2492       end_local_got = local_got + locsymcount;
2493       s = htab->sgot;
2494       srel = htab->srelgot;
2495       local_tls_type = (unsigned char *) elf_or1k_local_tls_type (ibfd);
2496       for (; local_got < end_local_got; ++local_got)
2497         {
2498           if (*local_got > 0)
2499             {
2500               *local_got = s->size;
2501
2502               /* TLS GD requires two GOT and two relocs.  */
2503               if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2504                 s->size += 8;
2505               else
2506                 s->size += 4;
2507               if (bfd_link_pic (info))
2508                 {
2509                   if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2510                     srel->size += 2 * sizeof (Elf32_External_Rela);
2511                   else
2512                     srel->size += sizeof (Elf32_External_Rela);
2513                 }
2514             }
2515           else
2516
2517             *local_got = (bfd_vma) -1;
2518
2519           if (local_tls_type)
2520             ++local_tls_type;
2521         }
2522     }
2523
2524   /* Allocate global sym .plt and .got entries, and space for global
2525      sym dynamic relocs.  */
2526   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2527
2528   /* We now have determined the sizes of the various dynamic sections.
2529      Allocate memory for them.  */
2530   relocs = FALSE;
2531   for (s = dynobj->sections; s != NULL; s = s->next)
2532     {
2533       if ((s->flags & SEC_LINKER_CREATED) == 0)
2534         continue;
2535
2536       if (s == htab->splt
2537           || s == htab->sgot
2538           || s == htab->sgotplt
2539           || s == htab->sdynbss)
2540         {
2541           /* Strip this section if we don't need it; see the
2542              comment below.  */
2543         }
2544       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2545         {
2546           if (s->size != 0 && s != htab->srelplt)
2547             relocs = TRUE;
2548
2549           /* We use the reloc_count field as a counter if we need
2550              to copy relocs into the output file.  */
2551           s->reloc_count = 0;
2552         }
2553       else
2554         /* It's not one of our sections, so don't allocate space.  */
2555         continue;
2556
2557       if (s->size == 0)
2558         {
2559           /* If we don't need this section, strip it from the
2560              output file.  This is mostly to handle .rela.bss and
2561              .rela.plt.  We must create both sections in
2562              create_dynamic_sections, because they must be created
2563              before the linker maps input sections to output
2564              sections.  The linker does that before
2565              adjust_dynamic_symbol is called, and it is that
2566              function which decides whether anything needs to go
2567              into these sections.  */
2568           s->flags |= SEC_EXCLUDE;
2569           continue;
2570         }
2571
2572       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2573         continue;
2574
2575       /* Allocate memory for the section contents.  We use bfd_zalloc
2576          here in case unused entries are not reclaimed before the
2577          section's contents are written out.  This should not happen,
2578          but this way if it does, we get a R_OR1K_NONE reloc instead
2579          of garbage.  */
2580       s->contents = bfd_zalloc (dynobj, s->size);
2581
2582       if (s->contents == NULL)
2583         return FALSE;
2584     }
2585
2586   if (htab->root.dynamic_sections_created)
2587     {
2588       /* Add some entries to the .dynamic section.  We fill in the
2589          values later, in or1k_elf_finish_dynamic_sections, but we
2590          must add the entries now so that we get the correct size for
2591          the .dynamic section.  The DT_DEBUG entry is filled in by the
2592          dynamic linker and used by the debugger.  */
2593 #define add_dynamic_entry(TAG, VAL) \
2594   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2595
2596      if (bfd_link_executable (info))
2597        {
2598          if (! add_dynamic_entry (DT_DEBUG, 0))
2599            return FALSE;
2600        }
2601
2602      if (htab->splt->size != 0)
2603        {
2604          if (! add_dynamic_entry (DT_PLTGOT, 0)
2605              || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2606              || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2607              || ! add_dynamic_entry (DT_JMPREL, 0))
2608            return FALSE;
2609         }
2610
2611      if (relocs)
2612        {
2613          if (! add_dynamic_entry (DT_RELA, 0)
2614              || ! add_dynamic_entry (DT_RELASZ, 0)
2615              || ! add_dynamic_entry (DT_RELAENT,
2616                                      sizeof (Elf32_External_Rela)))
2617            return FALSE;
2618
2619          /* If any dynamic relocs apply to a read-only section,
2620             then we need a DT_TEXTREL entry.  */
2621          if ((info->flags & DF_TEXTREL) == 0)
2622            elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2623                                    info);
2624
2625          if ((info->flags & DF_TEXTREL) != 0)
2626            {
2627              if (! add_dynamic_entry (DT_TEXTREL, 0))
2628                return FALSE;
2629            }
2630        }
2631     }
2632
2633 #undef add_dynamic_entry
2634   return TRUE;
2635 }
2636
2637 /* Create dynamic sections when linking against a dynamic object.  */
2638
2639 static bfd_boolean
2640 or1k_elf_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2641 {
2642   struct elf_or1k_link_hash_table *htab;
2643
2644   htab = or1k_elf_hash_table (info);
2645   if (htab == NULL)
2646     return FALSE;
2647
2648   if (!htab->sgot && !create_got_section (dynobj, info))
2649     return FALSE;
2650
2651   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2652     return FALSE;
2653
2654   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2655   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
2656   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2657   if (!bfd_link_pic (info))
2658     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
2659
2660   if (!htab->splt || !htab->srelplt || !htab->sdynbss
2661       || (!bfd_link_pic (info) && !htab->srelbss))
2662     abort ();
2663
2664   return TRUE;
2665 }
2666
2667 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2668
2669 static void
2670 or1k_elf_copy_indirect_symbol (struct bfd_link_info *info,
2671                                struct elf_link_hash_entry *dir,
2672                                struct elf_link_hash_entry *ind)
2673 {
2674   struct elf_or1k_link_hash_entry * edir;
2675   struct elf_or1k_link_hash_entry * eind;
2676
2677   edir = (struct elf_or1k_link_hash_entry *) dir;
2678   eind = (struct elf_or1k_link_hash_entry *) ind;
2679
2680   if (eind->dyn_relocs != NULL)
2681     {
2682       if (edir->dyn_relocs != NULL)
2683         {
2684           struct elf_or1k_dyn_relocs **pp;
2685           struct elf_or1k_dyn_relocs *p;
2686
2687           /* Add reloc counts against the indirect sym to the direct sym
2688              list.  Merge any entries against the same section.  */
2689           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2690             {
2691               struct elf_or1k_dyn_relocs *q;
2692
2693               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2694                 if (q->sec == p->sec)
2695                   {
2696                     q->pc_count += p->pc_count;
2697                     q->count += p->count;
2698                     *pp = p->next;
2699                     break;
2700                   }
2701               if (q == NULL)
2702                 pp = &p->next;
2703             }
2704           *pp = edir->dyn_relocs;
2705         }
2706
2707       edir->dyn_relocs = eind->dyn_relocs;
2708       eind->dyn_relocs = NULL;
2709     }
2710
2711   if (ind->root.type == bfd_link_hash_indirect)
2712     {
2713       if (dir->got.refcount <= 0)
2714         {
2715           edir->tls_type = eind->tls_type;
2716           eind->tls_type = TLS_UNKNOWN;
2717         }
2718     }
2719
2720   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2721 }
2722
2723 /* Set the right machine number.  */
2724
2725 static bfd_boolean
2726 or1k_elf_object_p (bfd *abfd)
2727 {
2728   unsigned long mach = bfd_mach_or1k;
2729
2730   if (elf_elfheader (abfd)->e_flags & EF_OR1K_NODELAY)
2731     mach = bfd_mach_or1knd;
2732
2733   return bfd_default_set_arch_mach (abfd, bfd_arch_or1k, mach);
2734 }
2735
2736 /* Store the machine number in the flags field.  */
2737
2738 static void
2739 or1k_elf_final_write_processing (bfd *abfd,
2740                                  bfd_boolean linker ATTRIBUTE_UNUSED)
2741 {
2742   switch (bfd_get_mach (abfd))
2743     {
2744     default:
2745     case bfd_mach_or1k:
2746       break;
2747     case bfd_mach_or1knd:
2748       elf_elfheader (abfd)->e_flags |= EF_OR1K_NODELAY;
2749       break;
2750     }
2751 }
2752
2753 static bfd_boolean
2754 or1k_elf_set_private_flags (bfd *abfd, flagword flags)
2755 {
2756   BFD_ASSERT (!elf_flags_init (abfd)
2757               || elf_elfheader (abfd)->e_flags == flags);
2758
2759   elf_elfheader (abfd)->e_flags = flags;
2760   elf_flags_init (abfd) = TRUE;
2761   return TRUE;
2762 }
2763
2764 /* Make sure all input files are consistent with respect to
2765    EF_OR1K_NODELAY flag setting.  */
2766
2767 static bfd_boolean
2768 elf32_or1k_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
2769 {
2770   flagword out_flags;
2771   flagword in_flags;
2772
2773   in_flags  = elf_elfheader (ibfd)->e_flags;
2774   out_flags = elf_elfheader (obfd)->e_flags;
2775
2776   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2777       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2778     return TRUE;
2779
2780   if (!elf_flags_init (obfd))
2781     {
2782       elf_flags_init (obfd) = TRUE;
2783       elf_elfheader (obfd)->e_flags = in_flags;
2784
2785       return TRUE;
2786     }
2787
2788   if (in_flags == out_flags)
2789     return TRUE;
2790
2791   if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY))
2792     {
2793       (*_bfd_error_handler)
2794         (_("%B: EF_OR1K_NODELAY flag mismatch with previous modules"), ibfd);
2795
2796       bfd_set_error (bfd_error_bad_value);
2797       return FALSE;
2798     }
2799
2800   return TRUE;
2801
2802 }
2803
2804 #define ELF_ARCH                        bfd_arch_or1k
2805 #define ELF_MACHINE_CODE                EM_OR1K
2806 #define ELF_TARGET_ID                   OR1K_ELF_DATA
2807 #define ELF_MAXPAGESIZE                 0x2000
2808
2809 #define TARGET_BIG_SYM                  or1k_elf32_vec
2810 #define TARGET_BIG_NAME                 "elf32-or1k"
2811
2812 #define elf_info_to_howto_rel           NULL
2813 #define elf_info_to_howto               or1k_info_to_howto_rela
2814 #define elf_backend_relocate_section    or1k_elf_relocate_section
2815 #define elf_backend_gc_mark_hook        or1k_elf_gc_mark_hook
2816 #define elf_backend_gc_sweep_hook       or1k_elf_gc_sweep_hook
2817 #define elf_backend_check_relocs        or1k_elf_check_relocs
2818 #define elf_backend_reloc_type_class    or1k_elf_reloc_type_class
2819 #define elf_backend_can_gc_sections     1
2820 #define elf_backend_rela_normal         1
2821
2822 #define bfd_elf32_mkobject                   elf_or1k_mkobject
2823
2824 #define bfd_elf32_bfd_merge_private_bfd_data elf32_or1k_merge_private_bfd_data
2825 #define bfd_elf32_bfd_set_private_flags or1k_elf_set_private_flags
2826 #define bfd_elf32_bfd_reloc_type_lookup or1k_reloc_type_lookup
2827 #define bfd_elf32_bfd_reloc_name_lookup or1k_reloc_name_lookup
2828
2829 #define elf_backend_object_p                or1k_elf_object_p
2830 #define elf_backend_final_write_processing  or1k_elf_final_write_processing
2831 #define elf_backend_can_refcount                1
2832
2833 #define elf_backend_plt_readonly                1
2834 #define elf_backend_want_got_plt                1
2835 #define elf_backend_want_plt_sym                0
2836 #define elf_backend_got_header_size             12
2837 #define bfd_elf32_bfd_link_hash_table_create    or1k_elf_link_hash_table_create
2838 #define elf_backend_copy_indirect_symbol        or1k_elf_copy_indirect_symbol
2839 #define elf_backend_create_dynamic_sections     or1k_elf_create_dynamic_sections
2840 #define elf_backend_finish_dynamic_sections     or1k_elf_finish_dynamic_sections
2841 #define elf_backend_size_dynamic_sections       or1k_elf_size_dynamic_sections
2842 #define elf_backend_adjust_dynamic_symbol       or1k_elf_adjust_dynamic_symbol
2843 #define elf_backend_finish_dynamic_symbol       or1k_elf_finish_dynamic_symbol
2844
2845 #include "elf32-target.h"