bfd/elf32-or1k.c

   1 /* Or1k-specific support for 32-bit ELF.
   2    Copyright (C) 2001-2018 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 #define TLS_UNKNOWN    0
 560 #define TLS_NONE       1
 561 #define TLS_GD         2
 562 #define TLS_LD         3
 563 #define TLS_IE         4
 564 #define TLS_LE         5
 565
 566 /* ELF linker hash entry.  */
 567 struct elf_or1k_link_hash_entry
 568 {
 569   struct elf_link_hash_entry root;
 570
 571   /* Track dynamic relocs copied for this symbol.  */
 572   struct elf_dyn_relocs *dyn_relocs;
 573
 574   /* Track type of TLS access.  */
 575   unsigned char tls_type;
 576 };
 577
 578 /* ELF object data.  */
 579 struct elf_or1k_obj_tdata
 580 {
 581   struct elf_obj_tdata root;
 582
 583   /* tls_type for each local got entry.  */
 584   unsigned char *local_tls_type;
 585 };
 586
 587 #define elf_or1k_tdata(abfd) \
 588   ((struct elf_or1k_obj_tdata *) (abfd)->tdata.any)
 589
 590 #define elf_or1k_local_tls_type(abfd) \
 591   (elf_or1k_tdata (abfd)->local_tls_type)
 592
 593 /* ELF linker hash table.  */
 594 struct elf_or1k_link_hash_table
 595 {
 596   struct elf_link_hash_table root;
 597
 598   /* Small local sym to section mapping cache.  */
 599   struct sym_cache sym_sec;
 600 };
 601
 602 /* Get the ELF linker hash table from a link_info structure.  */
 603 #define or1k_elf_hash_table(p) \
 604   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 605    == OR1K_ELF_DATA ? ((struct elf_or1k_link_hash_table *) ((p)->hash)) : NULL)
 606
 607 static bfd_boolean
 608 elf_or1k_mkobject (bfd *abfd)
 609 {
 610   return bfd_elf_allocate_object (abfd, sizeof (struct elf_or1k_obj_tdata),
 611                                   OR1K_ELF_DATA);
 612 }
 613
 614 /* Create an entry in an or1k ELF linker hash table.  */
 615
 616 static struct bfd_hash_entry *
 617 or1k_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 618                             struct bfd_hash_table *table,
 619                             const char *string)
 620 {
 621   struct elf_or1k_link_hash_entry *ret =
 622     (struct elf_or1k_link_hash_entry *) entry;
 623
 624   /* Allocate the structure if it has not already been allocated by a
 625      subclass.  */
 626   if (ret == NULL)
 627     ret = bfd_hash_allocate (table,
 628                              sizeof (struct elf_or1k_link_hash_entry));
 629   if (ret == NULL)
 630     return NULL;
 631
 632   /* Call the allocation method of the superclass.  */
 633   ret = ((struct elf_or1k_link_hash_entry *)
 634          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 635                                      table, string));
 636   if (ret != NULL)
 637     {
 638       struct elf_or1k_link_hash_entry *eh;
 639
 640       eh = (struct elf_or1k_link_hash_entry *) ret;
 641       eh->dyn_relocs = NULL;
 642       eh->tls_type = TLS_UNKNOWN;
 643     }
 644
 645   return (struct bfd_hash_entry *) ret;
 646 }
 647
 648 /* Create an or1k ELF linker hash table.  */
 649
 650 static struct bfd_link_hash_table *
 651 or1k_elf_link_hash_table_create (bfd *abfd)
 652 {
 653   struct elf_or1k_link_hash_table *ret;
 654   bfd_size_type amt = sizeof (struct elf_or1k_link_hash_table);
 655
 656   ret = bfd_zmalloc (amt);
 657   if (ret == NULL)
 658     return NULL;
 659
 660   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 661                                       or1k_elf_link_hash_newfunc,
 662                                       sizeof (struct elf_or1k_link_hash_entry),
 663                                       OR1K_ELF_DATA))
 664     {
 665       free (ret);
 666       return NULL;
 667     }
 668
 669   return &ret->root.root;
 670 }
 671
 672 static reloc_howto_type *
 673 or1k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 674                         bfd_reloc_code_real_type code)
 675 {
 676   unsigned int i;
 677
 678   for (i = ARRAY_SIZE (or1k_reloc_map); i--;)
 679     if (or1k_reloc_map[i].bfd_reloc_val == code)
 680       return & or1k_elf_howto_table[or1k_reloc_map[i].or1k_reloc_val];
 681
 682   return NULL;
 683 }
 684
 685 static reloc_howto_type *
 686 or1k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 687                         const char *r_name)
 688 {
 689   unsigned int i;
 690
 691   for (i = 0;
 692        i < (sizeof (or1k_elf_howto_table)
 693             / sizeof (or1k_elf_howto_table[0]));
 694        i++)
 695     if (or1k_elf_howto_table[i].name != NULL
 696         && strcasecmp (or1k_elf_howto_table[i].name, r_name) == 0)
 697       return &or1k_elf_howto_table[i];
 698
 699   return NULL;
 700 }
 701
 702 /* Set the howto pointer for an Or1k ELF reloc.  */
 703
 704 static void
 705 or1k_info_to_howto_rela (bfd * abfd,
 706                          arelent * cache_ptr,
 707                          Elf_Internal_Rela * dst)
 708 {
 709   unsigned int r_type;
 710
 711   r_type = ELF32_R_TYPE (dst->r_info);
 712   if (r_type >= (unsigned int) R_OR1K_max)
 713     {
 714       /* xgettext:c-format */
 715       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 716                           abfd, r_type);
 717       r_type = 0;
 718     }
 719   cache_ptr->howto = & or1k_elf_howto_table[r_type];
 720 }
 721
 722
 723 /* Return the relocation value for @tpoff relocations..  */
 724 static bfd_vma
 725 tpoff (struct bfd_link_info *info, bfd_vma address)
 726 {
 727   /* If tls_sec is NULL, we should have signalled an error already.  */
 728   if (elf_hash_table (info)->tls_sec == NULL)
 729     return 0;
 730
 731   /* The thread pointer on or1k stores the address after the TCB where
 732      the data is, just compute the difference. No need to compensate
 733      for the size of TCB.  */
 734   return (address - elf_hash_table (info)->tls_sec->vma);
 735 }
 736
 737 /* Relocate an Or1k ELF section.
 738
 739    The RELOCATE_SECTION function is called by the new ELF backend linker
 740    to handle the relocations for a section.
 741
 742    The relocs are always passed as Rela structures; if the section
 743    actually uses Rel structures, the r_addend field will always be
 744    zero.
 745
 746    This function is responsible for adjusting the section contents as
 747    necessary, and (if using Rela relocs and generating a relocatable
 748    output file) adjusting the reloc addend as necessary.
 749
 750    This function does not have to worry about setting the reloc
 751    address or the reloc symbol index.
 752
 753    LOCAL_SYMS is a pointer to the swapped in local symbols.
 754
 755    LOCAL_SECTIONS is an array giving the section in the input file
 756    corresponding to the st_shndx field of each local symbol.
 757
 758    The global hash table entry for the global symbols can be found
 759    via elf_sym_hashes (input_bfd).
 760
 761    When generating relocatable output, this function must handle
 762    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 763    going to be the section symbol corresponding to the output
 764    section, which means that the addend must be adjusted
 765    accordingly.  */
 766
 767 static bfd_boolean
 768 or1k_elf_relocate_section (bfd *output_bfd,
 769                            struct bfd_link_info *info,
 770                            bfd *input_bfd,
 771                            asection *input_section,
 772                            bfd_byte *contents,
 773                            Elf_Internal_Rela *relocs,
 774                            Elf_Internal_Sym *local_syms,
 775                            asection **local_sections)
 776 {
 777   Elf_Internal_Shdr *symtab_hdr;
 778   struct elf_link_hash_entry **sym_hashes;
 779   Elf_Internal_Rela *rel;
 780   Elf_Internal_Rela *relend;
 781   struct elf_or1k_link_hash_table *htab = or1k_elf_hash_table (info);
 782   bfd *dynobj;
 783   asection *sreloc;
 784   bfd_vma *local_got_offsets;
 785   asection *sgot;
 786
 787   if (htab == NULL)
 788     return FALSE;
 789
 790   dynobj = htab->root.dynobj;
 791   local_got_offsets = elf_local_got_offsets (input_bfd);
 792
 793   sreloc = elf_section_data (input_section)->sreloc;
 794
 795   sgot = htab->root.sgot;
 796
 797   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 798   sym_hashes = elf_sym_hashes (input_bfd);
 799   relend = relocs + input_section->reloc_count;
 800
 801   for (rel = relocs; rel < relend; rel++)
 802     {
 803       reloc_howto_type *howto;
 804       unsigned long r_symndx;
 805       Elf_Internal_Sym *sym;
 806       asection *sec;
 807       struct elf_link_hash_entry *h;
 808       bfd_vma relocation;
 809       bfd_reloc_status_type r;
 810       const char *name = NULL;
 811       int r_type;
 812
 813       r_type = ELF32_R_TYPE (rel->r_info);
 814       r_symndx = ELF32_R_SYM (rel->r_info);
 815
 816       if (r_type == R_OR1K_GNU_VTINHERIT
 817           || r_type == R_OR1K_GNU_VTENTRY)
 818         continue;
 819
 820       if (r_type < 0 || r_type >= (int) R_OR1K_max)
 821         {
 822           bfd_set_error (bfd_error_bad_value);
 823           return FALSE;
 824         }
 825
 826       howto = or1k_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 827       h = NULL;
 828       sym = NULL;
 829       sec = NULL;
 830
 831       if (r_symndx < symtab_hdr->sh_info)
 832         {
 833           sym = local_syms + r_symndx;
 834           sec = local_sections[r_symndx];
 835           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 836
 837           name = bfd_elf_string_from_elf_section
 838             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 839           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 840         }
 841       else
 842         {
 843           bfd_boolean unresolved_reloc, warned, ignored;
 844
 845           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 846                                    r_symndx, symtab_hdr, sym_hashes,
 847                                    h, sec, relocation,
 848                                    unresolved_reloc, warned, ignored);
 849         }
 850
 851       if (sec != NULL && discarded_section (sec))
 852         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 853                                          rel, 1, relend, howto, 0, contents);
 854
 855       if (bfd_link_relocatable (info))
 856         continue;
 857
 858       switch (howto->type)
 859         {
 860         case R_OR1K_PLT26:
 861           {
 862             if (htab->root.splt != NULL && h != NULL
 863                 && h->plt.offset != (bfd_vma) -1)
 864               {
 865                 relocation = (htab->root.splt->output_section->vma
 866                               + htab->root.splt->output_offset
 867                               + h->plt.offset);
 868               }
 869             break;
 870           }
 871
 872         case R_OR1K_GOT16:
 873           /* Relocation is to the entry for this symbol in the global
 874              offset table.  */
 875           BFD_ASSERT (sgot != NULL);
 876           if (h != NULL)
 877             {
 878               bfd_boolean dyn;
 879               bfd_vma off;
 880
 881               off = h->got.offset;
 882               BFD_ASSERT (off != (bfd_vma) -1);
 883
 884               dyn = htab->root.dynamic_sections_created;
 885               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
 886                                                      bfd_link_pic (info),
 887                                                      h)
 888                   || (bfd_link_pic (info)
 889                       && SYMBOL_REFERENCES_LOCAL (info, h)))
 890                 {
 891                   /* This is actually a static link, or it is a
 892                      -Bsymbolic link and the symbol is defined
 893                      locally, or the symbol was forced to be local
 894                      because of a version file.  We must initialize
 895                      this entry in the global offset table.  Since the
 896                      offset must always be a multiple of 4, we use the
 897                      least significant bit to record whether we have
 898                      initialized it already.
 899
 900                      When doing a dynamic link, we create a .rela.got
 901                      relocation entry to initialize the value.  This
 902                      is done in the finish_dynamic_symbol routine.  */
 903                   if ((off & 1) != 0)
 904                     off &= ~1;
 905                   else
 906                     {
 907                       /* Write entry in GOT.  */
 908                       bfd_put_32 (output_bfd, relocation,
 909                                   sgot->contents + off);
 910                       /* Mark GOT entry as having been written.  */
 911                       h->got.offset |= 1;
 912                     }
 913                 }
 914
 915               relocation = sgot->output_offset + off;
 916             }
 917           else
 918             {
 919               bfd_vma off;
 920               bfd_byte *loc;
 921
 922               BFD_ASSERT (local_got_offsets != NULL
 923                           && local_got_offsets[r_symndx] != (bfd_vma) -1);
 924
 925               /* Get offset into GOT table.  */
 926               off = local_got_offsets[r_symndx];
 927
 928               /* The offset must always be a multiple of 4.  We use
 929                  the least significant bit to record whether we have
 930                  already processed this entry.  */
 931               if ((off & 1) != 0)
 932                 off &= ~1;
 933               else
 934                 {
 935                   /* Write entry in GOT.  */
 936                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
 937                   if (bfd_link_pic (info))
 938                     {
 939                       asection *srelgot;
 940                       Elf_Internal_Rela outrel;
 941
 942                       /* We need to generate a R_OR1K_RELATIVE reloc
 943                          for the dynamic linker.  */
 944                       srelgot = htab->root.srelgot;
 945                       BFD_ASSERT (srelgot != NULL);
 946
 947                       outrel.r_offset = (sgot->output_section->vma
 948                                          + sgot->output_offset
 949                                          + off);
 950                       outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
 951                       outrel.r_addend = relocation;
 952                       loc = srelgot->contents;
 953                       loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
 954                       bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
 955                       ++srelgot->reloc_count;
 956                     }
 957
 958                   local_got_offsets[r_symndx] |= 1;
 959                 }
 960               relocation = sgot->output_offset + off;
 961             }
 962
 963           /* Addend should be zero.  */
 964           if (rel->r_addend != 0)
 965             _bfd_error_handler
 966               (_("internal error: addend should be zero for %s"),
 967                "R_OR1K_GOT16");
 968
 969           break;
 970
 971         case R_OR1K_GOTOFF_LO16:
 972         case R_OR1K_GOTOFF_HI16:
 973           /* Relocation is offset from GOT.  */
 974           BFD_ASSERT (sgot != NULL);
 975           relocation
 976             -= (htab->root.hgot->root.u.def.value
 977                 + htab->root.hgot->root.u.def.section->output_offset
 978                 + htab->root.hgot->root.u.def.section->output_section->vma);
 979           break;
 980
 981         case R_OR1K_INSN_REL_26:
 982         case R_OR1K_HI_16_IN_INSN:
 983         case R_OR1K_LO_16_IN_INSN:
 984         case R_OR1K_32:
 985           /* R_OR1K_16? */
 986           {
 987             /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
 988                from removed linkonce sections, or sections discarded by
 989                a linker script.  */
 990             if (r_symndx == STN_UNDEF
 991                 || (input_section->flags & SEC_ALLOC) == 0)
 992               break;
 993
 994             if ((bfd_link_pic (info)
 995                  && (h == NULL
 996                      || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
 997                      || h->root.type != bfd_link_hash_undefweak)
 998                  && (howto->type != R_OR1K_INSN_REL_26
 999                      || !SYMBOL_CALLS_LOCAL (info, h)))
1000                 || (!bfd_link_pic (info)
1001                     && h != NULL
1002                     && h->dynindx != -1
1003                     && !h->non_got_ref
1004                     && ((h->def_dynamic
1005                          && !h->def_regular)
1006                         || h->root.type == bfd_link_hash_undefweak
1007                         || h->root.type == bfd_link_hash_undefined)))
1008               {
1009                 Elf_Internal_Rela outrel;
1010                 bfd_byte *loc;
1011                 bfd_boolean skip;
1012
1013                 /* When generating a shared object, these relocations
1014                    are copied into the output file to be resolved at run
1015                    time.  */
1016
1017                 BFD_ASSERT (sreloc != NULL);
1018
1019                 skip = FALSE;
1020
1021                 outrel.r_offset =
1022                   _bfd_elf_section_offset (output_bfd, info, input_section,
1023                                            rel->r_offset);
1024                 if (outrel.r_offset == (bfd_vma) -1)
1025                   skip = TRUE;
1026                 else if (outrel.r_offset == (bfd_vma) -2)
1027                   skip = TRUE;
1028                 outrel.r_offset += (input_section->output_section->vma
1029                                     + input_section->output_offset);
1030
1031                 if (skip)
1032                   memset (&outrel, 0, sizeof outrel);
1033                 /* h->dynindx may be -1 if the symbol was marked to
1034                    become local.  */
1035                 else if (h != NULL
1036                          && ((! info->symbolic && h->dynindx != -1)
1037                              || !h->def_regular))
1038                   {
1039                     BFD_ASSERT (h->dynindx != -1);
1040                     outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1041                     outrel.r_addend = rel->r_addend;
1042                   }
1043                 else
1044                   {
1045                     if (r_type == R_OR1K_32)
1046                       {
1047                         outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1048                         outrel.r_addend = relocation + rel->r_addend;
1049                       }
1050                     else
1051                       {
1052                         BFD_FAIL ();
1053                         _bfd_error_handler
1054                           (_("%pB: probably compiled without -fPIC?"),
1055                            input_bfd);
1056                         bfd_set_error (bfd_error_bad_value);
1057                         return FALSE;
1058                       }
1059                   }
1060
1061                 loc = sreloc->contents;
1062                 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1063                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1064                 break;
1065               }
1066             break;
1067           }
1068
1069         case R_OR1K_TLS_LDM_HI16:
1070         case R_OR1K_TLS_LDM_LO16:
1071         case R_OR1K_TLS_LDO_HI16:
1072         case R_OR1K_TLS_LDO_LO16:
1073           /* TODO: implement support for local dynamic.  */
1074           BFD_FAIL ();
1075           _bfd_error_handler
1076             (_("%pB: support for local dynamic not implemented"),
1077              input_bfd);
1078           bfd_set_error (bfd_error_bad_value);
1079           return FALSE;
1080
1081
1082         case R_OR1K_TLS_GD_HI16:
1083         case R_OR1K_TLS_GD_LO16:
1084         case R_OR1K_TLS_IE_HI16:
1085         case R_OR1K_TLS_IE_LO16:
1086           {
1087             bfd_vma gotoff;
1088             Elf_Internal_Rela rela;
1089             bfd_byte *loc;
1090             int dynamic;
1091
1092             sreloc = bfd_get_section_by_name (dynobj, ".rela.got");
1093
1094             /* Mark as TLS related GOT entry by setting
1095                bit 2 as well as bit 1.  */
1096             if (h != NULL)
1097               {
1098                 gotoff = h->got.offset;
1099                 h->got.offset |= 3;
1100               }
1101             else
1102               {
1103                 gotoff = local_got_offsets[r_symndx];
1104                 local_got_offsets[r_symndx] |= 3;
1105               }
1106
1107             /* Only process the relocation once.  */
1108             if (gotoff & 1)
1109               {
1110                 relocation = sgot->output_offset + (gotoff  & ~3);
1111                 break;
1112               }
1113
1114             BFD_ASSERT (elf_hash_table (info)->hgot == NULL
1115                         || elf_hash_table (info)->hgot->root.u.def.value == 0);
1116
1117             /* Dynamic entries will require relocations. if we do not need
1118                them we will just use the default R_OR1K_NONE and
1119                not set anything.  */
1120             dynamic = bfd_link_pic (info)
1121               || (sec && (sec->flags & SEC_ALLOC) != 0
1122                   && h != NULL
1123                   && (h->root.type == bfd_link_hash_defweak || !h->def_regular));
1124
1125             /* Shared GD.  */
1126             if (dynamic && (howto->type == R_OR1K_TLS_GD_HI16
1127                             || howto->type == R_OR1K_TLS_GD_LO16))
1128               {
1129                 int i;
1130
1131                 /* Add DTPMOD and DTPOFF GOT and rela entries.  */
1132                 for (i = 0; i < 2; ++i)
1133                   {
1134                     rela.r_offset = sgot->output_section->vma +
1135                       sgot->output_offset + gotoff + i*4;
1136                     if (h != NULL && h->dynindx != -1)
1137                       {
1138                         rela.r_info = ELF32_R_INFO (h->dynindx,
1139                             (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1140                         rela.r_addend = 0;
1141                       }
1142                     else
1143                       {
1144                         rela.r_info = ELF32_R_INFO (0,
1145                             (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF));
1146                         rela.r_addend = tpoff (info, relocation);
1147                       }
1148
1149                     loc = sreloc->contents;
1150                     loc += sreloc->reloc_count++ *
1151                       sizeof (Elf32_External_Rela);
1152
1153                     bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1154                     bfd_put_32 (output_bfd, 0, sgot->contents + gotoff + i*4);
1155                   }
1156               }
1157             /* Static GD.  */
1158             else if (howto->type == R_OR1K_TLS_GD_HI16
1159                      || howto->type == R_OR1K_TLS_GD_LO16)
1160               {
1161                 bfd_put_32 (output_bfd, 1, sgot->contents + gotoff);
1162                 bfd_put_32 (output_bfd, tpoff (info, relocation),
1163                     sgot->contents + gotoff + 4);
1164               }
1165             /* Shared IE.  */
1166             else if (dynamic)
1167               {
1168                 /* Add TPOFF GOT and rela entries.  */
1169                 rela.r_offset = sgot->output_section->vma +
1170                   sgot->output_offset + gotoff;
1171                 if (h != NULL && h->dynindx != -1)
1172                   {
1173                     rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_TLS_TPOFF);
1174                     rela.r_addend = 0;
1175                   }
1176                 else
1177                   {
1178                     rela.r_info = ELF32_R_INFO (0, R_OR1K_TLS_TPOFF);
1179                     rela.r_addend = tpoff (info, relocation);
1180                   }
1181
1182                 loc = sreloc->contents;
1183                 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1184
1185                 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1186                 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff);
1187               }
1188             /* Static IE.  */
1189             else
1190               {
1191                 bfd_put_32 (output_bfd, tpoff (info, relocation),
1192                             sgot->contents + gotoff);
1193               }
1194             relocation = sgot->output_offset + gotoff;
1195             break;
1196           }
1197         case R_OR1K_TLS_LE_HI16:
1198         case R_OR1K_TLS_LE_LO16:
1199
1200           /* Relocation is offset from TP.  */
1201           relocation = tpoff (info, relocation);
1202           break;
1203
1204         case R_OR1K_TLS_DTPMOD:
1205         case R_OR1K_TLS_DTPOFF:
1206         case R_OR1K_TLS_TPOFF:
1207           /* These are resolved dynamically on load and shouldn't
1208              be used as linker input.  */
1209           BFD_FAIL ();
1210           _bfd_error_handler
1211             (_("%pB: will not resolve runtime TLS relocation"),
1212              input_bfd);
1213           bfd_set_error (bfd_error_bad_value);
1214           return FALSE;
1215
1216         default:
1217           break;
1218         }
1219       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1220                                     rel->r_offset, relocation, rel->r_addend);
1221
1222       if (r != bfd_reloc_ok)
1223         {
1224           const char *msg = NULL;
1225
1226           switch (r)
1227             {
1228             case bfd_reloc_overflow:
1229               (*info->callbacks->reloc_overflow)
1230                 (info, (h ? &h->root : NULL), name, howto->name,
1231                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1232               break;
1233
1234             case bfd_reloc_undefined:
1235               (*info->callbacks->undefined_symbol)
1236                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1237               break;
1238
1239             case bfd_reloc_outofrange:
1240               msg = _("internal error: out of range error");
1241               break;
1242
1243             case bfd_reloc_notsupported:
1244               msg = _("internal error: unsupported relocation error");
1245               break;
1246
1247             case bfd_reloc_dangerous:
1248               msg = _("internal error: dangerous relocation");
1249               break;
1250
1251             default:
1252               msg = _("internal error: unknown error");
1253               break;
1254             }
1255
1256           if (msg)
1257             (*info->callbacks->warning) (info, msg, name, input_bfd,
1258                                          input_section, rel->r_offset);
1259         }
1260     }
1261
1262   return TRUE;
1263 }
1264
1265 /* Return the section that should be marked against GC for a given
1266    relocation.  */
1267
1268 static asection *
1269 or1k_elf_gc_mark_hook (asection *sec,
1270                        struct bfd_link_info *info,
1271                        Elf_Internal_Rela *rel,
1272                        struct elf_link_hash_entry *h,
1273                        Elf_Internal_Sym *sym)
1274 {
1275   if (h != NULL)
1276     switch (ELF32_R_TYPE (rel->r_info))
1277       {
1278       case R_OR1K_GNU_VTINHERIT:
1279       case R_OR1K_GNU_VTENTRY:
1280         return NULL;
1281       }
1282
1283   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1284 }
1285
1286 /* Look through the relocs for a section during the first phase.  */
1287
1288 static bfd_boolean
1289 or1k_elf_check_relocs (bfd *abfd,
1290                        struct bfd_link_info *info,
1291                        asection *sec,
1292                        const Elf_Internal_Rela *relocs)
1293 {
1294   Elf_Internal_Shdr *symtab_hdr;
1295   struct elf_link_hash_entry **sym_hashes;
1296   const Elf_Internal_Rela *rel;
1297
1298   const Elf_Internal_Rela *rel_end;
1299   struct elf_or1k_link_hash_table *htab;
1300   bfd *dynobj;
1301   asection *sreloc = NULL;
1302
1303   if (bfd_link_relocatable (info))
1304     return TRUE;
1305
1306   /* Don't do anything special with non-loaded, non-alloced sections.
1307      In particular, any relocs in such sections should not affect GOT
1308      and PLT reference counting (ie. we don't allow them to create GOT
1309      or PLT entries), there's no possibility or desire to optimize TLS
1310      relocs, and there's not much point in propagating relocs to shared
1311      libs that the dynamic linker won't relocate.  */
1312   if ((sec->flags & SEC_ALLOC) == 0)
1313     return TRUE;
1314
1315   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1316   sym_hashes = elf_sym_hashes (abfd);
1317
1318   htab = or1k_elf_hash_table (info);
1319   if (htab == NULL)
1320     return FALSE;
1321
1322   dynobj = htab->root.dynobj;
1323
1324   rel_end = relocs + sec->reloc_count;
1325   for (rel = relocs; rel < rel_end; rel++)
1326     {
1327       struct elf_link_hash_entry *h;
1328       unsigned long r_symndx;
1329       unsigned char tls_type;
1330
1331       r_symndx = ELF32_R_SYM (rel->r_info);
1332       if (r_symndx < symtab_hdr->sh_info)
1333         h = NULL;
1334       else
1335         {
1336           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1337           while (h->root.type == bfd_link_hash_indirect
1338                  || h->root.type == bfd_link_hash_warning)
1339             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1340         }
1341
1342       switch (ELF32_R_TYPE (rel->r_info))
1343         {
1344         case R_OR1K_TLS_GD_HI16:
1345         case R_OR1K_TLS_GD_LO16:
1346           tls_type = TLS_GD;
1347           break;
1348         case R_OR1K_TLS_LDM_HI16:
1349         case R_OR1K_TLS_LDM_LO16:
1350         case R_OR1K_TLS_LDO_HI16:
1351         case R_OR1K_TLS_LDO_LO16:
1352           tls_type = TLS_LD;
1353           break;
1354         case R_OR1K_TLS_IE_HI16:
1355         case R_OR1K_TLS_IE_LO16:
1356           tls_type = TLS_IE;
1357           break;
1358         case R_OR1K_TLS_LE_HI16:
1359         case R_OR1K_TLS_LE_LO16:
1360           tls_type = TLS_LE;
1361           break;
1362         default:
1363           tls_type = TLS_NONE;
1364         }
1365
1366       /* Record TLS type.  */
1367       if (h != NULL)
1368           ((struct elf_or1k_link_hash_entry *) h)->tls_type = tls_type;
1369       else
1370         {
1371           unsigned char *local_tls_type;
1372
1373           /* This is a TLS type record for a local symbol.  */
1374           local_tls_type = (unsigned char *) elf_or1k_local_tls_type (abfd);
1375           if (local_tls_type == NULL)
1376             {
1377               bfd_size_type size;
1378
1379               size = symtab_hdr->sh_info;
1380               local_tls_type = bfd_zalloc (abfd, size);
1381               if (local_tls_type == NULL)
1382                 return FALSE;
1383               elf_or1k_local_tls_type (abfd) = local_tls_type;
1384             }
1385           local_tls_type[r_symndx] = tls_type;
1386         }
1387
1388       switch (ELF32_R_TYPE (rel->r_info))
1389         {
1390           /* This relocation describes the C++ object vtable hierarchy.
1391              Reconstruct it for later use during GC.  */
1392         case R_OR1K_GNU_VTINHERIT:
1393           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1394             return FALSE;
1395           break;
1396
1397           /* This relocation describes which C++ vtable entries are actually
1398              used.  Record for later use during GC.  */
1399         case R_OR1K_GNU_VTENTRY:
1400           BFD_ASSERT (h != NULL);
1401           if (h != NULL
1402               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1403             return FALSE;
1404           break;
1405
1406           /* This relocation requires .plt entry.  */
1407         case R_OR1K_PLT26:
1408           if (h != NULL)
1409             {
1410               h->needs_plt = 1;
1411               h->plt.refcount += 1;
1412             }
1413           break;
1414
1415         case R_OR1K_GOT16:
1416         case R_OR1K_GOTOFF_HI16:
1417         case R_OR1K_GOTOFF_LO16:
1418         case R_OR1K_TLS_GD_HI16:
1419         case R_OR1K_TLS_GD_LO16:
1420         case R_OR1K_TLS_IE_HI16:
1421         case R_OR1K_TLS_IE_LO16:
1422           if (htab->root.sgot == NULL)
1423             {
1424               if (dynobj == NULL)
1425                 htab->root.dynobj = dynobj = abfd;
1426               if (!_bfd_elf_create_got_section (dynobj, info))
1427                 return FALSE;
1428             }
1429
1430           if (ELF32_R_TYPE (rel->r_info) != R_OR1K_GOTOFF_HI16 &&
1431               ELF32_R_TYPE (rel->r_info) != R_OR1K_GOTOFF_LO16)
1432             {
1433               if (h != NULL)
1434                 h->got.refcount += 1;
1435               else
1436                 {
1437                   bfd_signed_vma *local_got_refcounts;
1438
1439                   /* This is a global offset table entry for a local symbol.  */
1440                   local_got_refcounts = elf_local_got_refcounts (abfd);
1441                   if (local_got_refcounts == NULL)
1442                     {
1443                       bfd_size_type size;
1444
1445                       size = symtab_hdr->sh_info;
1446                       size *= sizeof (bfd_signed_vma);
1447                       local_got_refcounts = bfd_zalloc (abfd, size);
1448                       if (local_got_refcounts == NULL)
1449                         return FALSE;
1450                       elf_local_got_refcounts (abfd) = local_got_refcounts;
1451                     }
1452                   local_got_refcounts[r_symndx] += 1;
1453                 }
1454             }
1455           break;
1456
1457         case R_OR1K_INSN_REL_26:
1458         case R_OR1K_HI_16_IN_INSN:
1459         case R_OR1K_LO_16_IN_INSN:
1460         case R_OR1K_32:
1461           /* R_OR1K_16? */
1462           {
1463             if (h != NULL && !bfd_link_pic (info))
1464               {
1465                 /* We may need a copy reloc.  */
1466                 h->non_got_ref = 1;
1467
1468                 /* We may also need a .plt entry.  */
1469                 h->plt.refcount += 1;
1470                 if (ELF32_R_TYPE (rel->r_info) != R_OR1K_INSN_REL_26)
1471                   h->pointer_equality_needed = 1;
1472               }
1473
1474             /* If we are creating a shared library, and this is a reloc
1475                against a global symbol, or a non PC relative reloc
1476                against a local symbol, then we need to copy the reloc
1477                into the shared library.  However, if we are linking with
1478                -Bsymbolic, we do not need to copy a reloc against a
1479                global symbol which is defined in an object we are
1480                including in the link (i.e., DEF_REGULAR is set).  At
1481                this point we have not seen all the input files, so it is
1482                possible that DEF_REGULAR is not set now but will be set
1483                later (it is never cleared).  In case of a weak definition,
1484                DEF_REGULAR may be cleared later by a strong definition in
1485                a shared library.  We account for that possibility below by
1486                storing information in the relocs_copied field of the hash
1487                table entry.  A similar situation occurs when creating
1488                shared libraries and symbol visibility changes render the
1489                symbol local.
1490
1491                If on the other hand, we are creating an executable, we
1492                may need to keep relocations for symbols satisfied by a
1493                dynamic library if we manage to avoid copy relocs for the
1494                symbol.  */
1495
1496             if ((bfd_link_pic (info)
1497                  && (sec->flags & SEC_ALLOC) != 0
1498                  && (ELF32_R_TYPE (rel->r_info) != R_OR1K_INSN_REL_26
1499                      || (h != NULL
1500                          && (!SYMBOLIC_BIND (info, h)
1501                              || h->root.type == bfd_link_hash_defweak
1502                              || !h->def_regular))))
1503                 || (!bfd_link_pic (info)
1504                     && (sec->flags & SEC_ALLOC) != 0
1505                     && h != NULL
1506                     && (h->root.type == bfd_link_hash_defweak
1507                         || !h->def_regular)))
1508               {
1509                 struct elf_dyn_relocs *p;
1510                 struct elf_dyn_relocs **head;
1511
1512                 /* When creating a shared object, we must copy these
1513                    relocs into the output file.  We create a reloc
1514                    section in dynobj and make room for the reloc.  */
1515                 if (sreloc == NULL)
1516                   {
1517                     const char *name;
1518                     unsigned int strndx = elf_elfheader (abfd)->e_shstrndx;
1519                     unsigned int shnam = _bfd_elf_single_rel_hdr (sec)->sh_name;
1520
1521                     name = bfd_elf_string_from_elf_section (abfd, strndx, shnam);
1522                     if (name == NULL)
1523                       return FALSE;
1524
1525                     if (strncmp (name, ".rela", 5) != 0
1526                         || strcmp (bfd_get_section_name (abfd, sec),
1527                                    name + 5) != 0)
1528                       {
1529                         _bfd_error_handler
1530                           /* xgettext:c-format */
1531                           (_("%pB: bad relocation section name `%s\'"),
1532                            abfd, name);
1533                       }
1534
1535                     if (htab->root.dynobj == NULL)
1536                       htab->root.dynobj = abfd;
1537                     dynobj = htab->root.dynobj;
1538
1539                     sreloc = bfd_get_section_by_name (dynobj, name);
1540                     if (sreloc == NULL)
1541                       {
1542                         sreloc = _bfd_elf_make_dynamic_reloc_section
1543                           (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
1544
1545                         if (sreloc == NULL)
1546                           return FALSE;
1547                       }
1548                     elf_section_data (sec)->sreloc = sreloc;
1549                   }
1550
1551                 /* If this is a global symbol, we count the number of
1552                    relocations we need for this symbol.  */
1553                 if (h != NULL)
1554                   head = &((struct elf_or1k_link_hash_entry *) h)->dyn_relocs;
1555                 else
1556                   {
1557                     /* Track dynamic relocs needed for local syms too.
1558                        We really need local syms available to do this
1559                        easily.  Oh well.  */
1560
1561                     asection *s;
1562                     Elf_Internal_Sym *isym;
1563                     void *vpp;
1564
1565                     isym = bfd_sym_from_r_symndx (&htab->sym_sec,
1566                                                   abfd, r_symndx);
1567                     if (isym == NULL)
1568                       return FALSE;
1569
1570                     s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1571                     if (s == NULL)
1572                       return FALSE;
1573
1574                     vpp = &elf_section_data (s)->local_dynrel;
1575                     head = (struct elf_dyn_relocs **) vpp;
1576                   }
1577
1578                 p = *head;
1579                 if (p == NULL || p->sec != sec)
1580                   {
1581                     bfd_size_type amt = sizeof *p;
1582                     p = ((struct elf_dyn_relocs *)
1583                          bfd_alloc (htab->root.dynobj, amt));
1584                     if (p == NULL)
1585                       return FALSE;
1586                     p->next = *head;
1587                     *head = p;
1588                     p->sec = sec;
1589                     p->count = 0;
1590                     p->pc_count = 0;
1591                   }
1592
1593                 p->count += 1;
1594                 if (ELF32_R_TYPE (rel->r_info) == R_OR1K_INSN_REL_26)
1595                   p->pc_count += 1;
1596               }
1597           }
1598           break;
1599         }
1600     }
1601
1602   return TRUE;
1603 }
1604
1605 /* Finish up the dynamic sections.  */
1606
1607 static bfd_boolean
1608 or1k_elf_finish_dynamic_sections (bfd *output_bfd,
1609                                   struct bfd_link_info *info)
1610 {
1611   bfd *dynobj;
1612   asection *sdyn, *sgot;
1613   struct elf_or1k_link_hash_table *htab;
1614
1615   htab = or1k_elf_hash_table (info);
1616   if (htab == NULL)
1617     return FALSE;
1618
1619   dynobj = htab->root.dynobj;
1620
1621   sgot = htab->root.sgotplt;
1622   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1623
1624   if (htab->root.dynamic_sections_created)
1625     {
1626       asection *splt;
1627       Elf32_External_Dyn *dyncon, *dynconend;
1628
1629       BFD_ASSERT (sgot != NULL && sdyn != NULL);
1630
1631       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1632       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1633
1634       for (; dyncon < dynconend; dyncon++)
1635         {
1636           Elf_Internal_Dyn dyn;
1637           asection *s;
1638
1639           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1640
1641           switch (dyn.d_tag)
1642             {
1643             default:
1644               continue;
1645
1646             case DT_PLTGOT:
1647               s = htab->root.sgotplt;
1648               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1649               break;
1650
1651             case DT_JMPREL:
1652               s = htab->root.srelplt;
1653               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1654               break;
1655
1656             case DT_PLTRELSZ:
1657               s = htab->root.srelplt;
1658               dyn.d_un.d_val = s->size;
1659               break;
1660             }
1661           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1662         }
1663
1664
1665       /* Fill in the first entry in the procedure linkage table.  */
1666       splt = htab->root.splt;
1667       if (splt && splt->size > 0)
1668         {
1669           if (bfd_link_pic (info))
1670             {
1671               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0,
1672                           splt->contents);
1673               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1,
1674                           splt->contents + 4);
1675               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2,
1676                           splt->contents + 8);
1677               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3,
1678                           splt->contents + 12);
1679               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4,
1680                           splt->contents + 16);
1681             }
1682           else
1683             {
1684               unsigned long addr;
1685               /* addr = .got + 4 */
1686               addr = sgot->output_section->vma + sgot->output_offset + 4;
1687               bfd_put_32 (output_bfd,
1688                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1689                           splt->contents);
1690               bfd_put_32 (output_bfd,
1691                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1692                           splt->contents + 4);
1693               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1694               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1695               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1696             }
1697
1698           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
1699         }
1700     }
1701
1702   /* Set the first entry in the global offset table to the address of
1703      the dynamic section.  */
1704   if (sgot && sgot->size > 0)
1705     {
1706       if (sdyn == NULL)
1707         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1708       else
1709         bfd_put_32 (output_bfd,
1710                     sdyn->output_section->vma + sdyn->output_offset,
1711                     sgot->contents);
1712       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1713     }
1714
1715   if (htab->root.sgot && htab->root.sgot->size > 0)
1716     elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize = 4;
1717
1718   return TRUE;
1719 }
1720
1721 /* Finish up dynamic symbol handling.  We set the contents of various
1722    dynamic sections here.  */
1723
1724 static bfd_boolean
1725 or1k_elf_finish_dynamic_symbol (bfd *output_bfd,
1726                                 struct bfd_link_info *info,
1727                                 struct elf_link_hash_entry *h,
1728                                 Elf_Internal_Sym *sym)
1729 {
1730   struct elf_or1k_link_hash_table *htab;
1731   bfd_byte *loc;
1732
1733   htab = or1k_elf_hash_table (info);
1734   if (htab == NULL)
1735     return FALSE;
1736
1737   if (h->plt.offset != (bfd_vma) -1)
1738     {
1739       asection *splt;
1740       asection *sgot;
1741       asection *srela;
1742
1743       bfd_vma plt_index;
1744       bfd_vma got_offset;
1745       bfd_vma got_addr;
1746       Elf_Internal_Rela rela;
1747
1748       /* This symbol has an entry in the procedure linkage table.  Set
1749          it up.  */
1750       BFD_ASSERT (h->dynindx != -1);
1751
1752       splt = htab->root.splt;
1753       sgot = htab->root.sgotplt;
1754       srela = htab->root.srelplt;
1755       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1756
1757       /* Get the index in the procedure linkage table which
1758          corresponds to this symbol.  This is the index of this symbol
1759          in all the symbols for which we are making plt entries.  The
1760          first entry in the procedure linkage table is reserved.  */
1761       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1762
1763       /* Get the offset into the .got table of the entry that
1764         corresponds to this function.  Each .got entry is 4 bytes.
1765         The first three are reserved.  */
1766       got_offset = (plt_index + 3) * 4;
1767       got_addr = got_offset;
1768
1769       /* Fill in the entry in the procedure linkage table.  */
1770       if (! bfd_link_pic (info))
1771         {
1772           got_addr += htab->root.sgotplt->output_section->vma
1773             + htab->root.sgotplt->output_offset;
1774           bfd_put_32 (output_bfd, PLT_ENTRY_WORD0 | ((got_addr >> 16) & 0xffff),
1775                       splt->contents + h->plt.offset);
1776           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1 | (got_addr & 0xffff),
1777                       splt->contents + h->plt.offset + 4);
1778           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
1779                       splt->contents + h->plt.offset + 8);
1780           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
1781                       splt->contents + h->plt.offset + 12);
1782           bfd_put_32 (output_bfd, PLT_ENTRY_WORD4
1783                       | plt_index * sizeof (Elf32_External_Rela),
1784                       splt->contents + h->plt.offset + 16);
1785         }
1786       else
1787         {
1788           bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD0 | (got_addr & 0xffff),
1789                       splt->contents + h->plt.offset);
1790           bfd_put_32 (output_bfd, PLT_PIC_ENTRY_WORD1
1791                       | plt_index * sizeof (Elf32_External_Rela),
1792                       splt->contents + h->plt.offset + 4);
1793           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
1794                       splt->contents + h->plt.offset + 8);
1795           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
1796                       splt->contents + h->plt.offset + 12);
1797           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
1798                       splt->contents + h->plt.offset + 16);
1799         }
1800
1801       /* Fill in the entry in the global offset table.  */
1802       bfd_put_32 (output_bfd,
1803                   (splt->output_section->vma
1804                    + splt->output_offset), /* Same offset.  */
1805                   sgot->contents + got_offset);
1806
1807       /* Fill in the entry in the .rela.plt section.  */
1808       rela.r_offset = (sgot->output_section->vma
1809                        + sgot->output_offset
1810                        + got_offset);
1811       rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_JMP_SLOT);
1812       rela.r_addend = 0;
1813       loc = srela->contents;
1814       loc += plt_index * sizeof (Elf32_External_Rela);
1815       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1816
1817       if (!h->def_regular)
1818         {
1819           /* Mark the symbol as undefined, rather than as defined in
1820              the .plt section.  Leave the value alone.  */
1821           sym->st_shndx = SHN_UNDEF;
1822         }
1823
1824     }
1825
1826   if (h->got.offset != (bfd_vma) -1
1827       && (h->got.offset & 2) == 0) /* Homemade TLS check.  */
1828     {
1829       asection *sgot;
1830       asection *srela;
1831       Elf_Internal_Rela rela;
1832
1833       /* This symbol has an entry in the global offset table.  Set it
1834          up.  */
1835       sgot = htab->root.sgot;
1836       srela = htab->root.srelgot;
1837       BFD_ASSERT (sgot != NULL && srela != NULL);
1838
1839       rela.r_offset = (sgot->output_section->vma
1840                        + sgot->output_offset
1841                        + (h->got.offset &~ 1));
1842
1843       /* If this is a -Bsymbolic link, and the symbol is defined
1844          locally, we just want to emit a RELATIVE reloc.  Likewise if
1845          the symbol was forced to be local because of a version file.
1846          The entry in the global offset table will already have been
1847          initialized in the relocate_section function.  */
1848       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
1849         {
1850           rela.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE);
1851           rela.r_addend = (h->root.u.def.value
1852                            + h->root.u.def.section->output_section->vma
1853                            + h->root.u.def.section->output_offset);
1854         }
1855       else
1856         {
1857           BFD_ASSERT ((h->got.offset & 1) == 0);
1858           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1859           rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_GLOB_DAT);
1860           rela.r_addend = 0;
1861         }
1862
1863       loc = srela->contents;
1864       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1865       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1866       ++srela->reloc_count;
1867     }
1868
1869   if (h->needs_copy)
1870     {
1871       asection *s;
1872       Elf_Internal_Rela rela;
1873
1874       /* This symbols needs a copy reloc.  Set it up.  */
1875       BFD_ASSERT (h->dynindx != -1
1876                   && (h->root.type == bfd_link_hash_defined
1877                       || h->root.type == bfd_link_hash_defweak));
1878
1879       rela.r_offset = (h->root.u.def.value
1880                        + h->root.u.def.section->output_section->vma
1881                        + h->root.u.def.section->output_offset);
1882       rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_COPY);
1883       rela.r_addend = 0;
1884       if (h->root.u.def.section == htab->root.sdynrelro)
1885         s = htab->root.sreldynrelro;
1886       else
1887         s = htab->root.srelbss;
1888       loc = s->contents + s->reloc_count * sizeof (Elf32_External_Rela);
1889       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1890       ++s->reloc_count;
1891     }
1892
1893   /* Mark some specially defined symbols as absolute.  */
1894   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1895       || h == htab->root.hgot)
1896     sym->st_shndx = SHN_ABS;
1897
1898   return TRUE;
1899 }
1900
1901 static enum elf_reloc_type_class
1902 or1k_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1903                            const asection *rel_sec ATTRIBUTE_UNUSED,
1904                            const Elf_Internal_Rela *rela)
1905 {
1906   switch ((int) ELF32_R_TYPE (rela->r_info))
1907     {
1908     case R_OR1K_RELATIVE:  return reloc_class_relative;
1909     case R_OR1K_JMP_SLOT:  return reloc_class_plt;
1910     case R_OR1K_COPY:      return reloc_class_copy;
1911     default:               return reloc_class_normal;
1912     }
1913 }
1914
1915 /* Find dynamic relocs for H that apply to read-only sections.  */
1916
1917 static asection *
1918 readonly_dynrelocs (struct elf_link_hash_entry *h)
1919 {
1920   struct elf_dyn_relocs *p;
1921   struct elf_or1k_link_hash_entry *eh = (struct elf_or1k_link_hash_entry *) h;
1922
1923   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1924     {
1925       asection *s = p->sec->output_section;
1926
1927       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1928         return p->sec;
1929     }
1930   return NULL;
1931 }
1932
1933 /* Adjust a symbol defined by a dynamic object and referenced by a
1934    regular object.  The current definition is in some section of the
1935    dynamic object, but we're not including those sections.  We have to
1936    change the definition to something the rest of the link can
1937    understand.  */
1938
1939 static bfd_boolean
1940 or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1941                                 struct elf_link_hash_entry *h)
1942 {
1943   struct elf_or1k_link_hash_table *htab;
1944   bfd *dynobj;
1945   asection *s, *srel;
1946
1947   dynobj = elf_hash_table (info)->dynobj;
1948
1949   /* Make sure we know what is going on here.  */
1950   BFD_ASSERT (dynobj != NULL
1951               && (h->needs_plt
1952                   || h->is_weakalias
1953                   || (h->def_dynamic
1954                       && h->ref_regular
1955                       && !h->def_regular)));
1956
1957   /* If this is a function, put it in the procedure linkage table.  We
1958      will fill in the contents of the procedure linkage table later,
1959      when we know the address of the .got section.  */
1960   if (h->type == STT_FUNC
1961       || h->needs_plt)
1962     {
1963       if (! bfd_link_pic (info)
1964           && !h->def_dynamic
1965           && !h->ref_dynamic
1966           && h->root.type != bfd_link_hash_undefweak
1967           && h->root.type != bfd_link_hash_undefined)
1968         {
1969           /* This case can occur if we saw a PLT reloc in an input
1970              file, but the symbol was never referred to by a dynamic
1971              object.  In such a case, we don't actually need to build
1972              a procedure linkage table, and we can just do a PCREL
1973              reloc instead.  */
1974           h->plt.offset = (bfd_vma) -1;
1975           h->needs_plt = 0;
1976         }
1977
1978       return TRUE;
1979     }
1980   else
1981     h->plt.offset = (bfd_vma) -1;
1982
1983   /* If this is a weak symbol, and there is a real definition, the
1984      processor independent code will have arranged for us to see the
1985      real definition first, and we can just use the same value.  */
1986   if (h->is_weakalias)
1987     {
1988       struct elf_link_hash_entry *def = weakdef (h);
1989       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1990       h->root.u.def.section = def->root.u.def.section;
1991       h->root.u.def.value = def->root.u.def.value;
1992       return TRUE;
1993     }
1994
1995   /* This is a reference to a symbol defined by a dynamic object which
1996      is not a function.  */
1997
1998   /* If we are creating a shared library, we must presume that the
1999      only references to the symbol are via the global offset table.
2000      For such cases we need not do anything here; the relocations will
2001      be handled correctly by relocate_section.  */
2002   if (bfd_link_pic (info))
2003     return TRUE;
2004
2005   /* If there are no references to this symbol that do not use the
2006      GOT, we don't need to generate a copy reloc.  */
2007   if (!h->non_got_ref)
2008     return TRUE;
2009
2010   /* If -z nocopyreloc was given, we won't generate them either.  */
2011   if (info->nocopyreloc)
2012     {
2013       h->non_got_ref = 0;
2014       return TRUE;
2015     }
2016
2017   /* If we don't find any dynamic relocs in read-only sections, then
2018      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2019   if (!readonly_dynrelocs (h))
2020     {
2021       h->non_got_ref = 0;
2022       return TRUE;
2023     }
2024
2025   /* We must allocate the symbol in our .dynbss section, which will
2026      become part of the .bss section of the executable.  There will be
2027      an entry for this symbol in the .dynsym section.  The dynamic
2028      object will contain position independent code, so all references
2029      from the dynamic object to this symbol will go through the global
2030      offset table.  The dynamic linker will use the .dynsym entry to
2031      determine the address it must put in the global offset table, so
2032      both the dynamic object and the regular object will refer to the
2033      same memory location for the variable.  */
2034
2035   htab = or1k_elf_hash_table (info);
2036   if (htab == NULL)
2037     return FALSE;
2038
2039   /* We must generate a R_OR1K_COPY reloc to tell the dynamic linker
2040      to copy the initial value out of the dynamic object and into the
2041      runtime process image.  We need to remember the offset into the
2042      .rela.bss section we are going to use.  */
2043   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2044     {
2045       s = htab->root.sdynrelro;
2046       srel = htab->root.sreldynrelro;
2047     }
2048   else
2049     {
2050       s = htab->root.sdynbss;
2051       srel = htab->root.srelbss;
2052     }
2053   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2054     {
2055       srel->size += sizeof (Elf32_External_Rela);
2056       h->needs_copy = 1;
2057     }
2058
2059   return _bfd_elf_adjust_dynamic_copy (info, h, s);
2060 }
2061
2062 /* Allocate space in .plt, .got and associated reloc sections for
2063    dynamic relocs.  */
2064
2065 static bfd_boolean
2066 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2067 {
2068   struct bfd_link_info *info;
2069   struct elf_or1k_link_hash_table *htab;
2070   struct elf_or1k_link_hash_entry *eh;
2071   struct elf_dyn_relocs *p;
2072
2073   if (h->root.type == bfd_link_hash_indirect)
2074     return TRUE;
2075
2076   info = (struct bfd_link_info *) inf;
2077   htab = or1k_elf_hash_table (info);
2078   if (htab == NULL)
2079     return FALSE;
2080
2081   eh = (struct elf_or1k_link_hash_entry *) h;
2082
2083   if (htab->root.dynamic_sections_created
2084       && h->plt.refcount > 0)
2085     {
2086       /* Make sure this symbol is output as a dynamic symbol.
2087          Undefined weak syms won't yet be marked as dynamic.  */
2088       if (h->dynindx == -1
2089           && !h->forced_local)
2090         {
2091           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2092             return FALSE;
2093         }
2094
2095       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2096         {
2097           asection *s = htab->root.splt;
2098
2099           /* If this is the first .plt entry, make room for the special
2100              first entry.  */
2101           if (s->size == 0)
2102             s->size = PLT_ENTRY_SIZE;
2103
2104           h->plt.offset = s->size;
2105
2106           /* If this symbol is not defined in a regular file, and we are
2107              not generating a shared library, then set the symbol to this
2108              location in the .plt.  This is required to make function
2109              pointers compare as equal between the normal executable and
2110              the shared library.  */
2111           if (! bfd_link_pic (info)
2112               && !h->def_regular)
2113             {
2114               h->root.u.def.section = s;
2115               h->root.u.def.value = h->plt.offset;
2116             }
2117
2118           /* Make room for this entry.  */
2119           s->size += PLT_ENTRY_SIZE;
2120
2121           /* We also need to make an entry in the .got.plt section, which
2122              will be placed in the .got section by the linker script.  */
2123           htab->root.sgotplt->size += 4;
2124
2125           /* We also need to make an entry in the .rel.plt section.  */
2126           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
2127         }
2128       else
2129         {
2130           h->plt.offset = (bfd_vma) -1;
2131           h->needs_plt = 0;
2132         }
2133     }
2134   else
2135     {
2136       h->plt.offset = (bfd_vma) -1;
2137       h->needs_plt = 0;
2138     }
2139
2140   if (h->got.refcount > 0)
2141     {
2142       asection *s;
2143       bfd_boolean dyn;
2144       unsigned char tls_type;
2145
2146       /* Make sure this symbol is output as a dynamic symbol.
2147          Undefined weak syms won't yet be marked as dynamic.  */
2148       if (h->dynindx == -1
2149           && !h->forced_local)
2150         {
2151           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2152             return FALSE;
2153         }
2154
2155       s = htab->root.sgot;
2156
2157       h->got.offset = s->size;
2158
2159       tls_type = ((struct elf_or1k_link_hash_entry *) h)->tls_type;
2160
2161       /* TLS GD requires two GOT and two relocs.  */
2162       if (tls_type == TLS_GD)
2163         s->size += 8;
2164       else
2165         s->size += 4;
2166       dyn = htab->root.dynamic_sections_created;
2167       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
2168         {
2169           if (tls_type == TLS_GD)
2170             htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela);
2171           else
2172             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
2173         }
2174     }
2175   else
2176     h->got.offset = (bfd_vma) -1;
2177
2178   if (eh->dyn_relocs == NULL)
2179     return TRUE;
2180
2181   /* In the shared -Bsymbolic case, discard space allocated for
2182      dynamic pc-relative relocs against symbols which turn out to be
2183      defined in regular objects.  For the normal shared case, discard
2184      space for pc-relative relocs that have become local due to symbol
2185      visibility changes.  */
2186
2187   if (bfd_link_pic (info))
2188     {
2189       if (SYMBOL_CALLS_LOCAL (info, h))
2190         {
2191           struct elf_dyn_relocs **pp;
2192
2193           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2194             {
2195               p->count -= p->pc_count;
2196               p->pc_count = 0;
2197               if (p->count == 0)
2198                 *pp = p->next;
2199               else
2200                 pp = &p->next;
2201             }
2202         }
2203
2204       /* Also discard relocs on undefined weak syms with non-default
2205          visibility.  */
2206       if (eh->dyn_relocs != NULL
2207           && h->root.type == bfd_link_hash_undefweak)
2208         {
2209           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2210             eh->dyn_relocs = NULL;
2211
2212           /* Make sure undefined weak symbols are output as a dynamic
2213              symbol in PIEs.  */
2214           else if (h->dynindx == -1
2215                    && !h->forced_local)
2216             {
2217               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2218                 return FALSE;
2219             }
2220         }
2221     }
2222   else
2223     {
2224       /* For the non-shared case, discard space for relocs against
2225          symbols which turn out to need copy relocs or are not
2226          dynamic.  */
2227
2228       if (!h->non_got_ref
2229           && ((h->def_dynamic
2230                && !h->def_regular)
2231               || (htab->root.dynamic_sections_created
2232                   && (h->root.type == bfd_link_hash_undefweak
2233                       || h->root.type == bfd_link_hash_undefined))))
2234         {
2235           /* Make sure this symbol is output as a dynamic symbol.
2236              Undefined weak syms won't yet be marked as dynamic.  */
2237           if (h->dynindx == -1
2238               && !h->forced_local)
2239             {
2240               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2241                 return FALSE;
2242             }
2243
2244           /* If that succeeded, we know we'll be keeping all the
2245              relocs.  */
2246           if (h->dynindx != -1)
2247             goto keep;
2248         }
2249
2250       eh->dyn_relocs = NULL;
2251
2252     keep: ;
2253     }
2254
2255   /* Finally, allocate space.  */
2256   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2257     {
2258       asection *sreloc = elf_section_data (p->sec)->sreloc;
2259       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2260     }
2261
2262   return TRUE;
2263 }
2264
2265 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2266    read-only sections.  */
2267
2268 static bfd_boolean
2269 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2270 {
2271   asection *sec;
2272
2273   if (h->root.type == bfd_link_hash_indirect)
2274     return TRUE;
2275
2276   sec = readonly_dynrelocs (h);
2277   if (sec != NULL)
2278     {
2279       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2280
2281       info->flags |= DF_TEXTREL;
2282       info->callbacks->minfo
2283         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2284          sec->owner, h->root.root.string, sec);
2285
2286       /* Not an error, just cut short the traversal.  */
2287       return FALSE;
2288     }
2289   return TRUE;
2290 }
2291
2292 /* Set the sizes of the dynamic sections.  */
2293
2294 static bfd_boolean
2295 or1k_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2296                                 struct bfd_link_info *info)
2297 {
2298   struct elf_or1k_link_hash_table *htab;
2299   bfd *dynobj;
2300   asection *s;
2301   bfd_boolean relocs;
2302   bfd *ibfd;
2303
2304   htab = or1k_elf_hash_table (info);
2305   if (htab == NULL)
2306     return FALSE;
2307
2308   dynobj = htab->root.dynobj;
2309   BFD_ASSERT (dynobj != NULL);
2310
2311   if (htab->root.dynamic_sections_created)
2312     {
2313       /* Set the contents of the .interp section to the interpreter.  */
2314       if (bfd_link_executable (info) && !info->nointerp)
2315         {
2316           s = bfd_get_section_by_name (dynobj, ".interp");
2317           BFD_ASSERT (s != NULL);
2318           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2319           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2320         }
2321     }
2322
2323   /* Set up .got offsets for local syms, and space for local dynamic
2324      relocs.  */
2325   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2326     {
2327       bfd_signed_vma *local_got;
2328       bfd_signed_vma *end_local_got;
2329       bfd_size_type locsymcount;
2330       Elf_Internal_Shdr *symtab_hdr;
2331       unsigned char *local_tls_type;
2332       asection *srel;
2333
2334       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2335         continue;
2336
2337       for (s = ibfd->sections; s != NULL; s = s->next)
2338         {
2339           struct elf_dyn_relocs *p;
2340
2341           for (p = ((struct elf_dyn_relocs *)
2342                     elf_section_data (s)->local_dynrel);
2343                p != NULL;
2344                p = p->next)
2345             {
2346               if (! bfd_is_abs_section (p->sec)
2347                   && bfd_is_abs_section (p->sec->output_section))
2348                 {
2349                   /* Input section has been discarded, either because
2350                      it is a copy of a linkonce section or due to
2351                      linker script /DISCARD/, so we'll be discarding
2352                      the relocs too.  */
2353                 }
2354               else if (p->count != 0)
2355                 {
2356                   srel = elf_section_data (p->sec)->sreloc;
2357                   srel->size += p->count * sizeof (Elf32_External_Rela);
2358                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2359                     info->flags |= DF_TEXTREL;
2360                 }
2361             }
2362         }
2363
2364       local_got = elf_local_got_refcounts (ibfd);
2365       if (!local_got)
2366         continue;
2367
2368       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2369       locsymcount = symtab_hdr->sh_info;
2370       end_local_got = local_got + locsymcount;
2371       s = htab->root.sgot;
2372       srel = htab->root.srelgot;
2373       local_tls_type = (unsigned char *) elf_or1k_local_tls_type (ibfd);
2374       for (; local_got < end_local_got; ++local_got)
2375         {
2376           if (*local_got > 0)
2377             {
2378               *local_got = s->size;
2379
2380               /* TLS GD requires two GOT and two relocs.  */
2381               if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2382                 s->size += 8;
2383               else
2384                 s->size += 4;
2385               if (bfd_link_pic (info))
2386                 {
2387                   if (local_tls_type != NULL && *local_tls_type == TLS_GD)
2388                     srel->size += 2 * sizeof (Elf32_External_Rela);
2389                   else
2390                     srel->size += sizeof (Elf32_External_Rela);
2391                 }
2392             }
2393           else
2394
2395             *local_got = (bfd_vma) -1;
2396
2397           if (local_tls_type)
2398             ++local_tls_type;
2399         }
2400     }
2401
2402   /* Allocate global sym .plt and .got entries, and space for global
2403      sym dynamic relocs.  */
2404   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2405
2406   /* We now have determined the sizes of the various dynamic sections.
2407      Allocate memory for them.  */
2408   relocs = FALSE;
2409   for (s = dynobj->sections; s != NULL; s = s->next)
2410     {
2411       if ((s->flags & SEC_LINKER_CREATED) == 0)
2412         continue;
2413
2414       if (s == htab->root.splt
2415           || s == htab->root.sgot
2416           || s == htab->root.sgotplt
2417           || s == htab->root.sdynbss
2418           || s == htab->root.sdynrelro)
2419         {
2420           /* Strip this section if we don't need it; see the
2421              comment below.  */
2422         }
2423       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2424         {
2425           if (s->size != 0 && s != htab->root.srelplt)
2426             relocs = TRUE;
2427
2428           /* We use the reloc_count field as a counter if we need
2429              to copy relocs into the output file.  */
2430           s->reloc_count = 0;
2431         }
2432       else
2433         /* It's not one of our sections, so don't allocate space.  */
2434         continue;
2435
2436       if (s->size == 0)
2437         {
2438           /* If we don't need this section, strip it from the
2439              output file.  This is mostly to handle .rela.bss and
2440              .rela.plt.  We must create both sections in
2441              create_dynamic_sections, because they must be created
2442              before the linker maps input sections to output
2443              sections.  The linker does that before
2444              adjust_dynamic_symbol is called, and it is that
2445              function which decides whether anything needs to go
2446              into these sections.  */
2447           s->flags |= SEC_EXCLUDE;
2448           continue;
2449         }
2450
2451       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2452         continue;
2453
2454       /* Allocate memory for the section contents.  We use bfd_zalloc
2455          here in case unused entries are not reclaimed before the
2456          section's contents are written out.  This should not happen,
2457          but this way if it does, we get a R_OR1K_NONE reloc instead
2458          of garbage.  */
2459       s->contents = bfd_zalloc (dynobj, s->size);
2460
2461       if (s->contents == NULL)
2462         return FALSE;
2463     }
2464
2465   if (htab->root.dynamic_sections_created)
2466     {
2467       /* Add some entries to the .dynamic section.  We fill in the
2468          values later, in or1k_elf_finish_dynamic_sections, but we
2469          must add the entries now so that we get the correct size for
2470          the .dynamic section.  The DT_DEBUG entry is filled in by the
2471          dynamic linker and used by the debugger.  */
2472 #define add_dynamic_entry(TAG, VAL) \
2473   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2474
2475      if (bfd_link_executable (info))
2476        {
2477          if (! add_dynamic_entry (DT_DEBUG, 0))
2478            return FALSE;
2479        }
2480
2481      if (htab->root.splt->size != 0)
2482        {
2483          if (! add_dynamic_entry (DT_PLTGOT, 0)
2484              || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2485              || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2486              || ! add_dynamic_entry (DT_JMPREL, 0))
2487            return FALSE;
2488         }
2489
2490      if (relocs)
2491        {
2492          if (! add_dynamic_entry (DT_RELA, 0)
2493              || ! add_dynamic_entry (DT_RELASZ, 0)
2494              || ! add_dynamic_entry (DT_RELAENT,
2495                                      sizeof (Elf32_External_Rela)))
2496            return FALSE;
2497
2498          /* If any dynamic relocs apply to a read-only section,
2499             then we need a DT_TEXTREL entry.  */
2500          if ((info->flags & DF_TEXTREL) == 0)
2501            elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2502
2503          if ((info->flags & DF_TEXTREL) != 0)
2504            {
2505              if (! add_dynamic_entry (DT_TEXTREL, 0))
2506                return FALSE;
2507            }
2508        }
2509     }
2510
2511 #undef add_dynamic_entry
2512   return TRUE;
2513 }
2514
2515 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2516
2517 static void
2518 or1k_elf_copy_indirect_symbol (struct bfd_link_info *info,
2519                                struct elf_link_hash_entry *dir,
2520                                struct elf_link_hash_entry *ind)
2521 {
2522   struct elf_or1k_link_hash_entry * edir;
2523   struct elf_or1k_link_hash_entry * eind;
2524
2525   edir = (struct elf_or1k_link_hash_entry *) dir;
2526   eind = (struct elf_or1k_link_hash_entry *) ind;
2527
2528   if (eind->dyn_relocs != NULL)
2529     {
2530       if (edir->dyn_relocs != NULL)
2531         {
2532           struct elf_dyn_relocs **pp;
2533           struct elf_dyn_relocs *p;
2534
2535           /* Add reloc counts against the indirect sym to the direct sym
2536              list.  Merge any entries against the same section.  */
2537           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2538             {
2539               struct elf_dyn_relocs *q;
2540
2541               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2542                 if (q->sec == p->sec)
2543                   {
2544                     q->pc_count += p->pc_count;
2545                     q->count += p->count;
2546                     *pp = p->next;
2547                     break;
2548                   }
2549               if (q == NULL)
2550                 pp = &p->next;
2551             }
2552           *pp = edir->dyn_relocs;
2553         }
2554
2555       edir->dyn_relocs = eind->dyn_relocs;
2556       eind->dyn_relocs = NULL;
2557     }
2558
2559   if (ind->root.type == bfd_link_hash_indirect)
2560     {
2561       if (dir->got.refcount <= 0)
2562         {
2563           edir->tls_type = eind->tls_type;
2564           eind->tls_type = TLS_UNKNOWN;
2565         }
2566     }
2567
2568   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2569 }
2570
2571 /* Set the right machine number.  */
2572
2573 static bfd_boolean
2574 or1k_elf_object_p (bfd *abfd)
2575 {
2576   unsigned long mach = bfd_mach_or1k;
2577
2578   if (elf_elfheader (abfd)->e_flags & EF_OR1K_NODELAY)
2579     mach = bfd_mach_or1knd;
2580
2581   return bfd_default_set_arch_mach (abfd, bfd_arch_or1k, mach);
2582 }
2583
2584 /* Store the machine number in the flags field.  */
2585
2586 static void
2587 or1k_elf_final_write_processing (bfd *abfd,
2588                                  bfd_boolean linker ATTRIBUTE_UNUSED)
2589 {
2590   switch (bfd_get_mach (abfd))
2591     {
2592     default:
2593     case bfd_mach_or1k:
2594       break;
2595     case bfd_mach_or1knd:
2596       elf_elfheader (abfd)->e_flags |= EF_OR1K_NODELAY;
2597       break;
2598     }
2599 }
2600
2601 static bfd_boolean
2602 or1k_elf_set_private_flags (bfd *abfd, flagword flags)
2603 {
2604   BFD_ASSERT (!elf_flags_init (abfd)
2605               || elf_elfheader (abfd)->e_flags == flags);
2606
2607   elf_elfheader (abfd)->e_flags = flags;
2608   elf_flags_init (abfd) = TRUE;
2609   return TRUE;
2610 }
2611
2612 /* Make sure all input files are consistent with respect to
2613    EF_OR1K_NODELAY flag setting.  */
2614
2615 static bfd_boolean
2616 elf32_or1k_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2617 {
2618   bfd *obfd = info->output_bfd;
2619   flagword out_flags;
2620   flagword in_flags;
2621
2622   in_flags  = elf_elfheader (ibfd)->e_flags;
2623   out_flags = elf_elfheader (obfd)->e_flags;
2624
2625   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2626       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2627     return TRUE;
2628
2629   if (!elf_flags_init (obfd))
2630     {
2631       elf_flags_init (obfd) = TRUE;
2632       elf_elfheader (obfd)->e_flags = in_flags;
2633
2634       return TRUE;
2635     }
2636
2637   if (in_flags == out_flags)
2638     return TRUE;
2639
2640   if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY))
2641     {
2642       _bfd_error_handler
2643         (_("%pB: %s flag mismatch with previous modules"),
2644          ibfd, "EF_OR1K_NODELAY");
2645
2646       bfd_set_error (bfd_error_bad_value);
2647       return FALSE;
2648     }
2649
2650   return TRUE;
2651
2652 }
2653
2654 #define ELF_ARCH                        bfd_arch_or1k
2655 #define ELF_MACHINE_CODE                EM_OR1K
2656 #define ELF_TARGET_ID                   OR1K_ELF_DATA
2657 #define ELF_MAXPAGESIZE                 0x2000
2658
2659 #define TARGET_BIG_SYM                  or1k_elf32_vec
2660 #define TARGET_BIG_NAME                 "elf32-or1k"
2661
2662 #define elf_info_to_howto_rel           NULL
2663 #define elf_info_to_howto               or1k_info_to_howto_rela
2664 #define elf_backend_relocate_section    or1k_elf_relocate_section
2665 #define elf_backend_gc_mark_hook        or1k_elf_gc_mark_hook
2666 #define elf_backend_check_relocs        or1k_elf_check_relocs
2667 #define elf_backend_reloc_type_class    or1k_elf_reloc_type_class
2668 #define elf_backend_can_gc_sections     1
2669 #define elf_backend_rela_normal         1
2670
2671 #define bfd_elf32_mkobject                   elf_or1k_mkobject
2672
2673 #define bfd_elf32_bfd_merge_private_bfd_data elf32_or1k_merge_private_bfd_data
2674 #define bfd_elf32_bfd_set_private_flags or1k_elf_set_private_flags
2675 #define bfd_elf32_bfd_reloc_type_lookup or1k_reloc_type_lookup
2676 #define bfd_elf32_bfd_reloc_name_lookup or1k_reloc_name_lookup
2677
2678 #define elf_backend_object_p                or1k_elf_object_p
2679 #define elf_backend_final_write_processing  or1k_elf_final_write_processing
2680 #define elf_backend_can_refcount                1
2681
2682 #define elf_backend_plt_readonly                1
2683 #define elf_backend_want_got_plt                1
2684 #define elf_backend_want_plt_sym                0
2685 #define elf_backend_got_header_size             12
2686 #define elf_backend_dtrel_excludes_plt          1
2687 #define elf_backend_want_dynrelro               1
2688
2689 #define bfd_elf32_bfd_link_hash_table_create    or1k_elf_link_hash_table_create
2690 #define elf_backend_copy_indirect_symbol        or1k_elf_copy_indirect_symbol
2691 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
2692 #define elf_backend_finish_dynamic_sections     or1k_elf_finish_dynamic_sections
2693 #define elf_backend_size_dynamic_sections       or1k_elf_size_dynamic_sections
2694 #define elf_backend_adjust_dynamic_symbol       or1k_elf_adjust_dynamic_symbol
2695 #define elf_backend_finish_dynamic_symbol       or1k_elf_finish_dynamic_symbol
2696
2697 #include "elf32-target.h"