bfd/elf32-metag.c

   1 /* Meta support for 32-bit ELF
   2    Copyright (C) 2013-2016 Free Software Foundation, Inc.
   3    Contributed by Imagination Technologies Ltd.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf32-metag.h"
  27 #include "elf/metag.h"
  28
  29 #define GOT_ENTRY_SIZE 4
  30 #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
  31
  32 /* ABI version:
  33     0 - original
  34     1 - with GOT offset */
  35 #define METAG_ELF_ABI_VERSION 1
  36
  37 static const unsigned int plt0_entry[] =
  38   {
  39     0x02000005, /* MOVT D0Re0, #HI(GOT+4) */
  40     0x02000000, /* ADD  D0Re0, D0Re0, #LO(GOT+4) */
  41     0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
  42     0xc600012a, /* GETD PC, [D0Re0+#4] */
  43     0xa0fffffe  /* NOP */
  44   };
  45
  46 static const unsigned int plt0_pic_entry[] =
  47   {
  48     0x82900001, /* ADDT A0.2, CPC0, #0 */
  49     0x82100000, /* ADD  A0.2, A0.2, #0 */
  50     0xa3100c20, /* MOV  D0Re0, A0.2 */
  51     0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
  52     0xc600012a, /* GETD PC, [D0Re0+#4] */
  53   };
  54
  55 static const unsigned int plt_entry[] =
  56   {
  57     0x82100005, /* MOVT A0.2, #HI(GOT+off) */
  58     0x82100000, /* ADD  A0.2, A0.2, #LO(GOT+off) */
  59     0xc600806a, /* GETD PC, [A0.2] */
  60     0x03000004, /* MOV  D1Re0, #LO(offset) */
  61     0xa0000000  /* B    PLT0 */
  62   };
  63
  64 static const unsigned int plt_pic_entry[] =
  65   {
  66     0x82900001, /* ADDT A0.2, CPC0, #HI(GOT+off) */
  67     0x82100000, /* ADD  A0.2, A0.2, #LO(GOT+off) */
  68     0xc600806a, /* GETD PC, [A0.2] */
  69     0x03000004, /* MOV  D1Re0, #LO(offset) */
  70     0xa0000000  /* B    PLT0 */
  71   };
  72
  73 /* Variable names follow a coding style.
  74    Please follow this (Apps Hungarian) style:
  75
  76    Structure/Variable              Prefix
  77    elf_link_hash_table             "etab"
  78    elf_link_hash_entry             "eh"
  79
  80    elf_metag_link_hash_table       "htab"
  81    elf_metag_link_hash_entry       "hh"
  82
  83    bfd_link_hash_table             "btab"
  84    bfd_link_hash_entry             "bh"
  85
  86    bfd_hash_table containing stubs "bstab"
  87    elf_metag_stub_hash_entry       "hsh"
  88
  89    elf_metag_dyn_reloc_entry       "hdh"
  90
  91    Always remember to use GNU Coding Style.  */
  92
  93 #define PLT_ENTRY_SIZE sizeof(plt_entry)
  94
  95 static reloc_howto_type elf_metag_howto_table[] =
  96 {
  97   /* High order 16 bit absolute.  */
  98   HOWTO (R_METAG_HIADDR16,      /* type */
  99          16,                    /* rightshift */
 100          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 101          16,                    /* bitsize */
 102          FALSE,                 /* pc_relative */
 103          3,                     /* bitpos */
 104          complain_overflow_dont, /* complain_on_overflow */
 105          bfd_elf_generic_reloc, /* special_function */
 106          "R_METAG_HIADDR16",    /* name */
 107          FALSE,                 /* partial_inplace */
 108          0,                     /* src_mask */
 109          0x0007fff8,            /* dst_mask */
 110          FALSE),                /* pcrel_offset */
 111
 112   /* Low order 16 bit absolute.  */
 113   HOWTO (R_METAG_LOADDR16,      /* type */
 114          0,                     /* rightshift */
 115          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 116          16,                    /* bitsize */
 117          FALSE,                 /* pc_relative */
 118          3,                     /* bitpos */
 119          complain_overflow_dont,/* complain_on_overflow */
 120          bfd_elf_generic_reloc, /* special_function */
 121          "R_METAG_LOADDR16",    /* name */
 122          FALSE,                 /* partial_inplace */
 123          0,                     /* src_mask */
 124          0x0007fff8,            /* dst_mask */
 125          FALSE),                /* pcrel_offset */
 126
 127   /* 32 bit absolute.  */
 128   HOWTO (R_METAG_ADDR32,        /* type */
 129          0,                     /* rightshift */
 130          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 131          32,                    /* bitsize */
 132          FALSE,                 /* pc_relative */
 133          0,                     /* bitpos */
 134          complain_overflow_bitfield, /* complain_on_overflow */
 135          bfd_elf_generic_reloc, /* special_function */
 136          "R_METAG_ADDR32",      /* name */
 137          FALSE,                 /* partial_inplace */
 138          0x00000000,            /* src_mask */
 139          0xffffffff,            /* dst_mask */
 140          FALSE),                /* pcrel_offset */
 141
 142   /* No relocation.  */
 143   HOWTO (R_METAG_NONE,          /* type */
 144          0,                     /* rightshift */
 145          3,                     /* size (0 = byte, 1 = short, 2 = long) */
 146          0,                     /* bitsize */
 147          FALSE,                 /* pc_relative */
 148          0,                     /* bitpos */
 149          complain_overflow_dont, /* complain_on_overflow */
 150          bfd_elf_generic_reloc, /* special_function */
 151          "R_METAG_NONE",        /* name */
 152          FALSE,                 /* partial_inplace */
 153          0,                     /* src_mask */
 154          0,                     /* dst_mask */
 155          FALSE),                /* pcrel_offset */
 156
 157   /* 19 bit pc relative */
 158   HOWTO (R_METAG_RELBRANCH,     /* type */
 159          2,                     /* rightshift */
 160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 161          19,                    /* bitsize */
 162          TRUE,                  /* pc_relative */
 163          5,                     /* bitpos */
 164          complain_overflow_signed, /* complain_on_overflow */
 165          bfd_elf_generic_reloc, /* special_function */
 166          "R_METAG_RELBRANCH",   /* name */
 167          FALSE,                 /* partial_inplace */
 168          0,                     /* src_mask */
 169          0x00ffffe0,            /* dst_mask */
 170          FALSE),                /* pcrel_offset */
 171
 172   /* GET/SET offset */
 173   HOWTO (R_METAG_GETSETOFF,     /* type */
 174          0,                     /* rightshift */
 175          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 176          12,                    /* bitsize */
 177          FALSE,                 /* pc_relative */
 178          7,                     /* bitpos */
 179          complain_overflow_dont, /* complain_on_overflow */
 180          bfd_elf_generic_reloc, /* special_function */
 181          "R_METAG_GETSETOFF",   /* name */
 182          FALSE,                 /* partial_inplace */
 183          0,                     /* src_mask */
 184          0,                     /* dst_mask */
 185          FALSE),                /* pcrel_offset */
 186
 187   EMPTY_HOWTO (6),
 188   EMPTY_HOWTO (7),
 189   EMPTY_HOWTO (8),
 190   EMPTY_HOWTO (9),
 191   EMPTY_HOWTO (10),
 192   EMPTY_HOWTO (11),
 193   EMPTY_HOWTO (12),
 194   EMPTY_HOWTO (13),
 195   EMPTY_HOWTO (14),
 196   EMPTY_HOWTO (15),
 197   EMPTY_HOWTO (16),
 198   EMPTY_HOWTO (17),
 199   EMPTY_HOWTO (18),
 200   EMPTY_HOWTO (19),
 201   EMPTY_HOWTO (20),
 202   EMPTY_HOWTO (21),
 203   EMPTY_HOWTO (22),
 204   EMPTY_HOWTO (23),
 205   EMPTY_HOWTO (24),
 206   EMPTY_HOWTO (25),
 207   EMPTY_HOWTO (26),
 208   EMPTY_HOWTO (27),
 209   EMPTY_HOWTO (28),
 210   EMPTY_HOWTO (29),
 211
 212   HOWTO (R_METAG_GNU_VTINHERIT, /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          0,                     /* bitsize */
 216          FALSE,         /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_dont, /* complain_on_overflow */
 219          NULL,                  /* special_function */
 220          "R_METAG_GNU_VTINHERIT", /* name */
 221          FALSE,         /* partial_inplace */
 222          0,                     /* src_mask */
 223          0,                     /* dst_mask */
 224          FALSE),                /* pcrel_offset */
 225
 226   HOWTO (R_METAG_GNU_VTENTRY,   /* type */
 227          0,                     /* rightshift */
 228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          0,                     /* bitsize */
 230          FALSE,                 /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_dont, /* complain_on_overflow */
 233          _bfd_elf_rel_vtable_reloc_fn, /* special_function */
 234          "R_METAG_GNU_VTENTRY",  /* name */
 235          FALSE,                 /* partial_inplace */
 236          0,                     /* src_mask */
 237          0,                     /* dst_mask */
 238          FALSE),                /* pcrel_offset */
 239
 240   /* High order 16 bit GOT offset */
 241   HOWTO (R_METAG_HI16_GOTOFF,   /* type */
 242          16,                    /* rightshift */
 243          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 244          16,                    /* bitsize */
 245          FALSE,                 /* pc_relative */
 246          3,                     /* bitpos */
 247          complain_overflow_dont, /* complain_on_overflow */
 248          bfd_elf_generic_reloc, /* special_function */
 249          "R_METAG_HI16_GOTOFF", /* name */
 250          FALSE,                 /* partial_inplace */
 251          0,                     /* src_mask */
 252          0x0007fff8,            /* dst_mask */
 253          FALSE),                /* pcrel_offset */
 254
 255   /* Low order 16 bit GOT offset */
 256   HOWTO (R_METAG_LO16_GOTOFF,   /* type */
 257          0,                     /* rightshift */
 258          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 259          16,                    /* bitsize */
 260          FALSE,                 /* pc_relative */
 261          3,                     /* bitpos */
 262          complain_overflow_dont, /* complain_on_overflow */
 263          bfd_elf_generic_reloc, /* special_function */
 264          "R_METAG_LO16_GOTOFF", /* name */
 265          FALSE,                 /* partial_inplace */
 266          0,                     /* src_mask */
 267          0x0007fff8,            /* dst_mask */
 268          FALSE),                /* pcrel_offset */
 269
 270   /* GET/SET GOT offset */
 271   HOWTO (R_METAG_GETSET_GOTOFF, /* type */
 272          0,                     /* rightshift */
 273          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 274          12,                    /* bitsize */
 275          FALSE,                 /* pc_relative */
 276          7,                     /* bitpos */
 277          complain_overflow_dont, /* complain_on_overflow */
 278          bfd_elf_generic_reloc, /* special_function */
 279          "R_METAG_GETSET_GOTOFF", /* name */
 280          FALSE,                 /* partial_inplace */
 281          0,                     /* src_mask */
 282          0,                     /* dst_mask */
 283          FALSE),                /* pcrel_offset */
 284
 285   /* GET/SET GOT relative */
 286   HOWTO (R_METAG_GETSET_GOT,    /* type */
 287          0,                     /* rightshift */
 288          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 289          12,                    /* bitsize */
 290          FALSE,                 /* pc_relative */
 291          7,                     /* bitpos */
 292          complain_overflow_dont, /* complain_on_overflow */
 293          bfd_elf_generic_reloc, /* special_function */
 294          "R_METAG_GETSET_GOT",  /* name */
 295          FALSE,                 /* partial_inplace */
 296          0,                     /* src_mask */
 297          0,                     /* dst_mask */
 298          FALSE),                /* pcrel_offset */
 299
 300   /* High order 16 bit GOT reference */
 301   HOWTO (R_METAG_HI16_GOTPC,    /* type */
 302          16,                    /* rightshift */
 303          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 304          16,                    /* bitsize */
 305          FALSE,                 /* pc_relative */
 306          3,                     /* bitpos */
 307          complain_overflow_dont, /* complain_on_overflow */
 308          bfd_elf_generic_reloc, /* special_function */
 309          "R_METAG_HI16_GOTPC",  /* name */
 310          FALSE,                 /* partial_inplace */
 311          0,                     /* src_mask */
 312          0x0007fff8,            /* dst_mask */
 313          FALSE),                /* pcrel_offset */
 314
 315   /* Low order 16 bit GOT reference */
 316   HOWTO (R_METAG_LO16_GOTPC,    /* type */
 317          0,                     /* rightshift */
 318          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 319          16,                    /* bitsize */
 320          FALSE,                 /* pc_relative */
 321          3,                     /* bitpos */
 322          complain_overflow_dont, /* complain_on_overflow */
 323          bfd_elf_generic_reloc, /* special_function */
 324          "R_METAG_LO16_GOTPC",  /* name */
 325          FALSE,                 /* partial_inplace */
 326          0,                     /* src_mask */
 327          0x0007fff8,            /* dst_mask */
 328          FALSE),                /* pcrel_offset */
 329
 330   /* High order 16 bit PLT */
 331   HOWTO (R_METAG_HI16_PLT,      /* type */
 332          16,                    /* rightshift */
 333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 334          16,                    /* bitsize */
 335          FALSE,                 /* pc_relative */
 336          3,                     /* bitpos */
 337          complain_overflow_dont, /* complain_on_overflow */
 338          bfd_elf_generic_reloc, /* special_function */
 339          "R_METAG_HI16_PLT",    /* name */
 340          FALSE,                 /* partial_inplace */
 341          0,                     /* src_mask */
 342          0x0007fff8,            /* dst_mask */
 343          FALSE),                /* pcrel_offset */
 344
 345   /* Low order 16 bit PLT */
 346   HOWTO (R_METAG_LO16_PLT,      /* type */
 347          0,                     /* rightshift */
 348          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 349          16,                    /* bitsize */
 350          FALSE,                 /* pc_relative */
 351          3,                     /* bitpos */
 352          complain_overflow_dont, /* complain_on_overflow */
 353          bfd_elf_generic_reloc, /* special_function */
 354          "R_METAG_LO16_PLT",    /* name */
 355          FALSE,                 /* partial_inplace */
 356          0,                     /* src_mask */
 357          0xffffffff,            /* dst_mask */
 358          FALSE),                /* pcrel_offset */
 359
 360   HOWTO (R_METAG_RELBRANCH_PLT, /* type */
 361          2,                     /* rightshift */
 362          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 363          19,                    /* bitsize */
 364          TRUE,                  /* pc_relative */
 365          5,                     /* bitpos */
 366          complain_overflow_signed, /* complain_on_overflow */
 367          bfd_elf_generic_reloc, /* special_function */
 368          "R_METAG_RELBRANCH_PLT", /* name */
 369          FALSE,                 /* partial_inplace */
 370          0,                     /* src_mask */
 371          0x00ffffe0,            /* dst_mask */
 372          FALSE),                /* pcrel_offset */
 373
 374   /* Dummy relocs used by the linker internally.  */
 375   HOWTO (R_METAG_GOTOFF,        /* type */
 376          0,                     /* rightshift */
 377          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 378          32,                    /* bitsize */
 379          FALSE,                 /* pc_relative */
 380          0,                     /* bitpos */
 381          complain_overflow_bitfield, /* complain_on_overflow */
 382          bfd_elf_generic_reloc, /* special_function */
 383          "R_METAG_GOTOFF",      /* name */
 384          FALSE,                 /* partial_inplace */
 385          0xffffffff,            /* src_mask */
 386          0xffffffff,            /* dst_mask */
 387          FALSE),                /* pcrel_offset */
 388
 389   HOWTO (R_METAG_PLT,           /* type */
 390          0,                     /* rightshift */
 391          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 392          32,                    /* bitsize */
 393          FALSE,                 /* pc_relative */
 394          0,                     /* bitpos */
 395          complain_overflow_bitfield, /* complain_on_overflow */
 396          bfd_elf_generic_reloc, /* special_function */
 397          "R_METAG_GOTOFF",      /* name */
 398          FALSE,                 /* partial_inplace */
 399          0xffffffff,            /* src_mask */
 400          0xffffffff,            /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403   /* This is used only by the dynamic linker.  The symbol should exist
 404      both in the object being run and in some shared library.  The
 405      dynamic linker copies the data addressed by the symbol from the
 406      shared library into the object, because the object being
 407      run has to have the data at some particular address.  */
 408   HOWTO (R_METAG_COPY,          /* type */
 409          0,                     /* rightshift */
 410          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 411          32,                    /* bitsize */
 412          FALSE,                 /* pc_relative */
 413          0,                     /* bitpos */
 414          complain_overflow_bitfield, /* complain_on_overflow */
 415          bfd_elf_generic_reloc, /* special_function */
 416          "R_METAG_COPY",        /* name */
 417          FALSE,                 /* partial_inplace */
 418          0xffffffff,            /* src_mask */
 419          0xffffffff,            /* dst_mask */
 420          FALSE),                /* pcrel_offset */
 421
 422   /* Marks a procedure linkage table entry for a symbol.  */
 423   HOWTO (R_METAG_JMP_SLOT,      /* type */
 424          0,                     /* rightshift */
 425          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 426          32,                    /* bitsize */
 427          FALSE,                 /* pc_relative */
 428          0,                     /* bitpos */
 429          complain_overflow_bitfield, /* complain_on_overflow */
 430          bfd_elf_generic_reloc, /* special_function */
 431          "R_METAG_JMP_SLOT",    /* name */
 432          FALSE,                 /* partial_inplace */
 433          0xffffffff,            /* src_mask */
 434          0xffffffff,            /* dst_mask */
 435          FALSE),                /* pcrel_offset */
 436
 437   /* Used only by the dynamic linker.  When the object is run, this
 438      longword is set to the load address of the object, plus the
 439      addend.  */
 440   HOWTO (R_METAG_RELATIVE,      /* type */
 441          0,                     /* rightshift */
 442          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 443          32,                    /* bitsize */
 444          FALSE,                 /* pc_relative */
 445          0,                     /* bitpos */
 446          complain_overflow_bitfield, /* complain_on_overflow */
 447          bfd_elf_generic_reloc, /* special_function */
 448          "R_METAG_RELATIVE",    /* name */
 449          FALSE,                 /* partial_inplace */
 450          0xffffffff,            /* src_mask */
 451          0xffffffff,            /* dst_mask */
 452          FALSE),                /* pcrel_offset */
 453
 454   HOWTO (R_METAG_GLOB_DAT,      /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          32,                    /* bitsize */
 458          FALSE,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_bitfield, /* complain_on_overflow */
 461          bfd_elf_generic_reloc, /* special_function */
 462          "R_METAG_GLOB_DAT",    /* name */
 463          FALSE,                 /* partial_inplace */
 464          0xffffffff,            /* src_mask */
 465          0xffffffff,            /* dst_mask */
 466          FALSE),                /* pcrel_offset */
 467
 468   HOWTO (R_METAG_TLS_GD,        /* type */
 469          0,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          16,                    /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          3,                     /* bitpos */
 474          complain_overflow_dont, /* complain_on_overflow */
 475          bfd_elf_generic_reloc, /* special_function */
 476          "R_METAG_TLS_GD",      /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0x0007fff8,            /* dst_mask */
 480          FALSE),                /* pcrel_offset */
 481
 482   HOWTO (R_METAG_TLS_LDM,       /* type */
 483          0,                     /* rightshift */
 484          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 485          16,                    /* bitsize */
 486          FALSE,                 /* pc_relative */
 487          3,                     /* bitpos */
 488          complain_overflow_bitfield, /* complain_on_overflow */
 489          bfd_elf_generic_reloc, /* special_function */
 490          "R_METAG_TLS_LDM",     /* name */
 491          FALSE,                 /* partial_inplace */
 492          0,                     /* src_mask */
 493          0x0007fff8,            /* dst_mask */
 494          FALSE),                /* pcrel_offset */
 495
 496   HOWTO (R_METAG_TLS_LDO_HI16,  /* type */
 497          16,                    /* rightshift */
 498          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          16,                    /* bitsize */
 500          FALSE,                 /* pc_relative */
 501          3,                     /* bitpos */
 502          complain_overflow_bitfield, /* complain_on_overflow */
 503          bfd_elf_generic_reloc, /* special_function */
 504          "R_METAG_TLS_LDO_HI16", /* name */
 505          FALSE,                 /* partial_inplace */
 506          0,                     /* src_mask */
 507          0x0007fff8,            /* dst_mask */
 508          FALSE),                /* pcrel_offset */
 509
 510   HOWTO (R_METAG_TLS_LDO_LO16,  /* type */
 511          0,                     /* rightshift */
 512          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 513          16,                    /* bitsize */
 514          FALSE,                 /* pc_relative */
 515          3,                     /* bitpos */
 516          complain_overflow_bitfield, /* complain_on_overflow */
 517          bfd_elf_generic_reloc, /* special_function */
 518          "R_METAG_TLS_LDO_LO16", /* name */
 519          FALSE,                 /* partial_inplace */
 520          0,                     /* src_mask */
 521          0x0007fff8,            /* dst_mask */
 522          FALSE),                /* pcrel_offset */
 523
 524   /* Dummy reloc used by the linker internally.  */
 525   HOWTO (R_METAG_TLS_LDO,       /* type */
 526          0,                     /* rightshift */
 527          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 528          16,                    /* bitsize */
 529          FALSE,                 /* pc_relative */
 530          3,                     /* bitpos */
 531          complain_overflow_bitfield, /* complain_on_overflow */
 532          bfd_elf_generic_reloc, /* special_function */
 533          "R_METAG_TLS_LDO",     /* name */
 534          FALSE,                 /* partial_inplace */
 535          0,                     /* src_mask */
 536          0x0007fff8,            /* dst_mask */
 537          FALSE),                /* pcrel_offset */
 538
 539   HOWTO (R_METAG_TLS_IE,        /* type */
 540          2,                     /* rightshift */
 541          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 542          12,                    /* bitsize */
 543          FALSE,                 /* pc_relative */
 544          7,                     /* bitpos */
 545          complain_overflow_dont, /* complain_on_overflow */
 546          bfd_elf_generic_reloc, /* special_function */
 547          "R_METAG_TLS_IE",      /* name */
 548          FALSE,                 /* partial_inplace */
 549          0,                     /* src_mask */
 550          0x0007ff80,            /* dst_mask */
 551          FALSE),                /* pcrel_offset */
 552
 553   /* Dummy reloc used by the linker internally.  */
 554   HOWTO (R_METAG_TLS_IENONPIC,  /* type */
 555          0,                     /* rightshift */
 556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 557          16,                    /* bitsize */
 558          FALSE,                 /* pc_relative */
 559          3,                     /* bitpos */
 560          complain_overflow_dont, /* complain_on_overflow */
 561          bfd_elf_generic_reloc, /* special_function */
 562          "R_METAG_TLS_IENONPIC", /* name */
 563          FALSE,                 /* partial_inplace */
 564          0,                     /* src_mask */
 565          0x0007fff8,            /* dst_mask */
 566          FALSE),                /* pcrel_offset */
 567
 568   HOWTO (R_METAG_TLS_IENONPIC_HI16,/* type */
 569          16,                    /* rightshift */
 570          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          16,                    /* bitsize */
 572          FALSE,                 /* pc_relative */
 573          3,                     /* bitpos */
 574          complain_overflow_dont, /* complain_on_overflow */
 575          bfd_elf_generic_reloc, /* special_function */
 576          "R_METAG_TLS_IENONPIC_HI16", /* name */
 577          FALSE,                 /* partial_inplace */
 578          0,                     /* src_mask */
 579          0x0007fff8,            /* dst_mask */
 580          FALSE),                /* pcrel_offset */
 581
 582   HOWTO (R_METAG_TLS_IENONPIC_LO16,/* type */
 583          0,                     /* rightshift */
 584          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 585          16,                    /* bitsize */
 586          FALSE,                 /* pc_relative */
 587          3,                     /* bitpos */
 588          complain_overflow_dont, /* complain_on_overflow */
 589          bfd_elf_generic_reloc, /* special_function */
 590          "R_METAG_TLS_IENONPIC_LO16", /* name */
 591          FALSE,                 /* partial_inplace */
 592          0,                     /* src_mask */
 593          0x0007fff8,            /* dst_mask */
 594          FALSE),                /* pcrel_offset */
 595
 596   HOWTO (R_METAG_TLS_TPOFF,     /* type */
 597          0,                     /* rightshift */
 598          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 599          32,                    /* bitsize */
 600          FALSE,                 /* pc_relative */
 601          0,                     /* bitpos */
 602          complain_overflow_bitfield, /* complain_on_overflow */
 603          bfd_elf_generic_reloc, /* special_function */
 604          "R_METAG_TLS_TPOFF",   /* name */
 605          FALSE,                 /* partial_inplace */
 606          0,                     /* src_mask */
 607          0xffffffff,            /* dst_mask */
 608          FALSE),                /* pcrel_offset */
 609
 610   HOWTO (R_METAG_TLS_DTPMOD,    /* type */
 611          0,                     /* rightshift */
 612          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 613          32,                    /* bitsize */
 614          FALSE,                 /* pc_relative */
 615          0,                     /* bitpos */
 616          complain_overflow_bitfield, /* complain_on_overflow */
 617          bfd_elf_generic_reloc, /* special_function */
 618          "R_METAG_TLS_DTPMOD",  /* name */
 619          FALSE,                 /* partial_inplace */
 620          0,                     /* src_mask */
 621          0xffffffff,            /* dst_mask */
 622          FALSE),                /* pcrel_offset */
 623
 624   HOWTO (R_METAG_TLS_DTPOFF,    /* type */
 625          0,                     /* rightshift */
 626          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 627          32,                    /* bitsize */
 628          FALSE,                 /* pc_relative */
 629          0,                     /* bitpos */
 630          complain_overflow_bitfield, /* complain_on_overflow */
 631          bfd_elf_generic_reloc, /* special_function */
 632          "R_METAG_TLS_DTPOFF",  /* name */
 633          FALSE,                 /* partial_inplace */
 634          0,                     /* src_mask */
 635          0xffffffff,            /* dst_mask */
 636          FALSE),                /* pcrel_offset */
 637
 638   /* Dummy reloc used by the linker internally.  */
 639   HOWTO (R_METAG_TLS_LE,        /* type */
 640          0,                     /* rightshift */
 641          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 642          32,                    /* bitsize */
 643          FALSE,                 /* pc_relative */
 644          0,                     /* bitpos */
 645          complain_overflow_bitfield, /* complain_on_overflow */
 646          bfd_elf_generic_reloc, /* special_function */
 647          "R_METAG_TLS_LE",      /* name */
 648          FALSE,                 /* partial_inplace */
 649          0,                     /* src_mask */
 650          0xffffffff,            /* dst_mask */
 651          FALSE),                /* pcrel_offset */
 652
 653   HOWTO (R_METAG_TLS_LE_HI16,   /* type */
 654          16,                    /* rightshift */
 655          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 656          16,                    /* bitsize */
 657          FALSE,                 /* pc_relative */
 658          3,                     /* bitpos */
 659          complain_overflow_dont, /* complain_on_overflow */
 660          bfd_elf_generic_reloc, /* special_function */
 661          "R_METAG_TLS_LE_HI16", /* name */
 662          FALSE,                 /* partial_inplace */
 663          0,                     /* src_mask */
 664          0x0007fff8,            /* dst_mask */
 665          FALSE),                /* pcrel_offset */
 666
 667   HOWTO (R_METAG_TLS_LE_LO16,   /* type */
 668          0,                     /* rightshift */
 669          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 670          16,                    /* bitsize */
 671          FALSE,                 /* pc_relative */
 672          3,                     /* bitpos */
 673          complain_overflow_dont, /* complain_on_overflow */
 674          bfd_elf_generic_reloc, /* special_function */
 675          "R_METAG_TLS_LE_LO16", /* name */
 676          FALSE,                 /* partial_inplace */
 677          0,                     /* src_mask */
 678          0x0007fff8,            /* dst_mask */
 679          FALSE),                /* pcrel_offset */
 680
 681 };
 682
 683 #define BRANCH_BITS 19
 684
 685 /* The GOT is typically accessed using a [GS]ETD instruction. The size of the
 686    immediate offset which can be used in such instructions therefore limits
 687    the usable size of the GOT. If the base register for the [GS]ETD (A1LbP)
 688    is pointing to the base of the GOT then the size is limited to the maximum
 689    11 bits unsigned dword offset, or 2^13 = 0x2000 bytes. However the offset
 690    in a [GS]ETD instruction is signed, so by setting the base address register
 691    to an offset of that 0x2000 byte maximum unsigned offset from the base of
 692    the GOT we can use negative offsets in addition to positive. This
 693    effectively doubles the usable GOT size to 0x4000 bytes.  */
 694 #define GOT_REG_OFFSET 0x2000
 695
 696 struct metag_reloc_map
 697 {
 698   bfd_reloc_code_real_type bfd_reloc_val;
 699   unsigned int metag_reloc_val;
 700 };
 701
 702 static const struct metag_reloc_map metag_reloc_map [] =
 703   {
 704     { BFD_RELOC_NONE,                R_METAG_NONE },
 705     { BFD_RELOC_32,                  R_METAG_ADDR32 },
 706     { BFD_RELOC_METAG_HIADDR16,      R_METAG_HIADDR16 },
 707     { BFD_RELOC_METAG_LOADDR16,      R_METAG_LOADDR16 },
 708     { BFD_RELOC_METAG_RELBRANCH,     R_METAG_RELBRANCH },
 709     { BFD_RELOC_METAG_GETSETOFF,     R_METAG_GETSETOFF },
 710     { BFD_RELOC_VTABLE_INHERIT,      R_METAG_GNU_VTINHERIT },
 711     { BFD_RELOC_VTABLE_ENTRY,        R_METAG_GNU_VTENTRY },
 712     { BFD_RELOC_METAG_REL8,          R_METAG_REL8 },
 713     { BFD_RELOC_METAG_REL16,         R_METAG_REL16 },
 714     { BFD_RELOC_METAG_HI16_GOTOFF,   R_METAG_HI16_GOTOFF },
 715     { BFD_RELOC_METAG_LO16_GOTOFF,   R_METAG_LO16_GOTOFF },
 716     { BFD_RELOC_METAG_GETSET_GOTOFF, R_METAG_GETSET_GOTOFF },
 717     { BFD_RELOC_METAG_GETSET_GOT,    R_METAG_GETSET_GOT },
 718     { BFD_RELOC_METAG_HI16_GOTPC,    R_METAG_HI16_GOTPC },
 719     { BFD_RELOC_METAG_LO16_GOTPC,    R_METAG_LO16_GOTPC },
 720     { BFD_RELOC_METAG_HI16_PLT,      R_METAG_HI16_PLT },
 721     { BFD_RELOC_METAG_LO16_PLT,      R_METAG_LO16_PLT },
 722     { BFD_RELOC_METAG_RELBRANCH_PLT, R_METAG_RELBRANCH_PLT },
 723     { BFD_RELOC_METAG_GOTOFF,        R_METAG_GOTOFF },
 724     { BFD_RELOC_METAG_PLT,           R_METAG_PLT },
 725     { BFD_RELOC_METAG_COPY,          R_METAG_COPY },
 726     { BFD_RELOC_METAG_JMP_SLOT,      R_METAG_JMP_SLOT },
 727     { BFD_RELOC_METAG_RELATIVE,      R_METAG_RELATIVE },
 728     { BFD_RELOC_METAG_GLOB_DAT,      R_METAG_GLOB_DAT },
 729     { BFD_RELOC_METAG_TLS_GD,        R_METAG_TLS_GD },
 730     { BFD_RELOC_METAG_TLS_LDM,       R_METAG_TLS_LDM },
 731     { BFD_RELOC_METAG_TLS_LDO_HI16,  R_METAG_TLS_LDO_HI16 },
 732     { BFD_RELOC_METAG_TLS_LDO_LO16,  R_METAG_TLS_LDO_LO16 },
 733     { BFD_RELOC_METAG_TLS_LDO,       R_METAG_TLS_LDO },
 734     { BFD_RELOC_METAG_TLS_IE,        R_METAG_TLS_IE },
 735     { BFD_RELOC_METAG_TLS_IENONPIC,  R_METAG_TLS_IENONPIC },
 736     { BFD_RELOC_METAG_TLS_IENONPIC_HI16, R_METAG_TLS_IENONPIC_HI16 },
 737     { BFD_RELOC_METAG_TLS_IENONPIC_LO16, R_METAG_TLS_IENONPIC_LO16 },
 738     { BFD_RELOC_METAG_TLS_TPOFF,     R_METAG_TLS_TPOFF },
 739     { BFD_RELOC_METAG_TLS_DTPMOD,    R_METAG_TLS_DTPMOD },
 740     { BFD_RELOC_METAG_TLS_DTPOFF,    R_METAG_TLS_DTPOFF },
 741     { BFD_RELOC_METAG_TLS_LE,        R_METAG_TLS_LE },
 742     { BFD_RELOC_METAG_TLS_LE_HI16,   R_METAG_TLS_LE_HI16 },
 743     { BFD_RELOC_METAG_TLS_LE_LO16,   R_METAG_TLS_LE_LO16 },
 744   };
 745
 746 enum elf_metag_stub_type
 747 {
 748   metag_stub_long_branch,
 749   metag_stub_long_branch_shared,
 750   metag_stub_none
 751 };
 752
 753 struct elf_metag_stub_hash_entry
 754 {
 755   /* Base hash table entry structure.  */
 756   struct bfd_hash_entry bh_root;
 757
 758   /* The stub section.  */
 759   asection *stub_sec;
 760
 761   /* Offset within stub_sec of the beginning of this stub.  */
 762   bfd_vma stub_offset;
 763
 764   /* Given the symbol's value and its section we can determine its final
 765      value when building the stubs (so the stub knows where to jump.  */
 766   bfd_vma target_value;
 767   asection *target_section;
 768
 769   enum elf_metag_stub_type stub_type;
 770
 771   /* The symbol table entry, if any, that this was derived from.  */
 772   struct elf_metag_link_hash_entry *hh;
 773
 774   /* And the reloc addend that this was derived from.  */
 775   bfd_vma addend;
 776
 777   /* Where this stub is being called from, or, in the case of combined
 778      stub sections, the first input section in the group.  */
 779   asection *id_sec;
 780 };
 781
 782 struct elf_metag_link_hash_entry
 783 {
 784   struct elf_link_hash_entry eh;
 785
 786   /* A pointer to the most recently used stub hash entry against this
 787      symbol.  */
 788   struct elf_metag_stub_hash_entry *hsh_cache;
 789
 790   /* Used to count relocations for delayed sizing of relocation
 791      sections.  */
 792   struct elf_metag_dyn_reloc_entry {
 793
 794     /* Next relocation in the chain.  */
 795     struct elf_metag_dyn_reloc_entry *hdh_next;
 796
 797     /* The input section of the reloc.  */
 798     asection *sec;
 799
 800     /* Number of relocs copied in this section.  */
 801     bfd_size_type count;
 802
 803     /* Number of relative relocs copied for the input section.  */
 804     bfd_size_type relative_count;
 805   } *dyn_relocs;
 806
 807   enum
 808     {
 809       GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_IE = 2, GOT_TLS_LDM = 4, GOT_TLS_GD = 8
 810     } tls_type;
 811 };
 812
 813 struct elf_metag_link_hash_table
 814 {
 815   /* The main hash table.  */
 816   struct elf_link_hash_table etab;
 817
 818   /* The stub hash table.  */
 819   struct bfd_hash_table bstab;
 820
 821   /* Linker stub bfd.  */
 822   bfd *stub_bfd;
 823
 824   /* Linker call-backs.  */
 825   asection * (*add_stub_section) (const char *, asection *);
 826   void (*layout_sections_again) (void);
 827
 828   /* Array to keep track of which stub sections have been created, and
 829      information on stub grouping.  */
 830   struct map_stub
 831   {
 832     /* This is the section to which stubs in the group will be
 833        attached.  */
 834     asection *link_sec;
 835     /* The stub section.  */
 836     asection *stub_sec;
 837   } *stub_group;
 838
 839   /* Assorted information used by elf_metag_size_stubs.  */
 840   unsigned int bfd_count;
 841   unsigned int top_index;
 842   asection **input_list;
 843   Elf_Internal_Sym **all_local_syms;
 844
 845   /* Short-cuts to get to dynamic linker sections.  */
 846   asection *sdynbss;
 847   asection *srelbss;
 848
 849   /* Small local sym cache.  */
 850   struct sym_cache sym_cache;
 851
 852   /* Data for LDM relocations.  */
 853   union
 854   {
 855     bfd_signed_vma refcount;
 856     bfd_vma offset;
 857   } tls_ldm_got;
 858 };
 859
 860 /* Return the base vma address which should be subtracted from the
 861    real address when resolving a dtpoff relocation.  This is PT_TLS
 862    segment p_vaddr.  */
 863 static bfd_vma
 864 dtpoff_base (struct bfd_link_info *info)
 865 {
 866   /* If tls_sec is NULL, we should have signalled an error already.  */
 867   if (elf_hash_table (info)->tls_sec == NULL)
 868     return 0;
 869   return elf_hash_table (info)->tls_sec->vma;
 870 }
 871
 872 /* Return the relocation value for R_METAG_TLS_IE */
 873 static bfd_vma
 874 tpoff (struct bfd_link_info *info, bfd_vma address)
 875 {
 876   /* If tls_sec is NULL, we should have signalled an error already.  */
 877   if (elf_hash_table (info)->tls_sec == NULL)
 878     return 0;
 879   /* METAG TLS ABI is variant I and static TLS blocks start just after
 880      tcbhead structure which has 2 pointer fields.  */
 881   return (address - elf_hash_table (info)->tls_sec->vma
 882           + align_power ((bfd_vma) 8,
 883                          elf_hash_table (info)->tls_sec->alignment_power));
 884 }
 885
 886 static void
 887 metag_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 888                           arelent *cache_ptr,
 889                           Elf_Internal_Rela *dst)
 890 {
 891   unsigned int r_type;
 892
 893   r_type = ELF32_R_TYPE (dst->r_info);
 894   if (r_type >= (unsigned int) R_METAG_MAX)
 895     {
 896       /* xgettext:c-format */
 897       _bfd_error_handler (_("%B: invalid METAG reloc number: %d"), abfd, r_type);
 898       r_type = 0;
 899     }
 900   cache_ptr->howto = & elf_metag_howto_table [r_type];
 901 }
 902
 903 static reloc_howto_type *
 904 metag_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 905                          bfd_reloc_code_real_type code)
 906 {
 907   unsigned int i;
 908
 909   for (i = 0; i < sizeof (metag_reloc_map) / sizeof (metag_reloc_map[0]); i++)
 910     if (metag_reloc_map [i].bfd_reloc_val == code)
 911       return & elf_metag_howto_table [metag_reloc_map[i].metag_reloc_val];
 912
 913   return NULL;
 914 }
 915
 916 static reloc_howto_type *
 917 metag_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 918                          const char *r_name)
 919 {
 920   unsigned int i;
 921
 922   for (i = 0; i < sizeof (elf_metag_howto_table) / sizeof (elf_metag_howto_table[0]); i++)
 923     if (elf_metag_howto_table[i].name != NULL
 924         && strcasecmp (elf_metag_howto_table[i].name, r_name) == 0)
 925       return &elf_metag_howto_table[i];
 926
 927   return NULL;
 928 }
 929
 930 /* Various hash macros and functions.  */
 931 #define metag_link_hash_table(p) \
 932   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 933   == METAG_ELF_DATA ? ((struct elf_metag_link_hash_table *) ((p)->hash)) : NULL)
 934
 935 #define metag_elf_hash_entry(ent) \
 936   ((struct elf_metag_link_hash_entry *)(ent))
 937
 938 #define metag_stub_hash_entry(ent) \
 939   ((struct elf_metag_stub_hash_entry *)(ent))
 940
 941 #define metag_stub_hash_lookup(table, string, create, copy) \
 942   ((struct elf_metag_stub_hash_entry *) \
 943    bfd_hash_lookup ((table), (string), (create), (copy)))
 944
 945 #define metag_elf_local_got_tls_type(abfd) \
 946   ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info)))
 947
 948 /* Assorted hash table functions.  */
 949
 950 /* Initialize an entry in the stub hash table.  */
 951
 952 static struct bfd_hash_entry *
 953 stub_hash_newfunc (struct bfd_hash_entry *entry,
 954                    struct bfd_hash_table *table,
 955                    const char *string)
 956 {
 957   /* Allocate the structure if it has not already been allocated by a
 958      subclass.  */
 959   if (entry == NULL)
 960     {
 961       entry = bfd_hash_allocate (table,
 962                                  sizeof (struct elf_metag_stub_hash_entry));
 963       if (entry == NULL)
 964         return entry;
 965     }
 966
 967   /* Call the allocation method of the superclass.  */
 968   entry = bfd_hash_newfunc (entry, table, string);
 969   if (entry != NULL)
 970     {
 971       struct elf_metag_stub_hash_entry *hsh;
 972
 973       /* Initialize the local fields.  */
 974       hsh = (struct elf_metag_stub_hash_entry *) entry;
 975       hsh->stub_sec = NULL;
 976       hsh->stub_offset = 0;
 977       hsh->target_value = 0;
 978       hsh->target_section = NULL;
 979       hsh->stub_type = metag_stub_long_branch;
 980       hsh->hh = NULL;
 981       hsh->id_sec = NULL;
 982     }
 983
 984   return entry;
 985 }
 986
 987 /* Initialize an entry in the link hash table.  */
 988
 989 static struct bfd_hash_entry *
 990 metag_link_hash_newfunc (struct bfd_hash_entry *entry,
 991                          struct bfd_hash_table *table,
 992                          const char *string)
 993 {
 994   /* Allocate the structure if it has not already been allocated by a
 995      subclass.  */
 996   if (entry == NULL)
 997     {
 998       entry = bfd_hash_allocate (table,
 999                                  sizeof (struct elf_metag_link_hash_entry));
1000       if (entry == NULL)
1001         return entry;
1002     }
1003
1004   /* Call the allocation method of the superclass.  */
1005   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1006   if (entry != NULL)
1007     {
1008       struct elf_metag_link_hash_entry *hh;
1009
1010       /* Initialize the local fields.  */
1011       hh = (struct elf_metag_link_hash_entry *) entry;
1012       hh->hsh_cache = NULL;
1013       hh->dyn_relocs = NULL;
1014       hh->tls_type = GOT_UNKNOWN;
1015     }
1016
1017   return entry;
1018 }
1019
1020 /* Free the derived linker hash table.  */
1021
1022 static void
1023 elf_metag_link_hash_table_free (bfd *obfd)
1024 {
1025   struct elf_metag_link_hash_table *htab
1026     = (struct elf_metag_link_hash_table *) obfd->link.hash;
1027
1028   bfd_hash_table_free (&htab->bstab);
1029   _bfd_elf_link_hash_table_free (obfd);
1030 }
1031
1032 /* Create the derived linker hash table.  The Meta ELF port uses the derived
1033    hash table to keep information specific to the Meta ELF linker (without
1034    using static variables).  */
1035
1036 static struct bfd_link_hash_table *
1037 elf_metag_link_hash_table_create (bfd *abfd)
1038 {
1039   struct elf_metag_link_hash_table *htab;
1040   bfd_size_type amt = sizeof (*htab);
1041
1042   htab = bfd_zmalloc (amt);
1043   if (htab == NULL)
1044     return NULL;
1045
1046   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
1047                                       metag_link_hash_newfunc,
1048                                       sizeof (struct elf_metag_link_hash_entry),
1049                                       METAG_ELF_DATA))
1050     {
1051       free (htab);
1052       return NULL;
1053     }
1054
1055   /* Init the stub hash table too.  */
1056   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
1057                             sizeof (struct elf_metag_stub_hash_entry)))
1058     {
1059       _bfd_elf_link_hash_table_free (abfd);
1060       return NULL;
1061     }
1062   htab->etab.root.hash_table_free = elf_metag_link_hash_table_free;
1063
1064   return &htab->etab.root;
1065 }
1066
1067 /* Section name for stubs is the associated section name plus this
1068    string.  */
1069 #define STUB_SUFFIX ".stub"
1070
1071 /* Build a name for an entry in the stub hash table.  */
1072
1073 static char *
1074 metag_stub_name (const asection *input_section,
1075                  const asection *sym_sec,
1076                  const struct elf_metag_link_hash_entry *hh,
1077                  const Elf_Internal_Rela *rel)
1078 {
1079   char *stub_name;
1080   bfd_size_type len;
1081
1082   if (hh)
1083     {
1084       len = 8 + 1 + strlen (hh->eh.root.root.string) + 1 + 8 + 1;
1085       stub_name = bfd_malloc (len);
1086       if (stub_name != NULL)
1087         {
1088           sprintf (stub_name, "%08x_%s+%x",
1089                    input_section->id & 0xffffffff,
1090                    hh->eh.root.root.string,
1091                    (int) rel->r_addend & 0xffffffff);
1092         }
1093     }
1094   else
1095     {
1096       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1097       stub_name = bfd_malloc (len);
1098       if (stub_name != NULL)
1099         {
1100           sprintf (stub_name, "%08x_%x:%x+%x",
1101                    input_section->id & 0xffffffff,
1102                    sym_sec->id & 0xffffffff,
1103                    (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
1104                    (int) rel->r_addend & 0xffffffff);
1105         }
1106     }
1107   return stub_name;
1108 }
1109
1110 /* Look up an entry in the stub hash.  Stub entries are cached because
1111    creating the stub name takes a bit of time.  */
1112
1113 static struct elf_metag_stub_hash_entry *
1114 metag_get_stub_entry (const asection *input_section,
1115                       const asection *sym_sec,
1116                       struct elf_metag_link_hash_entry *hh,
1117                       const Elf_Internal_Rela *rel,
1118                       struct elf_metag_link_hash_table *htab)
1119 {
1120   struct elf_metag_stub_hash_entry *hsh;
1121   const asection *id_sec;
1122
1123   /* If this input section is part of a group of sections sharing one
1124      stub section, then use the id of the first section in the group.
1125      Stub names need to include a section id, as there may well be
1126      more than one stub used to reach say, printf, and we need to
1127      distinguish between them.  */
1128   id_sec = htab->stub_group[input_section->id].link_sec;
1129
1130   if (hh != NULL && hh->hsh_cache != NULL
1131       && hh->hsh_cache->hh == hh
1132       && hh->hsh_cache->id_sec == id_sec)
1133     {
1134       hsh = hh->hsh_cache;
1135     }
1136   else
1137     {
1138       char *stub_name;
1139
1140       stub_name = metag_stub_name (id_sec, sym_sec, hh, rel);
1141       if (stub_name == NULL)
1142         return NULL;
1143
1144       hsh = metag_stub_hash_lookup (&htab->bstab,
1145                                     stub_name, FALSE, FALSE);
1146
1147       if (hh != NULL)
1148         hh->hsh_cache = hsh;
1149
1150       free (stub_name);
1151     }
1152
1153   return hsh;
1154 }
1155
1156 /* Add a new stub entry to the stub hash.  Not all fields of the new
1157    stub entry are initialised.  */
1158
1159 static struct elf_metag_stub_hash_entry *
1160 metag_add_stub (const char *stub_name,
1161                 asection *section,
1162                 struct elf_metag_link_hash_table *htab)
1163 {
1164   asection *link_sec;
1165   asection *stub_sec;
1166   struct elf_metag_stub_hash_entry *hsh;
1167
1168   link_sec = htab->stub_group[section->id].link_sec;
1169   stub_sec = htab->stub_group[section->id].stub_sec;
1170   if (stub_sec == NULL)
1171     {
1172       stub_sec = htab->stub_group[link_sec->id].stub_sec;
1173       if (stub_sec == NULL)
1174         {
1175           size_t namelen;
1176           bfd_size_type len;
1177           char *s_name;
1178
1179           namelen = strlen (link_sec->name);
1180           len = namelen + sizeof (STUB_SUFFIX);
1181           s_name = bfd_alloc (htab->stub_bfd, len);
1182           if (s_name == NULL)
1183             return NULL;
1184
1185           memcpy (s_name, link_sec->name, namelen);
1186           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
1187
1188           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
1189           if (stub_sec == NULL)
1190             return NULL;
1191           htab->stub_group[link_sec->id].stub_sec = stub_sec;
1192         }
1193       htab->stub_group[section->id].stub_sec = stub_sec;
1194     }
1195
1196   /* Enter this entry into the linker stub hash table.  */
1197   hsh = metag_stub_hash_lookup (&htab->bstab, stub_name,
1198                                 TRUE, FALSE);
1199   if (hsh == NULL)
1200     {
1201       /* xgettext:c-format */
1202       _bfd_error_handler (_("%B: cannot create stub entry %s"),
1203                           section->owner, stub_name);
1204       return NULL;
1205     }
1206
1207   hsh->stub_sec = stub_sec;
1208   hsh->stub_offset = 0;
1209   hsh->id_sec = link_sec;
1210   return hsh;
1211 }
1212
1213 /* Check a signed integer value can be represented in the given number
1214    of bits.  */
1215
1216 static bfd_boolean
1217 within_signed_range (int value, unsigned int bits)
1218 {
1219   int min_val = -(1 << (bits - 1));
1220   int max_val = (1 << (bits - 1)) - 1;
1221   return (value <= max_val) && (value >= min_val);
1222 }
1223
1224 /* Perform a relocation as part of a final link.  */
1225
1226 static bfd_reloc_status_type
1227 metag_final_link_relocate (reloc_howto_type *howto,
1228                            bfd *input_bfd,
1229                            asection *input_section,
1230                            bfd_byte *contents,
1231                            Elf_Internal_Rela *rel,
1232                            bfd_vma relocation,
1233                            struct elf_metag_link_hash_entry *hh,
1234                            struct elf_metag_link_hash_table *htab,
1235                            asection *sym_sec)
1236 {
1237   bfd_reloc_status_type r = bfd_reloc_ok;
1238   bfd_byte *hit_data = contents + rel->r_offset;
1239   int opcode, op_shift, op_extended, l1, l2;
1240   bfd_signed_vma srel, addend = rel->r_addend;
1241   struct elf_metag_stub_hash_entry *hsh = NULL;
1242   bfd_vma location;
1243
1244   /* Find out where we are and where we're going.  */
1245   location = (rel->r_offset +
1246               input_section->output_offset +
1247               input_section->output_section->vma);
1248
1249   switch (howto->type)
1250     {
1251     case R_METAG_RELBRANCH:
1252     case R_METAG_RELBRANCH_PLT:
1253       /* Make it a pc relative offset.  */
1254       relocation -= location;
1255       break;
1256     case R_METAG_TLS_GD:
1257     case R_METAG_TLS_IE:
1258       relocation -= elf_gp (input_section->output_section->owner);
1259       break;
1260     default:
1261       break;
1262     }
1263
1264   switch (howto->type)
1265     {
1266     case R_METAG_RELBRANCH_PLT:
1267     case R_METAG_RELBRANCH:
1268       opcode = bfd_get_32 (input_bfd, hit_data);
1269
1270       srel = (bfd_signed_vma) relocation;
1271       srel += addend;
1272
1273       /* If the branch is out of reach, then redirect the
1274          call to the local stub for this function.  */
1275       if (srel > ((1 << (BRANCH_BITS + 1)) - 1) ||
1276           (srel < - (1 << (BRANCH_BITS + 1))))
1277         {
1278           if (sym_sec == NULL)
1279             break;
1280
1281           hsh = metag_get_stub_entry (input_section, sym_sec,
1282                                       hh, rel, htab);
1283           if (hsh == NULL)
1284             return bfd_reloc_undefined;
1285
1286           /* Munge up the value and addend so that we call the stub
1287              rather than the procedure directly.  */
1288           srel = (hsh->stub_offset
1289                   + hsh->stub_sec->output_offset
1290                   + hsh->stub_sec->output_section->vma);
1291           srel -= location;
1292         }
1293
1294       srel = srel >> 2;
1295
1296       if (!within_signed_range (srel, BRANCH_BITS))
1297         {
1298           if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1299             srel = 0;
1300           else
1301             return bfd_reloc_overflow;
1302         }
1303
1304       opcode &= ~(0x7ffff << 5);
1305       opcode |= ((srel & 0x7ffff) << 5);
1306
1307       bfd_put_32 (input_bfd, opcode, hit_data);
1308       break;
1309     case R_METAG_GETSETOFF:
1310     case R_METAG_GETSET_GOT:
1311     case R_METAG_GETSET_GOTOFF:
1312       opcode = bfd_get_32 (input_bfd, hit_data);
1313
1314       srel = (bfd_signed_vma) relocation;
1315       srel += addend;
1316
1317       /* Is this a standard or extended GET/SET?  */
1318       if ((opcode & 0xf0000000) == 0xa0000000)
1319         {
1320           /* Extended GET/SET.  */
1321           l1 = opcode & 0x2;
1322           l2 = opcode & 0x4;
1323           op_extended = 1;
1324         }
1325       else
1326         {
1327           /* Standard GET/SET.  */
1328           l1 = opcode & 0x01000000;
1329           l2 = opcode & 0x04000000;
1330           op_extended = 0;
1331         }
1332
1333       /* Calculate the width of the GET/SET and how much we need to
1334          shift the result by.  */
1335       if (l2)
1336         if (l1)
1337           op_shift = 3;
1338         else
1339           op_shift = 2;
1340       else
1341         if (l1)
1342           op_shift = 1;
1343         else
1344           op_shift = 0;
1345
1346       /* GET/SET offsets are scaled by the width of the transfer.  */
1347       srel = srel >> op_shift;
1348
1349       /* Extended GET/SET has signed 12 bits of offset, standard has
1350          signed 6 bits.  */
1351       if (op_extended)
1352         {
1353           if (!within_signed_range (srel, 12))
1354             {
1355               if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1356                 srel = 0;
1357               else
1358                 return bfd_reloc_overflow;
1359             }
1360           opcode &= ~(0xfff << 7);
1361           opcode |= ((srel & 0xfff) << 7);
1362         }
1363       else
1364         {
1365           if (!within_signed_range (srel, 5))
1366             {
1367               if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1368                 srel = 0;
1369               else
1370                 return bfd_reloc_overflow;
1371             }
1372           opcode &= ~(0x3f << 8);
1373           opcode |= ((srel & 0x3f) << 8);
1374         }
1375
1376       bfd_put_32 (input_bfd, opcode, hit_data);
1377       break;
1378     case R_METAG_TLS_GD:
1379     case R_METAG_TLS_LDM:
1380       opcode = bfd_get_32 (input_bfd, hit_data);
1381
1382       if ((bfd_signed_vma)relocation < 0)
1383        {
1384          /* sign extend immediate */
1385          if ((opcode & 0xf2000001) == 0x02000000)
1386           {
1387             /* ADD De.e,Dx.r,#I16 */
1388             /* set SE bit */
1389             opcode |= (1 << 1);
1390           } else
1391             return bfd_reloc_overflow;
1392        }
1393
1394       bfd_put_32 (input_bfd, opcode, hit_data);
1395
1396       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1397                                     contents, rel->r_offset,
1398                                     relocation, rel->r_addend);
1399       break;
1400     default:
1401       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1402                                     contents, rel->r_offset,
1403                                     relocation, rel->r_addend);
1404     }
1405
1406   return r;
1407 }
1408
1409 /* This is defined because R_METAG_NONE != 0...
1410    See RELOC_AGAINST_DISCARDED_SECTION for details.  */
1411 #define METAG_RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \
1412                                               rel, relend, howto, contents) \
1413   {                                                                     \
1414     _bfd_clear_contents (howto, input_bfd, input_section,               \
1415                          contents + rel->r_offset);                     \
1416                                                                         \
1417     if (bfd_link_relocatable (info)                                     \
1418         && (input_section->flags & SEC_DEBUGGING))                      \
1419       {                                                                 \
1420         /* Only remove relocations in debug sections since other        \
1421            sections may require relocations.  */                        \
1422         Elf_Internal_Shdr *rel_hdr;                                     \
1423                                                                         \
1424         rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \
1425                                                                         \
1426         /* Avoid empty output section.  */                              \
1427         if (rel_hdr->sh_size > rel_hdr->sh_entsize)                     \
1428           {                                                             \
1429             rel_hdr->sh_size -= rel_hdr->sh_entsize;                    \
1430             rel_hdr = _bfd_elf_single_rel_hdr (input_section);          \
1431             rel_hdr->sh_size -= rel_hdr->sh_entsize;                    \
1432                                                                         \
1433             memmove (rel, rel + 1, (relend - rel) * sizeof (*rel));     \
1434                                                                         \
1435             input_section->reloc_count--;                               \
1436             relend--;                                                   \
1437             rel--;                                                      \
1438             continue;                                                   \
1439           }                                                             \
1440       }                                                                 \
1441                                                                         \
1442     rel->r_info = R_METAG_NONE;                                         \
1443     rel->r_addend = 0;                                                  \
1444     continue;                                                           \
1445   }
1446
1447 /* Relocate a META ELF section.
1448
1449 The RELOCATE_SECTION function is called by the new ELF backend linker
1450 to handle the relocations for a section.
1451
1452 The relocs are always passed as Rela structures; if the section
1453 actually uses Rel structures, the r_addend field will always be
1454 zero.
1455
1456 This function is responsible for adjusting the section contents as
1457 necessary, and (if using Rela relocs and generating a relocatable
1458 output file) adjusting the reloc addend as necessary.
1459
1460 This function does not have to worry about setting the reloc
1461 address or the reloc symbol index.
1462
1463 LOCAL_SYMS is a pointer to the swapped in local symbols.
1464
1465 LOCAL_SECTIONS is an array giving the section in the input file
1466 corresponding to the st_shndx field of each local symbol.
1467
1468 The global hash table entry for the global symbols can be found
1469 via elf_sym_hashes (input_bfd).
1470
1471 When generating relocatable output, this function must handle
1472 STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1473 going to be the section symbol corresponding to the output
1474 section, which means that the addend must be adjusted
1475 accordingly.  */
1476
1477 static bfd_boolean
1478 elf_metag_relocate_section (bfd *output_bfd,
1479                             struct bfd_link_info *info,
1480                             bfd *input_bfd,
1481                             asection *input_section,
1482                             bfd_byte *contents,
1483                             Elf_Internal_Rela *relocs,
1484                             Elf_Internal_Sym *local_syms,
1485                             asection **local_sections)
1486 {
1487   bfd_vma *local_got_offsets;
1488   Elf_Internal_Shdr *symtab_hdr;
1489   struct elf_link_hash_entry **eh_syms;
1490   struct elf_metag_link_hash_table *htab;
1491   Elf_Internal_Rela *rel;
1492   Elf_Internal_Rela *relend;
1493   asection *sreloc;
1494
1495   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1496   eh_syms = elf_sym_hashes (input_bfd);
1497   relend = relocs + input_section->reloc_count;
1498
1499   htab = metag_link_hash_table (info);
1500   local_got_offsets = elf_local_got_offsets (input_bfd);
1501
1502   sreloc = NULL;
1503
1504   for (rel = relocs; rel < relend; rel ++)
1505     {
1506       reloc_howto_type *howto;
1507       unsigned long r_symndx;
1508       Elf_Internal_Sym *sym;
1509       asection *sec;
1510       struct elf_metag_link_hash_entry *hh;
1511       bfd_vma relocation;
1512       bfd_reloc_status_type r;
1513       const char *name;
1514       int r_type;
1515
1516       r_type = ELF32_R_TYPE (rel->r_info);
1517
1518       if (r_type == R_METAG_GNU_VTINHERIT
1519           || r_type == R_METAG_GNU_VTENTRY
1520           || r_type == R_METAG_NONE)
1521         continue;
1522
1523       r_symndx = ELF32_R_SYM (rel->r_info);
1524
1525       howto  = elf_metag_howto_table + ELF32_R_TYPE (rel->r_info);
1526       hh     = NULL;
1527       sym    = NULL;
1528       sec    = NULL;
1529
1530       if (r_symndx < symtab_hdr->sh_info)
1531         {
1532           sym = local_syms + r_symndx;
1533           sec = local_sections [r_symndx];
1534           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1535
1536           name = bfd_elf_string_from_elf_section
1537             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1538           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1539         }
1540       else
1541         {
1542           struct elf_link_hash_entry *eh;
1543           bfd_boolean unresolved_reloc, warned, ignored;
1544
1545           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1546                                    r_symndx, symtab_hdr, eh_syms,
1547                                    eh, sec, relocation,
1548                                    unresolved_reloc, warned, ignored);
1549
1550           name = eh->root.root.string;
1551           hh = (struct elf_metag_link_hash_entry *) eh;
1552         }
1553
1554       if (sec != NULL && discarded_section (sec))
1555           METAG_RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1556                                                  rel, relend, howto, contents);
1557
1558       if (bfd_link_relocatable (info))
1559         continue;
1560
1561       switch (r_type)
1562         {
1563         case R_METAG_ADDR32:
1564         case R_METAG_RELBRANCH:
1565           if ((input_section->flags & SEC_ALLOC) == 0)
1566             break;
1567
1568           if ((bfd_link_pic (info)
1569                && r_symndx != STN_UNDEF
1570                && (input_section->flags & SEC_ALLOC) != 0
1571                && (r_type != R_METAG_RELBRANCH
1572                    || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
1573               || (!bfd_link_pic (info)
1574                   && hh != NULL
1575                   && hh->eh.dynindx != -1
1576                   && !hh->eh.non_got_ref
1577                   && ((hh->eh.def_dynamic
1578                        && !hh->eh.def_regular)
1579                       || hh->eh.root.type == bfd_link_hash_undefweak
1580                       || hh->eh.root.type == bfd_link_hash_undefined)))
1581             {
1582               Elf_Internal_Rela outrel;
1583               bfd_boolean skip, relocate;
1584               bfd_byte *loc;
1585
1586               /* When generating a shared object, these relocations
1587                  are copied into the output file to be resolved at run
1588                  time.  */
1589
1590               sreloc = elf_section_data (input_section)->sreloc;
1591               BFD_ASSERT (sreloc != NULL);
1592
1593               skip = FALSE;
1594               relocate = FALSE;
1595
1596               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
1597                                                          info,
1598                                                          input_section,
1599                                                          rel->r_offset);
1600               if (outrel.r_offset == (bfd_vma) -1)
1601                 skip = TRUE;
1602               else if (outrel.r_offset == (bfd_vma) -2)
1603                 skip = TRUE, relocate = TRUE;
1604               outrel.r_offset += (input_section->output_section->vma
1605                                   + input_section->output_offset);
1606
1607               if (skip)
1608                 {
1609                   memset (&outrel, 0, sizeof outrel);
1610                   outrel.r_info = ELF32_R_INFO (0, R_METAG_NONE);
1611                 }
1612               else if (r_type == R_METAG_RELBRANCH)
1613                 {
1614                   BFD_ASSERT (hh != NULL && hh->eh.dynindx != -1);
1615                   outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1616                   outrel.r_addend = rel->r_addend;
1617                 }
1618               else
1619                 {
1620                   /* h->dynindx may be -1 if this symbol was marked to
1621                      become local.  */
1622                   if (hh == NULL
1623                       || ((info->symbolic || hh->eh.dynindx == -1)
1624                           && hh->eh.def_regular))
1625                     {
1626                       relocate = TRUE;
1627                       outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1628                       outrel.r_addend = relocation + rel->r_addend;
1629                     }
1630                   else
1631                     {
1632                       BFD_ASSERT (hh->eh.dynindx != -1);
1633                       outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1634                       outrel.r_addend = rel->r_addend;
1635                     }
1636                 }
1637
1638               loc = sreloc->contents;
1639               loc += sreloc->reloc_count * sizeof(Elf32_External_Rela);
1640               bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1641               ++sreloc->reloc_count;
1642
1643               /* If this reloc is against an external symbol, we do
1644                  not want to fiddle with the addend.  Otherwise, we
1645                  need to include the symbol value so that it becomes
1646                  an addend for the dynamic reloc.  */
1647               if (! relocate)
1648                 continue;
1649             }
1650           break;
1651
1652         case R_METAG_RELBRANCH_PLT:
1653           /* Relocation is to the entry for this symbol in the
1654              procedure linkage table.  */
1655
1656           if (hh == NULL)
1657             break;
1658
1659           if (hh->eh.forced_local)
1660             break;
1661
1662           if (hh->eh.plt.offset == (bfd_vma) -1 || htab->etab.splt == NULL)
1663             {
1664               /* We didn't make a PLT entry for this symbol.  This
1665                  happens when statically linking PIC code, or when
1666                  using -Bsymbolic.  */
1667               break;
1668             }
1669
1670           relocation = (htab->etab.splt->output_section->vma
1671                         + htab->etab.splt->output_offset
1672                         + hh->eh.plt.offset);
1673           break;
1674         case R_METAG_HI16_GOTPC:
1675         case R_METAG_LO16_GOTPC:
1676           BFD_ASSERT (htab->etab.sgot != NULL);
1677
1678           relocation = (htab->etab.sgot->output_section->vma +
1679                         htab->etab.sgot->output_offset);
1680           relocation += GOT_REG_OFFSET;
1681           relocation -= (input_section->output_section->vma
1682                          + input_section->output_offset
1683                          + rel->r_offset);
1684           break;
1685         case R_METAG_HI16_GOTOFF:
1686         case R_METAG_LO16_GOTOFF:
1687         case R_METAG_GETSET_GOTOFF:
1688           BFD_ASSERT (htab->etab.sgot != NULL);
1689
1690           relocation -= (htab->etab.sgot->output_section->vma +
1691                          htab->etab.sgot->output_offset);
1692           relocation -= GOT_REG_OFFSET;
1693           break;
1694         case R_METAG_GETSET_GOT:
1695           {
1696             bfd_vma off;
1697             bfd_boolean do_got = 0;
1698
1699             /* Relocation is to the entry for this symbol in the
1700                global offset table.  */
1701             if (hh != NULL)
1702               {
1703                 bfd_boolean dyn;
1704
1705                 off = hh->eh.got.offset;
1706                 dyn = htab->etab.dynamic_sections_created;
1707                 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1708                                                        bfd_link_pic (info),
1709                                                        &hh->eh))
1710                   {
1711                     /* If we aren't going to call finish_dynamic_symbol,
1712                        then we need to handle initialisation of the .got
1713                        entry and create needed relocs here.  Since the
1714                        offset must always be a multiple of 4, we use the
1715                        least significant bit to record whether we have
1716                        initialised it already.  */
1717                     if ((off & 1) != 0)
1718                       off &= ~1;
1719                     else
1720                       {
1721                         hh->eh.got.offset |= 1;
1722                         do_got = 1;
1723                       }
1724                   }
1725               }
1726             else
1727               {
1728                 /* Local symbol case.  */
1729                 if (local_got_offsets == NULL)
1730                   abort ();
1731
1732                 off = local_got_offsets[r_symndx];
1733
1734                 /* The offset must always be a multiple of 4.  We use
1735                    the least significant bit to record whether we have
1736                    already generated the necessary reloc.  */
1737                 if ((off & 1) != 0)
1738                   off &= ~1;
1739                 else
1740                   {
1741                     local_got_offsets[r_symndx] |= 1;
1742                     do_got = 1;
1743                   }
1744               }
1745
1746             if (do_got)
1747               {
1748                 if (bfd_link_pic (info))
1749                   {
1750                     /* Output a dynamic relocation for this GOT entry.
1751                        In this case it is relative to the base of the
1752                        object because the symbol index is zero.  */
1753                     Elf_Internal_Rela outrel;
1754                     bfd_byte *loc;
1755                     asection *s = htab->etab.srelgot;
1756
1757                     outrel.r_offset = (off
1758                                        + htab->etab.sgot->output_offset
1759                                        + htab->etab.sgot->output_section->vma);
1760                     outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1761                     outrel.r_addend = relocation;
1762                     loc = s->contents;
1763                     loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1764                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1765                   }
1766                 else
1767                   bfd_put_32 (output_bfd, relocation,
1768                               htab->etab.sgot->contents + off);
1769               }
1770
1771             if (off >= (bfd_vma) -2)
1772               abort ();
1773
1774             relocation = off - GOT_REG_OFFSET;
1775           }
1776           break;
1777         case R_METAG_TLS_GD:
1778         case R_METAG_TLS_IE:
1779           {
1780             /* XXXMJF There is room here for optimisations. For example
1781                converting from GD->IE, etc.  */
1782             bfd_vma off;
1783             int indx;
1784             char tls_type;
1785
1786             if (htab->etab.sgot == NULL)
1787               abort();
1788
1789             indx = 0;
1790             if (hh != NULL)
1791               {
1792                 bfd_boolean dyn;
1793                 dyn = htab->etab.dynamic_sections_created;
1794
1795                 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1796                                                      bfd_link_pic (info),
1797                                                      &hh->eh)
1798                     && (!bfd_link_pic (info)
1799                         || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
1800                   {
1801                     indx = hh->eh.dynindx;
1802                   }
1803                 off = hh->eh.got.offset;
1804                 tls_type = hh->tls_type;
1805               }
1806             else
1807               {
1808                 /* Local symbol case.  */
1809                 if (local_got_offsets == NULL)
1810                   abort ();
1811
1812                 off = local_got_offsets[r_symndx];
1813                 tls_type = metag_elf_local_got_tls_type (input_bfd) [r_symndx];
1814               }
1815
1816             if (tls_type == GOT_UNKNOWN)
1817               abort ();
1818
1819             if ((off & 1) != 0)
1820               off &= ~1;
1821             else
1822               {
1823                 bfd_boolean need_relocs = FALSE;
1824                 Elf_Internal_Rela outrel;
1825                 bfd_byte *loc = NULL;
1826                 int cur_off = off;
1827
1828                 /* The GOT entries have not been initialized yet.  Do it
1829                    now, and emit any relocations.  If both an IE GOT and a
1830                    GD GOT are necessary, we emit the GD first.  */
1831
1832                 if ((bfd_link_pic (info) || indx != 0)
1833                     && (hh == NULL
1834                         || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
1835                         || hh->eh.root.type != bfd_link_hash_undefweak))
1836                   {
1837                     need_relocs = TRUE;
1838                     loc = htab->etab.srelgot->contents;
1839                     /* FIXME (CAO): Should this be reloc_count++ ? */
1840                     loc += htab->etab.srelgot->reloc_count * sizeof (Elf32_External_Rela);
1841                   }
1842
1843                 if (tls_type & GOT_TLS_GD)
1844                   {
1845                     if (need_relocs)
1846                       {
1847                         outrel.r_offset = (cur_off
1848                                            + htab->etab.sgot->output_section->vma
1849                                            + htab->etab.sgot->output_offset);
1850                         outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_DTPMOD);
1851                         outrel.r_addend = 0;
1852                         bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + cur_off);
1853
1854                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1855                         htab->etab.srelgot->reloc_count++;
1856                         loc += sizeof (Elf32_External_Rela);
1857
1858                         if (indx == 0)
1859                           bfd_put_32 (output_bfd, 0,
1860                                       htab->etab.sgot->contents + cur_off + 4);
1861                         else
1862                           {
1863                             bfd_put_32 (output_bfd, 0,
1864                                         htab->etab.sgot->contents + cur_off + 4);
1865                             outrel.r_info = ELF32_R_INFO (indx,
1866                                                       R_METAG_TLS_DTPOFF);
1867                             outrel.r_offset += 4;
1868                             bfd_elf32_swap_reloca_out (output_bfd,
1869                                                        &outrel, loc);
1870                             htab->etab.srelgot->reloc_count++;
1871                             loc += sizeof (Elf32_External_Rela);
1872                           }
1873                       }
1874                     else
1875                       {
1876                         /* We don't support changing the TLS model.  */
1877                         /* PR 20675 */
1878                         if (bfd_link_pic (info))
1879                           _bfd_error_handler (_("%B(%A): multiple TLS models are not supported"),
1880                                               input_bfd, input_section, name);
1881                         else
1882                           _bfd_error_handler (_("%B(%A): shared library symbol %s encountered whilst performing a static link"),
1883                                               input_bfd, input_section, name);
1884                         return FALSE;
1885                       }
1886
1887                     cur_off += 8;
1888                   }
1889
1890                 if (tls_type & GOT_TLS_IE)
1891                   {
1892                     if (need_relocs)
1893                       {
1894                         outrel.r_offset = (cur_off
1895                                            + htab->etab.sgot->output_section->vma
1896                                            + htab->etab.sgot->output_offset);
1897                         outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_TPOFF);
1898
1899                         if (indx == 0)
1900                           outrel.r_addend = relocation - dtpoff_base (info);
1901                         else
1902                           outrel.r_addend = 0;
1903
1904                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1905                         htab->etab.srelgot->reloc_count++;
1906                         loc += sizeof (Elf32_External_Rela);
1907                       }
1908                     else
1909                       bfd_put_32 (output_bfd, tpoff (info, relocation),
1910                                   htab->etab.sgot->contents + cur_off);
1911
1912                     cur_off += 4;
1913                   }
1914
1915                   if (hh != NULL)
1916                     hh->eh.got.offset |= 1;
1917                   else
1918                     local_got_offsets[r_symndx] |= 1;
1919               }
1920
1921             /* Add the base of the GOT to the relocation value.  */
1922             relocation = off - GOT_REG_OFFSET;
1923
1924             break;
1925           }
1926
1927         case R_METAG_TLS_IENONPIC_HI16:
1928         case R_METAG_TLS_IENONPIC_LO16:
1929         case R_METAG_TLS_LE_HI16:
1930         case R_METAG_TLS_LE_LO16:
1931           if (bfd_link_pic (info))
1932             {
1933               _bfd_error_handler
1934                 /* xgettext:c-format */
1935                 (_("%B(%A+0x%lx): R_METAG_TLS_LE/IENONPIC relocation not permitted in shared object"),
1936                  input_bfd, input_section,
1937                  (long) rel->r_offset, howto->name);
1938               return FALSE;
1939             }
1940           else
1941             relocation = tpoff (info, relocation);
1942           break;
1943         case R_METAG_TLS_LDO_HI16:
1944         case R_METAG_TLS_LDO_LO16:
1945           if (! bfd_link_pic (info))
1946             relocation = tpoff (info, relocation);
1947           else
1948             relocation -= dtpoff_base (info);
1949           break;
1950         case R_METAG_TLS_LDM:
1951           {
1952             bfd_vma off;
1953
1954             if (htab->etab.sgot == NULL)
1955               abort();
1956             off = htab->tls_ldm_got.offset;
1957             if (off & 1)
1958               off &= ~1;
1959             else
1960               {
1961                 Elf_Internal_Rela outrel;
1962                 bfd_byte *loc;
1963
1964                 outrel.r_offset = (off
1965                                    + htab->etab.sgot->output_section->vma
1966                                    + htab->etab.sgot->output_offset);
1967
1968                 outrel.r_addend = 0;
1969                 outrel.r_info = ELF32_R_INFO (0, R_METAG_TLS_DTPMOD);
1970                 loc = htab->etab.srelgot->contents;
1971                 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1972                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1973                 htab->tls_ldm_got.offset |= 1;
1974               }
1975
1976             relocation = off - GOT_REG_OFFSET;
1977             break;
1978           }
1979         default:
1980           break;
1981         }
1982
1983       r = metag_final_link_relocate (howto, input_bfd, input_section,
1984                                      contents, rel, relocation, hh, htab,
1985                                      sec);
1986
1987       if (r != bfd_reloc_ok)
1988         {
1989           const char * msg = (const char *) NULL;
1990
1991           switch (r)
1992             {
1993             case bfd_reloc_overflow:
1994               (*info->callbacks->reloc_overflow)
1995                 (info, (hh ? &hh->eh.root : NULL), name, howto->name,
1996                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1997               break;
1998
1999             case bfd_reloc_undefined:
2000               (*info->callbacks->undefined_symbol)
2001                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2002               break;
2003
2004             case bfd_reloc_outofrange:
2005               msg = _("internal error: out of range error");
2006               break;
2007
2008             case bfd_reloc_notsupported:
2009               msg = _("internal error: unsupported relocation error");
2010               break;
2011
2012             case bfd_reloc_dangerous:
2013               msg = _("internal error: dangerous relocation");
2014               break;
2015
2016             default:
2017               msg = _("internal error: unknown error");
2018               break;
2019             }
2020
2021           if (msg)
2022             (*info->callbacks->warning) (info, msg, name, input_bfd,
2023                                          input_section, rel->r_offset);
2024         }
2025     }
2026
2027   return TRUE;
2028 }
2029
2030 /* Create the .plt and .got sections, and set up our hash table
2031    short-cuts to various dynamic sections.  */
2032
2033 static bfd_boolean
2034 elf_metag_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2035 {
2036   struct elf_metag_link_hash_table *htab;
2037   struct elf_link_hash_entry *eh;
2038   struct bfd_link_hash_entry *bh;
2039   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2040
2041   /* Don't try to create the .plt and .got twice.  */
2042   htab = metag_link_hash_table (info);
2043   if (htab->etab.splt != NULL)
2044     return TRUE;
2045
2046   /* Call the generic code to do most of the work.  */
2047   if (! _bfd_elf_create_dynamic_sections (abfd, info))
2048     return FALSE;
2049
2050   /* The header goes at the start of the dynamic .got section, which
2051      is placed after the dynamic .got.plt section.  ie. The header is
2052      not necessarily at the start of the output .got section.  */
2053   htab->etab.sgot->size += 12;
2054
2055   /* Define the symbol __GLOBAL_OFFSET_TABLE__ on the header.  */
2056   bh = NULL;
2057   if (!(_bfd_generic_link_add_one_symbol
2058         (info, abfd, "__GLOBAL_OFFSET_TABLE__", BSF_GLOBAL, htab->etab.sgot,
2059          (bfd_vma) 0, NULL, FALSE, bed->collect, &bh)))
2060     return FALSE;
2061   eh = (struct elf_link_hash_entry *) bh;
2062   eh->def_regular = 1;
2063   eh->type = STT_OBJECT;
2064   eh->other = STV_HIDDEN;
2065
2066   if (! bfd_link_executable (info)
2067       && ! bfd_elf_link_record_dynamic_symbol (info, eh))
2068     return FALSE;
2069
2070   htab->etab.hgot = eh;
2071
2072   htab->sdynbss = bfd_get_linker_section (abfd, ".dynbss");
2073   htab->srelbss = bfd_get_linker_section (abfd, ".rela.bss");
2074
2075   return TRUE;
2076 }
2077
2078 /* Look through the relocs for a section during the first phase, and
2079    calculate needed space in the global offset table, procedure linkage
2080    table, and dynamic reloc sections.  At this point we haven't
2081    necessarily read all the input files.  */
2082
2083 static bfd_boolean
2084 elf_metag_check_relocs (bfd *abfd,
2085                         struct bfd_link_info *info,
2086                         asection *sec,
2087                         const Elf_Internal_Rela *relocs)
2088 {
2089   Elf_Internal_Shdr *symtab_hdr;
2090   struct elf_link_hash_entry **eh_syms;
2091   const Elf_Internal_Rela *rel;
2092   const Elf_Internal_Rela *rel_end;
2093   struct elf_metag_link_hash_table *htab;
2094   asection *sreloc;
2095   bfd *dynobj;
2096   int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
2097
2098   if (bfd_link_relocatable (info))
2099     return TRUE;
2100
2101   htab = metag_link_hash_table (info);
2102   dynobj = htab->etab.dynobj;
2103   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2104   eh_syms = elf_sym_hashes (abfd);
2105   sreloc = NULL;
2106
2107   if (htab == NULL)
2108     return FALSE;
2109
2110   rel_end = relocs + sec->reloc_count;
2111   for (rel = relocs; rel < rel_end; rel++)
2112     {
2113       int r_type;
2114       struct elf_metag_link_hash_entry *hh;
2115       Elf_Internal_Sym *isym;
2116       unsigned long r_symndx;
2117
2118       r_symndx = ELF32_R_SYM (rel->r_info);
2119       r_type = ELF32_R_TYPE (rel->r_info);
2120       if (r_symndx < symtab_hdr->sh_info)
2121         {
2122           /* A local symbol.  */
2123           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2124                                         abfd, r_symndx);
2125           if (isym == NULL)
2126             return FALSE;
2127
2128           hh = NULL;
2129         }
2130       else
2131         {
2132           isym = NULL;
2133
2134           hh = (struct elf_metag_link_hash_entry *)
2135             eh_syms[r_symndx - symtab_hdr->sh_info];
2136           while (hh->eh.root.type == bfd_link_hash_indirect
2137                  || hh->eh.root.type == bfd_link_hash_warning)
2138             hh = (struct elf_metag_link_hash_entry *) hh->eh.root.u.i.link;
2139
2140           /* PR15323, ref flags aren't set for references in the same
2141              object.  */
2142           hh->eh.root.non_ir_ref = 1;
2143         }
2144
2145       /* Some relocs require a global offset table.  */
2146       if (htab->etab.sgot == NULL)
2147         {
2148           switch (r_type)
2149             {
2150             case R_METAG_TLS_GD:
2151             case R_METAG_TLS_LDM:
2152             case R_METAG_TLS_IE:
2153               if (bfd_link_pic (info))
2154                 info->flags |= DF_STATIC_TLS;
2155               /* Fall through.  */
2156
2157             case R_METAG_HI16_GOTOFF:
2158             case R_METAG_LO16_GOTOFF:
2159             case R_METAG_GETSET_GOTOFF:
2160             case R_METAG_GETSET_GOT:
2161             case R_METAG_HI16_GOTPC:
2162             case R_METAG_LO16_GOTPC:
2163               if (dynobj == NULL)
2164                 htab->etab.dynobj = dynobj = abfd;
2165               if (!elf_metag_create_dynamic_sections (dynobj, info))
2166                 return FALSE;
2167               break;
2168
2169             default:
2170               break;
2171             }
2172         }
2173
2174       switch (r_type)
2175         {
2176         case R_METAG_TLS_IE:
2177         case R_METAG_TLS_GD:
2178         case R_METAG_GETSET_GOT:
2179           switch (r_type)
2180             {
2181             default:
2182               tls_type = GOT_NORMAL;
2183               break;
2184             case R_METAG_TLS_IE:
2185               tls_type = GOT_TLS_IE;
2186               break;
2187             case R_METAG_TLS_GD:
2188               tls_type = GOT_TLS_GD;
2189               break;
2190             }
2191
2192           if (hh != NULL)
2193             {
2194               hh->eh.got.refcount += 1;
2195               old_tls_type = hh->tls_type;
2196             }
2197           else
2198             {
2199               bfd_signed_vma *local_got_refcounts;
2200
2201               /* This is a global offset table entry for a local
2202                  symbol.  */
2203               local_got_refcounts = elf_local_got_refcounts (abfd);
2204               if (local_got_refcounts == NULL)
2205                 {
2206                   bfd_size_type size;
2207
2208                   size = symtab_hdr->sh_info;
2209                   size *= sizeof (bfd_signed_vma);
2210                   /* Add in space to store the local GOT TLS types.  */
2211                   size += symtab_hdr->sh_info;
2212                   local_got_refcounts = ((bfd_signed_vma *)
2213                                          bfd_zalloc (abfd, size));
2214                   if (local_got_refcounts == NULL)
2215                     return FALSE;
2216                   elf_local_got_refcounts (abfd) = local_got_refcounts;
2217                   memset (metag_elf_local_got_tls_type (abfd),
2218                           GOT_UNKNOWN, symtab_hdr->sh_info);
2219                 }
2220               local_got_refcounts[r_symndx] += 1;
2221               old_tls_type = metag_elf_local_got_tls_type (abfd) [r_symndx];
2222             }
2223
2224           if (old_tls_type != tls_type)
2225             {
2226               if (hh != NULL)
2227                 {
2228                   hh->tls_type = tls_type;
2229                 }
2230               else
2231                 {
2232                   metag_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
2233                 }
2234             }
2235
2236           break;
2237
2238         case R_METAG_TLS_LDM:
2239           metag_link_hash_table (info)->tls_ldm_got.refcount += 1;
2240           break;
2241
2242         case R_METAG_RELBRANCH_PLT:
2243           /* This symbol requires a procedure linkage table entry.  We
2244              actually build the entry in adjust_dynamic_symbol,
2245              because this might be a case of linking PIC code without
2246              linking in any dynamic objects, in which case we don't
2247              need to generate a procedure linkage table after all.  */
2248
2249           /* If this is a local symbol, we resolve it directly without
2250              creating a procedure linkage table entry.  */
2251           if (hh == NULL)
2252             continue;
2253
2254           if (hh->eh.forced_local)
2255             break;
2256
2257           hh->eh.needs_plt = 1;
2258           hh->eh.plt.refcount += 1;
2259           break;
2260
2261         case R_METAG_HIADDR16:
2262         case R_METAG_LOADDR16:
2263           /* Let's help debug shared library creation.  These relocs
2264              cannot be used in shared libs.  Don't error out for
2265              sections we don't care about, such as debug sections or
2266              non-constant sections.  */
2267           if (bfd_link_pic (info)
2268               && (sec->flags & SEC_ALLOC) != 0
2269               && (sec->flags & SEC_READONLY) != 0)
2270             {
2271               const char *name;
2272
2273               if (hh)
2274                 name = hh->eh.root.root.string;
2275               else
2276                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
2277               _bfd_error_handler
2278                 /* xgettext:c-format */
2279                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2280                  abfd, elf_metag_howto_table[r_type].name, name);
2281               bfd_set_error (bfd_error_bad_value);
2282               return FALSE;
2283             }
2284
2285           /* Fall through.  */
2286         case R_METAG_ADDR32:
2287         case R_METAG_RELBRANCH:
2288         case R_METAG_GETSETOFF:
2289           if (hh != NULL && !bfd_link_pic (info))
2290             {
2291               hh->eh.non_got_ref = 1;
2292               hh->eh.plt.refcount += 1;
2293             }
2294
2295           /* If we are creating a shared library, and this is a reloc
2296              against a global symbol, or a non PC relative reloc
2297              against a local symbol, then we need to copy the reloc
2298              into the shared library.  However, if we are linking with
2299              -Bsymbolic, we do not need to copy a reloc against a
2300              global symbol which is defined in an object we are
2301              including in the link (i.e., DEF_REGULAR is set).  At
2302              this point we have not seen all the input files, so it is
2303              possible that DEF_REGULAR is not set now but will be set
2304              later (it is never cleared).  We account for that
2305              possibility below by storing information in the
2306              dyn_relocs field of the hash table entry. A similar
2307              situation occurs when creating shared libraries and symbol
2308              visibility changes render the symbol local.
2309
2310              If on the other hand, we are creating an executable, we
2311              may need to keep relocations for symbols satisfied by a
2312              dynamic library if we manage to avoid copy relocs for the
2313              symbol.  */
2314           if ((bfd_link_pic (info)
2315                && (sec->flags & SEC_ALLOC) != 0
2316                && (r_type != R_METAG_RELBRANCH
2317                    || (hh != NULL
2318                        && (! info->symbolic
2319                            || hh->eh.root.type == bfd_link_hash_defweak
2320                            || !hh->eh.def_regular))))
2321               || (!bfd_link_pic (info)
2322                   && (sec->flags & SEC_ALLOC) != 0
2323                   && hh != NULL
2324                   && (hh->eh.root.type == bfd_link_hash_defweak
2325                       || !hh->eh.def_regular)))
2326             {
2327               struct elf_metag_dyn_reloc_entry *hdh_p;
2328               struct elf_metag_dyn_reloc_entry **hdh_head;
2329
2330               if (dynobj == NULL)
2331                 htab->etab.dynobj = dynobj = abfd;
2332
2333               /* When creating a shared object, we must copy these
2334                  relocs into the output file.  We create a reloc
2335                  section in dynobj and make room for the reloc.  */
2336               if (sreloc == NULL)
2337                 {
2338                   sreloc = _bfd_elf_make_dynamic_reloc_section
2339                     (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
2340
2341                   if (sreloc == NULL)
2342                     {
2343                       bfd_set_error (bfd_error_bad_value);
2344                       return FALSE;
2345                     }
2346
2347                   elf_section_data (sec)->sreloc = sreloc;
2348                 }
2349
2350               /* If this is a global symbol, we count the number of
2351                  relocations we need for this symbol.  */
2352               if (hh != NULL)
2353                 hdh_head = &((struct elf_metag_link_hash_entry *) hh)->dyn_relocs;
2354               else
2355                 {
2356                   /* Track dynamic relocs needed for local syms too.  */
2357                   asection *sr;
2358                   void *vpp;
2359
2360                   sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
2361                   if (sr == NULL)
2362                     sr = sec;
2363
2364                   vpp = &elf_section_data (sr)->local_dynrel;
2365                   hdh_head = (struct elf_metag_dyn_reloc_entry **) vpp;
2366                 }
2367
2368               hdh_p = *hdh_head;
2369               if (hdh_p == NULL || hdh_p->sec != sec)
2370                 {
2371                   hdh_p = ((struct elf_metag_dyn_reloc_entry *)
2372                            bfd_alloc (dynobj, sizeof *hdh_p));
2373                   if (hdh_p == NULL)
2374                     return FALSE;
2375                   hdh_p->hdh_next = *hdh_head;
2376                   *hdh_head = hdh_p;
2377                   hdh_p->sec = sec;
2378                   hdh_p->count = 0;
2379                   hdh_p->relative_count = 0;
2380                 }
2381
2382               hdh_p->count += 1;
2383               if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
2384                 hdh_p->relative_count += 1;
2385             }
2386           break;
2387
2388           /* This relocation describes the C++ object vtable hierarchy.
2389              Reconstruct it for later use during GC.  */
2390         case R_METAG_GNU_VTINHERIT:
2391           if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh,
2392                                             rel->r_offset))
2393             return FALSE;
2394           break;
2395
2396           /* This relocation describes which C++ vtable entries are actually
2397              used.  Record for later use during GC.  */
2398         case R_METAG_GNU_VTENTRY:
2399           BFD_ASSERT (hh != NULL);
2400           if (hh != NULL
2401               && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
2402             return FALSE;
2403           break;
2404         }
2405     }
2406
2407   return TRUE;
2408 }
2409
2410 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2411
2412 static void
2413 elf_metag_copy_indirect_symbol (struct bfd_link_info *info,
2414                                 struct elf_link_hash_entry *eh_dir,
2415                                 struct elf_link_hash_entry *eh_ind)
2416 {
2417   struct elf_metag_link_hash_entry *hh_dir, *hh_ind;
2418
2419   hh_dir = metag_elf_hash_entry (eh_dir);
2420   hh_ind = metag_elf_hash_entry (eh_ind);
2421
2422   if (hh_ind->dyn_relocs != NULL)
2423     {
2424       if (hh_dir->dyn_relocs != NULL)
2425         {
2426           struct elf_metag_dyn_reloc_entry **hdh_pp;
2427           struct elf_metag_dyn_reloc_entry *hdh_p;
2428
2429           if (eh_ind->root.type == bfd_link_hash_indirect)
2430             abort ();
2431
2432           /* Add reloc counts against the weak sym to the strong sym
2433              list.  Merge any entries against the same section.  */
2434           for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2435             {
2436               struct elf_metag_dyn_reloc_entry *hdh_q;
2437
2438               for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
2439                    hdh_q = hdh_q->hdh_next)
2440                 if (hdh_q->sec == hdh_p->sec)
2441                   {
2442                     hdh_q->relative_count += hdh_p->relative_count;
2443                     hdh_q->count += hdh_p->count;
2444                     *hdh_pp = hdh_p->hdh_next;
2445                     break;
2446                   }
2447               if (hdh_q == NULL)
2448                 hdh_pp = &hdh_p->hdh_next;
2449             }
2450           *hdh_pp = hh_dir->dyn_relocs;
2451         }
2452
2453       hh_dir->dyn_relocs = hh_ind->dyn_relocs;
2454       hh_ind->dyn_relocs = NULL;
2455     }
2456
2457   if (eh_ind->root.type == bfd_link_hash_indirect
2458       && eh_dir->got.refcount <= 0)
2459     {
2460       hh_dir->tls_type = hh_ind->tls_type;
2461       hh_ind->tls_type = GOT_UNKNOWN;
2462     }
2463
2464   _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
2465 }
2466
2467 /* Adjust a symbol defined by a dynamic object and referenced by a
2468    regular object.  The current definition is in some section of the
2469    dynamic object, but we're not including those sections.  We have to
2470    change the definition to something the rest of the link can
2471    understand.  */
2472
2473 static bfd_boolean
2474 elf_metag_adjust_dynamic_symbol (struct bfd_link_info *info,
2475                                  struct elf_link_hash_entry *eh)
2476 {
2477   struct elf_metag_link_hash_table *htab;
2478   struct elf_metag_link_hash_entry *hh;
2479   struct elf_metag_dyn_reloc_entry *hdh_p;
2480   asection *s;
2481
2482   /* If this is a function, put it in the procedure linkage table.  We
2483      will fill in the contents of the procedure linkage table later,
2484      when we know the address of the .got section.  */
2485   if (eh->type == STT_FUNC
2486       || eh->needs_plt)
2487     {
2488       if (eh->plt.refcount <= 0
2489           || SYMBOL_CALLS_LOCAL (info, eh)
2490           || (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT
2491               && eh->root.type == bfd_link_hash_undefweak))
2492         {
2493           /* This case can occur if we saw a PLT reloc in an input
2494              file, but the symbol was never referred to by a dynamic
2495              object.  In such a case, we don't actually need to build
2496              a procedure linkage table, and we can just do a PCREL
2497              reloc instead.  */
2498           eh->plt.offset = (bfd_vma) -1;
2499           eh->needs_plt = 0;
2500         }
2501
2502       return TRUE;
2503     }
2504   else
2505     eh->plt.offset = (bfd_vma) -1;
2506
2507   /* If this is a weak symbol, and there is a real definition, the
2508      processor independent code will have arranged for us to see the
2509      real definition first, and we can just use the same value.  */
2510   if (eh->u.weakdef != NULL)
2511     {
2512       if (eh->u.weakdef->root.type != bfd_link_hash_defined
2513           && eh->u.weakdef->root.type != bfd_link_hash_defweak)
2514         abort ();
2515       eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
2516       eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
2517       eh->non_got_ref = eh->u.weakdef->non_got_ref;
2518       return TRUE;
2519     }
2520
2521   /* This is a reference to a symbol defined by a dynamic object which
2522      is not a function.  */
2523
2524   /* If we are creating a shared library, we must presume that the
2525      only references to the symbol are via the global offset table.
2526      For such cases we need not do anything here; the relocations will
2527      be handled correctly by relocate_section.  */
2528   if (bfd_link_pic (info))
2529     return TRUE;
2530
2531   /* If there are no references to this symbol that do not use the
2532      GOT, we don't need to generate a copy reloc.  */
2533   if (!eh->non_got_ref)
2534     return TRUE;
2535
2536   /* If -z nocopyreloc was given, we won't generate them either.  */
2537   if (info->nocopyreloc)
2538     {
2539       eh->non_got_ref = 0;
2540       return TRUE;
2541     }
2542
2543   hh = (struct elf_metag_link_hash_entry *) eh;
2544   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2545     {
2546       s = hdh_p->sec->output_section;
2547       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2548         break;
2549     }
2550
2551   /* If we didn't find any dynamic relocs in read-only sections, then
2552      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2553   if (hdh_p == NULL)
2554     {
2555       eh->non_got_ref = 0;
2556       return TRUE;
2557     }
2558
2559   /* We must allocate the symbol in our .dynbss section, which will
2560      become part of the .bss section of the executable.  There will be
2561      an entry for this symbol in the .dynsym section.  The dynamic
2562      object will contain position independent code, so all references
2563      from the dynamic object to this symbol will go through the global
2564      offset table.  The dynamic linker will use the .dynsym entry to
2565      determine the address it must put in the global offset table, so
2566      both the dynamic object and the regular object will refer to the
2567      same memory location for the variable.  */
2568
2569   htab = metag_link_hash_table (info);
2570
2571   /* We must generate a COPY reloc to tell the dynamic linker to
2572      copy the initial value out of the dynamic object and into the
2573      runtime process image.  */
2574   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
2575     {
2576       htab->srelbss->size += sizeof (Elf32_External_Rela);
2577       eh->needs_copy = 1;
2578     }
2579
2580   s = htab->sdynbss;
2581
2582   return _bfd_elf_adjust_dynamic_copy (info, eh, s);
2583 }
2584
2585 /* Allocate space in .plt, .got and associated reloc sections for
2586    global syms.  */
2587
2588 static bfd_boolean
2589 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2590 {
2591   struct bfd_link_info *info;
2592   struct elf_metag_link_hash_table *htab;
2593   struct elf_metag_link_hash_entry *hh;
2594   struct elf_metag_dyn_reloc_entry *hdh_p;
2595
2596   if (eh->root.type == bfd_link_hash_indirect)
2597     return TRUE;
2598
2599   if (eh->root.type == bfd_link_hash_warning)
2600     eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2601
2602   info = inf;
2603   htab = metag_link_hash_table (info);
2604
2605   if (htab->etab.dynamic_sections_created
2606       && eh->plt.refcount > 0)
2607     {
2608       /* Make sure this symbol is output as a dynamic symbol.
2609          Undefined weak syms won't yet be marked as dynamic.  */
2610       if (eh->dynindx == -1
2611           && !eh->forced_local)
2612         {
2613           if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2614             return FALSE;
2615         }
2616
2617       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
2618         {
2619           asection *s = htab->etab.splt;
2620
2621           /* If this is the first .plt entry, make room for the special
2622              first entry.  */
2623           if (s->size == 0)
2624             s->size += PLT_ENTRY_SIZE;
2625
2626           eh->plt.offset = s->size;
2627
2628           /* If this symbol is not defined in a regular file, and we are
2629              not generating a shared library, then set the symbol to this
2630              location in the .plt.  This is required to make function
2631              pointers compare as equal between the normal executable and
2632              the shared library.  */
2633           if (! bfd_link_pic (info)
2634               && !eh->def_regular)
2635             {
2636               eh->root.u.def.section = s;
2637               eh->root.u.def.value = eh->plt.offset;
2638             }
2639
2640           /* Make room for this entry.  */
2641           s->size += PLT_ENTRY_SIZE;
2642
2643           /* We also need to make an entry in the .got.plt section, which
2644              will be placed in the .got section by the linker script.  */
2645           htab->etab.sgotplt->size += 4;
2646
2647           /* We also need to make an entry in the .rel.plt section.  */
2648           htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
2649         }
2650       else
2651         {
2652           eh->plt.offset = (bfd_vma) -1;
2653           eh->needs_plt = 0;
2654         }
2655     }
2656   else
2657     {
2658       eh->plt.offset = (bfd_vma) -1;
2659       eh->needs_plt = 0;
2660     }
2661
2662   if (eh->got.refcount > 0)
2663     {
2664       asection *s;
2665       bfd_boolean dyn;
2666       int tls_type = metag_elf_hash_entry (eh)->tls_type;
2667
2668       /* Make sure this symbol is output as a dynamic symbol.
2669          Undefined weak syms won't yet be marked as dynamic.  */
2670       if (eh->dynindx == -1
2671           && !eh->forced_local)
2672         {
2673           if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2674             return FALSE;
2675         }
2676
2677       s = htab->etab.sgot;
2678
2679       eh->got.offset = s->size;
2680       s->size += 4;
2681       /* R_METAG_TLS_GD needs 2 consecutive GOT slots.  */
2682       if (tls_type == GOT_TLS_GD)
2683           s->size += 4;
2684       dyn = htab->etab.dynamic_sections_created;
2685       /* R_METAG_TLS_IE needs one dynamic relocation if dynamic,
2686          R_METAG_TLS_GD needs one if local symbol and two if global.  */
2687       if ((tls_type == GOT_TLS_GD && eh->dynindx == -1)
2688           || (tls_type == GOT_TLS_IE && dyn))
2689         htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2690       else if (tls_type == GOT_TLS_GD)
2691           htab->etab.srelgot->size += 2 * sizeof (Elf32_External_Rela);
2692       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2693                                                 bfd_link_pic (info),
2694                                                 eh))
2695           htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2696     }
2697   else
2698     eh->got.offset = (bfd_vma) -1;
2699
2700   hh = (struct elf_metag_link_hash_entry *) eh;
2701   if (hh->dyn_relocs == NULL)
2702     return TRUE;
2703
2704   /* If this is a -Bsymbolic shared link, then we need to discard all
2705      space allocated for dynamic pc-relative relocs against symbols
2706      defined in a regular object.  For the normal shared case, discard
2707      space for relocs that have become local due to symbol visibility
2708      changes.  */
2709   if (bfd_link_pic (info))
2710     {
2711       if (SYMBOL_CALLS_LOCAL (info, eh))
2712         {
2713           struct elf_metag_dyn_reloc_entry **hdh_pp;
2714
2715           for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2716             {
2717               hdh_p->count -= hdh_p->relative_count;
2718               hdh_p->relative_count = 0;
2719               if (hdh_p->count == 0)
2720                 *hdh_pp = hdh_p->hdh_next;
2721               else
2722                 hdh_pp = &hdh_p->hdh_next;
2723             }
2724         }
2725
2726       /* Also discard relocs on undefined weak syms with non-default
2727          visibility.  */
2728       if (hh->dyn_relocs != NULL
2729           && eh->root.type == bfd_link_hash_undefweak)
2730         {
2731           if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
2732             hh->dyn_relocs = NULL;
2733
2734           /* Make sure undefined weak symbols are output as a dynamic
2735              symbol in PIEs.  */
2736           else if (eh->dynindx == -1
2737                    && !eh->forced_local)
2738             {
2739               if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2740                 return FALSE;
2741             }
2742         }
2743     }
2744   else
2745     {
2746       /* For the non-shared case, discard space for relocs against
2747          symbols which turn out to need copy relocs or are not
2748          dynamic.  */
2749       if (!eh->non_got_ref
2750           && ((eh->def_dynamic
2751                && !eh->def_regular)
2752               || (htab->etab.dynamic_sections_created
2753                   && (eh->root.type == bfd_link_hash_undefweak
2754                       || eh->root.type == bfd_link_hash_undefined))))
2755         {
2756           /* Make sure this symbol is output as a dynamic symbol.
2757              Undefined weak syms won't yet be marked as dynamic.  */
2758           if (eh->dynindx == -1
2759               && !eh->forced_local)
2760             {
2761               if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2762                 return FALSE;
2763             }
2764
2765           /* If that succeeded, we know we'll be keeping all the
2766              relocs.  */
2767           if (eh->dynindx != -1)
2768             goto keep;
2769         }
2770
2771       hh->dyn_relocs = NULL;
2772       return TRUE;
2773
2774     keep: ;
2775     }
2776
2777   /* Finally, allocate space.  */
2778   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2779     {
2780       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
2781       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
2782     }
2783
2784   return TRUE;
2785 }
2786
2787 /* Find any dynamic relocs that apply to read-only sections.  */
2788
2789 static bfd_boolean
2790 readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2791 {
2792   struct elf_metag_link_hash_entry *hh;
2793   struct elf_metag_dyn_reloc_entry *hdh_p;
2794
2795   if (eh->root.type == bfd_link_hash_warning)
2796     eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2797
2798   hh = (struct elf_metag_link_hash_entry *) eh;
2799   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2800     {
2801       asection *s = hdh_p->sec->output_section;
2802
2803       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2804         {
2805           struct bfd_link_info *info = inf;
2806
2807           info->flags |= DF_TEXTREL;
2808
2809           /* Not an error, just cut short the traversal.  */
2810           return FALSE;
2811         }
2812     }
2813   return TRUE;
2814 }
2815
2816 /* Set the sizes of the dynamic sections.  */
2817
2818 static bfd_boolean
2819 elf_metag_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2820                                  struct bfd_link_info *info)
2821 {
2822   struct elf_metag_link_hash_table *htab;
2823   bfd *dynobj;
2824   bfd *ibfd;
2825   asection *s;
2826   bfd_boolean relocs;
2827
2828   htab = metag_link_hash_table (info);
2829   dynobj = htab->etab.dynobj;
2830   if (dynobj == NULL)
2831     abort ();
2832
2833   if (htab->etab.dynamic_sections_created)
2834     {
2835       /* Set the contents of the .interp section to the interpreter.  */
2836       if (bfd_link_executable (info) && !info->nointerp)
2837         {
2838           s = bfd_get_linker_section (dynobj, ".interp");
2839           if (s == NULL)
2840             abort ();
2841           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2842           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2843         }
2844     }
2845
2846   /* Set up .got offsets for local syms, and space for local dynamic
2847      relocs.  */
2848   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2849     {
2850       bfd_signed_vma *local_got;
2851       bfd_signed_vma *end_local_got;
2852       bfd_size_type locsymcount;
2853       Elf_Internal_Shdr *symtab_hdr;
2854       asection *srel;
2855       char *local_tls_type;
2856
2857       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2858         continue;
2859
2860       for (s = ibfd->sections; s != NULL; s = s->next)
2861         {
2862           struct elf_metag_dyn_reloc_entry *hdh_p;
2863
2864           for (hdh_p = ((struct elf_metag_dyn_reloc_entry *)
2865                         elf_section_data (s)->local_dynrel);
2866                hdh_p != NULL;
2867                hdh_p = hdh_p->hdh_next)
2868             {
2869               if (!bfd_is_abs_section (hdh_p->sec)
2870                   && bfd_is_abs_section (hdh_p->sec->output_section))
2871                 {
2872                   /* Input section has been discarded, either because
2873                      it is a copy of a linkonce section or due to
2874                      linker script /DISCARD/, so we'll be discarding
2875                      the relocs too.  */
2876                 }
2877               else if (hdh_p->count != 0)
2878                 {
2879                   srel = elf_section_data (hdh_p->sec)->sreloc;
2880                   srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
2881                   if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
2882                     info->flags |= DF_TEXTREL;
2883                 }
2884             }
2885         }
2886
2887       local_got = elf_local_got_refcounts (ibfd);
2888       if (!local_got)
2889         continue;
2890
2891       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2892       locsymcount = symtab_hdr->sh_info;
2893       end_local_got = local_got + locsymcount;
2894       local_tls_type = metag_elf_local_got_tls_type (ibfd);
2895       s = htab->etab.sgot;
2896       srel = htab->etab.srelgot;
2897       for (; local_got < end_local_got; ++local_got)
2898         {
2899           if (*local_got > 0)
2900             {
2901               *local_got = s->size;
2902               s->size += GOT_ENTRY_SIZE;
2903               /* R_METAG_TLS_GD relocs need 2 consecutive GOT entries.  */
2904               if (*local_tls_type == GOT_TLS_GD)
2905                 s->size += 4;
2906               if (bfd_link_pic (info))
2907                 srel->size += sizeof (Elf32_External_Rela);
2908             }
2909           else
2910             *local_got = (bfd_vma) -1;
2911           ++local_tls_type;
2912         }
2913     }
2914
2915   if (htab->tls_ldm_got.refcount > 0)
2916     {
2917       /* Allocate 2 got entries and 1 dynamic reloc for R_METAG_TLS_LDM
2918          reloc.  */
2919       htab->tls_ldm_got.offset = htab->etab.sgot->size;
2920       htab->etab.sgot->size += 8;
2921       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2922     }
2923   else
2924     htab->tls_ldm_got.offset = -1;
2925
2926   /* Allocate global sym .plt and .got entries, and space for global
2927      sym dynamic relocs.  */
2928   elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
2929
2930   /* We now have determined the sizes of the various dynamic sections.
2931      Allocate memory for them.  */
2932   relocs = FALSE;
2933   for (s = dynobj->sections; s != NULL; s = s->next)
2934     {
2935       bfd_boolean reloc_section = FALSE;
2936
2937       if ((s->flags & SEC_LINKER_CREATED) == 0)
2938         continue;
2939
2940       if (s == htab->etab.splt
2941           || s == htab->etab.sgot
2942           || s == htab->etab.sgotplt
2943           || s == htab->sdynbss)
2944         {
2945           /* Strip this section if we don't need it; see the
2946              comment below.  */
2947         }
2948       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2949         {
2950           if (s->size != 0 && s != htab->etab.srelplt)
2951             relocs = TRUE;
2952
2953           /* We use the reloc_count field as a counter if we need
2954              to copy relocs into the output file.  */
2955           s->reloc_count = 0;
2956           reloc_section = TRUE;
2957         }
2958       else
2959         {
2960           /* It's not one of our sections, so don't allocate space.  */
2961           continue;
2962         }
2963
2964       if (s->size == 0)
2965         {
2966           /* If we don't need this section, strip it from the
2967              output file.  This is mostly to handle .rela.bss and
2968              .rela.plt.  We must create both sections in
2969              create_dynamic_sections, because they must be created
2970              before the linker maps input sections to output
2971              sections.  The linker does that before
2972              adjust_dynamic_symbol is called, and it is that
2973              function which decides whether anything needs to go
2974              into these sections.  */
2975           s->flags |= SEC_EXCLUDE;
2976           continue;
2977         }
2978
2979       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2980         continue;
2981
2982       /* Allocate memory for the section contents.  */
2983       s->contents = bfd_zalloc (dynobj, s->size);
2984       if (s->contents == NULL)
2985         return FALSE;
2986       else if (reloc_section)
2987         {
2988           unsigned char *contents = s->contents;
2989           Elf32_External_Rela reloc;
2990
2991           /* Fill the reloc section with a R_METAG_NONE type reloc.  */
2992           memset(&reloc, 0, sizeof(Elf32_External_Rela));
2993           reloc.r_info[0] = R_METAG_NONE;
2994           for (; contents < (s->contents + s->size);
2995                contents += sizeof(Elf32_External_Rela))
2996             {
2997               memcpy(contents, &reloc, sizeof(Elf32_External_Rela));
2998             }
2999         }
3000     }
3001
3002   if (htab->etab.dynamic_sections_created)
3003     {
3004       /* Add some entries to the .dynamic section.  We fill in the
3005          values later, in elf_metag_finish_dynamic_sections, but we
3006          must add the entries now so that we get the correct size for
3007          the .dynamic section.  The DT_DEBUG entry is filled in by the
3008          dynamic linker and used by the debugger.  */
3009 #define add_dynamic_entry(TAG, VAL) \
3010   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3011
3012       if (!add_dynamic_entry (DT_PLTGOT, 0))
3013         return FALSE;
3014
3015       if (bfd_link_executable (info))
3016         {
3017           if (!add_dynamic_entry (DT_DEBUG, 0))
3018             return FALSE;
3019         }
3020
3021       if (htab->etab.srelplt->size != 0)
3022         {
3023           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3024               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3025               || !add_dynamic_entry (DT_JMPREL, 0))
3026             return FALSE;
3027         }
3028
3029       if (relocs)
3030         {
3031           if (!add_dynamic_entry (DT_RELA, 0)
3032               || !add_dynamic_entry (DT_RELASZ, 0)
3033               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3034             return FALSE;
3035
3036           /* If any dynamic relocs apply to a read-only section,
3037              then we need a DT_TEXTREL entry.  */
3038           if ((info->flags & DF_TEXTREL) == 0)
3039             elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info);
3040
3041           if ((info->flags & DF_TEXTREL) != 0)
3042             {
3043               if (!add_dynamic_entry (DT_TEXTREL, 0))
3044                 return FALSE;
3045             }
3046         }
3047     }
3048 #undef add_dynamic_entry
3049
3050   return TRUE;
3051 }
3052
3053 /* Finish up dynamic symbol handling.  We set the contents of various
3054    dynamic sections here.  */
3055
3056 static bfd_boolean
3057 elf_metag_finish_dynamic_symbol (bfd *output_bfd,
3058                                  struct bfd_link_info *info,
3059                                  struct elf_link_hash_entry *eh,
3060                                  Elf_Internal_Sym *sym)
3061 {
3062   struct elf_metag_link_hash_table *htab;
3063   Elf_Internal_Rela rel;
3064   bfd_byte *loc;
3065
3066   htab = metag_link_hash_table (info);
3067
3068   if (eh->plt.offset != (bfd_vma) -1)
3069     {
3070       asection *splt;
3071       asection *sgot;
3072       asection *srela;
3073
3074       bfd_vma plt_index;
3075       bfd_vma got_offset;
3076       bfd_vma got_entry;
3077
3078       if (eh->plt.offset & 1)
3079         abort ();
3080
3081       BFD_ASSERT (eh->dynindx != -1);
3082
3083       splt = htab->etab.splt;
3084       sgot = htab->etab.sgotplt;
3085       srela = htab->etab.srelplt;
3086       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3087
3088       /* Get the index in the procedure linkage table which
3089          corresponds to this symbol.  This is the index of this symbol
3090          in all the symbols for which we are making plt entries.  The
3091          first entry in the procedure linkage table is reserved.  */
3092       plt_index = eh->plt.offset / PLT_ENTRY_SIZE - 1;
3093
3094       /* Get the offset into the .got.plt table of the entry that
3095          corresponds to this function.  */
3096       got_offset = plt_index * GOT_ENTRY_SIZE;
3097
3098       BFD_ASSERT (got_offset < (1 << 16));
3099
3100       got_entry = sgot->output_section->vma
3101         + sgot->output_offset
3102         + got_offset;
3103
3104       BFD_ASSERT (plt_index < (1 << 16));
3105
3106       /* Fill in the entry in the procedure linkage table.  */
3107       if (! bfd_link_pic (info))
3108         {
3109           bfd_put_32 (output_bfd,
3110                       (plt_entry[0]
3111                        | (((got_entry >> 16) & 0xffff) << 3)),
3112                       splt->contents + eh->plt.offset);
3113           bfd_put_32 (output_bfd,
3114                       (plt_entry[1]
3115                        | ((got_entry & 0xffff) << 3)),
3116                       splt->contents + eh->plt.offset + 4);
3117           bfd_put_32 (output_bfd, plt_entry[2],
3118                       splt->contents + eh->plt.offset + 8);
3119           bfd_put_32 (output_bfd,
3120                       (plt_entry[3] | (plt_index << 3)),
3121                       splt->contents + eh->plt.offset + 12);
3122           bfd_put_32 (output_bfd,
3123                       (plt_entry[4]
3124                        | ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3125                       splt->contents + eh->plt.offset + 16);
3126         }
3127       else
3128         {
3129           bfd_vma addr = got_entry - (splt->output_section->vma +
3130                                       splt->output_offset + eh->plt.offset);
3131
3132           bfd_put_32 (output_bfd,
3133                       plt_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3134                       splt->contents + eh->plt.offset);
3135           bfd_put_32 (output_bfd,
3136                       plt_pic_entry[1] | ((addr & 0xffff) << 3),
3137                       splt->contents + eh->plt.offset + 4);
3138           bfd_put_32 (output_bfd, plt_pic_entry[2],
3139                       splt->contents + eh->plt.offset + 8);
3140           bfd_put_32 (output_bfd,
3141                       (plt_pic_entry[3] | (plt_index << 3)),
3142                       splt->contents + eh->plt.offset + 12);
3143           bfd_put_32 (output_bfd,
3144                       (plt_pic_entry[4]
3145                        + ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3146                       splt->contents + eh->plt.offset + 16);
3147         }
3148
3149       /* Fill in the entry in the global offset table.  */
3150       bfd_put_32 (output_bfd,
3151                   (splt->output_section->vma
3152                    + splt->output_offset
3153                    + eh->plt.offset
3154                    + 12), /* offset within PLT entry */
3155                   sgot->contents + got_offset);
3156
3157       /* Fill in the entry in the .rela.plt section.  */
3158       rel.r_offset = (sgot->output_section->vma
3159                       + sgot->output_offset
3160                       + got_offset);
3161       rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_JMP_SLOT);
3162       rel.r_addend = 0;
3163       loc = htab->etab.srelplt->contents;
3164       loc += plt_index * sizeof(Elf32_External_Rela);
3165       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3166
3167       if (!eh->def_regular)
3168         {
3169           /* Mark the symbol as undefined, rather than as defined in
3170              the .plt section.  Leave the value alone.  */
3171           sym->st_shndx = SHN_UNDEF;
3172         }
3173     }
3174
3175   if (eh->got.offset != (bfd_vma) -1
3176       && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
3177       && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
3178     {
3179       /* This symbol has an entry in the global offset table.  Set it
3180          up.  */
3181
3182       rel.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
3183                       + htab->etab.sgot->output_offset
3184                       + htab->etab.sgot->output_section->vma);
3185
3186       /* If this is a -Bsymbolic link and the symbol is defined
3187          locally or was forced to be local because of a version file,
3188          we just want to emit a RELATIVE reloc.  The entry in the
3189          global offset table will already have been initialized in the
3190          relocate_section function.  */
3191       if (bfd_link_pic (info)
3192           && (info->symbolic || eh->dynindx == -1)
3193           && eh->def_regular)
3194         {
3195           rel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
3196           rel.r_addend = (eh->root.u.def.value
3197                           + eh->root.u.def.section->output_offset
3198                           + eh->root.u.def.section->output_section->vma);
3199         }
3200       else
3201         {
3202           if ((eh->got.offset & 1) != 0)
3203             abort ();
3204           bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + eh->got.offset);
3205           rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_GLOB_DAT);
3206           rel.r_addend = 0;
3207         }
3208
3209       loc = htab->etab.srelgot->contents;
3210       loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3211       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3212     }
3213
3214   if (eh->needs_copy)
3215     {
3216       asection *s;
3217
3218       /* This symbol needs a copy reloc.  Set it up.  */
3219
3220       if (! (eh->dynindx != -1
3221              && (eh->root.type == bfd_link_hash_defined
3222                  || eh->root.type == bfd_link_hash_defweak)))
3223         abort ();
3224
3225       s = htab->srelbss;
3226
3227       rel.r_offset = (eh->root.u.def.value
3228                       + eh->root.u.def.section->output_offset
3229                       + eh->root.u.def.section->output_section->vma);
3230       rel.r_addend = 0;
3231       rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_COPY);
3232       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3233       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3234     }
3235
3236   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3237   if (eh->root.root.string[0] == '_'
3238       && (strcmp (eh->root.root.string, "_DYNAMIC") == 0
3239           || eh == htab->etab.hgot))
3240     {
3241       sym->st_shndx = SHN_ABS;
3242     }
3243
3244   return TRUE;
3245 }
3246
3247 /* Set the Meta ELF ABI version.  */
3248
3249 static void
3250 elf_metag_post_process_headers (bfd * abfd, struct bfd_link_info * link_info)
3251 {
3252   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
3253
3254   _bfd_elf_post_process_headers (abfd, link_info);
3255   i_ehdrp = elf_elfheader (abfd);
3256   i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
3257 }
3258
3259 /* Used to decide how to sort relocs in an optimal manner for the
3260    dynamic linker, before writing them out.  */
3261
3262 static enum elf_reloc_type_class
3263 elf_metag_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3264                             const asection *rel_sec ATTRIBUTE_UNUSED,
3265                             const Elf_Internal_Rela *rela)
3266 {
3267   switch ((int) ELF32_R_TYPE (rela->r_info))
3268     {
3269     case R_METAG_RELATIVE:
3270       return reloc_class_relative;
3271     case R_METAG_JMP_SLOT:
3272       return reloc_class_plt;
3273     case R_METAG_COPY:
3274       return reloc_class_copy;
3275     default:
3276       return reloc_class_normal;
3277     }
3278 }
3279
3280 /* Finish up the dynamic sections.  */
3281
3282 static bfd_boolean
3283 elf_metag_finish_dynamic_sections (bfd *output_bfd,
3284                                    struct bfd_link_info *info)
3285 {
3286   bfd *dynobj;
3287   struct elf_metag_link_hash_table *htab;
3288   asection *sdyn;
3289
3290   htab = metag_link_hash_table (info);
3291   dynobj = htab->etab.dynobj;
3292
3293   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3294
3295   if (htab->etab.dynamic_sections_created)
3296     {
3297       asection *splt;
3298       Elf32_External_Dyn *dyncon, *dynconend;
3299
3300       if (sdyn == NULL)
3301         abort ();
3302
3303       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3304       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3305       for (; dyncon < dynconend; dyncon++)
3306         {
3307           Elf_Internal_Dyn dyn;
3308           asection *s;
3309
3310           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3311
3312           switch (dyn.d_tag)
3313             {
3314             default:
3315               continue;
3316
3317             case DT_PLTGOT:
3318               s = htab->etab.sgot;
3319               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3320               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3321               break;
3322
3323             case DT_JMPREL:
3324               s = htab->etab.srelplt;
3325               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3326               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3327               break;
3328
3329             case DT_PLTRELSZ:
3330               s = htab->etab.srelplt;
3331               dyn.d_un.d_val = s->size;
3332               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3333               break;
3334
3335             case DT_RELASZ:
3336               /* Don't count procedure linkage table relocs in the
3337                  overall reloc count.  */
3338               if (htab->etab.srelplt) {
3339                 s = htab->etab.srelplt;
3340                 dyn.d_un.d_val -= s->size;
3341               }
3342               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3343               break;
3344
3345             case DT_RELA:
3346               /* We may not be using the standard ELF linker script.
3347                  If .rela.plt is the first .rela section, we adjust
3348                  DT_RELA to not include it.  */
3349               if (htab->etab.srelplt) {
3350                 s = htab->etab.srelplt;
3351                 if (dyn.d_un.d_ptr == s->output_section->vma + s->output_offset)
3352                   dyn.d_un.d_ptr += s->size;
3353               }
3354               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3355               break;
3356             }
3357
3358         }
3359
3360       /* Fill in the first entry in the procedure linkage table.  */
3361       splt = htab->etab.splt;
3362       if (splt && splt->size > 0)
3363         {
3364           unsigned long addr;
3365           /* addr = .got + 4 */
3366           addr = (htab->etab.sgot->output_section->vma
3367                   + htab->etab.sgot->output_offset + 4);
3368           if (bfd_link_pic (info))
3369             {
3370               addr -= splt->output_section->vma + splt->output_offset;
3371               bfd_put_32 (output_bfd,
3372                           plt0_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3373                           splt->contents);
3374               bfd_put_32 (output_bfd,
3375                           plt0_pic_entry[1] | ((addr & 0xffff) << 3),
3376                           splt->contents + 4);
3377               bfd_put_32 (output_bfd, plt0_pic_entry[2], splt->contents + 8);
3378               bfd_put_32 (output_bfd, plt0_pic_entry[3], splt->contents + 12);
3379               bfd_put_32 (output_bfd, plt0_pic_entry[4], splt->contents + 16);
3380             }
3381           else
3382             {
3383               bfd_put_32 (output_bfd,
3384                           plt0_entry[0] | (((addr >> 16) & 0xffff) << 3),
3385                           splt->contents);
3386               bfd_put_32 (output_bfd,
3387                           plt0_entry[1] | ((addr & 0xffff) << 3),
3388                           splt->contents + 4);
3389               bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
3390               bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
3391               bfd_put_32 (output_bfd, plt0_entry[4], splt->contents + 16);
3392             }
3393
3394           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3395             PLT_ENTRY_SIZE;
3396         }
3397     }
3398
3399   if (htab->etab.sgot != NULL && htab->etab.sgot->size != 0)
3400     {
3401       /* Fill in the first entry in the global offset table.
3402          We use it to point to our dynamic section, if we have one.  */
3403       bfd_put_32 (output_bfd,
3404                   sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
3405                   htab->etab.sgot->contents);
3406
3407       /* The second entry is reserved for use by the dynamic linker.  */
3408       memset (htab->etab.sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
3409
3410       /* Set .got entry size.  */
3411       elf_section_data (htab->etab.sgot->output_section)
3412         ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
3413     }
3414
3415   return TRUE;
3416 }
3417
3418 /* Return the section that should be marked against GC for a given
3419    relocation.  */
3420
3421 static asection *
3422 elf_metag_gc_mark_hook (asection *sec,
3423                         struct bfd_link_info *info,
3424                         Elf_Internal_Rela *rela,
3425                         struct elf_link_hash_entry *hh,
3426                         Elf_Internal_Sym *sym)
3427 {
3428   if (hh != NULL)
3429     switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
3430       {
3431       case R_METAG_GNU_VTINHERIT:
3432       case R_METAG_GNU_VTENTRY:
3433         return NULL;
3434       }
3435
3436   return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
3437 }
3438
3439 /* Update the got and plt entry reference counts for the section being
3440    removed.  */
3441
3442 static bfd_boolean
3443 elf_metag_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3444                          struct bfd_link_info *info ATTRIBUTE_UNUSED,
3445                          asection *sec ATTRIBUTE_UNUSED,
3446                          const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3447 {
3448   Elf_Internal_Shdr *symtab_hdr;
3449   struct elf_link_hash_entry **eh_syms;
3450   bfd_signed_vma *local_got_refcounts;
3451   bfd_signed_vma *local_plt_refcounts;
3452   const Elf_Internal_Rela *rel, *relend;
3453
3454   if (bfd_link_relocatable (info))
3455     return TRUE;
3456
3457   elf_section_data (sec)->local_dynrel = NULL;
3458
3459   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3460   eh_syms = elf_sym_hashes (abfd);
3461   local_got_refcounts = elf_local_got_refcounts (abfd);
3462   local_plt_refcounts = local_got_refcounts;
3463   if (local_plt_refcounts != NULL)
3464     local_plt_refcounts += symtab_hdr->sh_info;
3465
3466   relend = relocs + sec->reloc_count;
3467   for (rel = relocs; rel < relend; rel++)
3468     {
3469       unsigned long r_symndx;
3470       unsigned int r_type;
3471       struct elf_link_hash_entry *eh = NULL;
3472
3473       r_symndx = ELF32_R_SYM (rel->r_info);
3474       if (r_symndx >= symtab_hdr->sh_info)
3475         {
3476           struct elf_metag_link_hash_entry *hh;
3477           struct elf_metag_dyn_reloc_entry **hdh_pp;
3478           struct elf_metag_dyn_reloc_entry *hdh_p;
3479
3480           eh = eh_syms[r_symndx - symtab_hdr->sh_info];
3481           while (eh->root.type == bfd_link_hash_indirect
3482                  || eh->root.type == bfd_link_hash_warning)
3483             eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
3484           hh = (struct elf_metag_link_hash_entry *) eh;
3485
3486           for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL;
3487                hdh_pp = &hdh_p->hdh_next)
3488             if (hdh_p->sec == sec)
3489               {
3490                 /* Everything must go for SEC.  */
3491                 *hdh_pp = hdh_p->hdh_next;
3492                 break;
3493               }
3494         }
3495
3496       r_type = ELF32_R_TYPE (rel->r_info);
3497       switch (r_type)
3498         {
3499         case R_METAG_TLS_LDM:
3500           if (metag_link_hash_table (info)->tls_ldm_got.refcount > 0)
3501             metag_link_hash_table (info)->tls_ldm_got.refcount -= 1;
3502           break;
3503         case R_METAG_TLS_IE:
3504         case R_METAG_TLS_GD:
3505         case R_METAG_GETSET_GOT:
3506           if (eh != NULL)
3507             {
3508               if (eh->got.refcount > 0)
3509                 eh->got.refcount -= 1;
3510             }
3511           else if (local_got_refcounts != NULL)
3512             {
3513               if (local_got_refcounts[r_symndx] > 0)
3514                 local_got_refcounts[r_symndx] -= 1;
3515             }
3516           break;
3517
3518         case R_METAG_RELBRANCH_PLT:
3519           if (eh != NULL)
3520             {
3521               if (eh->plt.refcount > 0)
3522                 eh->plt.refcount -= 1;
3523             }
3524           break;
3525
3526         case R_METAG_ADDR32:
3527         case R_METAG_HIADDR16:
3528         case R_METAG_LOADDR16:
3529         case R_METAG_GETSETOFF:
3530         case R_METAG_RELBRANCH:
3531           if (eh != NULL)
3532             {
3533               struct elf_metag_link_hash_entry *hh;
3534               struct elf_metag_dyn_reloc_entry **hdh_pp;
3535               struct elf_metag_dyn_reloc_entry *hdh_p;
3536
3537               if (!bfd_link_pic (info) && eh->plt.refcount > 0)
3538                 eh->plt.refcount -= 1;
3539
3540               hh = (struct elf_metag_link_hash_entry *) eh;
3541
3542               for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL;
3543                    hdh_pp = &hdh_p->hdh_next)
3544                 if (hdh_p->sec == sec)
3545                   {
3546                     if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
3547                       hdh_p->relative_count -= 1;
3548                     hdh_p->count -= 1;
3549                     if (hdh_p->count == 0)
3550                       *hdh_pp = hdh_p->hdh_next;
3551                     break;
3552                   }
3553             }
3554           break;
3555
3556         default:
3557           break;
3558         }
3559     }
3560
3561   return TRUE;
3562 }
3563
3564 /* Determine the type of stub needed, if any, for a call.  */
3565
3566 static enum elf_metag_stub_type
3567 metag_type_of_stub (asection *input_sec,
3568                     const Elf_Internal_Rela *rel,
3569                     struct elf_metag_link_hash_entry *hh,
3570                     bfd_vma destination,
3571                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
3572 {
3573   bfd_vma location;
3574   bfd_vma branch_offset;
3575   bfd_vma max_branch_offset;
3576
3577   if (hh != NULL &&
3578       !(hh->eh.root.type == bfd_link_hash_defined
3579         || hh->eh.root.type == bfd_link_hash_defweak))
3580     return metag_stub_none;
3581
3582   /* Determine where the call point is.  */
3583   location = (input_sec->output_offset
3584               + input_sec->output_section->vma
3585               + rel->r_offset);
3586
3587   branch_offset = destination - location;
3588
3589   /* Determine if a long branch stub is needed.  Meta branch offsets
3590      are signed 19 bits 4 byte aligned.  */
3591   max_branch_offset = (1 << (BRANCH_BITS-1)) << 2;
3592
3593   if (branch_offset + max_branch_offset >= 2*max_branch_offset)
3594     {
3595       if (bfd_link_pic (info))
3596         return metag_stub_long_branch_shared;
3597       else
3598         return metag_stub_long_branch;
3599     }
3600
3601   return metag_stub_none;
3602 }
3603
3604 #define MOVT_A0_3       0x82180005
3605 #define JUMP_A0_3       0xac180003
3606
3607 #define MOVT_A1LBP      0x83080005
3608 #define ADD_A1LBP       0x83080000
3609
3610 #define ADDT_A0_3_CPC   0x82980001
3611 #define ADD_A0_3_A0_3   0x82180000
3612 #define MOV_PC_A0_3     0xa3180ca0
3613
3614 static bfd_boolean
3615 metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3616 {
3617   struct elf_metag_stub_hash_entry *hsh;
3618   asection *stub_sec;
3619   bfd *stub_bfd;
3620   bfd_byte *loc;
3621   bfd_vma sym_value;
3622   int size;
3623
3624   /* Massage our args to the form they really have.  */
3625   hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3626
3627   stub_sec = hsh->stub_sec;
3628
3629   /* Make a note of the offset within the stubs for this entry.  */
3630   hsh->stub_offset = stub_sec->size;
3631   loc = stub_sec->contents + hsh->stub_offset;
3632
3633   stub_bfd = stub_sec->owner;
3634
3635   switch (hsh->stub_type)
3636     {
3637     case metag_stub_long_branch_shared:
3638       /* A PIC long branch stub is an ADDT and an ADD instruction used to
3639          calculate the jump target using A0.3 as a temporary. Then a MOV
3640          to PC carries out the jump.  */
3641       sym_value = (hsh->target_value
3642                    + hsh->target_section->output_offset
3643                    + hsh->target_section->output_section->vma
3644                    + hsh->addend);
3645
3646       sym_value -= (hsh->stub_offset
3647                     + stub_sec->output_offset
3648                     + stub_sec->output_section->vma);
3649
3650       bfd_put_32 (stub_bfd, ADDT_A0_3_CPC | (((sym_value >> 16) & 0xffff) << 3),
3651                   loc);
3652
3653       bfd_put_32 (stub_bfd, ADD_A0_3_A0_3 | ((sym_value & 0xffff) << 3),
3654                   loc + 4);
3655
3656       bfd_put_32 (stub_bfd, MOV_PC_A0_3, loc + 8);
3657
3658       size = 12;
3659       break;
3660     case metag_stub_long_branch:
3661       /* A standard long branch stub is a MOVT instruction followed by a
3662          JUMP instruction using the A0.3 register as a temporary. This is
3663          the same method used by the LDLK linker (patch.c).  */
3664       sym_value = (hsh->target_value
3665                    + hsh->target_section->output_offset
3666                    + hsh->target_section->output_section->vma
3667                    + hsh->addend);
3668
3669       bfd_put_32 (stub_bfd, MOVT_A0_3 | (((sym_value >> 16) & 0xffff) << 3),
3670                   loc);
3671
3672       bfd_put_32 (stub_bfd, JUMP_A0_3 | ((sym_value & 0xffff) << 3), loc + 4);
3673
3674       size = 8;
3675       break;
3676     default:
3677       BFD_FAIL ();
3678       return FALSE;
3679     }
3680
3681   stub_sec->size += size;
3682   return TRUE;
3683 }
3684
3685 /* As above, but don't actually build the stub.  Just bump offset so
3686    we know stub section sizes.  */
3687
3688 static bfd_boolean
3689 metag_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3690 {
3691   struct elf_metag_stub_hash_entry *hsh;
3692   int size = 0;
3693
3694   /* Massage our args to the form they really have.  */
3695   hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3696
3697   if (hsh->stub_type == metag_stub_long_branch)
3698     size = 8;
3699   else if (hsh->stub_type == metag_stub_long_branch_shared)
3700     size = 12;
3701
3702   hsh->stub_sec->size += size;
3703   return TRUE;
3704 }
3705
3706 /* Set up various things so that we can make a list of input sections
3707    for each output section included in the link.  Returns -1 on error,
3708    0 when no stubs will be needed, and 1 on success.  */
3709
3710 int
3711 elf_metag_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3712 {
3713   bfd *input_bfd;
3714   unsigned int bfd_count;
3715   unsigned int top_id, top_index;
3716   asection *section;
3717   asection **input_list, **list;
3718   bfd_size_type amt;
3719   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3720
3721   /* Count the number of input BFDs and find the top input section id.  */
3722   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3723        input_bfd != NULL;
3724        input_bfd = input_bfd->link.next)
3725     {
3726       bfd_count += 1;
3727       for (section = input_bfd->sections;
3728            section != NULL;
3729            section = section->next)
3730         {
3731           if (top_id < section->id)
3732             top_id = section->id;
3733         }
3734     }
3735
3736   htab->bfd_count = bfd_count;
3737
3738   amt = sizeof (struct map_stub) * (top_id + 1);
3739   htab->stub_group = bfd_zmalloc (amt);
3740   if (htab->stub_group == NULL)
3741     return -1;
3742
3743   /* We can't use output_bfd->section_count here to find the top output
3744      section index as some sections may have been removed, and
3745      strip_excluded_output_sections doesn't renumber the indices.  */
3746   for (section = output_bfd->sections, top_index = 0;
3747        section != NULL;
3748        section = section->next)
3749     {
3750       if (top_index < section->index)
3751         top_index = section->index;
3752     }
3753
3754   htab->top_index = top_index;
3755   amt = sizeof (asection *) * (top_index + 1);
3756   input_list = bfd_malloc (amt);
3757   htab->input_list = input_list;
3758   if (input_list == NULL)
3759     return -1;
3760
3761   /* For sections we aren't interested in, mark their entries with a
3762      value we can check later.  */
3763   list = input_list + top_index;
3764   do
3765     *list = bfd_abs_section_ptr;
3766   while (list-- != input_list);
3767
3768   for (section = output_bfd->sections;
3769        section != NULL;
3770        section = section->next)
3771     {
3772       /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
3773        * have PC relative relocs in them but no code flag set.  */
3774       if (((section->flags & SEC_CODE) != 0) ||
3775           strcmp(".ctors", section->name) ||
3776           strcmp(".dtors", section->name))
3777         input_list[section->index] = NULL;
3778     }
3779
3780   return 1;
3781 }
3782
3783 /* The linker repeatedly calls this function for each input section,
3784    in the order that input sections are linked into output sections.
3785    Build lists of input sections to determine groupings between which
3786    we may insert linker stubs.  */
3787
3788 void
3789 elf_metag_next_input_section (struct bfd_link_info *info, asection *isec)
3790 {
3791   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3792
3793   if (isec->output_section->index <= htab->top_index)
3794     {
3795       asection **list = htab->input_list + isec->output_section->index;
3796       if (*list != bfd_abs_section_ptr)
3797         {
3798           /* Steal the link_sec pointer for our list.  */
3799 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3800           /* This happens to make the list in reverse order,
3801              which is what we want.  */
3802           PREV_SEC (isec) = *list;
3803           *list = isec;
3804         }
3805     }
3806 }
3807
3808 /* See whether we can group stub sections together.  Grouping stub
3809    sections may result in fewer stubs.  More importantly, we need to
3810    put all .init* and .fini* stubs at the beginning of the .init or
3811    .fini output sections respectively, because glibc splits the
3812    _init and _fini functions into multiple parts.  Putting a stub in
3813    the middle of a function is not a good idea.  */
3814
3815 static void
3816 group_sections (struct elf_metag_link_hash_table *htab,
3817                 bfd_size_type stub_group_size,
3818                 bfd_boolean stubs_always_before_branch)
3819 {
3820   asection **list = htab->input_list + htab->top_index;
3821   do
3822     {
3823       asection *tail = *list;
3824       if (tail == bfd_abs_section_ptr)
3825         continue;
3826       while (tail != NULL)
3827         {
3828           asection *curr;
3829           asection *prev;
3830           bfd_size_type total;
3831           bfd_boolean big_sec;
3832
3833           curr = tail;
3834           total = tail->size;
3835           big_sec = total >= stub_group_size;
3836
3837           while ((prev = PREV_SEC (curr)) != NULL
3838                  && ((total += curr->output_offset - prev->output_offset)
3839                      < stub_group_size))
3840             curr = prev;
3841
3842           /* OK, the size from the start of CURR to the end is less
3843              than stub_group_size bytes and thus can be handled by one stub
3844              section.  (or the tail section is itself larger than
3845              stub_group_size bytes, in which case we may be toast.)
3846              We should really be keeping track of the total size of
3847              stubs added here, as stubs contribute to the final output
3848              section size.  */
3849           do
3850             {
3851               prev = PREV_SEC (tail);
3852               /* Set up this stub group.  */
3853               htab->stub_group[tail->id].link_sec = curr;
3854             }
3855           while (tail != curr && (tail = prev) != NULL);
3856
3857           /* But wait, there's more!  Input sections up to stub_group_size
3858              bytes before the stub section can be handled by it too.
3859              Don't do this if we have a really large section after the
3860              stubs, as adding more stubs increases the chance that
3861              branches may not reach into the stub section.  */
3862           if (!stubs_always_before_branch && !big_sec)
3863             {
3864               total = 0;
3865               while (prev != NULL
3866                      && ((total += tail->output_offset - prev->output_offset)
3867                          < stub_group_size))
3868                 {
3869                   tail = prev;
3870                   prev = PREV_SEC (tail);
3871                   htab->stub_group[tail->id].link_sec = curr;
3872                 }
3873             }
3874           tail = prev;
3875         }
3876     }
3877   while (list-- != htab->input_list);
3878   free (htab->input_list);
3879 #undef PREV_SEC
3880 }
3881
3882 /* Read in all local syms for all input bfds.
3883    Returns -1 on error, 0 otherwise.  */
3884
3885 static int
3886 get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
3887                 struct bfd_link_info *info)
3888 {
3889   unsigned int bfd_indx;
3890   Elf_Internal_Sym *local_syms, **all_local_syms;
3891   int stub_changed = 0;
3892   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3893
3894   /* We want to read in symbol extension records only once.  To do this
3895      we need to read in the local symbols in parallel and save them for
3896      later use; so hold pointers to the local symbols in an array.  */
3897   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3898   all_local_syms = bfd_zmalloc (amt);
3899   htab->all_local_syms = all_local_syms;
3900   if (all_local_syms == NULL)
3901     return -1;
3902
3903   /* Walk over all the input BFDs, swapping in local symbols.  */
3904   for (bfd_indx = 0;
3905        input_bfd != NULL;
3906        input_bfd = input_bfd->link.next, bfd_indx++)
3907     {
3908       Elf_Internal_Shdr *symtab_hdr;
3909
3910       /* We'll need the symbol table in a second.  */
3911       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3912       if (symtab_hdr->sh_info == 0)
3913         continue;
3914
3915       /* We need an array of the local symbols attached to the input bfd.  */
3916       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3917       if (local_syms == NULL)
3918         {
3919           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3920                                              symtab_hdr->sh_info, 0,
3921                                              NULL, NULL, NULL);
3922           /* Cache them for elf_link_input_bfd.  */
3923           symtab_hdr->contents = (unsigned char *) local_syms;
3924         }
3925       if (local_syms == NULL)
3926         return -1;
3927
3928       all_local_syms[bfd_indx] = local_syms;
3929     }
3930
3931   return stub_changed;
3932 }
3933
3934 /* Determine and set the size of the stub section for a final link.
3935
3936 The basic idea here is to examine all the relocations looking for
3937 PC-relative calls to a target that is unreachable with a "CALLR"
3938 instruction.  */
3939
3940 /* See elf32-hppa.c and elf64-ppc.c.  */
3941
3942 bfd_boolean
3943 elf_metag_size_stubs(bfd *output_bfd, bfd *stub_bfd,
3944                      struct bfd_link_info *info,
3945                      bfd_signed_vma group_size,
3946                      asection * (*add_stub_section) (const char *, asection *),
3947                      void (*layout_sections_again) (void))
3948 {
3949   bfd_size_type stub_group_size;
3950   bfd_boolean stubs_always_before_branch;
3951   bfd_boolean stub_changed;
3952   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3953
3954   /* Stash our params away.  */
3955   htab->stub_bfd = stub_bfd;
3956   htab->add_stub_section = add_stub_section;
3957   htab->layout_sections_again = layout_sections_again;
3958   stubs_always_before_branch = group_size < 0;
3959   if (group_size < 0)
3960     stub_group_size = -group_size;
3961   else
3962     stub_group_size = group_size;
3963   if (stub_group_size == 1)
3964     {
3965       /* Default values.  */
3966       /* FIXME: not sure what these values should be */
3967       if (stubs_always_before_branch)
3968         {
3969           stub_group_size = (1 << BRANCH_BITS);
3970         }
3971       else
3972         {
3973           stub_group_size = (1 << BRANCH_BITS);
3974         }
3975     }
3976
3977   group_sections (htab, stub_group_size, stubs_always_before_branch);
3978
3979   switch (get_local_syms (output_bfd, info->input_bfds, info))
3980     {
3981     default:
3982       if (htab->all_local_syms)
3983         goto error_ret_free_local;
3984       return FALSE;
3985
3986     case 0:
3987       stub_changed = FALSE;
3988       break;
3989
3990     case 1:
3991       stub_changed = TRUE;
3992       break;
3993     }
3994
3995   while (1)
3996     {
3997       bfd *input_bfd;
3998       unsigned int bfd_indx;
3999       asection *stub_sec;
4000
4001       for (input_bfd = info->input_bfds, bfd_indx = 0;
4002            input_bfd != NULL;
4003            input_bfd = input_bfd->link.next, bfd_indx++)
4004         {
4005           Elf_Internal_Shdr *symtab_hdr;
4006           asection *section;
4007           Elf_Internal_Sym *local_syms;
4008
4009           /* We'll need the symbol table in a second.  */
4010           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4011           if (symtab_hdr->sh_info == 0)
4012             continue;
4013
4014           local_syms = htab->all_local_syms[bfd_indx];
4015
4016           /* Walk over each section attached to the input bfd.  */
4017           for (section = input_bfd->sections;
4018                section != NULL;
4019                section = section->next)
4020             {
4021               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4022
4023               /* If there aren't any relocs, then there's nothing more
4024                  to do.  */
4025               if ((section->flags & SEC_RELOC) == 0
4026                   || section->reloc_count == 0)
4027                 continue;
4028
4029               /* If this section is a link-once section that will be
4030                  discarded, then don't create any stubs.  */
4031               if (section->output_section == NULL
4032                   || section->output_section->owner != output_bfd)
4033                 continue;
4034
4035               /* Get the relocs.  */
4036               internal_relocs
4037                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
4038                                              info->keep_memory);
4039               if (internal_relocs == NULL)
4040                 goto error_ret_free_local;
4041
4042               /* Now examine each relocation.  */
4043               irela = internal_relocs;
4044               irelaend = irela + section->reloc_count;
4045               for (; irela < irelaend; irela++)
4046                 {
4047                   unsigned int r_type, r_indx;
4048                   enum elf_metag_stub_type stub_type;
4049                   struct elf_metag_stub_hash_entry *hsh;
4050                   asection *sym_sec;
4051                   bfd_vma sym_value;
4052                   bfd_vma destination;
4053                   struct elf_metag_link_hash_entry *hh;
4054                   char *stub_name;
4055                   const asection *id_sec;
4056
4057                   r_type = ELF32_R_TYPE (irela->r_info);
4058                   r_indx = ELF32_R_SYM (irela->r_info);
4059
4060                   if (r_type >= (unsigned int) R_METAG_MAX)
4061                     {
4062                       bfd_set_error (bfd_error_bad_value);
4063                     error_ret_free_internal:
4064                       if (elf_section_data (section)->relocs == NULL)
4065                         free (internal_relocs);
4066                       goto error_ret_free_local;
4067                     }
4068
4069                   /* Only look for stubs on CALLR and B instructions.  */
4070                   if (!(r_type == (unsigned int) R_METAG_RELBRANCH ||
4071                         r_type == (unsigned int) R_METAG_RELBRANCH_PLT))
4072                     continue;
4073
4074                   /* Now determine the call target, its name, value,
4075                      section.  */
4076                   sym_sec = NULL;
4077                   sym_value = 0;
4078                   destination = 0;
4079                   hh = NULL;
4080                   if (r_indx < symtab_hdr->sh_info)
4081                     {
4082                       /* It's a local symbol.  */
4083                       Elf_Internal_Sym *sym;
4084                       Elf_Internal_Shdr *hdr;
4085                       unsigned int shndx;
4086
4087                       sym = local_syms + r_indx;
4088                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4089                         sym_value = sym->st_value;
4090                       shndx = sym->st_shndx;
4091                       if (shndx < elf_numsections (input_bfd))
4092                         {
4093                           hdr = elf_elfsections (input_bfd)[shndx];
4094                           sym_sec = hdr->bfd_section;
4095                           destination = (sym_value + irela->r_addend
4096                                          + sym_sec->output_offset
4097                                          + sym_sec->output_section->vma);
4098                         }
4099                     }
4100                   else
4101                     {
4102                       /* It's an external symbol.  */
4103                       int e_indx;
4104
4105                       e_indx = r_indx - symtab_hdr->sh_info;
4106                       hh = ((struct elf_metag_link_hash_entry *)
4107                             elf_sym_hashes (input_bfd)[e_indx]);
4108
4109                       while (hh->eh.root.type == bfd_link_hash_indirect
4110                              || hh->eh.root.type == bfd_link_hash_warning)
4111                         hh = ((struct elf_metag_link_hash_entry *)
4112                               hh->eh.root.u.i.link);
4113
4114                       if (hh->eh.root.type == bfd_link_hash_defined
4115                           || hh->eh.root.type == bfd_link_hash_defweak)
4116                         {
4117                           sym_sec = hh->eh.root.u.def.section;
4118                           sym_value = hh->eh.root.u.def.value;
4119                           if (hh->eh.plt.offset != (bfd_vma) -1
4120                               && hh->eh.dynindx != -1
4121                               && r_type == (unsigned int) R_METAG_RELBRANCH_PLT)
4122                             {
4123                               sym_sec = htab->etab.splt;
4124                               sym_value = hh->eh.plt.offset;
4125                             }
4126
4127                           if (sym_sec->output_section != NULL)
4128                             destination = (sym_value + irela->r_addend
4129                                            + sym_sec->output_offset
4130                                            + sym_sec->output_section->vma);
4131                           else
4132                             continue;
4133                         }
4134                       else if (hh->eh.root.type == bfd_link_hash_undefweak)
4135                         {
4136                           if (! bfd_link_pic (info))
4137                             continue;
4138                         }
4139                       else if (hh->eh.root.type == bfd_link_hash_undefined)
4140                         {
4141                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
4142                                  && (ELF_ST_VISIBILITY (hh->eh.other)
4143                                      == STV_DEFAULT)))
4144                             continue;
4145                         }
4146                       else
4147                         {
4148                           bfd_set_error (bfd_error_bad_value);
4149                           goto error_ret_free_internal;
4150                         }
4151                     }
4152
4153                   /* Determine what (if any) linker stub is needed.  */
4154                   stub_type = metag_type_of_stub (section, irela, hh,
4155                                                   destination, info);
4156                   if (stub_type == metag_stub_none)
4157                     continue;
4158
4159                   /* Support for grouping stub sections.  */
4160                   id_sec = htab->stub_group[section->id].link_sec;
4161
4162                   /* Get the name of this stub.  */
4163                   stub_name = metag_stub_name (id_sec, sym_sec, hh, irela);
4164                   if (!stub_name)
4165                     goto error_ret_free_internal;
4166
4167                   hsh = metag_stub_hash_lookup (&htab->bstab,
4168                                                 stub_name,
4169                                                 FALSE, FALSE);
4170                   if (hsh != NULL)
4171                     {
4172                       /* The proper stub has already been created.  */
4173                       free (stub_name);
4174                       continue;
4175                     }
4176
4177                   hsh = metag_add_stub (stub_name, section, htab);
4178                   if (hsh == NULL)
4179                     {
4180                       free (stub_name);
4181                       goto error_ret_free_internal;
4182                     }
4183                   hsh->target_value = sym_value;
4184                   hsh->target_section = sym_sec;
4185                   hsh->stub_type = stub_type;
4186                   hsh->hh = hh;
4187                   hsh->addend = irela->r_addend;
4188                   stub_changed = TRUE;
4189                 }
4190
4191               /* We're done with the internal relocs, free them.  */
4192               if (elf_section_data (section)->relocs == NULL)
4193                 free (internal_relocs);
4194             }
4195         }
4196
4197       if (!stub_changed)
4198         break;
4199
4200       /* OK, we've added some stubs.  Find out the new size of the
4201          stub sections.  */
4202       for (stub_sec = htab->stub_bfd->sections;
4203            stub_sec != NULL;
4204            stub_sec = stub_sec->next)
4205         stub_sec->size = 0;
4206
4207       bfd_hash_traverse (&htab->bstab, metag_size_one_stub, htab);
4208
4209       /* Ask the linker to do its stuff.  */
4210       (*htab->layout_sections_again) ();
4211       stub_changed = FALSE;
4212     }
4213
4214   free (htab->all_local_syms);
4215   return TRUE;
4216
4217  error_ret_free_local:
4218   free (htab->all_local_syms);
4219   return FALSE;
4220 }
4221
4222 /* Build all the stubs associated with the current output file.  The
4223    stubs are kept in a hash table attached to the main linker hash
4224    table.  This function is called via metagelf_finish in the linker.  */
4225
4226 bfd_boolean
4227 elf_metag_build_stubs (struct bfd_link_info *info)
4228 {
4229   asection *stub_sec;
4230   struct bfd_hash_table *table;
4231   struct elf_metag_link_hash_table *htab;
4232
4233   htab = metag_link_hash_table (info);
4234
4235   for (stub_sec = htab->stub_bfd->sections;
4236        stub_sec != NULL;
4237        stub_sec = stub_sec->next)
4238     {
4239       bfd_size_type size;
4240
4241       /* Allocate memory to hold the linker stubs.  */
4242       size = stub_sec->size;
4243       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4244       if (stub_sec->contents == NULL && size != 0)
4245         return FALSE;
4246       stub_sec->size = 0;
4247     }
4248
4249   /* Build the stubs as directed by the stub hash table.  */
4250   table = &htab->bstab;
4251   bfd_hash_traverse (table, metag_build_one_stub, info);
4252
4253   return TRUE;
4254 }
4255
4256 /* Return TRUE if SYM represents a local label symbol.  */
4257
4258 static bfd_boolean
4259 elf_metag_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
4260 {
4261   if (name[0] == '$' && name[1] == 'L')
4262     return 1;
4263   return _bfd_elf_is_local_label_name (abfd, name);
4264 }
4265
4266 /* Return address for Ith PLT stub in section PLT, for relocation REL
4267    or (bfd_vma) -1 if it should not be included.  */
4268
4269 static bfd_vma
4270 elf_metag_plt_sym_val (bfd_vma i, const asection *plt,
4271                        const arelent *rel ATTRIBUTE_UNUSED)
4272 {
4273   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4274 }
4275
4276 #define ELF_ARCH                bfd_arch_metag
4277 #define ELF_TARGET_ID           METAG_ELF_DATA
4278 #define ELF_MACHINE_CODE        EM_METAG
4279 #define ELF_MINPAGESIZE 0x1000
4280 #define ELF_MAXPAGESIZE 0x4000
4281 #define ELF_COMMONPAGESIZE      0x1000
4282
4283 #define TARGET_LITTLE_SYM       metag_elf32_vec
4284 #define TARGET_LITTLE_NAME      "elf32-metag"
4285
4286 #define elf_symbol_leading_char '_'
4287
4288 #define elf_info_to_howto_rel                   NULL
4289 #define elf_info_to_howto                       metag_info_to_howto_rela
4290
4291 #define bfd_elf32_bfd_is_local_label_name       elf_metag_is_local_label_name
4292 #define bfd_elf32_bfd_link_hash_table_create \
4293         elf_metag_link_hash_table_create
4294 #define elf_backend_relocate_section            elf_metag_relocate_section
4295 #define elf_backend_gc_mark_hook                elf_metag_gc_mark_hook
4296 #define elf_backend_gc_sweep_hook               elf_metag_gc_sweep_hook
4297 #define elf_backend_check_relocs                elf_metag_check_relocs
4298 #define elf_backend_create_dynamic_sections     elf_metag_create_dynamic_sections
4299 #define elf_backend_adjust_dynamic_symbol       elf_metag_adjust_dynamic_symbol
4300 #define elf_backend_finish_dynamic_symbol       elf_metag_finish_dynamic_symbol
4301 #define elf_backend_finish_dynamic_sections     elf_metag_finish_dynamic_sections
4302 #define elf_backend_size_dynamic_sections       elf_metag_size_dynamic_sections
4303 #define elf_backend_omit_section_dynsym \
4304   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4305 #define elf_backend_post_process_headers        elf_metag_post_process_headers
4306 #define elf_backend_reloc_type_class            elf_metag_reloc_type_class
4307 #define elf_backend_copy_indirect_symbol        elf_metag_copy_indirect_symbol
4308 #define elf_backend_plt_sym_val         elf_metag_plt_sym_val
4309
4310 #define elf_backend_can_gc_sections             1
4311 #define elf_backend_can_refcount                1
4312 #define elf_backend_rela_normal                 1
4313 #define elf_backend_want_got_plt                1
4314 #define elf_backend_want_got_sym                0
4315 #define elf_backend_want_plt_sym                0
4316 #define elf_backend_plt_readonly                1
4317
4318 #define bfd_elf32_bfd_reloc_type_lookup metag_reloc_type_lookup
4319 #define bfd_elf32_bfd_reloc_name_lookup metag_reloc_name_lookup
4320
4321 #include "elf32-target.h"