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