bfd/elf32-microblaze.c

   1 /* Xilinx MicroBlaze-specific support for 32-bit ELF
   2
   3    Copyright (C) 2009-2017 Free Software Foundation, Inc.
   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
  19    Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22
  23 int dbg = 0;
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "bfdlink.h"
  28 #include "libbfd.h"
  29 #include "elf-bfd.h"
  30 #include "elf/microblaze.h"
  31 #include <assert.h>
  32
  33 #define USE_RELA        /* Only USE_REL is actually significant, but this is
  34                            here are a reminder...  */
  35 #define INST_WORD_SIZE 4
  36
  37 static int ro_small_data_pointer = 0;
  38 static int rw_small_data_pointer = 0;
  39
  40 static reloc_howto_type * microblaze_elf_howto_table [(int) R_MICROBLAZE_max];
  41
  42 static reloc_howto_type microblaze_elf_howto_raw[] =
  43 {
  44    /* This reloc does nothing.  */
  45    HOWTO (R_MICROBLAZE_NONE,    /* Type.  */
  46           0,                    /* Rightshift.  */
  47           3,                    /* Size (0 = byte, 1 = short, 2 = long).  */
  48           0,                    /* Bitsize.  */
  49           FALSE,                /* PC_relative.  */
  50           0,                    /* Bitpos.  */
  51           complain_overflow_dont,  /* Complain on overflow.  */
  52           NULL,                  /* Special Function.  */
  53           "R_MICROBLAZE_NONE",  /* Name.  */
  54           FALSE,                /* Partial Inplace.  */
  55           0,                    /* Source Mask.  */
  56           0,                    /* Dest Mask.  */
  57           FALSE),               /* PC relative offset?  */
  58
  59    /* A standard 32 bit relocation.  */
  60    HOWTO (R_MICROBLAZE_32,      /* Type.  */
  61           0,                    /* Rightshift.  */
  62           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
  63           32,                   /* Bitsize.  */
  64           FALSE,                /* PC_relative.  */
  65           0,                    /* Bitpos.  */
  66           complain_overflow_bitfield, /* Complain on overflow.  */
  67           bfd_elf_generic_reloc,/* Special Function.  */
  68           "R_MICROBLAZE_32",    /* Name.  */
  69           FALSE,                /* Partial Inplace.  */
  70           0,                    /* Source Mask.  */
  71           0xffffffff,           /* Dest Mask.  */
  72           FALSE),               /* PC relative offset?  */
  73
  74    /* A standard PCREL 32 bit relocation.  */
  75    HOWTO (R_MICROBLAZE_32_PCREL,/* Type.  */
  76           0,                    /* Rightshift.  */
  77           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
  78           32,                   /* Bitsize.  */
  79           TRUE,                 /* PC_relative.  */
  80           0,                    /* Bitpos.  */
  81           complain_overflow_bitfield, /* Complain on overflow.  */
  82           bfd_elf_generic_reloc,/* Special Function.  */
  83           "R_MICROBLAZE_32_PCREL",      /* Name.  */
  84           TRUE,                 /* Partial Inplace.  */
  85           0,                    /* Source Mask.  */
  86           0xffffffff,           /* Dest Mask.  */
  87           TRUE),                /* PC relative offset?  */
  88
  89    /* A 64 bit PCREL relocation.  Table-entry not really used.  */
  90    HOWTO (R_MICROBLAZE_64_PCREL,/* Type.  */
  91           0,                    /* Rightshift.  */
  92           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
  93           16,                   /* Bitsize.  */
  94           TRUE,                 /* PC_relative.  */
  95           0,                    /* Bitpos.  */
  96           complain_overflow_dont, /* Complain on overflow.  */
  97           bfd_elf_generic_reloc,/* Special Function.  */
  98           "R_MICROBLAZE_64_PCREL",      /* Name.  */
  99           FALSE,                /* Partial Inplace.  */
 100           0,                    /* Source Mask.  */
 101           0x0000ffff,           /* Dest Mask.  */
 102           TRUE),                /* PC relative offset?  */
 103
 104    /* The low half of a PCREL 32 bit relocation.  */
 105    HOWTO (R_MICROBLAZE_32_PCREL_LO,     /* Type.  */
 106           0,                    /* Rightshift.  */
 107           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 108           16,                   /* Bitsize.  */
 109           TRUE,                 /* PC_relative.  */
 110           0,                    /* Bitpos.  */
 111           complain_overflow_signed, /* Complain on overflow.  */
 112           bfd_elf_generic_reloc,        /* Special Function.  */
 113           "R_MICROBLAZE_32_PCREL_LO",   /* Name.  */
 114           FALSE,                /* Partial Inplace.  */
 115           0,                    /* Source Mask.  */
 116           0x0000ffff,           /* Dest Mask.  */
 117           TRUE),                /* PC relative offset?  */
 118
 119    /* A 64 bit relocation.  Table entry not really used.  */
 120    HOWTO (R_MICROBLAZE_64,      /* Type.  */
 121           0,                    /* Rightshift.  */
 122           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 123           16,                   /* Bitsize.  */
 124           FALSE,                /* PC_relative.  */
 125           0,                    /* Bitpos.  */
 126           complain_overflow_dont, /* Complain on overflow.  */
 127           bfd_elf_generic_reloc,/* Special Function.  */
 128           "R_MICROBLAZE_64",    /* Name.  */
 129           FALSE,                /* Partial Inplace.  */
 130           0,                    /* Source Mask.  */
 131           0x0000ffff,           /* Dest Mask.  */
 132           FALSE),               /* PC relative offset?  */
 133
 134    /* The low half of a 32 bit relocation.  */
 135    HOWTO (R_MICROBLAZE_32_LO,   /* Type.  */
 136           0,                    /* Rightshift.  */
 137           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 138           16,                   /* Bitsize.  */
 139           FALSE,                /* PC_relative.  */
 140           0,                    /* Bitpos.  */
 141           complain_overflow_signed, /* Complain on overflow.  */
 142           bfd_elf_generic_reloc,/* Special Function.  */
 143           "R_MICROBLAZE_32_LO", /* Name.  */
 144           FALSE,                /* Partial Inplace.  */
 145           0,                    /* Source Mask.  */
 146           0x0000ffff,           /* Dest Mask.  */
 147           FALSE),               /* PC relative offset?  */
 148
 149    /* Read-only small data section relocation.  */
 150    HOWTO (R_MICROBLAZE_SRO32,   /* Type.  */
 151           0,                    /* Rightshift.  */
 152           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 153           16,                   /* Bitsize.  */
 154           FALSE,                /* PC_relative.  */
 155           0,                    /* Bitpos.  */
 156           complain_overflow_bitfield, /* Complain on overflow.  */
 157           bfd_elf_generic_reloc,/* Special Function.  */
 158           "R_MICROBLAZE_SRO32", /* Name.  */
 159           FALSE,                /* Partial Inplace.  */
 160           0,                    /* Source Mask.  */
 161           0x0000ffff,           /* Dest Mask.  */
 162           FALSE),               /* PC relative offset?  */
 163
 164    /* Read-write small data area relocation.  */
 165    HOWTO (R_MICROBLAZE_SRW32,   /* Type.  */
 166           0,                    /* Rightshift.  */
 167           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 168           16,                   /* Bitsize.  */
 169           FALSE,                /* PC_relative.  */
 170           0,                    /* Bitpos.  */
 171           complain_overflow_bitfield, /* Complain on overflow.  */
 172           bfd_elf_generic_reloc,/* Special Function.  */
 173           "R_MICROBLAZE_SRW32", /* Name.  */
 174           FALSE,                /* Partial Inplace.  */
 175           0,                    /* Source Mask.  */
 176           0x0000ffff,           /* Dest Mask.  */
 177           FALSE),               /* PC relative offset?  */
 178
 179    /* This reloc does nothing.  Used for relaxation.  */
 180    HOWTO (R_MICROBLAZE_64_NONE, /* Type.  */
 181           0,                    /* Rightshift.  */
 182           3,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 183           0,                    /* Bitsize.  */
 184           TRUE,                 /* PC_relative.  */
 185           0,                    /* Bitpos.  */
 186           complain_overflow_dont, /* Complain on overflow.  */
 187           NULL,                  /* Special Function.  */
 188           "R_MICROBLAZE_64_NONE",/* Name.  */
 189           FALSE,                /* Partial Inplace.  */
 190           0,                    /* Source Mask.  */
 191           0,                    /* Dest Mask.  */
 192           FALSE),               /* PC relative offset?  */
 193
 194    /* Symbol Op Symbol relocation.  */
 195    HOWTO (R_MICROBLAZE_32_SYM_OP_SYM,           /* Type.  */
 196           0,                    /* Rightshift.  */
 197           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 198           32,                   /* Bitsize.  */
 199           FALSE,                /* PC_relative.  */
 200           0,                    /* Bitpos.  */
 201           complain_overflow_bitfield, /* Complain on overflow.  */
 202           bfd_elf_generic_reloc,/* Special Function.  */
 203           "R_MICROBLAZE_32_SYM_OP_SYM",         /* Name.  */
 204           FALSE,                /* Partial Inplace.  */
 205           0,                    /* Source Mask.  */
 206           0xffffffff,           /* Dest Mask.  */
 207           FALSE),               /* PC relative offset?  */
 208
 209    /* GNU extension to record C++ vtable hierarchy.  */
 210    HOWTO (R_MICROBLAZE_GNU_VTINHERIT, /* Type.  */
 211           0,                     /* Rightshift.  */
 212           2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 213           0,                     /* Bitsize.  */
 214           FALSE,                 /* PC_relative.  */
 215           0,                     /* Bitpos.  */
 216           complain_overflow_dont,/* Complain on overflow.  */
 217           NULL,                  /* Special Function.  */
 218           "R_MICROBLAZE_GNU_VTINHERIT", /* Name.  */
 219           FALSE,                 /* Partial Inplace.  */
 220           0,                     /* Source Mask.  */
 221           0,                     /* Dest Mask.  */
 222           FALSE),                /* PC relative offset?  */
 223
 224    /* GNU extension to record C++ vtable member usage.  */
 225    HOWTO (R_MICROBLAZE_GNU_VTENTRY,   /* Type.  */
 226           0,                     /* Rightshift.  */
 227           2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
 228           0,                     /* Bitsize.  */
 229           FALSE,                 /* PC_relative.  */
 230           0,                     /* Bitpos.  */
 231           complain_overflow_dont,/* Complain on overflow.  */
 232           _bfd_elf_rel_vtable_reloc_fn,  /* Special Function.  */
 233           "R_MICROBLAZE_GNU_VTENTRY", /* Name.  */
 234           FALSE,                 /* Partial Inplace.  */
 235           0,                     /* Source Mask.  */
 236           0,                     /* Dest Mask.  */
 237           FALSE),                /* PC relative offset?  */
 238
 239    /* A 64 bit GOTPC relocation.  Table-entry not really used.  */
 240    HOWTO (R_MICROBLAZE_GOTPC_64,        /* Type.  */
 241           0,                    /* Rightshift.  */
 242           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 243           16,                   /* Bitsize.  */
 244           TRUE,                 /* PC_relative.  */
 245           0,                    /* Bitpos.  */
 246           complain_overflow_dont, /* Complain on overflow.  */
 247           bfd_elf_generic_reloc,        /* Special Function.  */
 248           "R_MICROBLAZE_GOTPC_64",      /* Name.  */
 249           FALSE,                /* Partial Inplace.  */
 250           0,                    /* Source Mask.  */
 251           0x0000ffff,           /* Dest Mask.  */
 252           TRUE),                /* PC relative offset?  */
 253
 254    /* A 64 bit GOT relocation.  Table-entry not really used.  */
 255    HOWTO (R_MICROBLAZE_GOT_64,  /* Type.  */
 256           0,                    /* Rightshift.  */
 257           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 258           16,                   /* Bitsize.  */
 259           FALSE,                /* PC_relative.  */
 260           0,                    /* Bitpos.  */
 261           complain_overflow_dont, /* Complain on overflow.  */
 262           bfd_elf_generic_reloc,/* Special Function.  */
 263           "R_MICROBLAZE_GOT_64",/* Name.  */
 264           FALSE,                /* Partial Inplace.  */
 265           0,                    /* Source Mask.  */
 266           0x0000ffff,           /* Dest Mask.  */
 267           FALSE),               /* PC relative offset?  */
 268
 269    /* A 64 bit PLT relocation.  Table-entry not really used.  */
 270    HOWTO (R_MICROBLAZE_PLT_64,  /* Type.  */
 271           0,                    /* Rightshift.  */
 272           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 273           16,                   /* Bitsize.  */
 274           TRUE,                 /* PC_relative.  */
 275           0,                    /* Bitpos.  */
 276           complain_overflow_dont, /* Complain on overflow.  */
 277           bfd_elf_generic_reloc,/* Special Function.  */
 278           "R_MICROBLAZE_PLT_64",/* Name.  */
 279           FALSE,                /* Partial Inplace.  */
 280           0,                    /* Source Mask.  */
 281           0x0000ffff,           /* Dest Mask.  */
 282           TRUE),                /* PC relative offset?  */
 283
 284    /*  Table-entry not really used.  */
 285    HOWTO (R_MICROBLAZE_REL,     /* Type.  */
 286           0,                    /* Rightshift.  */
 287           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 288           16,                   /* Bitsize.  */
 289           TRUE,                 /* PC_relative.  */
 290           0,                    /* Bitpos.  */
 291           complain_overflow_dont, /* Complain on overflow.  */
 292           bfd_elf_generic_reloc,/* Special Function.  */
 293           "R_MICROBLAZE_REL",   /* Name.  */
 294           FALSE,                /* Partial Inplace.  */
 295           0,                    /* Source Mask.  */
 296           0x0000ffff,           /* Dest Mask.  */
 297           TRUE),                /* PC relative offset?  */
 298
 299    /*  Table-entry not really used.  */
 300    HOWTO (R_MICROBLAZE_JUMP_SLOT,/* Type.  */
 301           0,                    /* Rightshift.  */
 302           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 303           16,                   /* Bitsize.  */
 304           TRUE,                 /* PC_relative.  */
 305           0,                    /* Bitpos.  */
 306           complain_overflow_dont, /* Complain on overflow.  */
 307           bfd_elf_generic_reloc,/* Special Function.  */
 308           "R_MICROBLAZE_JUMP_SLOT",     /* Name.  */
 309           FALSE,                /* Partial Inplace.  */
 310           0,                    /* Source Mask.  */
 311           0x0000ffff,           /* Dest Mask.  */
 312           TRUE),                /* PC relative offset?  */
 313
 314    /*  Table-entry not really used.  */
 315    HOWTO (R_MICROBLAZE_GLOB_DAT,/* Type.  */
 316           0,                    /* Rightshift.  */
 317           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 318           16,                   /* Bitsize.  */
 319           TRUE,                 /* PC_relative.  */
 320           0,                    /* Bitpos.  */
 321           complain_overflow_dont, /* Complain on overflow.  */
 322           bfd_elf_generic_reloc,/* Special Function.  */
 323           "R_MICROBLAZE_GLOB_DAT",      /* Name.  */
 324           FALSE,                /* Partial Inplace.  */
 325           0,                    /* Source Mask.  */
 326           0x0000ffff,           /* Dest Mask.  */
 327           TRUE),                /* PC relative offset?  */
 328
 329    /* A 64 bit GOT relative relocation.  Table-entry not really used.  */
 330    HOWTO (R_MICROBLAZE_GOTOFF_64,       /* Type.  */
 331           0,                    /* Rightshift.  */
 332           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 333           16,                   /* Bitsize.  */
 334           FALSE,                /* PC_relative.  */
 335           0,                    /* Bitpos.  */
 336           complain_overflow_dont, /* Complain on overflow.  */
 337           bfd_elf_generic_reloc,/* Special Function.  */
 338           "R_MICROBLAZE_GOTOFF_64",     /* Name.  */
 339           FALSE,                /* Partial Inplace.  */
 340           0,                    /* Source Mask.  */
 341           0x0000ffff,           /* Dest Mask.  */
 342           FALSE),               /* PC relative offset?  */
 343
 344    /* A 32 bit GOT relative relocation.  Table-entry not really used.  */
 345    HOWTO (R_MICROBLAZE_GOTOFF_32,       /* Type.  */
 346           0,                    /* Rightshift.  */
 347           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 348           16,                   /* Bitsize.  */
 349           FALSE,                /* PC_relative.  */
 350           0,                    /* Bitpos.  */
 351           complain_overflow_dont, /* Complain on overflow.  */
 352           bfd_elf_generic_reloc,        /* Special Function.  */
 353           "R_MICROBLAZE_GOTOFF_32",     /* Name.  */
 354           FALSE,                /* Partial Inplace.  */
 355           0,                    /* Source Mask.  */
 356           0x0000ffff,           /* Dest Mask.  */
 357           FALSE),               /* PC relative offset?  */
 358
 359    /* COPY relocation.  Table-entry not really used.  */
 360    HOWTO (R_MICROBLAZE_COPY,    /* Type.  */
 361           0,                    /* Rightshift.  */
 362           2,                    /* Size (0 = byte, 1 = short, 2 = long).  */
 363           16,                   /* Bitsize.  */
 364           FALSE,                /* PC_relative.  */
 365           0,                    /* Bitpos.  */
 366           complain_overflow_dont, /* Complain on overflow.  */
 367           bfd_elf_generic_reloc,/* Special Function.  */
 368           "R_MICROBLAZE_COPY",  /* Name.  */
 369           FALSE,                /* Partial Inplace.  */
 370           0,                    /* Source Mask.  */
 371           0x0000ffff,           /* Dest Mask.  */
 372           FALSE),               /* PC relative offset?  */
 373
 374    /* Marker relocs for TLS.  */
 375    HOWTO (R_MICROBLAZE_TLS,
 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_dont, /* complain_on_overflow */
 382          bfd_elf_generic_reloc, /* special_function */
 383          "R_MICROBLAZE_TLS",            /* name */
 384          FALSE,                 /* partial_inplace */
 385          0,                     /* src_mask */
 386          0x0000ffff,                    /* dst_mask */
 387          FALSE),                /* pcrel_offset */
 388
 389    HOWTO (R_MICROBLAZE_TLSGD,
 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_dont, /* complain_on_overflow */
 396          bfd_elf_generic_reloc, /* special_function */
 397          "R_MICROBLAZE_TLSGD",          /* name */
 398          FALSE,                 /* partial_inplace */
 399          0,                     /* src_mask */
 400          0x0000ffff,                    /* dst_mask */
 401          FALSE),                /* pcrel_offset */
 402
 403    HOWTO (R_MICROBLAZE_TLSLD,
 404          0,                     /* rightshift */
 405          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 406          32,                    /* bitsize */
 407          FALSE,                 /* pc_relative */
 408          0,                     /* bitpos */
 409          complain_overflow_dont, /* complain_on_overflow */
 410          bfd_elf_generic_reloc, /* special_function */
 411          "R_MICROBLAZE_TLSLD",          /* name */
 412          FALSE,                 /* partial_inplace */
 413          0,                     /* src_mask */
 414          0x0000ffff,            /* dst_mask */
 415          FALSE),                /* pcrel_offset */
 416
 417    /* Computes the load module index of the load module that contains the
 418       definition of its TLS sym.  */
 419    HOWTO (R_MICROBLAZE_TLSDTPMOD32,
 420          0,                     /* rightshift */
 421          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 422          32,                    /* bitsize */
 423          FALSE,                 /* pc_relative */
 424          0,                     /* bitpos */
 425          complain_overflow_dont, /* complain_on_overflow */
 426          bfd_elf_generic_reloc, /* special_function */
 427          "R_MICROBLAZE_TLSDTPMOD32",    /* name */
 428          FALSE,                 /* partial_inplace */
 429          0,                     /* src_mask */
 430          0x0000ffff,            /* dst_mask */
 431          FALSE),                /* pcrel_offset */
 432
 433    /* Computes a dtv-relative displacement, the difference between the value
 434       of sym+add and the base address of the thread-local storage block that
 435       contains the definition of sym, minus 0x8000.  Used for initializing GOT */
 436    HOWTO (R_MICROBLAZE_TLSDTPREL32,
 437          0,                     /* rightshift */
 438          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 439          32,                    /* bitsize */
 440          FALSE,                 /* pc_relative */
 441          0,                     /* bitpos */
 442          complain_overflow_dont, /* complain_on_overflow */
 443          bfd_elf_generic_reloc, /* special_function */
 444          "R_MICROBLAZE_TLSDTPREL32",    /* name */
 445          FALSE,                 /* partial_inplace */
 446          0,                     /* src_mask */
 447          0x0000ffff,            /* dst_mask */
 448          FALSE),                /* pcrel_offset */
 449
 450    /* Computes a dtv-relative displacement, the difference between the value
 451       of sym+add and the base address of the thread-local storage block that
 452       contains the definition of sym, minus 0x8000.  */
 453    HOWTO (R_MICROBLAZE_TLSDTPREL64,
 454          0,                     /* rightshift */
 455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 456          32,                    /* bitsize */
 457          FALSE,                 /* pc_relative */
 458          0,                     /* bitpos */
 459          complain_overflow_dont, /* complain_on_overflow */
 460          bfd_elf_generic_reloc, /* special_function */
 461          "R_MICROBLAZE_TLSDTPREL64",    /* name */
 462          FALSE,                 /* partial_inplace */
 463          0,                     /* src_mask */
 464          0x0000ffff,            /* dst_mask */
 465          FALSE),                /* pcrel_offset */
 466
 467    /* Computes a tp-relative displacement, the difference between the value of
 468       sym+add and the value of the thread pointer (r13).  */
 469    HOWTO (R_MICROBLAZE_TLSGOTTPREL32,
 470          0,                     /* rightshift */
 471          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 472          32,                    /* bitsize */
 473          FALSE,                 /* pc_relative */
 474          0,                     /* bitpos */
 475          complain_overflow_dont, /* complain_on_overflow */
 476          bfd_elf_generic_reloc, /* special_function */
 477          "R_MICROBLAZE_TLSGOTTPREL32",  /* name */
 478          FALSE,                 /* partial_inplace */
 479          0,                     /* src_mask */
 480          0x0000ffff,            /* dst_mask */
 481          FALSE),                /* pcrel_offset */
 482
 483    /* Computes a tp-relative displacement, the difference between the value of
 484       sym+add and the value of the thread pointer (r13).  */
 485    HOWTO (R_MICROBLAZE_TLSTPREL32,
 486          0,                     /* rightshift */
 487          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 488          32,                    /* bitsize */
 489          FALSE,                 /* pc_relative */
 490          0,                     /* bitpos */
 491          complain_overflow_dont, /* complain_on_overflow */
 492          bfd_elf_generic_reloc, /* special_function */
 493          "R_MICROBLAZE_TLSTPREL32",     /* name */
 494          FALSE,                 /* partial_inplace */
 495          0,                     /* src_mask */
 496          0x0000ffff,            /* dst_mask */
 497          FALSE),                /* pcrel_offset */
 498
 499 };
 500
 501 #ifndef NUM_ELEM
 502 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
 503 #endif
 504 \f
 505 /* Initialize the microblaze_elf_howto_table, so that linear accesses can be done.  */
 506
 507 static void
 508 microblaze_elf_howto_init (void)
 509 {
 510   unsigned int i;
 511
 512   for (i = NUM_ELEM (microblaze_elf_howto_raw); i--;)
 513     {
 514       unsigned int type;
 515
 516       type = microblaze_elf_howto_raw[i].type;
 517
 518       BFD_ASSERT (type < NUM_ELEM (microblaze_elf_howto_table));
 519
 520       microblaze_elf_howto_table [type] = & microblaze_elf_howto_raw [i];
 521     }
 522 }
 523 \f
 524 static reloc_howto_type *
 525 microblaze_elf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 526                                   bfd_reloc_code_real_type code)
 527 {
 528   enum elf_microblaze_reloc_type microblaze_reloc = R_MICROBLAZE_NONE;
 529
 530   switch (code)
 531     {
 532     case BFD_RELOC_NONE:
 533       microblaze_reloc = R_MICROBLAZE_NONE;
 534       break;
 535     case BFD_RELOC_MICROBLAZE_64_NONE:
 536       microblaze_reloc = R_MICROBLAZE_64_NONE;
 537       break;
 538     case BFD_RELOC_32:
 539       microblaze_reloc = R_MICROBLAZE_32;
 540       break;
 541       /* RVA is treated the same as 32 */
 542     case BFD_RELOC_RVA:
 543       microblaze_reloc = R_MICROBLAZE_32;
 544       break;
 545     case BFD_RELOC_32_PCREL:
 546       microblaze_reloc = R_MICROBLAZE_32_PCREL;
 547       break;
 548     case BFD_RELOC_64_PCREL:
 549       microblaze_reloc = R_MICROBLAZE_64_PCREL;
 550       break;
 551     case BFD_RELOC_MICROBLAZE_32_LO_PCREL:
 552       microblaze_reloc = R_MICROBLAZE_32_PCREL_LO;
 553       break;
 554     case BFD_RELOC_64:
 555       microblaze_reloc = R_MICROBLAZE_64;
 556       break;
 557     case BFD_RELOC_MICROBLAZE_32_LO:
 558       microblaze_reloc = R_MICROBLAZE_32_LO;
 559       break;
 560     case BFD_RELOC_MICROBLAZE_32_ROSDA:
 561       microblaze_reloc = R_MICROBLAZE_SRO32;
 562       break;
 563     case BFD_RELOC_MICROBLAZE_32_RWSDA:
 564       microblaze_reloc = R_MICROBLAZE_SRW32;
 565       break;
 566     case BFD_RELOC_MICROBLAZE_32_SYM_OP_SYM:
 567       microblaze_reloc = R_MICROBLAZE_32_SYM_OP_SYM;
 568       break;
 569     case BFD_RELOC_VTABLE_INHERIT:
 570       microblaze_reloc = R_MICROBLAZE_GNU_VTINHERIT;
 571       break;
 572     case BFD_RELOC_VTABLE_ENTRY:
 573       microblaze_reloc = R_MICROBLAZE_GNU_VTENTRY;
 574       break;
 575     case BFD_RELOC_MICROBLAZE_64_GOTPC:
 576       microblaze_reloc = R_MICROBLAZE_GOTPC_64;
 577       break;
 578     case BFD_RELOC_MICROBLAZE_64_GOT:
 579       microblaze_reloc = R_MICROBLAZE_GOT_64;
 580       break;
 581     case BFD_RELOC_MICROBLAZE_64_PLT:
 582       microblaze_reloc = R_MICROBLAZE_PLT_64;
 583       break;
 584     case BFD_RELOC_MICROBLAZE_64_GOTOFF:
 585       microblaze_reloc = R_MICROBLAZE_GOTOFF_64;
 586       break;
 587     case BFD_RELOC_MICROBLAZE_32_GOTOFF:
 588       microblaze_reloc = R_MICROBLAZE_GOTOFF_32;
 589       break;
 590     case BFD_RELOC_MICROBLAZE_64_TLSGD:
 591       microblaze_reloc = R_MICROBLAZE_TLSGD;
 592       break;
 593     case BFD_RELOC_MICROBLAZE_64_TLSLD:
 594       microblaze_reloc = R_MICROBLAZE_TLSLD;
 595       break;
 596     case BFD_RELOC_MICROBLAZE_32_TLSDTPREL:
 597       microblaze_reloc = R_MICROBLAZE_TLSDTPREL32;
 598       break;
 599     case BFD_RELOC_MICROBLAZE_64_TLSDTPREL:
 600       microblaze_reloc = R_MICROBLAZE_TLSDTPREL64;
 601       break;
 602     case BFD_RELOC_MICROBLAZE_32_TLSDTPMOD:
 603       microblaze_reloc = R_MICROBLAZE_TLSDTPMOD32;
 604       break;
 605     case BFD_RELOC_MICROBLAZE_64_TLSGOTTPREL:
 606       microblaze_reloc = R_MICROBLAZE_TLSGOTTPREL32;
 607       break;
 608     case BFD_RELOC_MICROBLAZE_64_TLSTPREL:
 609       microblaze_reloc = R_MICROBLAZE_TLSTPREL32;
 610       break;
 611     case BFD_RELOC_MICROBLAZE_COPY:
 612       microblaze_reloc = R_MICROBLAZE_COPY;
 613       break;
 614     default:
 615       return (reloc_howto_type *) NULL;
 616     }
 617
 618   if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
 619     /* Initialize howto table if needed.  */
 620     microblaze_elf_howto_init ();
 621
 622   return microblaze_elf_howto_table [(int) microblaze_reloc];
 623 };
 624
 625 static reloc_howto_type *
 626 microblaze_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 627                                   const char *r_name)
 628 {
 629   unsigned int i;
 630
 631   for (i = 0; i < NUM_ELEM (microblaze_elf_howto_raw); i++)
 632     if (microblaze_elf_howto_raw[i].name != NULL
 633         && strcasecmp (microblaze_elf_howto_raw[i].name, r_name) == 0)
 634       return &microblaze_elf_howto_raw[i];
 635
 636   return NULL;
 637 }
 638
 639 /* Set the howto pointer for a RCE ELF reloc.  */
 640
 641 static void
 642 microblaze_elf_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED,
 643                               arelent * cache_ptr,
 644                               Elf_Internal_Rela * dst)
 645 {
 646   unsigned int r_type;
 647
 648   if (!microblaze_elf_howto_table [R_MICROBLAZE_32])
 649     /* Initialize howto table if needed.  */
 650     microblaze_elf_howto_init ();
 651
 652   r_type = ELF32_R_TYPE (dst->r_info);
 653   if (r_type >= R_MICROBLAZE_max)
 654     {
 655       /* xgettext:c-format */
 656       _bfd_error_handler (_("%B: unrecognised MicroBlaze reloc number: %d"),
 657                           abfd, r_type);
 658       bfd_set_error (bfd_error_bad_value);
 659       r_type = R_MICROBLAZE_NONE;
 660     }
 661
 662   cache_ptr->howto = microblaze_elf_howto_table [r_type];
 663 }
 664
 665 /* Microblaze ELF local labels start with 'L.' or '$L', not '.L'.  */
 666
 667 static bfd_boolean
 668 microblaze_elf_is_local_label_name (bfd *abfd, const char *name)
 669 {
 670   if (name[0] == 'L' && name[1] == '.')
 671     return TRUE;
 672
 673   if (name[0] == '$' && name[1] == 'L')
 674     return TRUE;
 675
 676   /* With gcc, the labels go back to starting with '.', so we accept
 677      the generic ELF local label syntax as well.  */
 678   return _bfd_elf_is_local_label_name (abfd, name);
 679 }
 680
 681 /* The microblaze linker (like many others) needs to keep track of
 682    the number of relocs that it decides to copy as dynamic relocs in
 683    check_relocs for each symbol. This is so that it can later discard
 684    them if they are found to be unnecessary.  We store the information
 685    in a field extending the regular ELF linker hash table.  */
 686
 687 struct elf32_mb_dyn_relocs
 688 {
 689   struct elf32_mb_dyn_relocs *next;
 690
 691   /* The input section of the reloc.  */
 692   asection *sec;
 693
 694   /* Total number of relocs copied for the input section.  */
 695   bfd_size_type count;
 696
 697   /* Number of pc-relative relocs copied for the input section.  */
 698   bfd_size_type pc_count;
 699 };
 700
 701 /* ELF linker hash entry.  */
 702
 703 struct elf32_mb_link_hash_entry
 704 {
 705   struct elf_link_hash_entry elf;
 706
 707   /* Track dynamic relocs copied for this symbol.  */
 708   struct elf32_mb_dyn_relocs *dyn_relocs;
 709
 710   /* TLS Reference Types for the symbol; Updated by check_relocs */
 711 #define TLS_GD     1  /* GD reloc. */
 712 #define TLS_LD     2  /* LD reloc. */
 713 #define TLS_TPREL  4  /* TPREL reloc, => IE. */
 714 #define TLS_DTPREL 8  /* DTPREL reloc, => LD. */
 715 #define TLS_TLS    16 /* Any TLS reloc.  */
 716   unsigned char tls_mask;
 717
 718 };
 719
 720 #define IS_TLS_GD(x)     (x == (TLS_TLS | TLS_GD))
 721 #define IS_TLS_LD(x)     (x == (TLS_TLS | TLS_LD))
 722 #define IS_TLS_DTPREL(x) (x == (TLS_TLS | TLS_DTPREL))
 723 #define IS_TLS_NONE(x)   (x == 0)
 724
 725 #define elf32_mb_hash_entry(ent) ((struct elf32_mb_link_hash_entry *)(ent))
 726
 727 /* ELF linker hash table.  */
 728
 729 struct elf32_mb_link_hash_table
 730 {
 731   struct elf_link_hash_table elf;
 732
 733   /* Small local sym to section mapping cache.  */
 734   struct sym_cache sym_sec;
 735
 736   /* TLS Local Dynamic GOT Entry */
 737   union {
 738     bfd_signed_vma refcount;
 739     bfd_vma offset;
 740   } tlsld_got;
 741 };
 742
 743 /* Nonzero if this section has TLS related relocations.  */
 744 #define has_tls_reloc sec_flg0
 745
 746 /* Get the ELF linker hash table from a link_info structure.  */
 747
 748 #define elf32_mb_hash_table(p)                          \
 749   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 750   == MICROBLAZE_ELF_DATA ? ((struct elf32_mb_link_hash_table *) ((p)->hash)) : NULL)
 751
 752 /* Create an entry in a microblaze ELF linker hash table.  */
 753
 754 static struct bfd_hash_entry *
 755 link_hash_newfunc (struct bfd_hash_entry *entry,
 756                    struct bfd_hash_table *table,
 757                    const char *string)
 758 {
 759   /* Allocate the structure if it has not already been allocated by a
 760      subclass.  */
 761   if (entry == NULL)
 762     {
 763       entry = bfd_hash_allocate (table,
 764                                  sizeof (struct elf32_mb_link_hash_entry));
 765       if (entry == NULL)
 766         return entry;
 767     }
 768
 769   /* Call the allocation method of the superclass.  */
 770   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 771   if (entry != NULL)
 772     {
 773       struct elf32_mb_link_hash_entry *eh;
 774
 775       eh = (struct elf32_mb_link_hash_entry *) entry;
 776       eh->dyn_relocs = NULL;
 777       eh->tls_mask = 0;
 778     }
 779
 780   return entry;
 781 }
 782
 783 /* Create a mb ELF linker hash table.  */
 784
 785 static struct bfd_link_hash_table *
 786 microblaze_elf_link_hash_table_create (bfd *abfd)
 787 {
 788   struct elf32_mb_link_hash_table *ret;
 789   bfd_size_type amt = sizeof (struct elf32_mb_link_hash_table);
 790
 791   ret = (struct elf32_mb_link_hash_table *) bfd_zmalloc (amt);
 792   if (ret == NULL)
 793     return NULL;
 794
 795   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 796                                       sizeof (struct elf32_mb_link_hash_entry),
 797                                       MICROBLAZE_ELF_DATA))
 798     {
 799       free (ret);
 800       return NULL;
 801     }
 802
 803   return &ret->elf.root;
 804 }
 805 \f
 806 /* Set the values of the small data pointers.  */
 807
 808 static void
 809 microblaze_elf_final_sdp (struct bfd_link_info *info)
 810 {
 811   struct bfd_link_hash_entry *h;
 812
 813   h = bfd_link_hash_lookup (info->hash, RO_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
 814   if (h != (struct bfd_link_hash_entry *) NULL
 815       && h->type == bfd_link_hash_defined)
 816     ro_small_data_pointer = (h->u.def.value
 817                              + h->u.def.section->output_section->vma
 818                              + h->u.def.section->output_offset);
 819
 820   h = bfd_link_hash_lookup (info->hash, RW_SDA_ANCHOR_NAME, FALSE, FALSE, TRUE);
 821   if (h != (struct bfd_link_hash_entry *) NULL
 822       && h->type == bfd_link_hash_defined)
 823     rw_small_data_pointer = (h->u.def.value
 824                              + h->u.def.section->output_section->vma
 825                              + h->u.def.section->output_offset);
 826 }
 827
 828 static bfd_vma
 829 dtprel_base (struct bfd_link_info *info)
 830 {
 831   /* If tls_sec is NULL, we should have signalled an error already.  */
 832   if (elf_hash_table (info)->tls_sec == NULL)
 833     return 0;
 834   return elf_hash_table (info)->tls_sec->vma;
 835 }
 836
 837 /* The size of the thread control block.  */
 838 #define TCB_SIZE        8
 839
 840 /* Output a simple dynamic relocation into SRELOC.  */
 841
 842 static void
 843 microblaze_elf_output_dynamic_relocation (bfd *output_bfd,
 844                                           asection *sreloc,
 845                                           unsigned long reloc_index,
 846                                           unsigned long indx,
 847                                           int r_type,
 848                                           bfd_vma offset,
 849                                           bfd_vma addend)
 850 {
 851
 852   Elf_Internal_Rela rel;
 853
 854   rel.r_info = ELF32_R_INFO (indx, r_type);
 855   rel.r_offset = offset;
 856   rel.r_addend = addend;
 857
 858   bfd_elf32_swap_reloca_out (output_bfd, &rel,
 859               (sreloc->contents + reloc_index * sizeof (Elf32_External_Rela)));
 860 }
 861
 862 /* This code is taken from elf32-m32r.c
 863    There is some attempt to make this function usable for many architectures,
 864    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 865    if only to serve as a learning tool.
 866
 867    The RELOCATE_SECTION function is called by the new ELF backend linker
 868    to handle the relocations for a section.
 869
 870    The relocs are always passed as Rela structures; if the section
 871    actually uses Rel structures, the r_addend field will always be
 872    zero.
 873
 874    This function is responsible for adjust the section contents as
 875    necessary, and (if using Rela relocs and generating a
 876    relocatable output file) adjusting the reloc addend as
 877    necessary.
 878
 879    This function does not have to worry about setting the reloc
 880    address or the reloc symbol index.
 881
 882    LOCAL_SYMS is a pointer to the swapped in local symbols.
 883
 884    LOCAL_SECTIONS is an array giving the section in the input file
 885    corresponding to the st_shndx field of each local symbol.
 886
 887    The global hash table entry for the global symbols can be found
 888    via elf_sym_hashes (input_bfd).
 889
 890    When generating relocatable output, this function must handle
 891    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 892    going to be the section symbol corresponding to the output
 893    section, which means that the addend must be adjusted
 894    accordingly.  */
 895
 896 static bfd_boolean
 897 microblaze_elf_relocate_section (bfd *output_bfd,
 898                                  struct bfd_link_info *info,
 899                                  bfd *input_bfd,
 900                                  asection *input_section,
 901                                  bfd_byte *contents,
 902                                  Elf_Internal_Rela *relocs,
 903                                  Elf_Internal_Sym *local_syms,
 904                                  asection **local_sections)
 905 {
 906   struct elf32_mb_link_hash_table *htab;
 907   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 908   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 909   Elf_Internal_Rela *rel, *relend;
 910   int endian = (bfd_little_endian (output_bfd)) ? 0 : 2;
 911   /* Assume success.  */
 912   bfd_boolean ret = TRUE;
 913   asection *sreloc;
 914   bfd_vma *local_got_offsets;
 915   unsigned int tls_type;
 916
 917   if (!microblaze_elf_howto_table[R_MICROBLAZE_max-1])
 918     microblaze_elf_howto_init ();
 919
 920   htab = elf32_mb_hash_table (info);
 921   if (htab == NULL)
 922     return FALSE;
 923
 924   local_got_offsets = elf_local_got_offsets (input_bfd);
 925
 926   sreloc = elf_section_data (input_section)->sreloc;
 927
 928   rel = relocs;
 929   relend = relocs + input_section->reloc_count;
 930   for (; rel < relend; rel++)
 931     {
 932       int r_type;
 933       reloc_howto_type *howto;
 934       unsigned long r_symndx;
 935       bfd_vma addend = rel->r_addend;
 936       bfd_vma offset = rel->r_offset;
 937       struct elf_link_hash_entry *h;
 938       Elf_Internal_Sym *sym;
 939       asection *sec;
 940       const char *sym_name;
 941       bfd_reloc_status_type r = bfd_reloc_ok;
 942       const char *errmsg = NULL;
 943       bfd_boolean unresolved_reloc = FALSE;
 944
 945       h = NULL;
 946       r_type = ELF32_R_TYPE (rel->r_info);
 947       tls_type = 0;
 948
 949       if (r_type < 0 || r_type >= (int) R_MICROBLAZE_max)
 950         {
 951           /* xgettext:c-format */
 952           _bfd_error_handler (_("%B: unknown relocation type %d"),
 953                               input_bfd, (int) r_type);
 954           bfd_set_error (bfd_error_bad_value);
 955           ret = FALSE;
 956           continue;
 957         }
 958
 959       howto = microblaze_elf_howto_table[r_type];
 960       r_symndx = ELF32_R_SYM (rel->r_info);
 961
 962       if (bfd_link_relocatable (info))
 963         {
 964           /* This is a relocatable link.  We don't have to change
 965              anything, unless the reloc is against a section symbol,
 966              in which case we have to adjust according to where the
 967              section symbol winds up in the output section.  */
 968           sec = NULL;
 969           if (r_symndx >= symtab_hdr->sh_info)
 970             /* External symbol.  */
 971             continue;
 972
 973           /* Local symbol.  */
 974           sym = local_syms + r_symndx;
 975           sym_name = "<local symbol>";
 976           /* STT_SECTION: symbol is associated with a section.  */
 977           if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
 978             /* Symbol isn't associated with a section.  Nothing to do.  */
 979             continue;
 980
 981           sec = local_sections[r_symndx];
 982           addend += sec->output_offset + sym->st_value;
 983 #ifndef USE_REL
 984           /* This can't be done for USE_REL because it doesn't mean anything
 985              and elf_link_input_bfd asserts this stays zero.  */
 986           /* rel->r_addend = addend; */
 987 #endif
 988
 989 #ifndef USE_REL
 990           /* Addends are stored with relocs.  We're done.  */
 991           continue;
 992 #else /* USE_REL */
 993           /* If partial_inplace, we need to store any additional addend
 994              back in the section.  */
 995           if (!howto->partial_inplace)
 996             continue;
 997           /* ??? Here is a nice place to call a special_function like handler.  */
 998           r = _bfd_relocate_contents (howto, input_bfd, addend,
 999                                       contents + offset);
1000 #endif /* USE_REL */
1001         }
1002       else
1003         {
1004           bfd_vma relocation;
1005           bfd_boolean resolved_to_zero;
1006
1007           /* This is a final link.  */
1008           sym = NULL;
1009           sec = NULL;
1010           unresolved_reloc = FALSE;
1011
1012           if (r_symndx < symtab_hdr->sh_info)
1013             {
1014               /* Local symbol.  */
1015               sym = local_syms + r_symndx;
1016               sec = local_sections[r_symndx];
1017               if (sec == 0)
1018                 continue;
1019               sym_name = "<local symbol>";
1020               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1021               /* r_addend may have changed if the reference section was
1022                  a merge section.  */
1023               addend = rel->r_addend;
1024             }
1025           else
1026             {
1027               /* External symbol.  */
1028               bfd_boolean warned ATTRIBUTE_UNUSED;
1029               bfd_boolean ignored ATTRIBUTE_UNUSED;
1030
1031               RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1032                                        r_symndx, symtab_hdr, sym_hashes,
1033                                        h, sec, relocation,
1034                                        unresolved_reloc, warned, ignored);
1035               sym_name = h->root.root.string;
1036             }
1037
1038           /* Sanity check the address.  */
1039           if (offset > bfd_get_section_limit (input_bfd, input_section))
1040             {
1041               r = bfd_reloc_outofrange;
1042               goto check_reloc;
1043             }
1044
1045           resolved_to_zero = (h != NULL
1046                               && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
1047
1048           switch ((int) r_type)
1049             {
1050             case (int) R_MICROBLAZE_SRO32 :
1051               {
1052                 const char *name;
1053
1054                 /* Only relocate if the symbol is defined.  */
1055                 if (sec)
1056                   {
1057                     name = bfd_get_section_name (sec->owner, sec);
1058
1059                     if (strcmp (name, ".sdata2") == 0
1060                         || strcmp (name, ".sbss2") == 0)
1061                       {
1062                         if (ro_small_data_pointer == 0)
1063                           microblaze_elf_final_sdp (info);
1064                         if (ro_small_data_pointer == 0)
1065                           {
1066                             ret = FALSE;
1067                             r = bfd_reloc_undefined;
1068                             goto check_reloc;
1069                           }
1070
1071                         /* At this point `relocation' contains the object's
1072                            address.  */
1073                         relocation -= ro_small_data_pointer;
1074                         /* Now it contains the offset from _SDA2_BASE_.  */
1075                         r = _bfd_final_link_relocate (howto, input_bfd,
1076                                                       input_section,
1077                                                       contents, offset,
1078                                                       relocation, addend);
1079                       }
1080                     else
1081                       {
1082                         _bfd_error_handler
1083                           /* xgettext:c-format */
1084                           (_("%B: The target (%s) of an %s relocation"
1085                              " is in the wrong section (%A)"),
1086                            input_bfd,
1087                            sym_name,
1088                            microblaze_elf_howto_table[(int) r_type]->name,
1089                            sec);
1090                         /*bfd_set_error (bfd_error_bad_value); ??? why? */
1091                         ret = FALSE;
1092                         continue;
1093                       }
1094                   }
1095               }
1096               break;
1097
1098             case (int) R_MICROBLAZE_SRW32 :
1099               {
1100                 const char *name;
1101
1102                 /* Only relocate if the symbol is defined.  */
1103                 if (sec)
1104                   {
1105                     name = bfd_get_section_name (sec->owner, sec);
1106
1107                     if (strcmp (name, ".sdata") == 0
1108                         || strcmp (name, ".sbss") == 0)
1109                       {
1110                         if (rw_small_data_pointer == 0)
1111                           microblaze_elf_final_sdp (info);
1112                         if (rw_small_data_pointer == 0)
1113                           {
1114                             ret = FALSE;
1115                             r = bfd_reloc_undefined;
1116                             goto check_reloc;
1117                           }
1118
1119                         /* At this point `relocation' contains the object's
1120                            address.  */
1121                         relocation -= rw_small_data_pointer;
1122                         /* Now it contains the offset from _SDA_BASE_.  */
1123                         r = _bfd_final_link_relocate (howto, input_bfd,
1124                                                       input_section,
1125                                                       contents, offset,
1126                                                       relocation, addend);
1127                       }
1128                     else
1129                       {
1130                         _bfd_error_handler
1131                           /* xgettext:c-format */
1132                           (_("%B: The target (%s) of an %s relocation"
1133                              " is in the wrong section (%A)"),
1134                            input_bfd,
1135                            sym_name,
1136                            microblaze_elf_howto_table[(int) r_type]->name,
1137                            sec);
1138                         /*bfd_set_error (bfd_error_bad_value); ??? why? */
1139                         ret = FALSE;
1140                         continue;
1141                       }
1142                   }
1143               }
1144               break;
1145
1146             case (int) R_MICROBLAZE_32_SYM_OP_SYM:
1147               break; /* Do nothing.  */
1148
1149             case (int) R_MICROBLAZE_GOTPC_64:
1150               relocation = (htab->elf.sgotplt->output_section->vma
1151                             + htab->elf.sgotplt->output_offset);
1152               relocation -= (input_section->output_section->vma
1153                              + input_section->output_offset
1154                              + offset + INST_WORD_SIZE);
1155               relocation += addend;
1156               bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1157                           contents + offset + endian);
1158               bfd_put_16 (input_bfd, relocation & 0xffff,
1159                           contents + offset + endian + INST_WORD_SIZE);
1160               break;
1161
1162             case (int) R_MICROBLAZE_PLT_64:
1163               {
1164                 bfd_vma immediate;
1165                 if (htab->elf.splt != NULL && h != NULL
1166                     && h->plt.offset != (bfd_vma) -1)
1167                   {
1168                     relocation = (htab->elf.splt->output_section->vma
1169                                   + htab->elf.splt->output_offset
1170                                   + h->plt.offset);
1171                     unresolved_reloc = FALSE;
1172                     immediate = relocation - (input_section->output_section->vma
1173                                               + input_section->output_offset
1174                                               + offset + INST_WORD_SIZE);
1175                     bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1176                                 contents + offset + endian);
1177                     bfd_put_16 (input_bfd, immediate & 0xffff,
1178                                 contents + offset + endian + INST_WORD_SIZE);
1179                   }
1180                 else
1181                   {
1182                     relocation -= (input_section->output_section->vma
1183                                    + input_section->output_offset
1184                                    + offset + INST_WORD_SIZE);
1185                     immediate = relocation;
1186                     bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1187                                 contents + offset + endian);
1188                     bfd_put_16 (input_bfd, immediate & 0xffff,
1189                                 contents + offset + endian + INST_WORD_SIZE);
1190                   }
1191                 break;
1192               }
1193
1194             case (int) R_MICROBLAZE_TLSGD:
1195               tls_type = (TLS_TLS | TLS_GD);
1196               goto dogot;
1197             case (int) R_MICROBLAZE_TLSLD:
1198               tls_type = (TLS_TLS | TLS_LD);
1199               /* Fall through.  */
1200             dogot:
1201             case (int) R_MICROBLAZE_GOT_64:
1202               {
1203                 bfd_vma *offp;
1204                 bfd_vma off, off2;
1205                 unsigned long indx;
1206                 bfd_vma static_value;
1207
1208                 bfd_boolean need_relocs = FALSE;
1209                 if (htab->elf.sgot == NULL)
1210                   abort ();
1211
1212                 indx = 0;
1213                 offp = NULL;
1214
1215                 /* 1. Identify GOT Offset;
1216                    2. Compute Static Values
1217                    3. Process Module Id, Process Offset
1218                    4. Fixup Relocation with GOT offset value. */
1219
1220                 /* 1. Determine GOT Offset to use : TLS_LD, global, local */
1221                 if (IS_TLS_LD (tls_type))
1222                   offp = &htab->tlsld_got.offset;
1223                 else if (h != NULL)
1224                   {
1225                     if (htab->elf.sgotplt != NULL
1226                         && h->got.offset != (bfd_vma) -1)
1227                       offp = &h->got.offset;
1228                     else
1229                       abort ();
1230                   }
1231                 else
1232                   {
1233                     if (local_got_offsets == NULL)
1234                       abort ();
1235                     offp = &local_got_offsets[r_symndx];
1236                   }
1237
1238                 if (!offp)
1239                   abort ();
1240
1241                 off = (*offp) & ~1;
1242                 off2 = off;
1243
1244                 if (IS_TLS_LD(tls_type) || IS_TLS_GD(tls_type))
1245                   off2 = off + 4;
1246
1247                 /* Symbol index to use for relocs */
1248                 if (h != NULL)
1249                   {
1250                     bfd_boolean dyn =
1251                         elf_hash_table (info)->dynamic_sections_created;
1252
1253                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1254                                                          bfd_link_pic (info),
1255                                                          h)
1256                         && (!bfd_link_pic (info)
1257                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
1258                       indx = h->dynindx;
1259                   }
1260
1261                 /* Need to generate relocs ? */
1262                 if ((bfd_link_pic (info) || indx != 0)
1263                     && (h == NULL
1264                     || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1265                         && !resolved_to_zero)
1266                     || h->root.type != bfd_link_hash_undefweak))
1267                   need_relocs = TRUE;
1268
1269                 /* 2. Compute/Emit Static value of r-expression */
1270                 static_value = relocation + addend;
1271
1272                 /* 3. Process module-id and offset */
1273                 if (! ((*offp) & 1) )
1274                   {
1275                     bfd_vma got_offset;
1276
1277                     got_offset = (htab->elf.sgot->output_section->vma
1278                                   + htab->elf.sgot->output_offset
1279                                   + off);
1280
1281                     /* Process module-id */
1282                     if (IS_TLS_LD(tls_type))
1283                       {
1284                         if (! bfd_link_pic (info))
1285                           bfd_put_32 (output_bfd, 1,
1286                                       htab->elf.sgot->contents + off);
1287                         else
1288                           microblaze_elf_output_dynamic_relocation
1289                             (output_bfd,
1290                              htab->elf.srelgot,
1291                              htab->elf.srelgot->reloc_count++,
1292                              /* symindex= */ 0, R_MICROBLAZE_TLSDTPMOD32,
1293                              got_offset, 0);
1294                       }
1295                     else if (IS_TLS_GD(tls_type))
1296                       {
1297                         if (! need_relocs)
1298                           bfd_put_32 (output_bfd, 1,
1299                                       htab->elf.sgot->contents + off);
1300                         else
1301                           microblaze_elf_output_dynamic_relocation
1302                             (output_bfd,
1303                              htab->elf.srelgot,
1304                              htab->elf.srelgot->reloc_count++,
1305                              /* symindex= */ indx, R_MICROBLAZE_TLSDTPMOD32,
1306                              got_offset, indx ? 0 : static_value);
1307                       }
1308
1309                     /* Process Offset */
1310                     if (htab->elf.srelgot == NULL)
1311                       abort ();
1312
1313                     got_offset = (htab->elf.sgot->output_section->vma
1314                                   + htab->elf.sgot->output_offset
1315                                   + off2);
1316                     if (IS_TLS_LD(tls_type))
1317                       {
1318                         /* For LD, offset should be 0 */
1319                         *offp |= 1;
1320                         bfd_put_32 (output_bfd, 0,
1321                                     htab->elf.sgot->contents + off2);
1322                       }
1323                     else if (IS_TLS_GD(tls_type))
1324                       {
1325                         *offp |= 1;
1326                         static_value -= dtprel_base(info);
1327                         if (need_relocs)
1328                           microblaze_elf_output_dynamic_relocation
1329                             (output_bfd,
1330                              htab->elf.srelgot,
1331                              htab->elf.srelgot->reloc_count++,
1332                              /* symindex= */ indx, R_MICROBLAZE_TLSDTPREL32,
1333                              got_offset, indx ? 0 : static_value);
1334                         else
1335                           bfd_put_32 (output_bfd, static_value,
1336                                       htab->elf.sgot->contents + off2);
1337                       }
1338                     else
1339                       {
1340                         bfd_put_32 (output_bfd, static_value,
1341                                     htab->elf.sgot->contents + off2);
1342
1343                         /* Relocs for dyn symbols generated by
1344                            finish_dynamic_symbols */
1345                         if (bfd_link_pic (info) && h == NULL)
1346                           {
1347                             *offp |= 1;
1348                             microblaze_elf_output_dynamic_relocation
1349                               (output_bfd,
1350                                htab->elf.srelgot,
1351                                htab->elf.srelgot->reloc_count++,
1352                                /* symindex= */ indx, R_MICROBLAZE_REL,
1353                                got_offset, static_value);
1354                           }
1355                       }
1356                   }
1357
1358                 /* 4. Fixup Relocation with GOT offset value
1359                       Compute relative address of GOT entry for applying
1360                       the current relocation */
1361                 relocation = htab->elf.sgot->output_section->vma
1362                              + htab->elf.sgot->output_offset
1363                              + off
1364                              - htab->elf.sgotplt->output_section->vma
1365                              - htab->elf.sgotplt->output_offset;
1366
1367                 /* Apply Current Relocation */
1368                 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1369                             contents + offset + endian);
1370                 bfd_put_16 (input_bfd, relocation & 0xffff,
1371                             contents + offset + endian + INST_WORD_SIZE);
1372
1373                 unresolved_reloc = FALSE;
1374                 break;
1375               }
1376
1377             case (int) R_MICROBLAZE_GOTOFF_64:
1378               {
1379                 bfd_vma immediate;
1380                 unsigned short lo, high;
1381                 relocation += addend;
1382                 relocation -= (htab->elf.sgotplt->output_section->vma
1383                                + htab->elf.sgotplt->output_offset);
1384                 /* Write this value into correct location.  */
1385                 immediate = relocation;
1386                 lo = immediate & 0x0000ffff;
1387                 high = (immediate >> 16) & 0x0000ffff;
1388                 bfd_put_16 (input_bfd, high, contents + offset + endian);
1389                 bfd_put_16 (input_bfd, lo,
1390                             contents + offset + INST_WORD_SIZE + endian);
1391                 break;
1392               }
1393
1394             case (int) R_MICROBLAZE_GOTOFF_32:
1395               {
1396                 relocation += addend;
1397                 relocation -= (htab->elf.sgotplt->output_section->vma
1398                                + htab->elf.sgotplt->output_offset);
1399                 /* Write this value into correct location.  */
1400                 bfd_put_32 (input_bfd, relocation, contents + offset);
1401                 break;
1402               }
1403
1404             case (int) R_MICROBLAZE_TLSDTPREL64:
1405               relocation += addend;
1406               relocation -= dtprel_base(info);
1407               bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1408                           contents + offset + 2);
1409               bfd_put_16 (input_bfd, relocation & 0xffff,
1410                           contents + offset + 2 + INST_WORD_SIZE);
1411               break;
1412             case (int) R_MICROBLAZE_64_PCREL :
1413             case (int) R_MICROBLAZE_64:
1414             case (int) R_MICROBLAZE_32:
1415               {
1416                 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
1417                    from removed linkonce sections, or sections discarded by
1418                    a linker script.  */
1419                 if (r_symndx == STN_UNDEF || (input_section->flags & SEC_ALLOC) == 0)
1420                   {
1421                     relocation += addend;
1422                     if (r_type == R_MICROBLAZE_32)
1423                       bfd_put_32 (input_bfd, relocation, contents + offset);
1424                     else
1425                       {
1426                         if (r_type == R_MICROBLAZE_64_PCREL)
1427                           relocation -= (input_section->output_section->vma
1428                                          + input_section->output_offset
1429                                          + offset + INST_WORD_SIZE);
1430                         bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1431                                     contents + offset + endian);
1432                         bfd_put_16 (input_bfd, relocation & 0xffff,
1433                                     contents + offset + endian + INST_WORD_SIZE);
1434                       }
1435                     break;
1436                   }
1437
1438                 if ((bfd_link_pic (info)
1439                      && (h == NULL
1440                          || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1441                              && !resolved_to_zero)
1442                          || h->root.type != bfd_link_hash_undefweak)
1443                      && (!howto->pc_relative
1444                          || (h != NULL
1445                              && h->dynindx != -1
1446                              && (!info->symbolic
1447                                  || !h->def_regular))))
1448                     || (!bfd_link_pic (info)
1449                         && h != NULL
1450                         && h->dynindx != -1
1451                         && !h->non_got_ref
1452                         && ((h->def_dynamic
1453                              && !h->def_regular)
1454                             || h->root.type == bfd_link_hash_undefweak
1455                             || h->root.type == bfd_link_hash_undefined)))
1456                   {
1457                     Elf_Internal_Rela outrel;
1458                     bfd_byte *loc;
1459                     bfd_boolean skip;
1460
1461                     /* When generating a shared object, these relocations
1462                        are copied into the output file to be resolved at run
1463                        time.  */
1464
1465                     BFD_ASSERT (sreloc != NULL);
1466
1467                     skip = FALSE;
1468
1469                     outrel.r_offset =
1470                       _bfd_elf_section_offset (output_bfd, info, input_section,
1471                                                rel->r_offset);
1472                     if (outrel.r_offset == (bfd_vma) -1)
1473                       skip = TRUE;
1474                     else if (outrel.r_offset == (bfd_vma) -2)
1475                       skip = TRUE;
1476                     outrel.r_offset += (input_section->output_section->vma
1477                                         + input_section->output_offset);
1478
1479                     if (skip)
1480                       memset (&outrel, 0, sizeof outrel);
1481                     /* h->dynindx may be -1 if the symbol was marked to
1482                        become local.  */
1483                     else if (h != NULL
1484                              && ((! info->symbolic && h->dynindx != -1)
1485                                  || !h->def_regular))
1486                       {
1487                         BFD_ASSERT (h->dynindx != -1);
1488                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1489                         outrel.r_addend = addend;
1490                       }
1491                     else
1492                       {
1493                         if (r_type == R_MICROBLAZE_32)
1494                           {
1495                             outrel.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
1496                             outrel.r_addend = relocation + addend;
1497                           }
1498                         else
1499                           {
1500                             BFD_FAIL ();
1501                             _bfd_error_handler
1502                               (_("%B: probably compiled without -fPIC?"),
1503                                input_bfd);
1504                             bfd_set_error (bfd_error_bad_value);
1505                             return FALSE;
1506                           }
1507                       }
1508
1509                     loc = sreloc->contents;
1510                     loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1511                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1512                     break;
1513                   }
1514                 else
1515                   {
1516                     relocation += addend;
1517                     if (r_type == R_MICROBLAZE_32)
1518                       bfd_put_32 (input_bfd, relocation, contents + offset);
1519                     else
1520                       {
1521                         if (r_type == R_MICROBLAZE_64_PCREL)
1522                           relocation -= (input_section->output_section->vma
1523                                          + input_section->output_offset
1524                                          + offset + INST_WORD_SIZE);
1525                         bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1526                                     contents + offset + endian);
1527                         bfd_put_16 (input_bfd, relocation & 0xffff,
1528                                     contents + offset + endian + INST_WORD_SIZE);
1529                       }
1530                     break;
1531                   }
1532               }
1533
1534             default :
1535               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1536                                             contents, offset,
1537                                             relocation, addend);
1538               break;
1539             }
1540         }
1541
1542     check_reloc:
1543
1544       if (r != bfd_reloc_ok)
1545         {
1546           /* FIXME: This should be generic enough to go in a utility.  */
1547           const char *name;
1548
1549           if (h != NULL)
1550             name = h->root.root.string;
1551           else
1552             {
1553               name = (bfd_elf_string_from_elf_section
1554                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1555               if (name == NULL || *name == '\0')
1556                 name = bfd_section_name (input_bfd, sec);
1557             }
1558
1559           if (errmsg != NULL)
1560             goto common_error;
1561
1562           switch (r)
1563             {
1564             case bfd_reloc_overflow:
1565               (*info->callbacks->reloc_overflow)
1566                 (info, (h ? &h->root : NULL), name, howto->name,
1567                  (bfd_vma) 0, input_bfd, input_section, offset);
1568               break;
1569
1570             case bfd_reloc_undefined:
1571               (*info->callbacks->undefined_symbol)
1572                 (info, name, input_bfd, input_section, offset, TRUE);
1573               break;
1574
1575             case bfd_reloc_outofrange:
1576               errmsg = _("internal error: out of range error");
1577               goto common_error;
1578
1579             case bfd_reloc_notsupported:
1580               errmsg = _("internal error: unsupported relocation error");
1581               goto common_error;
1582
1583             case bfd_reloc_dangerous:
1584               errmsg = _("internal error: dangerous error");
1585               goto common_error;
1586
1587             default:
1588               errmsg = _("internal error: unknown error");
1589               /* Fall through.  */
1590             common_error:
1591               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
1592                                            input_section, offset);
1593               break;
1594             }
1595         }
1596     }
1597
1598   return ret;
1599 }
1600 \f
1601 /* Calculate fixup value for reference.  */
1602
1603 static int
1604 calc_fixup (bfd_vma start, bfd_vma size, asection *sec)
1605 {
1606   bfd_vma end = start + size;
1607   int i, fixup = 0;
1608
1609   if (sec == NULL || sec->relax == NULL)
1610     return 0;
1611
1612   /* Look for addr in relax table, total fixup value.  */
1613   for (i = 0; i < sec->relax_count; i++)
1614     {
1615       if (end <= sec->relax[i].addr)
1616         break;
1617       if ((end != start) && (start > sec->relax[i].addr))
1618         continue;
1619       fixup += sec->relax[i].size;
1620     }
1621   return fixup;
1622 }
1623
1624 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1625    a 32-bit instruction.  */
1626 static void
1627 microblaze_bfd_write_imm_value_32 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1628 {
1629     unsigned long instr = bfd_get_32 (abfd, bfd_addr);
1630     instr &= ~0x0000ffff;
1631     instr |= (val & 0x0000ffff);
1632     bfd_put_32 (abfd, instr, bfd_addr);
1633 }
1634
1635 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1636    two consecutive 32-bit instructions.  */
1637 static void
1638 microblaze_bfd_write_imm_value_64 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1639 {
1640     unsigned long instr_hi;
1641     unsigned long instr_lo;
1642
1643     instr_hi = bfd_get_32 (abfd, bfd_addr);
1644     instr_hi &= ~0x0000ffff;
1645     instr_hi |= ((val >> 16) & 0x0000ffff);
1646     bfd_put_32 (abfd, instr_hi, bfd_addr);
1647
1648     instr_lo = bfd_get_32 (abfd, bfd_addr + INST_WORD_SIZE);
1649     instr_lo &= ~0x0000ffff;
1650     instr_lo |= (val & 0x0000ffff);
1651     bfd_put_32 (abfd, instr_lo, bfd_addr + INST_WORD_SIZE);
1652 }
1653
1654 static bfd_boolean
1655 microblaze_elf_relax_section (bfd *abfd,
1656                               asection *sec,
1657                               struct bfd_link_info *link_info,
1658                               bfd_boolean *again)
1659 {
1660   Elf_Internal_Shdr *symtab_hdr;
1661   Elf_Internal_Rela *internal_relocs;
1662   Elf_Internal_Rela *free_relocs = NULL;
1663   Elf_Internal_Rela *irel, *irelend;
1664   bfd_byte *contents = NULL;
1665   bfd_byte *free_contents = NULL;
1666   int rel_count;
1667   unsigned int shndx;
1668   int i, sym_index;
1669   asection *o;
1670   struct elf_link_hash_entry *sym_hash;
1671   Elf_Internal_Sym *isymbuf, *isymend;
1672   Elf_Internal_Sym *isym;
1673   int symcount;
1674   int offset;
1675   bfd_vma src, dest;
1676
1677   /* We only do this once per section.  We may be able to delete some code
1678      by running multiple passes, but it is not worth it.  */
1679   *again = FALSE;
1680
1681   /* Only do this for a text section.  */
1682   if (bfd_link_relocatable (link_info)
1683       || (sec->flags & SEC_RELOC) == 0
1684       || (sec->reloc_count == 0)
1685       || (sec->flags & SEC_CODE) == 0)
1686     return TRUE;
1687
1688   BFD_ASSERT ((sec->size > 0) || (sec->rawsize > 0));
1689
1690   /* If this is the first time we have been called for this section,
1691      initialize the cooked size.  */
1692   if (sec->size == 0)
1693     sec->size = sec->rawsize;
1694
1695   /* Get symbols for this section.  */
1696   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1697   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1698   symcount =  symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1699   if (isymbuf == NULL)
1700     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, symcount,
1701                                     0, NULL, NULL, NULL);
1702   BFD_ASSERT (isymbuf != NULL);
1703
1704   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1705   if (internal_relocs == NULL)
1706     goto error_return;
1707   if (! link_info->keep_memory)
1708     free_relocs = internal_relocs;
1709
1710   sec->relax = (struct relax_table *) bfd_malloc ((sec->reloc_count + 1)
1711                                                   * sizeof (struct relax_table));
1712   if (sec->relax == NULL)
1713     goto error_return;
1714   sec->relax_count = 0;
1715
1716   irelend = internal_relocs + sec->reloc_count;
1717   rel_count = 0;
1718   for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1719     {
1720       bfd_vma symval;
1721       if ((ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64_PCREL)
1722           && (ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64 ))
1723         continue; /* Can't delete this reloc.  */
1724
1725       /* Get the section contents.  */
1726       if (contents == NULL)
1727         {
1728           if (elf_section_data (sec)->this_hdr.contents != NULL)
1729             contents = elf_section_data (sec)->this_hdr.contents;
1730           else
1731             {
1732               contents = (bfd_byte *) bfd_malloc (sec->size);
1733               if (contents == NULL)
1734                 goto error_return;
1735               free_contents = contents;
1736
1737               if (!bfd_get_section_contents (abfd, sec, contents,
1738                                              (file_ptr) 0, sec->size))
1739                 goto error_return;
1740               elf_section_data (sec)->this_hdr.contents = contents;
1741             }
1742         }
1743
1744       /* Get the value of the symbol referred to by the reloc.  */
1745       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1746         {
1747           /* A local symbol.  */
1748           asection *sym_sec;
1749
1750           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1751           if (isym->st_shndx == SHN_UNDEF)
1752             sym_sec = bfd_und_section_ptr;
1753           else if (isym->st_shndx == SHN_ABS)
1754             sym_sec = bfd_abs_section_ptr;
1755           else if (isym->st_shndx == SHN_COMMON)
1756             sym_sec = bfd_com_section_ptr;
1757           else
1758             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1759
1760           symval = _bfd_elf_rela_local_sym (abfd, isym, &sym_sec, irel);
1761         }
1762       else
1763         {
1764           unsigned long indx;
1765           struct elf_link_hash_entry *h;
1766
1767           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1768           h = elf_sym_hashes (abfd)[indx];
1769           BFD_ASSERT (h != NULL);
1770
1771           if (h->root.type != bfd_link_hash_defined
1772               && h->root.type != bfd_link_hash_defweak)
1773             /* This appears to be a reference to an undefined
1774                symbol.  Just ignore it--it will be caught by the
1775                regular reloc processing.  */
1776             continue;
1777
1778           symval = (h->root.u.def.value
1779                     + h->root.u.def.section->output_section->vma
1780                     + h->root.u.def.section->output_offset);
1781         }
1782
1783       /* If this is a PC-relative reloc, subtract the instr offset from
1784          the symbol value.  */
1785       if (ELF32_R_TYPE (irel->r_info) == (int) R_MICROBLAZE_64_PCREL)
1786         {
1787           symval = symval + irel->r_addend
1788             - (irel->r_offset
1789                + sec->output_section->vma
1790                + sec->output_offset);
1791         }
1792       else
1793         symval += irel->r_addend;
1794
1795       if ((symval & 0xffff8000) == 0
1796           || (symval & 0xffff8000) == 0xffff8000)
1797         {
1798           /* We can delete this instruction.  */
1799           sec->relax[sec->relax_count].addr = irel->r_offset;
1800           sec->relax[sec->relax_count].size = INST_WORD_SIZE;
1801           sec->relax_count++;
1802
1803           /* Rewrite relocation type.  */
1804           switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1805             {
1806             case R_MICROBLAZE_64_PCREL:
1807               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1808                                            (int) R_MICROBLAZE_32_PCREL_LO);
1809               break;
1810             case R_MICROBLAZE_64:
1811               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1812                                            (int) R_MICROBLAZE_32_LO);
1813               break;
1814             default:
1815               /* Cannot happen.  */
1816               BFD_ASSERT (FALSE);
1817             }
1818         }
1819     } /* Loop through all relocations.  */
1820
1821   /* Loop through the relocs again, and see if anything needs to change.  */
1822   if (sec->relax_count > 0)
1823     {
1824       shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1825       rel_count = 0;
1826       sec->relax[sec->relax_count].addr = sec->size;
1827
1828       for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1829         {
1830           bfd_vma nraddr;
1831
1832           /* Get the new reloc address.  */
1833           nraddr = irel->r_offset - calc_fixup (irel->r_offset, 0, sec);
1834           switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1835             {
1836             default:
1837               break;
1838             case R_MICROBLAZE_64_PCREL:
1839               break;
1840             case R_MICROBLAZE_64:
1841             case R_MICROBLAZE_32_LO:
1842               /* If this reloc is against a symbol defined in this
1843                  section, we must check the addend to see it will put the value in
1844                  range to be adjusted, and hence must be changed.  */
1845               if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1846                 {
1847                   isym = isymbuf + ELF32_R_SYM (irel->r_info);
1848                   /* Only handle relocs against .text.  */
1849                   if (isym->st_shndx == shndx
1850                       && ELF32_ST_TYPE (isym->st_info) == STT_SECTION)
1851                     irel->r_addend -= calc_fixup (irel->r_addend, 0, sec);
1852                 }
1853               break;
1854             case R_MICROBLAZE_NONE:
1855               {
1856                 /* This was a PC-relative instruction that was
1857                    completely resolved.  */
1858                 int sfix, efix;
1859                 bfd_vma target_address;
1860                 target_address = irel->r_addend + irel->r_offset;
1861                 sfix = calc_fixup (irel->r_offset, 0, sec);
1862                 efix = calc_fixup (target_address, 0, sec);
1863                 irel->r_addend -= (efix - sfix);
1864                 /* Should use HOWTO.  */
1865                 microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset,
1866                                                    irel->r_addend);
1867               }
1868               break;
1869             case R_MICROBLAZE_64_NONE:
1870               {
1871                 /* This was a PC-relative 64-bit instruction that was
1872                    completely resolved.  */
1873                 int sfix, efix;
1874                 bfd_vma target_address;
1875                 target_address = irel->r_addend + irel->r_offset + INST_WORD_SIZE;
1876                 sfix = calc_fixup (irel->r_offset + INST_WORD_SIZE, 0, sec);
1877                 efix = calc_fixup (target_address, 0, sec);
1878                 irel->r_addend -= (efix - sfix);
1879     microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset
1880                                        + INST_WORD_SIZE, irel->r_addend);
1881               }
1882               break;
1883             }
1884           irel->r_offset = nraddr;
1885         } /* Change all relocs in this section.  */
1886
1887       /* Look through all other sections.  */
1888       for (o = abfd->sections; o != NULL; o = o->next)
1889         {
1890           Elf_Internal_Rela *irelocs;
1891           Elf_Internal_Rela *irelscan, *irelscanend;
1892           bfd_byte *ocontents;
1893
1894           if (o == sec
1895               || (o->flags & SEC_RELOC) == 0
1896               || o->reloc_count == 0)
1897             continue;
1898
1899           /* We always cache the relocs.  Perhaps, if info->keep_memory is
1900              FALSE, we should free them, if we are permitted to.  */
1901
1902           irelocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, TRUE);
1903           if (irelocs == NULL)
1904             goto error_return;
1905
1906           ocontents = NULL;
1907           irelscanend = irelocs + o->reloc_count;
1908           for (irelscan = irelocs; irelscan < irelscanend; irelscan++)
1909             {
1910               if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32)
1911                 {
1912                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1913
1914                   /* Look at the reloc only if the value has been resolved.  */
1915                   if (isym->st_shndx == shndx
1916                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1917                     {
1918                       if (ocontents == NULL)
1919                         {
1920                           if (elf_section_data (o)->this_hdr.contents != NULL)
1921                             ocontents = elf_section_data (o)->this_hdr.contents;
1922                           else
1923                             {
1924                               /* We always cache the section contents.
1925                                  Perhaps, if info->keep_memory is FALSE, we
1926                                  should free them, if we are permitted to.  */
1927                               if (o->rawsize == 0)
1928                                 o->rawsize = o->size;
1929                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1930                               if (ocontents == NULL)
1931                                 goto error_return;
1932                               if (!bfd_get_section_contents (abfd, o, ocontents,
1933                                                              (file_ptr) 0,
1934                                                              o->rawsize))
1935                                 goto error_return;
1936                               elf_section_data (o)->this_hdr.contents = ocontents;
1937                             }
1938
1939                         }
1940                       irelscan->r_addend -= calc_fixup (irelscan->r_addend, 0, sec);
1941                     }
1942                   else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_SYM_OP_SYM)
1943                     {
1944                       isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1945
1946                       /* Look at the reloc only if the value has been resolved.  */
1947                       if (ocontents == NULL)
1948                         {
1949                           if (elf_section_data (o)->this_hdr.contents != NULL)
1950                             ocontents = elf_section_data (o)->this_hdr.contents;
1951                           else
1952                             {
1953                               /* We always cache the section contents.
1954                                  Perhaps, if info->keep_memory is FALSE, we
1955                                  should free them, if we are permitted to.  */
1956
1957                               if (o->rawsize == 0)
1958                                 o->rawsize = o->size;
1959                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1960                               if (ocontents == NULL)
1961                                 goto error_return;
1962                               if (!bfd_get_section_contents (abfd, o, ocontents,
1963                                                              (file_ptr) 0,
1964                                                              o->rawsize))
1965                                 goto error_return;
1966                               elf_section_data (o)->this_hdr.contents = ocontents;
1967                             }
1968                         }
1969                       irelscan->r_addend -= calc_fixup (irel->r_addend
1970                                                         + isym->st_value,
1971                                                         0,
1972                                                         sec);
1973                     }
1974                 }
1975               else if ((ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_PCREL_LO)
1976                        || (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_LO))
1977                 {
1978                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1979
1980                   /* Look at the reloc only if the value has been resolved.  */
1981                   if (isym->st_shndx == shndx
1982                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1983                     {
1984                       bfd_vma immediate;
1985                       bfd_vma target_address;
1986
1987                       if (ocontents == NULL)
1988                         {
1989                           if (elf_section_data (o)->this_hdr.contents != NULL)
1990                             ocontents = elf_section_data (o)->this_hdr.contents;
1991                           else
1992                             {
1993                               /* We always cache the section contents.
1994                                  Perhaps, if info->keep_memory is FALSE, we
1995                                  should free them, if we are permitted to.  */
1996                               if (o->rawsize == 0)
1997                                 o->rawsize = o->size;
1998                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1999                               if (ocontents == NULL)
2000                                 goto error_return;
2001                               if (!bfd_get_section_contents (abfd, o, ocontents,
2002                                                              (file_ptr) 0,
2003                                                              o->rawsize))
2004                                 goto error_return;
2005                               elf_section_data (o)->this_hdr.contents = ocontents;
2006                             }
2007                         }
2008
2009                       unsigned long instr = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
2010                       immediate = instr & 0x0000ffff;
2011                       target_address = immediate;
2012                       offset = calc_fixup (target_address, 0, sec);
2013                       immediate -= offset;
2014                       irelscan->r_addend -= offset;
2015           microblaze_bfd_write_imm_value_32 (abfd, ocontents + irelscan->r_offset,
2016                                              irelscan->r_addend);
2017                     }
2018                 }
2019
2020               if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64)
2021                 {
2022                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2023
2024                   /* Look at the reloc only if the value has been resolved.  */
2025                   if (isym->st_shndx == shndx
2026                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2027                     {
2028                       bfd_vma immediate;
2029
2030                       if (ocontents == NULL)
2031                         {
2032                           if (elf_section_data (o)->this_hdr.contents != NULL)
2033                             ocontents = elf_section_data (o)->this_hdr.contents;
2034                           else
2035                             {
2036                               /* We always cache the section contents.
2037                                  Perhaps, if info->keep_memory is FALSE, we
2038                                  should free them, if we are permitted to.  */
2039
2040                               if (o->rawsize == 0)
2041                                 o->rawsize = o->size;
2042                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2043                               if (ocontents == NULL)
2044                                 goto error_return;
2045                               if (!bfd_get_section_contents (abfd, o, ocontents,
2046                                                              (file_ptr) 0,
2047                                                              o->rawsize))
2048                                 goto error_return;
2049                               elf_section_data (o)->this_hdr.contents = ocontents;
2050                             }
2051                         }
2052           unsigned long instr_hi =  bfd_get_32 (abfd, ocontents
2053                                                 + irelscan->r_offset);
2054           unsigned long instr_lo =  bfd_get_32 (abfd, ocontents
2055                                                 + irelscan->r_offset
2056                                                 + INST_WORD_SIZE);
2057           immediate = (instr_hi & 0x0000ffff) << 16;
2058           immediate |= (instr_lo & 0x0000ffff);
2059                       offset = calc_fixup (irelscan->r_addend, 0, sec);
2060                       immediate -= offset;
2061                       irelscan->r_addend -= offset;
2062                     }
2063                 }
2064               else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64_PCREL)
2065                 {
2066                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2067
2068                   /* Look at the reloc only if the value has been resolved.  */
2069                   if (isym->st_shndx == shndx
2070                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2071                     {
2072                       bfd_vma immediate;
2073                       bfd_vma target_address;
2074
2075                       if (ocontents == NULL)
2076                         {
2077                           if (elf_section_data (o)->this_hdr.contents != NULL)
2078                             ocontents = elf_section_data (o)->this_hdr.contents;
2079                           else
2080                             {
2081                               /* We always cache the section contents.
2082                                  Perhaps, if info->keep_memory is FALSE, we
2083                                  should free them, if we are permitted to.  */
2084                               if (o->rawsize == 0)
2085                                 o->rawsize = o->size;
2086                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2087                               if (ocontents == NULL)
2088                                 goto error_return;
2089                               if (!bfd_get_section_contents (abfd, o, ocontents,
2090                                                              (file_ptr) 0,
2091                                                              o->rawsize))
2092                                 goto error_return;
2093                               elf_section_data (o)->this_hdr.contents = ocontents;
2094                             }
2095                         }
2096           unsigned long instr_hi =  bfd_get_32 (abfd, ocontents
2097                                                 + irelscan->r_offset);
2098           unsigned long instr_lo =  bfd_get_32 (abfd, ocontents
2099                                                 + irelscan->r_offset
2100                                                 + INST_WORD_SIZE);
2101           immediate = (instr_hi & 0x0000ffff) << 16;
2102           immediate |= (instr_lo & 0x0000ffff);
2103                       target_address = immediate;
2104                       offset = calc_fixup (target_address, 0, sec);
2105                       immediate -= offset;
2106                       irelscan->r_addend -= offset;
2107           microblaze_bfd_write_imm_value_64 (abfd, ocontents
2108                                              + irelscan->r_offset, immediate);
2109                     }
2110                 }
2111             }
2112         }
2113
2114       /* Adjust the local symbols defined in this section.  */
2115       isymend = isymbuf + symtab_hdr->sh_info;
2116       for (isym = isymbuf; isym < isymend; isym++)
2117         {
2118           if (isym->st_shndx == shndx)
2119             {
2120               isym->st_value -= calc_fixup (isym->st_value, 0, sec);
2121               if (isym->st_size)
2122                 isym->st_size -= calc_fixup (isym->st_value, isym->st_size, sec);
2123             }
2124         }
2125
2126       /* Now adjust the global symbols defined in this section.  */
2127       isym = isymbuf + symtab_hdr->sh_info;
2128       symcount =  (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)) - symtab_hdr->sh_info;
2129       for (sym_index = 0; sym_index < symcount; sym_index++)
2130         {
2131           sym_hash = elf_sym_hashes (abfd)[sym_index];
2132           if ((sym_hash->root.type == bfd_link_hash_defined
2133                   || sym_hash->root.type == bfd_link_hash_defweak)
2134               && sym_hash->root.u.def.section == sec)
2135             {
2136               sym_hash->root.u.def.value -= calc_fixup (sym_hash->root.u.def.value,
2137                                                         0, sec);
2138               if (sym_hash->size)
2139                 sym_hash->size -= calc_fixup (sym_hash->root.u.def.value,
2140                                               sym_hash->size, sec);
2141             }
2142         }
2143
2144       /* Physically move the code and change the cooked size.  */
2145       dest = sec->relax[0].addr;
2146       for (i = 0; i < sec->relax_count; i++)
2147         {
2148           int len;
2149           src = sec->relax[i].addr + sec->relax[i].size;
2150           len = sec->relax[i+1].addr - sec->relax[i].addr - sec->relax[i].size;
2151
2152           memmove (contents + dest, contents + src, len);
2153           sec->size -= sec->relax[i].size;
2154           dest += len;
2155         }
2156
2157       elf_section_data (sec)->relocs = internal_relocs;
2158       free_relocs = NULL;
2159
2160       elf_section_data (sec)->this_hdr.contents = contents;
2161       free_contents = NULL;
2162
2163       symtab_hdr->contents = (bfd_byte *) isymbuf;
2164     }
2165
2166   if (free_relocs != NULL)
2167     {
2168       free (free_relocs);
2169       free_relocs = NULL;
2170     }
2171
2172   if (free_contents != NULL)
2173     {
2174       if (!link_info->keep_memory)
2175         free (free_contents);
2176       else
2177         /* Cache the section contents for elf_link_input_bfd.  */
2178         elf_section_data (sec)->this_hdr.contents = contents;
2179       free_contents = NULL;
2180     }
2181
2182   if (sec->relax_count == 0)
2183     {
2184       *again = FALSE;
2185       free (sec->relax);
2186       sec->relax = NULL;
2187     }
2188   else
2189     *again = TRUE;
2190   return TRUE;
2191
2192  error_return:
2193   if (free_relocs != NULL)
2194     free (free_relocs);
2195   if (free_contents != NULL)
2196     free (free_contents);
2197   if (sec->relax != NULL)
2198     {
2199       free (sec->relax);
2200       sec->relax = NULL;
2201       sec->relax_count = 0;
2202     }
2203   return FALSE;
2204 }
2205
2206 /* Return the section that should be marked against GC for a given
2207    relocation.  */
2208
2209 static asection *
2210 microblaze_elf_gc_mark_hook (asection *sec,
2211                              struct bfd_link_info * info,
2212                              Elf_Internal_Rela * rel,
2213                              struct elf_link_hash_entry * h,
2214                              Elf_Internal_Sym * sym)
2215 {
2216   if (h != NULL)
2217     switch (ELF32_R_TYPE (rel->r_info))
2218       {
2219       case R_MICROBLAZE_GNU_VTINHERIT:
2220       case R_MICROBLAZE_GNU_VTENTRY:
2221         return NULL;
2222       }
2223
2224   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2225 }
2226
2227 /* Update the got entry reference counts for the section being removed.  */
2228
2229 static bfd_boolean
2230 microblaze_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
2231                               struct bfd_link_info * info ATTRIBUTE_UNUSED,
2232                               asection * sec ATTRIBUTE_UNUSED,
2233                               const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
2234 {
2235   return TRUE;
2236 }
2237
2238 /* PIC support.  */
2239
2240 #define PLT_ENTRY_SIZE 16
2241
2242 #define PLT_ENTRY_WORD_0  0xb0000000          /* "imm 0".  */
2243 #define PLT_ENTRY_WORD_1  0xe9940000          /* "lwi r12,r20,0" - relocated to lwi r12,r20,func@GOT.  */
2244 #define PLT_ENTRY_WORD_1_NOPIC  0xe9800000    /* "lwi r12,r0,0" - non-PIC object.  */
2245 #define PLT_ENTRY_WORD_2  0x98186000          /* "brad r12".  */
2246 #define PLT_ENTRY_WORD_3  0x80000000          /* "nop".  */
2247
2248 static bfd_boolean
2249 update_local_sym_info (bfd *abfd,
2250                        Elf_Internal_Shdr *symtab_hdr,
2251                        unsigned long r_symndx,
2252                        unsigned int tls_type)
2253 {
2254   bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
2255   unsigned char *local_got_tls_masks;
2256
2257   if (local_got_refcounts == NULL)
2258     {
2259       bfd_size_type size = symtab_hdr->sh_info;
2260
2261       size *= (sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks));
2262       local_got_refcounts = bfd_zalloc (abfd, size);
2263       if (local_got_refcounts == NULL)
2264         return FALSE;
2265       elf_local_got_refcounts (abfd) = local_got_refcounts;
2266     }
2267
2268   local_got_tls_masks =
2269          (unsigned char *) (local_got_refcounts + symtab_hdr->sh_info);
2270   local_got_tls_masks[r_symndx] |= tls_type;
2271   local_got_refcounts[r_symndx] += 1;
2272
2273   return TRUE;
2274 }
2275 /* Look through the relocs for a section during the first phase.  */
2276
2277 static bfd_boolean
2278 microblaze_elf_check_relocs (bfd * abfd,
2279                              struct bfd_link_info * info,
2280                              asection * sec,
2281                              const Elf_Internal_Rela * relocs)
2282 {
2283   Elf_Internal_Shdr *           symtab_hdr;
2284   struct elf_link_hash_entry ** sym_hashes;
2285   struct elf_link_hash_entry ** sym_hashes_end;
2286   const Elf_Internal_Rela *     rel;
2287   const Elf_Internal_Rela *     rel_end;
2288   struct elf32_mb_link_hash_table *htab;
2289   asection *sreloc = NULL;
2290
2291   if (bfd_link_relocatable (info))
2292     return TRUE;
2293
2294   htab = elf32_mb_hash_table (info);
2295   if (htab == NULL)
2296     return FALSE;
2297
2298   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2299   sym_hashes = elf_sym_hashes (abfd);
2300   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2301   if (!elf_bad_symtab (abfd))
2302     sym_hashes_end -= symtab_hdr->sh_info;
2303
2304   rel_end = relocs + sec->reloc_count;
2305
2306   for (rel = relocs; rel < rel_end; rel++)
2307     {
2308       unsigned int r_type;
2309       struct elf_link_hash_entry * h;
2310       unsigned long r_symndx;
2311       unsigned char tls_type = 0;
2312
2313       r_symndx = ELF32_R_SYM (rel->r_info);
2314       r_type = ELF32_R_TYPE (rel->r_info);
2315
2316       if (r_symndx < symtab_hdr->sh_info)
2317         h = NULL;
2318       else
2319         {
2320           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
2321
2322           /* PR15323, ref flags aren't set for references in the same
2323              object.  */
2324           h->root.non_ir_ref_regular = 1;
2325         }
2326
2327       switch (r_type)
2328         {
2329           /* This relocation describes the C++ object vtable hierarchy.
2330              Reconstruct it for later use during GC.  */
2331         case R_MICROBLAZE_GNU_VTINHERIT:
2332           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2333             return FALSE;
2334           break;
2335
2336           /* This relocation describes which C++ vtable entries are actually
2337              used.  Record for later use during GC.  */
2338         case R_MICROBLAZE_GNU_VTENTRY:
2339           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2340             return FALSE;
2341           break;
2342
2343           /* This relocation requires .plt entry.  */
2344         case R_MICROBLAZE_PLT_64:
2345           if (h != NULL)
2346             {
2347               h->needs_plt = 1;
2348               h->plt.refcount += 1;
2349             }
2350           break;
2351
2352           /* This relocation requires .got entry.  */
2353         case R_MICROBLAZE_TLSGD:
2354           tls_type |= (TLS_TLS | TLS_GD);
2355           goto dogottls;
2356         case R_MICROBLAZE_TLSLD:
2357           tls_type |= (TLS_TLS | TLS_LD);
2358           /* Fall through.  */
2359         dogottls:
2360           sec->has_tls_reloc = 1;
2361           /* Fall through.  */
2362         case R_MICROBLAZE_GOT_64:
2363           if (htab->elf.sgot == NULL)
2364             {
2365               if (htab->elf.dynobj == NULL)
2366                 htab->elf.dynobj = abfd;
2367               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2368                 return FALSE;
2369             }
2370           if (h != NULL)
2371             {
2372               h->got.refcount += 1;
2373               elf32_mb_hash_entry (h)->tls_mask |= tls_type;
2374             }
2375           else
2376             {
2377               if (! update_local_sym_info(abfd, symtab_hdr, r_symndx, tls_type) )
2378                 return FALSE;
2379             }
2380           break;
2381
2382         case R_MICROBLAZE_GOTOFF_64:
2383         case R_MICROBLAZE_GOTOFF_32:
2384           if (htab->elf.sgot == NULL)
2385             {
2386               if (htab->elf.dynobj == NULL)
2387                 htab->elf.dynobj = abfd;
2388               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2389                 return FALSE;
2390             }
2391           break;
2392
2393         case R_MICROBLAZE_64:
2394         case R_MICROBLAZE_64_PCREL:
2395         case R_MICROBLAZE_32:
2396           {
2397             if (h != NULL && !bfd_link_pic (info))
2398               {
2399                 /* we may need a copy reloc.  */
2400                 h->non_got_ref = 1;
2401
2402                 /* we may also need a .plt entry.  */
2403                 h->plt.refcount += 1;
2404                 if (ELF32_R_TYPE (rel->r_info) != R_MICROBLAZE_64_PCREL)
2405                   h->pointer_equality_needed = 1;
2406               }
2407
2408
2409             /* If we are creating a shared library, and this is a reloc
2410                against a global symbol, or a non PC relative reloc
2411                against a local symbol, then we need to copy the reloc
2412                into the shared library.  However, if we are linking with
2413                -Bsymbolic, we do not need to copy a reloc against a
2414                global symbol which is defined in an object we are
2415                including in the link (i.e., DEF_REGULAR is set).  At
2416                this point we have not seen all the input files, so it is
2417                possible that DEF_REGULAR is not set now but will be set
2418                later (it is never cleared).  In case of a weak definition,
2419                DEF_REGULAR may be cleared later by a strong definition in
2420                a shared library.  We account for that possibility below by
2421                storing information in the relocs_copied field of the hash
2422                table entry.  A similar situation occurs when creating
2423                shared libraries and symbol visibility changes render the
2424                symbol local.
2425
2426                If on the other hand, we are creating an executable, we
2427                may need to keep relocations for symbols satisfied by a
2428                dynamic library if we manage to avoid copy relocs for the
2429                symbol.  */
2430
2431             if ((bfd_link_pic (info)
2432                  && (sec->flags & SEC_ALLOC) != 0
2433                  && (r_type != R_MICROBLAZE_64_PCREL
2434                      || (h != NULL
2435                          && (! info->symbolic
2436                              || h->root.type == bfd_link_hash_defweak
2437                              || !h->def_regular))))
2438                 || (!bfd_link_pic (info)
2439                     && (sec->flags & SEC_ALLOC) != 0
2440                     && h != NULL
2441                     && (h->root.type == bfd_link_hash_defweak
2442                         || !h->def_regular)))
2443               {
2444                 struct elf32_mb_dyn_relocs *p;
2445                 struct elf32_mb_dyn_relocs **head;
2446
2447                 /* When creating a shared object, we must copy these
2448                    relocs into the output file.  We create a reloc
2449                    section in dynobj and make room for the reloc.  */
2450
2451                 if (sreloc == NULL)
2452                   {
2453                     bfd *dynobj;
2454
2455                     if (htab->elf.dynobj == NULL)
2456                       htab->elf.dynobj = abfd;
2457                     dynobj = htab->elf.dynobj;
2458
2459                     sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
2460                                                                   2, abfd, 1);
2461                     if (sreloc == NULL)
2462                       return FALSE;
2463                   }
2464
2465                 /* If this is a global symbol, we count the number of
2466                    relocations we need for this symbol.  */
2467                 if (h != NULL)
2468                   head = &((struct elf32_mb_link_hash_entry *) h)->dyn_relocs;
2469                 else
2470                   {
2471                     /* Track dynamic relocs needed for local syms too.
2472                        We really need local syms available to do this
2473                        easily.  Oh well.  */
2474
2475                     asection *s;
2476                     Elf_Internal_Sym *isym;
2477                     void *vpp;
2478
2479                     isym = bfd_sym_from_r_symndx (&htab->sym_sec,
2480                                                   abfd, r_symndx);
2481                     if (isym == NULL)
2482                       return FALSE;
2483
2484                     s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2485                     if (s == NULL)
2486                       return FALSE;
2487
2488                     vpp = &elf_section_data (s)->local_dynrel;
2489                     head = (struct elf32_mb_dyn_relocs **) vpp;
2490                   }
2491
2492                 p = *head;
2493                 if (p == NULL || p->sec != sec)
2494                   {
2495                     bfd_size_type amt = sizeof *p;
2496                     p = ((struct elf32_mb_dyn_relocs *)
2497                          bfd_alloc (htab->elf.dynobj, amt));
2498                     if (p == NULL)
2499                       return FALSE;
2500                     p->next = *head;
2501                     *head = p;
2502                     p->sec = sec;
2503                     p->count = 0;
2504                     p->pc_count = 0;
2505                   }
2506
2507                 p->count += 1;
2508                 if (r_type == R_MICROBLAZE_64_PCREL)
2509                   p->pc_count += 1;
2510               }
2511           }
2512           break;
2513         }
2514     }
2515
2516   return TRUE;
2517 }
2518
2519 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2520
2521 static void
2522 microblaze_elf_copy_indirect_symbol (struct bfd_link_info *info,
2523                                      struct elf_link_hash_entry *dir,
2524                                      struct elf_link_hash_entry *ind)
2525 {
2526   struct elf32_mb_link_hash_entry *edir, *eind;
2527
2528   edir = (struct elf32_mb_link_hash_entry *) dir;
2529   eind = (struct elf32_mb_link_hash_entry *) ind;
2530
2531   if (eind->dyn_relocs != NULL)
2532     {
2533       if (edir->dyn_relocs != NULL)
2534         {
2535           struct elf32_mb_dyn_relocs **pp;
2536           struct elf32_mb_dyn_relocs *p;
2537
2538           if (ind->root.type == bfd_link_hash_indirect)
2539             abort ();
2540
2541           /* Add reloc counts against the weak sym to the strong sym
2542              list.  Merge any entries against the same section.  */
2543           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2544             {
2545               struct elf32_mb_dyn_relocs *q;
2546
2547               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2548                 if (q->sec == p->sec)
2549                   {
2550                     q->pc_count += p->pc_count;
2551                     q->count += p->count;
2552                     *pp = p->next;
2553                     break;
2554                   }
2555               if (q == NULL)
2556                 pp = &p->next;
2557             }
2558           *pp = edir->dyn_relocs;
2559         }
2560
2561       edir->dyn_relocs = eind->dyn_relocs;
2562       eind->dyn_relocs = NULL;
2563     }
2564
2565   edir->tls_mask |= eind->tls_mask;
2566
2567   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2568 }
2569
2570 static bfd_boolean
2571 microblaze_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2572                                       struct elf_link_hash_entry *h)
2573 {
2574   struct elf32_mb_link_hash_table *htab;
2575   struct elf32_mb_link_hash_entry * eh;
2576   struct elf32_mb_dyn_relocs *p;
2577   asection *s, *srel;
2578   unsigned int power_of_two;
2579
2580   htab = elf32_mb_hash_table (info);
2581   if (htab == NULL)
2582     return FALSE;
2583
2584   /* If this is a function, put it in the procedure linkage table.  We
2585      will fill in the contents of the procedure linkage table later,
2586      when we know the address of the .got section.  */
2587   if (h->type == STT_FUNC
2588       || h->needs_plt)
2589     {
2590       if (h->plt.refcount <= 0
2591           || SYMBOL_CALLS_LOCAL (info, h)
2592           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2593               && h->root.type == bfd_link_hash_undefweak))
2594         {
2595           /* This case can occur if we saw a PLT reloc in an input
2596              file, but the symbol was never referred to by a dynamic
2597              object, or if all references were garbage collected.  In
2598              such a case, we don't actually need to build a procedure
2599              linkage table, and we can just do a PC32 reloc instead.  */
2600           h->plt.offset = (bfd_vma) -1;
2601           h->needs_plt = 0;
2602         }
2603
2604       return TRUE;
2605     }
2606   else
2607     /* It's possible that we incorrectly decided a .plt reloc was
2608        needed for an R_MICROBLAZE_64_PCREL reloc to a non-function sym in
2609        check_relocs.  We can't decide accurately between function and
2610        non-function syms in check-relocs;  Objects loaded later in
2611        the link may change h->type.  So fix it now.  */
2612     h->plt.offset = (bfd_vma) -1;
2613
2614   /* If this is a weak symbol, and there is a real definition, the
2615      processor independent code will have arranged for us to see the
2616      real definition first, and we can just use the same value.  */
2617   if (h->u.weakdef != NULL)
2618     {
2619       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2620                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2621       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2622       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2623       return TRUE;
2624     }
2625
2626   /* This is a reference to a symbol defined by a dynamic object which
2627      is not a function.  */
2628
2629   /* If we are creating a shared library, we must presume that the
2630      only references to the symbol are via the global offset table.
2631      For such cases we need not do anything here; the relocations will
2632      be handled correctly by relocate_section.  */
2633   if (bfd_link_pic (info))
2634     return TRUE;
2635
2636   /* If there are no references to this symbol that do not use the
2637      GOT, we don't need to generate a copy reloc.  */
2638   if (!h->non_got_ref)
2639     return TRUE;
2640
2641   /* If -z nocopyreloc was given, we won't generate them either.  */
2642   if (info->nocopyreloc)
2643     {
2644       h->non_got_ref = 0;
2645       return TRUE;
2646     }
2647
2648   eh = (struct elf32_mb_link_hash_entry *) h;
2649   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2650     {
2651       s = p->sec->output_section;
2652       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2653         break;
2654     }
2655
2656   /* If we didn't find any dynamic relocs in read-only sections, then
2657      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2658   if (p == NULL)
2659     {
2660       h->non_got_ref = 0;
2661       return TRUE;
2662     }
2663
2664   /* We must allocate the symbol in our .dynbss section, which will
2665      become part of the .bss section of the executable.  There will be
2666      an entry for this symbol in the .dynsym section.  The dynamic
2667      object will contain position independent code, so all references
2668      from the dynamic object to this symbol will go through the global
2669      offset table.  The dynamic linker will use the .dynsym entry to
2670      determine the address it must put in the global offset table, so
2671      both the dynamic object and the regular object will refer to the
2672      same memory location for the variable.  */
2673
2674   /* We must generate a R_MICROBLAZE_COPY reloc to tell the dynamic linker
2675      to copy the initial value out of the dynamic object and into the
2676      runtime process image.  */
2677   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2678     {
2679       s = htab->elf.sdynrelro;
2680       srel = htab->elf.sreldynrelro;
2681     }
2682   else
2683     {
2684       s = htab->elf.sdynbss;
2685       srel = htab->elf.srelbss;
2686     }
2687   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2688     {
2689       srel->size += sizeof (Elf32_External_Rela);
2690       h->needs_copy = 1;
2691     }
2692
2693   /* We need to figure out the alignment required for this symbol.  I
2694      have no idea how ELF linkers handle this.  */
2695   power_of_two = bfd_log2 (h->size);
2696   if (power_of_two > 3)
2697     power_of_two = 3;
2698
2699   /* Apply the required alignment.  */
2700   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2701   if (power_of_two > s->alignment_power)
2702     {
2703       if (!bfd_set_section_alignment (s->owner, s, power_of_two))
2704         return FALSE;
2705     }
2706
2707   /* Define the symbol as being at this point in the section.  */
2708   h->root.u.def.section = s;
2709   h->root.u.def.value = s->size;
2710
2711   /* Increment the section size to make room for the symbol.  */
2712   s->size += h->size;
2713   return TRUE;
2714 }
2715
2716 /* Allocate space in .plt, .got and associated reloc sections for
2717    dynamic relocs.  */
2718
2719 static bfd_boolean
2720 allocate_dynrelocs (struct elf_link_hash_entry *h, void * dat)
2721 {
2722   struct bfd_link_info *info;
2723   struct elf32_mb_link_hash_table *htab;
2724   struct elf32_mb_link_hash_entry *eh;
2725   struct elf32_mb_dyn_relocs *p;
2726
2727   if (h->root.type == bfd_link_hash_indirect)
2728     return TRUE;
2729
2730   info = (struct bfd_link_info *) dat;
2731   htab = elf32_mb_hash_table (info);
2732   if (htab == NULL)
2733     return FALSE;
2734
2735   if (htab->elf.dynamic_sections_created
2736       && h->plt.refcount > 0)
2737     {
2738       /* Make sure this symbol is output as a dynamic symbol.
2739          Undefined weak syms won't yet be marked as dynamic.  */
2740       if (h->dynindx == -1
2741           && !h->forced_local)
2742         {
2743           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2744             return FALSE;
2745         }
2746
2747       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2748         {
2749           asection *s = htab->elf.splt;
2750
2751           /* The first entry in .plt is reserved.  */
2752           if (s->size == 0)
2753             s->size = PLT_ENTRY_SIZE;
2754
2755           h->plt.offset = s->size;
2756
2757           /* If this symbol is not defined in a regular file, and we are
2758              not generating a shared library, then set the symbol to this
2759              location in the .plt.  This is required to make function
2760              pointers compare as equal between the normal executable and
2761              the shared library.  */
2762           if (! bfd_link_pic (info)
2763               && !h->def_regular)
2764             {
2765               h->root.u.def.section = s;
2766               h->root.u.def.value = h->plt.offset;
2767             }
2768
2769           /* Make room for this entry.  */
2770           s->size += PLT_ENTRY_SIZE;
2771
2772           /* We also need to make an entry in the .got.plt section, which
2773              will be placed in the .got section by the linker script.  */
2774           htab->elf.sgotplt->size += 4;
2775
2776           /* We also need to make an entry in the .rel.plt section.  */
2777           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
2778         }
2779       else
2780         {
2781           h->plt.offset = (bfd_vma) -1;
2782           h->needs_plt = 0;
2783         }
2784     }
2785   else
2786     {
2787       h->plt.offset = (bfd_vma) -1;
2788       h->needs_plt = 0;
2789     }
2790
2791   eh = (struct elf32_mb_link_hash_entry *) h;
2792   if (h->got.refcount > 0)
2793     {
2794       unsigned int need;
2795       asection *s;
2796
2797       /* Make sure this symbol is output as a dynamic symbol.
2798          Undefined weak syms won't yet be marked as dynamic.  */
2799       if (h->dynindx == -1
2800           && !h->forced_local)
2801         {
2802           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2803             return FALSE;
2804         }
2805
2806       need = 0;
2807       if ((eh->tls_mask & TLS_TLS) != 0)
2808         {
2809           /* Handle TLS Symbol */
2810           if ((eh->tls_mask & TLS_LD) != 0)
2811             {
2812               if (!eh->elf.def_dynamic)
2813                 /* We'll just use htab->tlsld_got.offset.  This should
2814                    always be the case.  It's a little odd if we have
2815                    a local dynamic reloc against a non-local symbol.  */
2816                 htab->tlsld_got.refcount += 1;
2817               else
2818                 need += 8;
2819             }
2820           if ((eh->tls_mask & TLS_GD) != 0)
2821             need += 8;
2822         }
2823       else
2824         {
2825           /* Regular (non-TLS) symbol */
2826           need += 4;
2827         }
2828       if (need == 0)
2829         {
2830           h->got.offset = (bfd_vma) -1;
2831         }
2832       else
2833         {
2834           s = htab->elf.sgot;
2835           h->got.offset = s->size;
2836           s->size += need;
2837           htab->elf.srelgot->size += need * (sizeof (Elf32_External_Rela) / 4);
2838         }
2839     }
2840   else
2841     h->got.offset = (bfd_vma) -1;
2842
2843   if (eh->dyn_relocs == NULL)
2844     return TRUE;
2845
2846   /* In the shared -Bsymbolic case, discard space allocated for
2847      dynamic pc-relative relocs against symbols which turn out to be
2848      defined in regular objects.  For the normal shared case, discard
2849      space for pc-relative relocs that have become local due to symbol
2850      visibility changes.  */
2851
2852   if (bfd_link_pic (info))
2853     {
2854       if (h->def_regular
2855           && (h->forced_local
2856               || info->symbolic))
2857         {
2858           struct elf32_mb_dyn_relocs **pp;
2859
2860           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2861             {
2862               p->count -= p->pc_count;
2863               p->pc_count = 0;
2864               if (p->count == 0)
2865                 *pp = p->next;
2866               else
2867                 pp = &p->next;
2868             }
2869         }
2870       else if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2871         eh->dyn_relocs = NULL;
2872     }
2873   else
2874     {
2875       /* For the non-shared case, discard space for relocs against
2876          symbols which turn out to need copy relocs or are not
2877          dynamic.  */
2878
2879       if (!h->non_got_ref
2880           && ((h->def_dynamic
2881                && !h->def_regular)
2882               || (htab->elf.dynamic_sections_created
2883                   && (h->root.type == bfd_link_hash_undefweak
2884                       || h->root.type == bfd_link_hash_undefined))))
2885         {
2886           /* Make sure this symbol is output as a dynamic symbol.
2887              Undefined weak syms won't yet be marked as dynamic.  */
2888           if (h->dynindx == -1
2889               && !h->forced_local)
2890             {
2891               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2892                 return FALSE;
2893             }
2894
2895           /* If that succeeded, we know we'll be keeping all the
2896              relocs.  */
2897           if (h->dynindx != -1)
2898             goto keep;
2899         }
2900
2901       eh->dyn_relocs = NULL;
2902
2903     keep: ;
2904     }
2905
2906   /* Finally, allocate space.  */
2907   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2908     {
2909       asection *sreloc = elf_section_data (p->sec)->sreloc;
2910       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2911     }
2912
2913   return TRUE;
2914 }
2915
2916 /* Set the sizes of the dynamic sections.  */
2917
2918 static bfd_boolean
2919 microblaze_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2920                                       struct bfd_link_info *info)
2921 {
2922   struct elf32_mb_link_hash_table *htab;
2923   bfd *dynobj;
2924   asection *s;
2925   bfd *ibfd;
2926
2927   htab = elf32_mb_hash_table (info);
2928   if (htab == NULL)
2929     return FALSE;
2930
2931   dynobj = htab->elf.dynobj;
2932   BFD_ASSERT (dynobj != NULL);
2933
2934   /* Set up .got offsets for local syms, and space for local dynamic
2935      relocs.  */
2936   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2937     {
2938       bfd_signed_vma *local_got;
2939       bfd_signed_vma *end_local_got;
2940       bfd_size_type locsymcount;
2941       Elf_Internal_Shdr *symtab_hdr;
2942       unsigned char *lgot_masks;
2943       asection *srel;
2944
2945       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2946         continue;
2947
2948       for (s = ibfd->sections; s != NULL; s = s->next)
2949         {
2950           struct elf32_mb_dyn_relocs *p;
2951
2952           for (p = ((struct elf32_mb_dyn_relocs *)
2953                     elf_section_data (s)->local_dynrel);
2954                p != NULL;
2955                p = p->next)
2956             {
2957               if (!bfd_is_abs_section (p->sec)
2958                   && bfd_is_abs_section (p->sec->output_section))
2959                 {
2960                   /* Input section has been discarded, either because
2961                      it is a copy of a linkonce section or due to
2962                      linker script /DISCARD/, so we'll be discarding
2963                      the relocs too.  */
2964                 }
2965               else if (p->count != 0)
2966                 {
2967                   srel = elf_section_data (p->sec)->sreloc;
2968                   srel->size += p->count * sizeof (Elf32_External_Rela);
2969                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2970                     info->flags |= DF_TEXTREL;
2971                 }
2972             }
2973         }
2974
2975       local_got = elf_local_got_refcounts (ibfd);
2976       if (!local_got)
2977         continue;
2978
2979       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2980       locsymcount = symtab_hdr->sh_info;
2981       end_local_got = local_got + locsymcount;
2982       lgot_masks = (unsigned char *) end_local_got;
2983       s = htab->elf.sgot;
2984       srel = htab->elf.srelgot;
2985
2986       for (; local_got < end_local_got; ++local_got, ++lgot_masks)
2987         {
2988           if (*local_got > 0)
2989             {
2990               unsigned int need = 0;
2991               if ((*lgot_masks & TLS_TLS) != 0)
2992                 {
2993                   if ((*lgot_masks & TLS_GD) != 0)
2994                     need += 8;
2995                   if ((*lgot_masks & TLS_LD) != 0)
2996                     htab->tlsld_got.refcount += 1;
2997                 }
2998               else
2999                 need += 4;
3000
3001               if (need == 0)
3002                 {
3003                   *local_got = (bfd_vma) -1;
3004                 }
3005               else
3006                 {
3007                   *local_got = s->size;
3008                   s->size += need;
3009                   if (bfd_link_pic (info))
3010                     srel->size += need * (sizeof (Elf32_External_Rela) / 4);
3011                 }
3012             }
3013           else
3014             *local_got = (bfd_vma) -1;
3015         }
3016     }
3017
3018   /* Allocate global sym .plt and .got entries, and space for global
3019      sym dynamic relocs.  */
3020   elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
3021
3022   if (htab->tlsld_got.refcount > 0)
3023     {
3024       htab->tlsld_got.offset = htab->elf.sgot->size;
3025       htab->elf.sgot->size += 8;
3026       if (bfd_link_pic (info))
3027         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
3028     }
3029   else
3030     htab->tlsld_got.offset = (bfd_vma) -1;
3031
3032   if (elf_hash_table (info)->dynamic_sections_created)
3033     {
3034       /* Make space for the trailing nop in .plt.  */
3035       if (htab->elf.splt->size > 0)
3036         htab->elf.splt->size += 4;
3037     }
3038
3039   /* The check_relocs and adjust_dynamic_symbol entry points have
3040      determined the sizes of the various dynamic sections.  Allocate
3041      memory for them.  */
3042   for (s = dynobj->sections; s != NULL; s = s->next)
3043     {
3044       const char *name;
3045       bfd_boolean strip = FALSE;
3046
3047       if ((s->flags & SEC_LINKER_CREATED) == 0)
3048         continue;
3049
3050       /* It's OK to base decisions on the section name, because none
3051          of the dynobj section names depend upon the input files.  */
3052       name = bfd_get_section_name (dynobj, s);
3053
3054       if (strncmp (name, ".rela", 5) == 0)
3055         {
3056           if (s->size == 0)
3057             {
3058               /* If we don't need this section, strip it from the
3059                  output file.  This is to handle .rela.bss and
3060                  .rela.plt.  We must create it in
3061                  create_dynamic_sections, because it must be created
3062                  before the linker maps input sections to output
3063                  sections.  The linker does that before
3064                  adjust_dynamic_symbol is called, and it is that
3065                  function which decides whether anything needs to go
3066                  into these sections.  */
3067               strip = TRUE;
3068             }
3069           else
3070             {
3071               /* We use the reloc_count field as a counter if we need
3072                  to copy relocs into the output file.  */
3073               s->reloc_count = 0;
3074             }
3075         }
3076       else if (s != htab->elf.splt
3077                && s != htab->elf.sgot
3078                && s != htab->elf.sgotplt
3079                && s != htab->elf.sdynbss
3080                && s != htab->elf.sdynrelro)
3081         {
3082           /* It's not one of our sections, so don't allocate space.  */
3083           continue;
3084         }
3085
3086       if (strip)
3087         {
3088           s->flags |= SEC_EXCLUDE;
3089           continue;
3090         }
3091
3092       /* Allocate memory for the section contents.  */
3093       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3094          Unused entries should be reclaimed before the section's contents
3095          are written out, but at the moment this does not happen.  Thus in
3096          order to prevent writing out garbage, we initialise the section's
3097          contents to zero.  */
3098       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3099       if (s->contents == NULL && s->size != 0)
3100         return FALSE;
3101     }
3102
3103   if (elf_hash_table (info)->dynamic_sections_created)
3104     {
3105       /* Add some entries to the .dynamic section.  We fill in the
3106          values later, in microblaze_elf_finish_dynamic_sections, but we
3107          must add the entries now so that we get the correct size for
3108          the .dynamic section.  The DT_DEBUG entry is filled in by the
3109          dynamic linker and used by the debugger.  */
3110 #define add_dynamic_entry(TAG, VAL)                     \
3111       _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3112
3113       if (bfd_link_executable (info))
3114         {
3115           if (!add_dynamic_entry (DT_DEBUG, 0))
3116             return FALSE;
3117         }
3118
3119       if (!add_dynamic_entry (DT_RELA, 0)
3120           || !add_dynamic_entry (DT_RELASZ, 0)
3121           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3122         return FALSE;
3123
3124       if (htab->elf.splt->size != 0)
3125         {
3126           if (!add_dynamic_entry (DT_PLTGOT, 0)
3127               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3128               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3129               || !add_dynamic_entry (DT_JMPREL, 0)
3130               || !add_dynamic_entry (DT_BIND_NOW, 1))
3131             return FALSE;
3132         }
3133
3134       if (info->flags & DF_TEXTREL)
3135         {
3136           if (!add_dynamic_entry (DT_TEXTREL, 0))
3137             return FALSE;
3138         }
3139     }
3140 #undef add_dynamic_entry
3141   return TRUE;
3142 }
3143
3144 /* Finish up dynamic symbol handling.  We set the contents of various
3145    dynamic sections here.  */
3146
3147 static bfd_boolean
3148 microblaze_elf_finish_dynamic_symbol (bfd *output_bfd,
3149                                       struct bfd_link_info *info,
3150                                       struct elf_link_hash_entry *h,
3151                                       Elf_Internal_Sym *sym)
3152 {
3153   struct elf32_mb_link_hash_table *htab;
3154   struct elf32_mb_link_hash_entry *eh = elf32_mb_hash_entry(h);
3155
3156   htab = elf32_mb_hash_table (info);
3157   if (htab == NULL)
3158     return FALSE;
3159
3160   if (h->plt.offset != (bfd_vma) -1)
3161     {
3162       asection *splt;
3163       asection *srela;
3164       asection *sgotplt;
3165       Elf_Internal_Rela rela;
3166       bfd_byte *loc;
3167       bfd_vma plt_index;
3168       bfd_vma got_offset;
3169       bfd_vma got_addr;
3170
3171       /* This symbol has an entry in the procedure linkage table.  Set
3172          it up.  */
3173       BFD_ASSERT (h->dynindx != -1);
3174
3175       splt = htab->elf.splt;
3176       srela = htab->elf.srelplt;
3177       sgotplt = htab->elf.sgotplt;
3178       BFD_ASSERT (splt != NULL && srela != NULL && sgotplt != NULL);
3179
3180       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; /* first entry reserved.  */
3181       got_offset = (plt_index + 3) * 4; /* 3 reserved ???  */
3182       got_addr = got_offset;
3183
3184       /* For non-PIC objects we need absolute address of the GOT entry.  */
3185       if (!bfd_link_pic (info))
3186         got_addr += sgotplt->output_section->vma + sgotplt->output_offset;
3187
3188       /* Fill in the entry in the procedure linkage table.  */
3189       bfd_put_32 (output_bfd, PLT_ENTRY_WORD_0 + ((got_addr >> 16) & 0xffff),
3190                   splt->contents + h->plt.offset);
3191       if (bfd_link_pic (info))
3192         bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1 + (got_addr & 0xffff),
3193                     splt->contents + h->plt.offset + 4);
3194       else
3195         bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1_NOPIC + (got_addr & 0xffff),
3196                     splt->contents + h->plt.offset + 4);
3197       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_2,
3198                   splt->contents + h->plt.offset + 8);
3199       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_3,
3200                   splt->contents + h->plt.offset + 12);
3201
3202       /* Any additions to the .got section??? */
3203       /*      bfd_put_32 (output_bfd,
3204               splt->output_section->vma + splt->output_offset + h->plt.offset + 4,
3205               sgotplt->contents + got_offset); */
3206
3207       /* Fill in the entry in the .rela.plt section.  */
3208       rela.r_offset = (sgotplt->output_section->vma
3209                        + sgotplt->output_offset
3210                        + got_offset);
3211       rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_JUMP_SLOT);
3212       rela.r_addend = 0;
3213       loc = srela->contents;
3214       loc += plt_index * sizeof (Elf32_External_Rela);
3215       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3216
3217       if (!h->def_regular)
3218         {
3219           /* Mark the symbol as undefined, rather than as defined in
3220              the .plt section.  Zero the value.  */
3221           sym->st_shndx = SHN_UNDEF;
3222           sym->st_value = 0;
3223         }
3224     }
3225
3226   /* h->got.refcount to be checked ? */
3227   if (h->got.offset != (bfd_vma) -1 &&
3228       ! ((h->got.offset & 1) ||
3229           IS_TLS_LD(eh->tls_mask) || IS_TLS_GD(eh->tls_mask)))
3230     {
3231       asection *sgot;
3232       asection *srela;
3233       bfd_vma offset;
3234
3235       /* This symbol has an entry in the global offset table.  Set it
3236          up.  */
3237
3238       sgot = htab->elf.sgot;
3239       srela = htab->elf.srelgot;
3240       BFD_ASSERT (sgot != NULL && srela != NULL);
3241
3242       offset = (sgot->output_section->vma + sgot->output_offset
3243                 + (h->got.offset &~ (bfd_vma) 1));
3244
3245       /* If this is a -Bsymbolic link, and the symbol is defined
3246          locally, we just want to emit a RELATIVE reloc.  Likewise if
3247          the symbol was forced to be local because of a version file.
3248          The entry in the global offset table will already have been
3249          initialized in the relocate_section function.  */
3250       if (bfd_link_pic (info)
3251           && ((info->symbolic && h->def_regular)
3252               || h->dynindx == -1))
3253         {
3254           asection *sec = h->root.u.def.section;
3255           bfd_vma value;
3256
3257           value = h->root.u.def.value;
3258           if (sec->output_section != NULL)
3259             /* PR 21180: If the output section is NULL, then the symbol is no
3260                longer needed, and in theory the GOT entry is redundant.  But
3261                it is too late to change our minds now...  */
3262             value += sec->output_section->vma + sec->output_offset;
3263
3264           microblaze_elf_output_dynamic_relocation (output_bfd,
3265                                                     srela, srela->reloc_count++,
3266                                                     /* symindex= */ 0,
3267                                                     R_MICROBLAZE_REL, offset,
3268                                                     value);
3269         }
3270       else
3271         {
3272           microblaze_elf_output_dynamic_relocation (output_bfd,
3273                                                     srela, srela->reloc_count++,
3274                                                     h->dynindx,
3275                                                     R_MICROBLAZE_GLOB_DAT,
3276                                                     offset, 0);
3277         }
3278
3279       bfd_put_32 (output_bfd, (bfd_vma) 0,
3280                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3281     }
3282
3283   if (h->needs_copy)
3284     {
3285       asection *s;
3286       Elf_Internal_Rela rela;
3287       bfd_byte *loc;
3288
3289       /* This symbols needs a copy reloc.  Set it up.  */
3290
3291       BFD_ASSERT (h->dynindx != -1);
3292
3293       rela.r_offset = (h->root.u.def.value
3294                        + h->root.u.def.section->output_section->vma
3295                        + h->root.u.def.section->output_offset);
3296       rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_COPY);
3297       rela.r_addend = 0;
3298       if (h->root.u.def.section == htab->elf.sdynrelro)
3299         s = htab->elf.sreldynrelro;
3300       else
3301         s = htab->elf.srelbss;
3302       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3303       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3304     }
3305
3306   /* Mark some specially defined symbols as absolute.  */
3307   if (h == htab->elf.hdynamic
3308       || h == htab->elf.hgot
3309       || h == htab->elf.hplt)
3310     sym->st_shndx = SHN_ABS;
3311
3312   return TRUE;
3313 }
3314
3315
3316 /* Finish up the dynamic sections.  */
3317
3318 static bfd_boolean
3319 microblaze_elf_finish_dynamic_sections (bfd *output_bfd,
3320                                         struct bfd_link_info *info)
3321 {
3322   bfd *dynobj;
3323   asection *sdyn, *sgot;
3324   struct elf32_mb_link_hash_table *htab;
3325
3326   htab = elf32_mb_hash_table (info);
3327   if (htab == NULL)
3328     return FALSE;
3329
3330   dynobj = htab->elf.dynobj;
3331
3332   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3333
3334   if (htab->elf.dynamic_sections_created)
3335     {
3336       asection *splt;
3337       Elf32_External_Dyn *dyncon, *dynconend;
3338
3339       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3340       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3341       for (; dyncon < dynconend; dyncon++)
3342         {
3343           Elf_Internal_Dyn dyn;
3344           asection *s;
3345           bfd_boolean size;
3346
3347           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3348
3349           switch (dyn.d_tag)
3350             {
3351             case DT_PLTGOT:
3352               s = htab->elf.sgotplt;
3353               size = FALSE;
3354               break;
3355
3356             case DT_PLTRELSZ:
3357               s = htab->elf.srelplt;
3358               size = TRUE;
3359               break;
3360
3361             case DT_JMPREL:
3362               s = htab->elf.srelplt;
3363               size = FALSE;
3364               break;
3365
3366             default:
3367               continue;
3368             }
3369
3370           if (s == NULL)
3371             dyn.d_un.d_val = 0;
3372           else
3373             {
3374               if (!size)
3375                 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3376               else
3377                 dyn.d_un.d_val = s->size;
3378             }
3379           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3380         }
3381
3382       splt = htab->elf.splt;
3383       BFD_ASSERT (splt != NULL && sdyn != NULL);
3384
3385       /* Clear the first entry in the procedure linkage table,
3386          and put a nop in the last four bytes.  */
3387       if (splt->size > 0)
3388         {
3389           memset (splt->contents, 0, PLT_ENTRY_SIZE);
3390           bfd_put_32 (output_bfd, (bfd_vma) 0x80000000 /* nop.  */,
3391                       splt->contents + splt->size - 4);
3392         }
3393
3394       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3395     }
3396
3397   /* Set the first entry in the global offset table to the address of
3398      the dynamic section.  */
3399   sgot = htab->elf.sgotplt;
3400   if (sgot && sgot->size > 0)
3401     {
3402       if (sdyn == NULL)
3403         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3404       else
3405         bfd_put_32 (output_bfd,
3406                     sdyn->output_section->vma + sdyn->output_offset,
3407                     sgot->contents);
3408       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3409     }
3410
3411   if (htab->elf.sgot && htab->elf.sgot->size > 0)
3412     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
3413
3414   return TRUE;
3415 }
3416
3417 /* Hook called by the linker routine which adds symbols from an object
3418    file.  We use it to put .comm items in .sbss, and not .bss.  */
3419
3420 static bfd_boolean
3421 microblaze_elf_add_symbol_hook (bfd *abfd,
3422                                 struct bfd_link_info *info,
3423                                 Elf_Internal_Sym *sym,
3424                                 const char **namep ATTRIBUTE_UNUSED,
3425                                 flagword *flagsp ATTRIBUTE_UNUSED,
3426                                 asection **secp,
3427                                 bfd_vma *valp)
3428 {
3429   if (sym->st_shndx == SHN_COMMON
3430       && !bfd_link_relocatable (info)
3431       && sym->st_size <= elf_gp_size (abfd))
3432     {
3433       /* Common symbols less than or equal to -G nn bytes are automatically
3434          put into .sbss.  */
3435       *secp = bfd_make_section_old_way (abfd, ".sbss");
3436       if (*secp == NULL
3437           || ! bfd_set_section_flags (abfd, *secp, SEC_IS_COMMON))
3438         return FALSE;
3439
3440       *valp = sym->st_size;
3441     }
3442
3443   return TRUE;
3444 }
3445
3446 #define TARGET_LITTLE_SYM      microblaze_elf32_le_vec
3447 #define TARGET_LITTLE_NAME     "elf32-microblazeel"
3448
3449 #define TARGET_BIG_SYM          microblaze_elf32_vec
3450 #define TARGET_BIG_NAME         "elf32-microblaze"
3451
3452 #define ELF_ARCH                bfd_arch_microblaze
3453 #define ELF_TARGET_ID           MICROBLAZE_ELF_DATA
3454 #define ELF_MACHINE_CODE        EM_MICROBLAZE
3455 #define ELF_MACHINE_ALT1        EM_MICROBLAZE_OLD
3456 #define ELF_MAXPAGESIZE         0x1000
3457 #define elf_info_to_howto       microblaze_elf_info_to_howto
3458 #define elf_info_to_howto_rel   NULL
3459
3460 #define bfd_elf32_bfd_reloc_type_lookup         microblaze_elf_reloc_type_lookup
3461 #define bfd_elf32_bfd_is_local_label_name       microblaze_elf_is_local_label_name
3462 #define elf_backend_relocate_section            microblaze_elf_relocate_section
3463 #define bfd_elf32_bfd_relax_section             microblaze_elf_relax_section
3464 #define bfd_elf32_bfd_merge_private_bfd_data    _bfd_generic_verify_endian_match
3465 #define bfd_elf32_bfd_reloc_name_lookup         microblaze_elf_reloc_name_lookup
3466
3467 #define elf_backend_gc_mark_hook                microblaze_elf_gc_mark_hook
3468 #define elf_backend_gc_sweep_hook               microblaze_elf_gc_sweep_hook
3469 #define elf_backend_check_relocs                microblaze_elf_check_relocs
3470 #define elf_backend_copy_indirect_symbol        microblaze_elf_copy_indirect_symbol
3471 #define bfd_elf32_bfd_link_hash_table_create    microblaze_elf_link_hash_table_create
3472 #define elf_backend_can_gc_sections             1
3473 #define elf_backend_can_refcount                1
3474 #define elf_backend_want_got_plt                1
3475 #define elf_backend_plt_readonly                1
3476 #define elf_backend_got_header_size             12
3477 #define elf_backend_want_dynrelro               1
3478 #define elf_backend_rela_normal                 1
3479 #define elf_backend_dtrel_excludes_plt          1
3480
3481 #define elf_backend_adjust_dynamic_symbol       microblaze_elf_adjust_dynamic_symbol
3482 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3483 #define elf_backend_finish_dynamic_sections     microblaze_elf_finish_dynamic_sections
3484 #define elf_backend_finish_dynamic_symbol       microblaze_elf_finish_dynamic_symbol
3485 #define elf_backend_size_dynamic_sections       microblaze_elf_size_dynamic_sections
3486 #define elf_backend_add_symbol_hook             microblaze_elf_add_symbol_hook
3487
3488 #include "elf32-target.h"