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
1006           /* This is a final link.  */
1007           sym = NULL;
1008           sec = NULL;
1009           unresolved_reloc = FALSE;
1010
1011           if (r_symndx < symtab_hdr->sh_info)
1012             {
1013               /* Local symbol.  */
1014               sym = local_syms + r_symndx;
1015               sec = local_sections[r_symndx];
1016               if (sec == 0)
1017                 continue;
1018               sym_name = "<local symbol>";
1019               relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1020               /* r_addend may have changed if the reference section was
1021                  a merge section.  */
1022               addend = rel->r_addend;
1023             }
1024           else
1025             {
1026               /* External symbol.  */
1027               bfd_boolean warned ATTRIBUTE_UNUSED;
1028               bfd_boolean ignored ATTRIBUTE_UNUSED;
1029
1030               RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1031                                        r_symndx, symtab_hdr, sym_hashes,
1032                                        h, sec, relocation,
1033                                        unresolved_reloc, warned, ignored);
1034               sym_name = h->root.root.string;
1035             }
1036
1037           /* Sanity check the address.  */
1038           if (offset > bfd_get_section_limit (input_bfd, input_section))
1039             {
1040               r = bfd_reloc_outofrange;
1041               goto check_reloc;
1042             }
1043
1044           switch ((int) r_type)
1045             {
1046             case (int) R_MICROBLAZE_SRO32 :
1047               {
1048                 const char *name;
1049
1050                 /* Only relocate if the symbol is defined.  */
1051                 if (sec)
1052                   {
1053                     name = bfd_get_section_name (sec->owner, sec);
1054
1055                     if (strcmp (name, ".sdata2") == 0
1056                         || strcmp (name, ".sbss2") == 0)
1057                       {
1058                         if (ro_small_data_pointer == 0)
1059                           microblaze_elf_final_sdp (info);
1060                         if (ro_small_data_pointer == 0)
1061                           {
1062                             ret = FALSE;
1063                             r = bfd_reloc_undefined;
1064                             goto check_reloc;
1065                           }
1066
1067                         /* At this point `relocation' contains the object's
1068                            address.  */
1069                         relocation -= ro_small_data_pointer;
1070                         /* Now it contains the offset from _SDA2_BASE_.  */
1071                         r = _bfd_final_link_relocate (howto, input_bfd,
1072                                                       input_section,
1073                                                       contents, offset,
1074                                                       relocation, addend);
1075                       }
1076                     else
1077                       {
1078                         _bfd_error_handler
1079                           /* xgettext:c-format */
1080                           (_("%B: The target (%s) of an %s relocation"
1081                              " is in the wrong section (%A)"),
1082                            input_bfd,
1083                            sym_name,
1084                            microblaze_elf_howto_table[(int) r_type]->name,
1085                            sec);
1086                         /*bfd_set_error (bfd_error_bad_value); ??? why? */
1087                         ret = FALSE;
1088                         continue;
1089                       }
1090                   }
1091               }
1092               break;
1093
1094             case (int) R_MICROBLAZE_SRW32 :
1095               {
1096                 const char *name;
1097
1098                 /* Only relocate if the symbol is defined.  */
1099                 if (sec)
1100                   {
1101                     name = bfd_get_section_name (sec->owner, sec);
1102
1103                     if (strcmp (name, ".sdata") == 0
1104                         || strcmp (name, ".sbss") == 0)
1105                       {
1106                         if (rw_small_data_pointer == 0)
1107                           microblaze_elf_final_sdp (info);
1108                         if (rw_small_data_pointer == 0)
1109                           {
1110                             ret = FALSE;
1111                             r = bfd_reloc_undefined;
1112                             goto check_reloc;
1113                           }
1114
1115                         /* At this point `relocation' contains the object's
1116                            address.  */
1117                         relocation -= rw_small_data_pointer;
1118                         /* Now it contains the offset from _SDA_BASE_.  */
1119                         r = _bfd_final_link_relocate (howto, input_bfd,
1120                                                       input_section,
1121                                                       contents, offset,
1122                                                       relocation, addend);
1123                       }
1124                     else
1125                       {
1126                         _bfd_error_handler
1127                           /* xgettext:c-format */
1128                           (_("%B: The target (%s) of an %s relocation"
1129                              " is in the wrong section (%A)"),
1130                            input_bfd,
1131                            sym_name,
1132                            microblaze_elf_howto_table[(int) r_type]->name,
1133                            sec);
1134                         /*bfd_set_error (bfd_error_bad_value); ??? why? */
1135                         ret = FALSE;
1136                         continue;
1137                       }
1138                   }
1139               }
1140               break;
1141
1142             case (int) R_MICROBLAZE_32_SYM_OP_SYM:
1143               break; /* Do nothing.  */
1144
1145             case (int) R_MICROBLAZE_GOTPC_64:
1146               relocation = (htab->elf.sgotplt->output_section->vma
1147                             + htab->elf.sgotplt->output_offset);
1148               relocation -= (input_section->output_section->vma
1149                              + input_section->output_offset
1150                              + offset + INST_WORD_SIZE);
1151               relocation += addend;
1152               bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1153                           contents + offset + endian);
1154               bfd_put_16 (input_bfd, relocation & 0xffff,
1155                           contents + offset + endian + INST_WORD_SIZE);
1156               break;
1157
1158             case (int) R_MICROBLAZE_PLT_64:
1159               {
1160                 bfd_vma immediate;
1161                 if (htab->elf.splt != NULL && h != NULL
1162                     && h->plt.offset != (bfd_vma) -1)
1163                   {
1164                     relocation = (htab->elf.splt->output_section->vma
1165                                   + htab->elf.splt->output_offset
1166                                   + h->plt.offset);
1167                     unresolved_reloc = FALSE;
1168                     immediate = relocation - (input_section->output_section->vma
1169                                               + input_section->output_offset
1170                                               + offset + INST_WORD_SIZE);
1171                     bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1172                                 contents + offset + endian);
1173                     bfd_put_16 (input_bfd, immediate & 0xffff,
1174                                 contents + offset + endian + INST_WORD_SIZE);
1175                   }
1176                 else
1177                   {
1178                     relocation -= (input_section->output_section->vma
1179                                    + input_section->output_offset
1180                                    + offset + INST_WORD_SIZE);
1181                     immediate = relocation;
1182                     bfd_put_16 (input_bfd, (immediate >> 16) & 0xffff,
1183                                 contents + offset + endian);
1184                     bfd_put_16 (input_bfd, immediate & 0xffff,
1185                                 contents + offset + endian + INST_WORD_SIZE);
1186                   }
1187                 break;
1188               }
1189
1190             case (int) R_MICROBLAZE_TLSGD:
1191               tls_type = (TLS_TLS | TLS_GD);
1192               goto dogot;
1193             case (int) R_MICROBLAZE_TLSLD:
1194               tls_type = (TLS_TLS | TLS_LD);
1195               /* Fall through.  */
1196             dogot:
1197             case (int) R_MICROBLAZE_GOT_64:
1198               {
1199                 bfd_vma *offp;
1200                 bfd_vma off, off2;
1201                 unsigned long indx;
1202                 bfd_vma static_value;
1203
1204                 bfd_boolean need_relocs = FALSE;
1205                 if (htab->elf.sgot == NULL)
1206                   abort ();
1207
1208                 indx = 0;
1209                 offp = NULL;
1210
1211                 /* 1. Identify GOT Offset;
1212                    2. Compute Static Values
1213                    3. Process Module Id, Process Offset
1214                    4. Fixup Relocation with GOT offset value. */
1215
1216                 /* 1. Determine GOT Offset to use : TLS_LD, global, local */
1217                 if (IS_TLS_LD (tls_type))
1218                   offp = &htab->tlsld_got.offset;
1219                 else if (h != NULL)
1220                   {
1221                     if (htab->elf.sgotplt != NULL
1222                         && h->got.offset != (bfd_vma) -1)
1223                       offp = &h->got.offset;
1224                     else
1225                       abort ();
1226                   }
1227                 else
1228                   {
1229                     if (local_got_offsets == NULL)
1230                       abort ();
1231                     offp = &local_got_offsets[r_symndx];
1232                   }
1233
1234                 if (!offp)
1235                   abort ();
1236
1237                 off = (*offp) & ~1;
1238                 off2 = off;
1239
1240                 if (IS_TLS_LD(tls_type) || IS_TLS_GD(tls_type))
1241                   off2 = off + 4;
1242
1243                 /* Symbol index to use for relocs */
1244                 if (h != NULL)
1245                   {
1246                     bfd_boolean dyn =
1247                         elf_hash_table (info)->dynamic_sections_created;
1248
1249                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1250                                                          bfd_link_pic (info),
1251                                                          h)
1252                         && (!bfd_link_pic (info)
1253                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
1254                       indx = h->dynindx;
1255                   }
1256
1257                 /* Need to generate relocs ? */
1258                 if ((bfd_link_pic (info) || indx != 0)
1259                     && (h == NULL
1260                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1261                     || h->root.type != bfd_link_hash_undefweak))
1262                   need_relocs = TRUE;
1263
1264                 /* 2. Compute/Emit Static value of r-expression */
1265                 static_value = relocation + addend;
1266
1267                 /* 3. Process module-id and offset */
1268                 if (! ((*offp) & 1) )
1269                   {
1270                     bfd_vma got_offset;
1271
1272                     got_offset = (htab->elf.sgot->output_section->vma
1273                                   + htab->elf.sgot->output_offset
1274                                   + off);
1275
1276                     /* Process module-id */
1277                     if (IS_TLS_LD(tls_type))
1278                       {
1279                         if (! bfd_link_pic (info))
1280                           bfd_put_32 (output_bfd, 1,
1281                                       htab->elf.sgot->contents + off);
1282                         else
1283                           microblaze_elf_output_dynamic_relocation
1284                             (output_bfd,
1285                              htab->elf.srelgot,
1286                              htab->elf.srelgot->reloc_count++,
1287                              /* symindex= */ 0, R_MICROBLAZE_TLSDTPMOD32,
1288                              got_offset, 0);
1289                       }
1290                     else if (IS_TLS_GD(tls_type))
1291                       {
1292                         if (! need_relocs)
1293                           bfd_put_32 (output_bfd, 1,
1294                                       htab->elf.sgot->contents + off);
1295                         else
1296                           microblaze_elf_output_dynamic_relocation
1297                             (output_bfd,
1298                              htab->elf.srelgot,
1299                              htab->elf.srelgot->reloc_count++,
1300                              /* symindex= */ indx, R_MICROBLAZE_TLSDTPMOD32,
1301                              got_offset, indx ? 0 : static_value);
1302                       }
1303
1304                     /* Process Offset */
1305                     if (htab->elf.srelgot == NULL)
1306                       abort ();
1307
1308                     got_offset = (htab->elf.sgot->output_section->vma
1309                                   + htab->elf.sgot->output_offset
1310                                   + off2);
1311                     if (IS_TLS_LD(tls_type))
1312                       {
1313                         /* For LD, offset should be 0 */
1314                         *offp |= 1;
1315                         bfd_put_32 (output_bfd, 0,
1316                                     htab->elf.sgot->contents + off2);
1317                       }
1318                     else if (IS_TLS_GD(tls_type))
1319                       {
1320                         *offp |= 1;
1321                         static_value -= dtprel_base(info);
1322                         if (need_relocs)
1323                           microblaze_elf_output_dynamic_relocation
1324                             (output_bfd,
1325                              htab->elf.srelgot,
1326                              htab->elf.srelgot->reloc_count++,
1327                              /* symindex= */ indx, R_MICROBLAZE_TLSDTPREL32,
1328                              got_offset, indx ? 0 : static_value);
1329                         else
1330                           bfd_put_32 (output_bfd, static_value,
1331                                       htab->elf.sgot->contents + off2);
1332                       }
1333                     else
1334                       {
1335                         bfd_put_32 (output_bfd, static_value,
1336                                     htab->elf.sgot->contents + off2);
1337
1338                         /* Relocs for dyn symbols generated by
1339                            finish_dynamic_symbols */
1340                         if (bfd_link_pic (info) && h == NULL)
1341                           {
1342                             *offp |= 1;
1343                             microblaze_elf_output_dynamic_relocation
1344                               (output_bfd,
1345                                htab->elf.srelgot,
1346                                htab->elf.srelgot->reloc_count++,
1347                                /* symindex= */ indx, R_MICROBLAZE_REL,
1348                                got_offset, static_value);
1349                           }
1350                       }
1351                   }
1352
1353                 /* 4. Fixup Relocation with GOT offset value
1354                       Compute relative address of GOT entry for applying
1355                       the current relocation */
1356                 relocation = htab->elf.sgot->output_section->vma
1357                              + htab->elf.sgot->output_offset
1358                              + off
1359                              - htab->elf.sgotplt->output_section->vma
1360                              - htab->elf.sgotplt->output_offset;
1361
1362                 /* Apply Current Relocation */
1363                 bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1364                             contents + offset + endian);
1365                 bfd_put_16 (input_bfd, relocation & 0xffff,
1366                             contents + offset + endian + INST_WORD_SIZE);
1367
1368                 unresolved_reloc = FALSE;
1369                 break;
1370               }
1371
1372             case (int) R_MICROBLAZE_GOTOFF_64:
1373               {
1374                 bfd_vma immediate;
1375                 unsigned short lo, high;
1376                 relocation += addend;
1377                 relocation -= (htab->elf.sgotplt->output_section->vma
1378                                + htab->elf.sgotplt->output_offset);
1379                 /* Write this value into correct location.  */
1380                 immediate = relocation;
1381                 lo = immediate & 0x0000ffff;
1382                 high = (immediate >> 16) & 0x0000ffff;
1383                 bfd_put_16 (input_bfd, high, contents + offset + endian);
1384                 bfd_put_16 (input_bfd, lo,
1385                             contents + offset + INST_WORD_SIZE + endian);
1386                 break;
1387               }
1388
1389             case (int) R_MICROBLAZE_GOTOFF_32:
1390               {
1391                 relocation += addend;
1392                 relocation -= (htab->elf.sgotplt->output_section->vma
1393                                + htab->elf.sgotplt->output_offset);
1394                 /* Write this value into correct location.  */
1395                 bfd_put_32 (input_bfd, relocation, contents + offset);
1396                 break;
1397               }
1398
1399             case (int) R_MICROBLAZE_TLSDTPREL64:
1400               relocation += addend;
1401               relocation -= dtprel_base(info);
1402               bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1403                           contents + offset + 2);
1404               bfd_put_16 (input_bfd, relocation & 0xffff,
1405                           contents + offset + 2 + INST_WORD_SIZE);
1406               break;
1407             case (int) R_MICROBLAZE_64_PCREL :
1408             case (int) R_MICROBLAZE_64:
1409             case (int) R_MICROBLAZE_32:
1410               {
1411                 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
1412                    from removed linkonce sections, or sections discarded by
1413                    a linker script.  */
1414                 if (r_symndx == STN_UNDEF || (input_section->flags & SEC_ALLOC) == 0)
1415                   {
1416                     relocation += addend;
1417                     if (r_type == R_MICROBLAZE_32)
1418                       bfd_put_32 (input_bfd, relocation, contents + offset);
1419                     else
1420                       {
1421                         if (r_type == R_MICROBLAZE_64_PCREL)
1422                           relocation -= (input_section->output_section->vma
1423                                          + input_section->output_offset
1424                                          + offset + INST_WORD_SIZE);
1425                         bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1426                                     contents + offset + endian);
1427                         bfd_put_16 (input_bfd, relocation & 0xffff,
1428                                     contents + offset + endian + INST_WORD_SIZE);
1429                       }
1430                     break;
1431                   }
1432
1433                 if ((bfd_link_pic (info)
1434                      && (h == NULL
1435                          || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1436                          || h->root.type != bfd_link_hash_undefweak)
1437                      && (!howto->pc_relative
1438                          || (h != NULL
1439                              && h->dynindx != -1
1440                              && (!info->symbolic
1441                                  || !h->def_regular))))
1442                     || (!bfd_link_pic (info)
1443                         && h != NULL
1444                         && h->dynindx != -1
1445                         && !h->non_got_ref
1446                         && ((h->def_dynamic
1447                              && !h->def_regular)
1448                             || h->root.type == bfd_link_hash_undefweak
1449                             || h->root.type == bfd_link_hash_undefined)))
1450                   {
1451                     Elf_Internal_Rela outrel;
1452                     bfd_byte *loc;
1453                     bfd_boolean skip;
1454
1455                     /* When generating a shared object, these relocations
1456                        are copied into the output file to be resolved at run
1457                        time.  */
1458
1459                     BFD_ASSERT (sreloc != NULL);
1460
1461                     skip = FALSE;
1462
1463                     outrel.r_offset =
1464                       _bfd_elf_section_offset (output_bfd, info, input_section,
1465                                                rel->r_offset);
1466                     if (outrel.r_offset == (bfd_vma) -1)
1467                       skip = TRUE;
1468                     else if (outrel.r_offset == (bfd_vma) -2)
1469                       skip = TRUE;
1470                     outrel.r_offset += (input_section->output_section->vma
1471                                         + input_section->output_offset);
1472
1473                     if (skip)
1474                       memset (&outrel, 0, sizeof outrel);
1475                     /* h->dynindx may be -1 if the symbol was marked to
1476                        become local.  */
1477                     else if (h != NULL
1478                              && ((! info->symbolic && h->dynindx != -1)
1479                                  || !h->def_regular))
1480                       {
1481                         BFD_ASSERT (h->dynindx != -1);
1482                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1483                         outrel.r_addend = addend;
1484                       }
1485                     else
1486                       {
1487                         if (r_type == R_MICROBLAZE_32)
1488                           {
1489                             outrel.r_info = ELF32_R_INFO (0, R_MICROBLAZE_REL);
1490                             outrel.r_addend = relocation + addend;
1491                           }
1492                         else
1493                           {
1494                             BFD_FAIL ();
1495                             _bfd_error_handler
1496                               (_("%B: probably compiled without -fPIC?"),
1497                                input_bfd);
1498                             bfd_set_error (bfd_error_bad_value);
1499                             return FALSE;
1500                           }
1501                       }
1502
1503                     loc = sreloc->contents;
1504                     loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1505                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1506                     break;
1507                   }
1508                 else
1509                   {
1510                     relocation += addend;
1511                     if (r_type == R_MICROBLAZE_32)
1512                       bfd_put_32 (input_bfd, relocation, contents + offset);
1513                     else
1514                       {
1515                         if (r_type == R_MICROBLAZE_64_PCREL)
1516                           relocation -= (input_section->output_section->vma
1517                                          + input_section->output_offset
1518                                          + offset + INST_WORD_SIZE);
1519                         bfd_put_16 (input_bfd, (relocation >> 16) & 0xffff,
1520                                     contents + offset + endian);
1521                         bfd_put_16 (input_bfd, relocation & 0xffff,
1522                                     contents + offset + endian + INST_WORD_SIZE);
1523                       }
1524                     break;
1525                   }
1526               }
1527
1528             default :
1529               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1530                                             contents, offset,
1531                                             relocation, addend);
1532               break;
1533             }
1534         }
1535
1536     check_reloc:
1537
1538       if (r != bfd_reloc_ok)
1539         {
1540           /* FIXME: This should be generic enough to go in a utility.  */
1541           const char *name;
1542
1543           if (h != NULL)
1544             name = h->root.root.string;
1545           else
1546             {
1547               name = (bfd_elf_string_from_elf_section
1548                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1549               if (name == NULL || *name == '\0')
1550                 name = bfd_section_name (input_bfd, sec);
1551             }
1552
1553           if (errmsg != NULL)
1554             goto common_error;
1555
1556           switch (r)
1557             {
1558             case bfd_reloc_overflow:
1559               (*info->callbacks->reloc_overflow)
1560                 (info, (h ? &h->root : NULL), name, howto->name,
1561                  (bfd_vma) 0, input_bfd, input_section, offset);
1562               break;
1563
1564             case bfd_reloc_undefined:
1565               (*info->callbacks->undefined_symbol)
1566                 (info, name, input_bfd, input_section, offset, TRUE);
1567               break;
1568
1569             case bfd_reloc_outofrange:
1570               errmsg = _("internal error: out of range error");
1571               goto common_error;
1572
1573             case bfd_reloc_notsupported:
1574               errmsg = _("internal error: unsupported relocation error");
1575               goto common_error;
1576
1577             case bfd_reloc_dangerous:
1578               errmsg = _("internal error: dangerous error");
1579               goto common_error;
1580
1581             default:
1582               errmsg = _("internal error: unknown error");
1583               /* Fall through.  */
1584             common_error:
1585               (*info->callbacks->warning) (info, errmsg, name, input_bfd,
1586                                            input_section, offset);
1587               break;
1588             }
1589         }
1590     }
1591
1592   return ret;
1593 }
1594 \f
1595 /* Calculate fixup value for reference.  */
1596
1597 static int
1598 calc_fixup (bfd_vma start, bfd_vma size, asection *sec)
1599 {
1600   bfd_vma end = start + size;
1601   int i, fixup = 0;
1602
1603   if (sec == NULL || sec->relax == NULL)
1604     return 0;
1605
1606   /* Look for addr in relax table, total fixup value.  */
1607   for (i = 0; i < sec->relax_count; i++)
1608     {
1609       if (end <= sec->relax[i].addr)
1610         break;
1611       if ((end != start) && (start > sec->relax[i].addr))
1612         continue;
1613       fixup += sec->relax[i].size;
1614     }
1615   return fixup;
1616 }
1617
1618 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1619    a 32-bit instruction.  */
1620 static void
1621 microblaze_bfd_write_imm_value_32 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1622 {
1623     unsigned long instr = bfd_get_32 (abfd, bfd_addr);
1624     instr &= ~0x0000ffff;
1625     instr |= (val & 0x0000ffff);
1626     bfd_put_32 (abfd, instr, bfd_addr);
1627 }
1628
1629 /* Read-modify-write into the bfd, an immediate value into appropriate fields of
1630    two consecutive 32-bit instructions.  */
1631 static void
1632 microblaze_bfd_write_imm_value_64 (bfd *abfd, bfd_byte *bfd_addr, bfd_vma val)
1633 {
1634     unsigned long instr_hi;
1635     unsigned long instr_lo;
1636
1637     instr_hi = bfd_get_32 (abfd, bfd_addr);
1638     instr_hi &= ~0x0000ffff;
1639     instr_hi |= ((val >> 16) & 0x0000ffff);
1640     bfd_put_32 (abfd, instr_hi, bfd_addr);
1641
1642     instr_lo = bfd_get_32 (abfd, bfd_addr + INST_WORD_SIZE);
1643     instr_lo &= ~0x0000ffff;
1644     instr_lo |= (val & 0x0000ffff);
1645     bfd_put_32 (abfd, instr_lo, bfd_addr + INST_WORD_SIZE);
1646 }
1647
1648 static bfd_boolean
1649 microblaze_elf_relax_section (bfd *abfd,
1650                               asection *sec,
1651                               struct bfd_link_info *link_info,
1652                               bfd_boolean *again)
1653 {
1654   Elf_Internal_Shdr *symtab_hdr;
1655   Elf_Internal_Rela *internal_relocs;
1656   Elf_Internal_Rela *free_relocs = NULL;
1657   Elf_Internal_Rela *irel, *irelend;
1658   bfd_byte *contents = NULL;
1659   bfd_byte *free_contents = NULL;
1660   int rel_count;
1661   unsigned int shndx;
1662   int i, sym_index;
1663   asection *o;
1664   struct elf_link_hash_entry *sym_hash;
1665   Elf_Internal_Sym *isymbuf, *isymend;
1666   Elf_Internal_Sym *isym;
1667   int symcount;
1668   int offset;
1669   bfd_vma src, dest;
1670
1671   /* We only do this once per section.  We may be able to delete some code
1672      by running multiple passes, but it is not worth it.  */
1673   *again = FALSE;
1674
1675   /* Only do this for a text section.  */
1676   if (bfd_link_relocatable (link_info)
1677       || (sec->flags & SEC_RELOC) == 0
1678       || (sec->reloc_count == 0)
1679       || (sec->flags & SEC_CODE) == 0)
1680     return TRUE;
1681
1682   BFD_ASSERT ((sec->size > 0) || (sec->rawsize > 0));
1683
1684   /* If this is the first time we have been called for this section,
1685      initialize the cooked size.  */
1686   if (sec->size == 0)
1687     sec->size = sec->rawsize;
1688
1689   /* Get symbols for this section.  */
1690   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1691   isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1692   symcount =  symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
1693   if (isymbuf == NULL)
1694     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, symcount,
1695                                     0, NULL, NULL, NULL);
1696   BFD_ASSERT (isymbuf != NULL);
1697
1698   internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1699   if (internal_relocs == NULL)
1700     goto error_return;
1701   if (! link_info->keep_memory)
1702     free_relocs = internal_relocs;
1703
1704   sec->relax = (struct relax_table *) bfd_malloc ((sec->reloc_count + 1)
1705                                                   * sizeof (struct relax_table));
1706   if (sec->relax == NULL)
1707     goto error_return;
1708   sec->relax_count = 0;
1709
1710   irelend = internal_relocs + sec->reloc_count;
1711   rel_count = 0;
1712   for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1713     {
1714       bfd_vma symval;
1715       if ((ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64_PCREL)
1716           && (ELF32_R_TYPE (irel->r_info) != (int) R_MICROBLAZE_64 ))
1717         continue; /* Can't delete this reloc.  */
1718
1719       /* Get the section contents.  */
1720       if (contents == NULL)
1721         {
1722           if (elf_section_data (sec)->this_hdr.contents != NULL)
1723             contents = elf_section_data (sec)->this_hdr.contents;
1724           else
1725             {
1726               contents = (bfd_byte *) bfd_malloc (sec->size);
1727               if (contents == NULL)
1728                 goto error_return;
1729               free_contents = contents;
1730
1731               if (!bfd_get_section_contents (abfd, sec, contents,
1732                                              (file_ptr) 0, sec->size))
1733                 goto error_return;
1734               elf_section_data (sec)->this_hdr.contents = contents;
1735             }
1736         }
1737
1738       /* Get the value of the symbol referred to by the reloc.  */
1739       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1740         {
1741           /* A local symbol.  */
1742           asection *sym_sec;
1743
1744           isym = isymbuf + ELF32_R_SYM (irel->r_info);
1745           if (isym->st_shndx == SHN_UNDEF)
1746             sym_sec = bfd_und_section_ptr;
1747           else if (isym->st_shndx == SHN_ABS)
1748             sym_sec = bfd_abs_section_ptr;
1749           else if (isym->st_shndx == SHN_COMMON)
1750             sym_sec = bfd_com_section_ptr;
1751           else
1752             sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1753
1754           symval = _bfd_elf_rela_local_sym (abfd, isym, &sym_sec, irel);
1755         }
1756       else
1757         {
1758           unsigned long indx;
1759           struct elf_link_hash_entry *h;
1760
1761           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1762           h = elf_sym_hashes (abfd)[indx];
1763           BFD_ASSERT (h != NULL);
1764
1765           if (h->root.type != bfd_link_hash_defined
1766               && h->root.type != bfd_link_hash_defweak)
1767             /* This appears to be a reference to an undefined
1768                symbol.  Just ignore it--it will be caught by the
1769                regular reloc processing.  */
1770             continue;
1771
1772           symval = (h->root.u.def.value
1773                     + h->root.u.def.section->output_section->vma
1774                     + h->root.u.def.section->output_offset);
1775         }
1776
1777       /* If this is a PC-relative reloc, subtract the instr offset from
1778          the symbol value.  */
1779       if (ELF32_R_TYPE (irel->r_info) == (int) R_MICROBLAZE_64_PCREL)
1780         {
1781           symval = symval + irel->r_addend
1782             - (irel->r_offset
1783                + sec->output_section->vma
1784                + sec->output_offset);
1785         }
1786       else
1787         symval += irel->r_addend;
1788
1789       if ((symval & 0xffff8000) == 0
1790           || (symval & 0xffff8000) == 0xffff8000)
1791         {
1792           /* We can delete this instruction.  */
1793           sec->relax[sec->relax_count].addr = irel->r_offset;
1794           sec->relax[sec->relax_count].size = INST_WORD_SIZE;
1795           sec->relax_count++;
1796
1797           /* Rewrite relocation type.  */
1798           switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1799             {
1800             case R_MICROBLAZE_64_PCREL:
1801               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1802                                            (int) R_MICROBLAZE_32_PCREL_LO);
1803               break;
1804             case R_MICROBLAZE_64:
1805               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1806                                            (int) R_MICROBLAZE_32_LO);
1807               break;
1808             default:
1809               /* Cannot happen.  */
1810               BFD_ASSERT (FALSE);
1811             }
1812         }
1813     } /* Loop through all relocations.  */
1814
1815   /* Loop through the relocs again, and see if anything needs to change.  */
1816   if (sec->relax_count > 0)
1817     {
1818       shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1819       rel_count = 0;
1820       sec->relax[sec->relax_count].addr = sec->size;
1821
1822       for (irel = internal_relocs; irel < irelend; irel++, rel_count++)
1823         {
1824           bfd_vma nraddr;
1825
1826           /* Get the new reloc address.  */
1827           nraddr = irel->r_offset - calc_fixup (irel->r_offset, 0, sec);
1828           switch ((enum elf_microblaze_reloc_type) ELF32_R_TYPE (irel->r_info))
1829             {
1830             default:
1831               break;
1832             case R_MICROBLAZE_64_PCREL:
1833               break;
1834             case R_MICROBLAZE_64:
1835             case R_MICROBLAZE_32_LO:
1836               /* If this reloc is against a symbol defined in this
1837                  section, we must check the addend to see it will put the value in
1838                  range to be adjusted, and hence must be changed.  */
1839               if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1840                 {
1841                   isym = isymbuf + ELF32_R_SYM (irel->r_info);
1842                   /* Only handle relocs against .text.  */
1843                   if (isym->st_shndx == shndx
1844                       && ELF32_ST_TYPE (isym->st_info) == STT_SECTION)
1845                     irel->r_addend -= calc_fixup (irel->r_addend, 0, sec);
1846                 }
1847               break;
1848             case R_MICROBLAZE_NONE:
1849               {
1850                 /* This was a PC-relative instruction that was
1851                    completely resolved.  */
1852                 int sfix, efix;
1853                 bfd_vma target_address;
1854                 target_address = irel->r_addend + irel->r_offset;
1855                 sfix = calc_fixup (irel->r_offset, 0, sec);
1856                 efix = calc_fixup (target_address, 0, sec);
1857                 irel->r_addend -= (efix - sfix);
1858                 /* Should use HOWTO.  */
1859                 microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset,
1860                                                    irel->r_addend);
1861               }
1862               break;
1863             case R_MICROBLAZE_64_NONE:
1864               {
1865                 /* This was a PC-relative 64-bit instruction that was
1866                    completely resolved.  */
1867                 int sfix, efix;
1868                 bfd_vma target_address;
1869                 target_address = irel->r_addend + irel->r_offset + INST_WORD_SIZE;
1870                 sfix = calc_fixup (irel->r_offset + INST_WORD_SIZE, 0, sec);
1871                 efix = calc_fixup (target_address, 0, sec);
1872                 irel->r_addend -= (efix - sfix);
1873     microblaze_bfd_write_imm_value_32 (abfd, contents + irel->r_offset
1874                                        + INST_WORD_SIZE, irel->r_addend);
1875               }
1876               break;
1877             }
1878           irel->r_offset = nraddr;
1879         } /* Change all relocs in this section.  */
1880
1881       /* Look through all other sections.  */
1882       for (o = abfd->sections; o != NULL; o = o->next)
1883         {
1884           Elf_Internal_Rela *irelocs;
1885           Elf_Internal_Rela *irelscan, *irelscanend;
1886           bfd_byte *ocontents;
1887
1888           if (o == sec
1889               || (o->flags & SEC_RELOC) == 0
1890               || o->reloc_count == 0)
1891             continue;
1892
1893           /* We always cache the relocs.  Perhaps, if info->keep_memory is
1894              FALSE, we should free them, if we are permitted to.  */
1895
1896           irelocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, TRUE);
1897           if (irelocs == NULL)
1898             goto error_return;
1899
1900           ocontents = NULL;
1901           irelscanend = irelocs + o->reloc_count;
1902           for (irelscan = irelocs; irelscan < irelscanend; irelscan++)
1903             {
1904               if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32)
1905                 {
1906                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1907
1908                   /* Look at the reloc only if the value has been resolved.  */
1909                   if (isym->st_shndx == shndx
1910                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1911                     {
1912                       if (ocontents == NULL)
1913                         {
1914                           if (elf_section_data (o)->this_hdr.contents != NULL)
1915                             ocontents = elf_section_data (o)->this_hdr.contents;
1916                           else
1917                             {
1918                               /* We always cache the section contents.
1919                                  Perhaps, if info->keep_memory is FALSE, we
1920                                  should free them, if we are permitted to.  */
1921                               if (o->rawsize == 0)
1922                                 o->rawsize = o->size;
1923                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1924                               if (ocontents == NULL)
1925                                 goto error_return;
1926                               if (!bfd_get_section_contents (abfd, o, ocontents,
1927                                                              (file_ptr) 0,
1928                                                              o->rawsize))
1929                                 goto error_return;
1930                               elf_section_data (o)->this_hdr.contents = ocontents;
1931                             }
1932
1933                         }
1934                       irelscan->r_addend -= calc_fixup (irelscan->r_addend, 0, sec);
1935                     }
1936                   else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_SYM_OP_SYM)
1937                     {
1938                       isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1939
1940                       /* Look at the reloc only if the value has been resolved.  */
1941                       if (ocontents == NULL)
1942                         {
1943                           if (elf_section_data (o)->this_hdr.contents != NULL)
1944                             ocontents = elf_section_data (o)->this_hdr.contents;
1945                           else
1946                             {
1947                               /* We always cache the section contents.
1948                                  Perhaps, if info->keep_memory is FALSE, we
1949                                  should free them, if we are permitted to.  */
1950
1951                               if (o->rawsize == 0)
1952                                 o->rawsize = o->size;
1953                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1954                               if (ocontents == NULL)
1955                                 goto error_return;
1956                               if (!bfd_get_section_contents (abfd, o, ocontents,
1957                                                              (file_ptr) 0,
1958                                                              o->rawsize))
1959                                 goto error_return;
1960                               elf_section_data (o)->this_hdr.contents = ocontents;
1961                             }
1962                         }
1963                       irelscan->r_addend -= calc_fixup (irel->r_addend
1964                                                         + isym->st_value,
1965                                                         0,
1966                                                         sec);
1967                     }
1968                 }
1969               else if ((ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_PCREL_LO)
1970                        || (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_32_LO))
1971                 {
1972                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
1973
1974                   /* Look at the reloc only if the value has been resolved.  */
1975                   if (isym->st_shndx == shndx
1976                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
1977                     {
1978                       bfd_vma immediate;
1979                       bfd_vma target_address;
1980
1981                       if (ocontents == NULL)
1982                         {
1983                           if (elf_section_data (o)->this_hdr.contents != NULL)
1984                             ocontents = elf_section_data (o)->this_hdr.contents;
1985                           else
1986                             {
1987                               /* We always cache the section contents.
1988                                  Perhaps, if info->keep_memory is FALSE, we
1989                                  should free them, if we are permitted to.  */
1990                               if (o->rawsize == 0)
1991                                 o->rawsize = o->size;
1992                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
1993                               if (ocontents == NULL)
1994                                 goto error_return;
1995                               if (!bfd_get_section_contents (abfd, o, ocontents,
1996                                                              (file_ptr) 0,
1997                                                              o->rawsize))
1998                                 goto error_return;
1999                               elf_section_data (o)->this_hdr.contents = ocontents;
2000                             }
2001                         }
2002
2003                       unsigned long instr = bfd_get_32 (abfd, ocontents + irelscan->r_offset);
2004                       immediate = instr & 0x0000ffff;
2005                       target_address = immediate;
2006                       offset = calc_fixup (target_address, 0, sec);
2007                       immediate -= offset;
2008                       irelscan->r_addend -= offset;
2009           microblaze_bfd_write_imm_value_32 (abfd, ocontents + irelscan->r_offset,
2010                                              irelscan->r_addend);
2011                     }
2012                 }
2013
2014               if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64)
2015                 {
2016                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2017
2018                   /* Look at the reloc only if the value has been resolved.  */
2019                   if (isym->st_shndx == shndx
2020                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2021                     {
2022                       bfd_vma immediate;
2023
2024                       if (ocontents == NULL)
2025                         {
2026                           if (elf_section_data (o)->this_hdr.contents != NULL)
2027                             ocontents = elf_section_data (o)->this_hdr.contents;
2028                           else
2029                             {
2030                               /* We always cache the section contents.
2031                                  Perhaps, if info->keep_memory is FALSE, we
2032                                  should free them, if we are permitted to.  */
2033
2034                               if (o->rawsize == 0)
2035                                 o->rawsize = o->size;
2036                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2037                               if (ocontents == NULL)
2038                                 goto error_return;
2039                               if (!bfd_get_section_contents (abfd, o, ocontents,
2040                                                              (file_ptr) 0,
2041                                                              o->rawsize))
2042                                 goto error_return;
2043                               elf_section_data (o)->this_hdr.contents = ocontents;
2044                             }
2045                         }
2046           unsigned long instr_hi =  bfd_get_32 (abfd, ocontents
2047                                                 + irelscan->r_offset);
2048           unsigned long instr_lo =  bfd_get_32 (abfd, ocontents
2049                                                 + irelscan->r_offset
2050                                                 + INST_WORD_SIZE);
2051           immediate = (instr_hi & 0x0000ffff) << 16;
2052           immediate |= (instr_lo & 0x0000ffff);
2053                       offset = calc_fixup (irelscan->r_addend, 0, sec);
2054                       immediate -= offset;
2055                       irelscan->r_addend -= offset;
2056                     }
2057                 }
2058               else if (ELF32_R_TYPE (irelscan->r_info) == (int) R_MICROBLAZE_64_PCREL)
2059                 {
2060                   isym = isymbuf + ELF32_R_SYM (irelscan->r_info);
2061
2062                   /* Look at the reloc only if the value has been resolved.  */
2063                   if (isym->st_shndx == shndx
2064                       && (ELF32_ST_TYPE (isym->st_info) == STT_SECTION))
2065                     {
2066                       bfd_vma immediate;
2067                       bfd_vma target_address;
2068
2069                       if (ocontents == NULL)
2070                         {
2071                           if (elf_section_data (o)->this_hdr.contents != NULL)
2072                             ocontents = elf_section_data (o)->this_hdr.contents;
2073                           else
2074                             {
2075                               /* We always cache the section contents.
2076                                  Perhaps, if info->keep_memory is FALSE, we
2077                                  should free them, if we are permitted to.  */
2078                               if (o->rawsize == 0)
2079                                 o->rawsize = o->size;
2080                               ocontents = (bfd_byte *) bfd_malloc (o->rawsize);
2081                               if (ocontents == NULL)
2082                                 goto error_return;
2083                               if (!bfd_get_section_contents (abfd, o, ocontents,
2084                                                              (file_ptr) 0,
2085                                                              o->rawsize))
2086                                 goto error_return;
2087                               elf_section_data (o)->this_hdr.contents = ocontents;
2088                             }
2089                         }
2090           unsigned long instr_hi =  bfd_get_32 (abfd, ocontents
2091                                                 + irelscan->r_offset);
2092           unsigned long instr_lo =  bfd_get_32 (abfd, ocontents
2093                                                 + irelscan->r_offset
2094                                                 + INST_WORD_SIZE);
2095           immediate = (instr_hi & 0x0000ffff) << 16;
2096           immediate |= (instr_lo & 0x0000ffff);
2097                       target_address = immediate;
2098                       offset = calc_fixup (target_address, 0, sec);
2099                       immediate -= offset;
2100                       irelscan->r_addend -= offset;
2101           microblaze_bfd_write_imm_value_64 (abfd, ocontents
2102                                              + irelscan->r_offset, immediate);
2103                     }
2104                 }
2105             }
2106         }
2107
2108       /* Adjust the local symbols defined in this section.  */
2109       isymend = isymbuf + symtab_hdr->sh_info;
2110       for (isym = isymbuf; isym < isymend; isym++)
2111         {
2112           if (isym->st_shndx == shndx)
2113             {
2114               isym->st_value -= calc_fixup (isym->st_value, 0, sec);
2115               if (isym->st_size)
2116                 isym->st_size -= calc_fixup (isym->st_value, isym->st_size, sec);
2117             }
2118         }
2119
2120       /* Now adjust the global symbols defined in this section.  */
2121       isym = isymbuf + symtab_hdr->sh_info;
2122       symcount =  (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)) - symtab_hdr->sh_info;
2123       for (sym_index = 0; sym_index < symcount; sym_index++)
2124         {
2125           sym_hash = elf_sym_hashes (abfd)[sym_index];
2126           if ((sym_hash->root.type == bfd_link_hash_defined
2127                   || sym_hash->root.type == bfd_link_hash_defweak)
2128               && sym_hash->root.u.def.section == sec)
2129             {
2130               sym_hash->root.u.def.value -= calc_fixup (sym_hash->root.u.def.value,
2131                                                         0, sec);
2132               if (sym_hash->size)
2133                 sym_hash->size -= calc_fixup (sym_hash->root.u.def.value,
2134                                               sym_hash->size, sec);
2135             }
2136         }
2137
2138       /* Physically move the code and change the cooked size.  */
2139       dest = sec->relax[0].addr;
2140       for (i = 0; i < sec->relax_count; i++)
2141         {
2142           int len;
2143           src = sec->relax[i].addr + sec->relax[i].size;
2144           len = sec->relax[i+1].addr - sec->relax[i].addr - sec->relax[i].size;
2145
2146           memmove (contents + dest, contents + src, len);
2147           sec->size -= sec->relax[i].size;
2148           dest += len;
2149         }
2150
2151       elf_section_data (sec)->relocs = internal_relocs;
2152       free_relocs = NULL;
2153
2154       elf_section_data (sec)->this_hdr.contents = contents;
2155       free_contents = NULL;
2156
2157       symtab_hdr->contents = (bfd_byte *) isymbuf;
2158     }
2159
2160   if (free_relocs != NULL)
2161     {
2162       free (free_relocs);
2163       free_relocs = NULL;
2164     }
2165
2166   if (free_contents != NULL)
2167     {
2168       if (!link_info->keep_memory)
2169         free (free_contents);
2170       else
2171         /* Cache the section contents for elf_link_input_bfd.  */
2172         elf_section_data (sec)->this_hdr.contents = contents;
2173       free_contents = NULL;
2174     }
2175
2176   if (sec->relax_count == 0)
2177     {
2178       *again = FALSE;
2179       free (sec->relax);
2180       sec->relax = NULL;
2181     }
2182   else
2183     *again = TRUE;
2184   return TRUE;
2185
2186  error_return:
2187   if (free_relocs != NULL)
2188     free (free_relocs);
2189   if (free_contents != NULL)
2190     free (free_contents);
2191   if (sec->relax != NULL)
2192     {
2193       free (sec->relax);
2194       sec->relax = NULL;
2195       sec->relax_count = 0;
2196     }
2197   return FALSE;
2198 }
2199
2200 /* Return the section that should be marked against GC for a given
2201    relocation.  */
2202
2203 static asection *
2204 microblaze_elf_gc_mark_hook (asection *sec,
2205                              struct bfd_link_info * info,
2206                              Elf_Internal_Rela * rel,
2207                              struct elf_link_hash_entry * h,
2208                              Elf_Internal_Sym * sym)
2209 {
2210   if (h != NULL)
2211     switch (ELF32_R_TYPE (rel->r_info))
2212       {
2213       case R_MICROBLAZE_GNU_VTINHERIT:
2214       case R_MICROBLAZE_GNU_VTENTRY:
2215         return NULL;
2216       }
2217
2218   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2219 }
2220
2221 /* Update the got entry reference counts for the section being removed.  */
2222
2223 static bfd_boolean
2224 microblaze_elf_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED,
2225                               struct bfd_link_info * info ATTRIBUTE_UNUSED,
2226                               asection * sec ATTRIBUTE_UNUSED,
2227                               const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
2228 {
2229   return TRUE;
2230 }
2231
2232 /* PIC support.  */
2233
2234 #define PLT_ENTRY_SIZE 16
2235
2236 #define PLT_ENTRY_WORD_0  0xb0000000          /* "imm 0".  */
2237 #define PLT_ENTRY_WORD_1  0xe9940000          /* "lwi r12,r20,0" - relocated to lwi r12,r20,func@GOT.  */
2238 #define PLT_ENTRY_WORD_1_NOPIC  0xe9800000    /* "lwi r12,r0,0" - non-PIC object.  */
2239 #define PLT_ENTRY_WORD_2  0x98186000          /* "brad r12".  */
2240 #define PLT_ENTRY_WORD_3  0x80000000          /* "nop".  */
2241
2242 static bfd_boolean
2243 update_local_sym_info (bfd *abfd,
2244                        Elf_Internal_Shdr *symtab_hdr,
2245                        unsigned long r_symndx,
2246                        unsigned int tls_type)
2247 {
2248   bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
2249   unsigned char *local_got_tls_masks;
2250
2251   if (local_got_refcounts == NULL)
2252     {
2253       bfd_size_type size = symtab_hdr->sh_info;
2254
2255       size *= (sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks));
2256       local_got_refcounts = bfd_zalloc (abfd, size);
2257       if (local_got_refcounts == NULL)
2258         return FALSE;
2259       elf_local_got_refcounts (abfd) = local_got_refcounts;
2260     }
2261
2262   local_got_tls_masks =
2263          (unsigned char *) (local_got_refcounts + symtab_hdr->sh_info);
2264   local_got_tls_masks[r_symndx] |= tls_type;
2265   local_got_refcounts[r_symndx] += 1;
2266
2267   return TRUE;
2268 }
2269 /* Look through the relocs for a section during the first phase.  */
2270
2271 static bfd_boolean
2272 microblaze_elf_check_relocs (bfd * abfd,
2273                              struct bfd_link_info * info,
2274                              asection * sec,
2275                              const Elf_Internal_Rela * relocs)
2276 {
2277   Elf_Internal_Shdr *           symtab_hdr;
2278   struct elf_link_hash_entry ** sym_hashes;
2279   struct elf_link_hash_entry ** sym_hashes_end;
2280   const Elf_Internal_Rela *     rel;
2281   const Elf_Internal_Rela *     rel_end;
2282   struct elf32_mb_link_hash_table *htab;
2283   asection *sreloc = NULL;
2284
2285   if (bfd_link_relocatable (info))
2286     return TRUE;
2287
2288   htab = elf32_mb_hash_table (info);
2289   if (htab == NULL)
2290     return FALSE;
2291
2292   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2293   sym_hashes = elf_sym_hashes (abfd);
2294   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2295   if (!elf_bad_symtab (abfd))
2296     sym_hashes_end -= symtab_hdr->sh_info;
2297
2298   rel_end = relocs + sec->reloc_count;
2299
2300   for (rel = relocs; rel < rel_end; rel++)
2301     {
2302       unsigned int r_type;
2303       struct elf_link_hash_entry * h;
2304       unsigned long r_symndx;
2305       unsigned char tls_type = 0;
2306
2307       r_symndx = ELF32_R_SYM (rel->r_info);
2308       r_type = ELF32_R_TYPE (rel->r_info);
2309
2310       if (r_symndx < symtab_hdr->sh_info)
2311         h = NULL;
2312       else
2313         {
2314           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
2315
2316           /* PR15323, ref flags aren't set for references in the same
2317              object.  */
2318           h->root.non_ir_ref_regular = 1;
2319         }
2320
2321       switch (r_type)
2322         {
2323           /* This relocation describes the C++ object vtable hierarchy.
2324              Reconstruct it for later use during GC.  */
2325         case R_MICROBLAZE_GNU_VTINHERIT:
2326           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2327             return FALSE;
2328           break;
2329
2330           /* This relocation describes which C++ vtable entries are actually
2331              used.  Record for later use during GC.  */
2332         case R_MICROBLAZE_GNU_VTENTRY:
2333           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2334             return FALSE;
2335           break;
2336
2337           /* This relocation requires .plt entry.  */
2338         case R_MICROBLAZE_PLT_64:
2339           if (h != NULL)
2340             {
2341               h->needs_plt = 1;
2342               h->plt.refcount += 1;
2343             }
2344           break;
2345
2346           /* This relocation requires .got entry.  */
2347         case R_MICROBLAZE_TLSGD:
2348           tls_type |= (TLS_TLS | TLS_GD);
2349           goto dogottls;
2350         case R_MICROBLAZE_TLSLD:
2351           tls_type |= (TLS_TLS | TLS_LD);
2352           /* Fall through.  */
2353         dogottls:
2354           sec->has_tls_reloc = 1;
2355           /* Fall through.  */
2356         case R_MICROBLAZE_GOTOFF_64:
2357         case R_MICROBLAZE_GOT_64:
2358           if (htab->elf.sgot == NULL)
2359             {
2360               if (htab->elf.dynobj == NULL)
2361                 htab->elf.dynobj = abfd;
2362               if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
2363                 return FALSE;
2364             }
2365           if (h != NULL)
2366             {
2367               h->got.refcount += 1;
2368               elf32_mb_hash_entry (h)->tls_mask |= tls_type;
2369             }
2370           else
2371             {
2372               if (! update_local_sym_info(abfd, symtab_hdr, r_symndx, tls_type) )
2373                 return FALSE;
2374             }
2375           break;
2376
2377         case R_MICROBLAZE_64:
2378         case R_MICROBLAZE_64_PCREL:
2379         case R_MICROBLAZE_32:
2380           {
2381             if (h != NULL && !bfd_link_pic (info))
2382               {
2383                 /* we may need a copy reloc.  */
2384                 h->non_got_ref = 1;
2385
2386                 /* we may also need a .plt entry.  */
2387                 h->plt.refcount += 1;
2388                 if (ELF32_R_TYPE (rel->r_info) != R_MICROBLAZE_64_PCREL)
2389                   h->pointer_equality_needed = 1;
2390               }
2391
2392
2393             /* If we are creating a shared library, and this is a reloc
2394                against a global symbol, or a non PC relative reloc
2395                against a local symbol, then we need to copy the reloc
2396                into the shared library.  However, if we are linking with
2397                -Bsymbolic, we do not need to copy a reloc against a
2398                global symbol which is defined in an object we are
2399                including in the link (i.e., DEF_REGULAR is set).  At
2400                this point we have not seen all the input files, so it is
2401                possible that DEF_REGULAR is not set now but will be set
2402                later (it is never cleared).  In case of a weak definition,
2403                DEF_REGULAR may be cleared later by a strong definition in
2404                a shared library.  We account for that possibility below by
2405                storing information in the relocs_copied field of the hash
2406                table entry.  A similar situation occurs when creating
2407                shared libraries and symbol visibility changes render the
2408                symbol local.
2409
2410                If on the other hand, we are creating an executable, we
2411                may need to keep relocations for symbols satisfied by a
2412                dynamic library if we manage to avoid copy relocs for the
2413                symbol.  */
2414
2415             if ((bfd_link_pic (info)
2416                  && (sec->flags & SEC_ALLOC) != 0
2417                  && (r_type != R_MICROBLAZE_64_PCREL
2418                      || (h != NULL
2419                          && (! info->symbolic
2420                              || h->root.type == bfd_link_hash_defweak
2421                              || !h->def_regular))))
2422                 || (!bfd_link_pic (info)
2423                     && (sec->flags & SEC_ALLOC) != 0
2424                     && h != NULL
2425                     && (h->root.type == bfd_link_hash_defweak
2426                         || !h->def_regular)))
2427               {
2428                 struct elf32_mb_dyn_relocs *p;
2429                 struct elf32_mb_dyn_relocs **head;
2430
2431                 /* When creating a shared object, we must copy these
2432                    relocs into the output file.  We create a reloc
2433                    section in dynobj and make room for the reloc.  */
2434
2435                 if (sreloc == NULL)
2436                   {
2437                     bfd *dynobj;
2438
2439                     if (htab->elf.dynobj == NULL)
2440                       htab->elf.dynobj = abfd;
2441                     dynobj = htab->elf.dynobj;
2442
2443                     sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj,
2444                                                                   2, abfd, 1);
2445                     if (sreloc == NULL)
2446                       return FALSE;
2447                   }
2448
2449                 /* If this is a global symbol, we count the number of
2450                    relocations we need for this symbol.  */
2451                 if (h != NULL)
2452                   head = &((struct elf32_mb_link_hash_entry *) h)->dyn_relocs;
2453                 else
2454                   {
2455                     /* Track dynamic relocs needed for local syms too.
2456                        We really need local syms available to do this
2457                        easily.  Oh well.  */
2458
2459                     asection *s;
2460                     Elf_Internal_Sym *isym;
2461                     void *vpp;
2462
2463                     isym = bfd_sym_from_r_symndx (&htab->sym_sec,
2464                                                   abfd, r_symndx);
2465                     if (isym == NULL)
2466                       return FALSE;
2467
2468                     s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2469                     if (s == NULL)
2470                       return FALSE;
2471
2472                     vpp = &elf_section_data (s)->local_dynrel;
2473                     head = (struct elf32_mb_dyn_relocs **) vpp;
2474                   }
2475
2476                 p = *head;
2477                 if (p == NULL || p->sec != sec)
2478                   {
2479                     bfd_size_type amt = sizeof *p;
2480                     p = ((struct elf32_mb_dyn_relocs *)
2481                          bfd_alloc (htab->elf.dynobj, amt));
2482                     if (p == NULL)
2483                       return FALSE;
2484                     p->next = *head;
2485                     *head = p;
2486                     p->sec = sec;
2487                     p->count = 0;
2488                     p->pc_count = 0;
2489                   }
2490
2491                 p->count += 1;
2492                 if (r_type == R_MICROBLAZE_64_PCREL)
2493                   p->pc_count += 1;
2494               }
2495           }
2496           break;
2497         }
2498     }
2499
2500   return TRUE;
2501 }
2502
2503 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2504
2505 static void
2506 microblaze_elf_copy_indirect_symbol (struct bfd_link_info *info,
2507                                      struct elf_link_hash_entry *dir,
2508                                      struct elf_link_hash_entry *ind)
2509 {
2510   struct elf32_mb_link_hash_entry *edir, *eind;
2511
2512   edir = (struct elf32_mb_link_hash_entry *) dir;
2513   eind = (struct elf32_mb_link_hash_entry *) ind;
2514
2515   if (eind->dyn_relocs != NULL)
2516     {
2517       if (edir->dyn_relocs != NULL)
2518         {
2519           struct elf32_mb_dyn_relocs **pp;
2520           struct elf32_mb_dyn_relocs *p;
2521
2522           if (ind->root.type == bfd_link_hash_indirect)
2523             abort ();
2524
2525           /* Add reloc counts against the weak sym to the strong sym
2526              list.  Merge any entries against the same section.  */
2527           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2528             {
2529               struct elf32_mb_dyn_relocs *q;
2530
2531               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2532                 if (q->sec == p->sec)
2533                   {
2534                     q->pc_count += p->pc_count;
2535                     q->count += p->count;
2536                     *pp = p->next;
2537                     break;
2538                   }
2539               if (q == NULL)
2540                 pp = &p->next;
2541             }
2542           *pp = edir->dyn_relocs;
2543         }
2544
2545       edir->dyn_relocs = eind->dyn_relocs;
2546       eind->dyn_relocs = NULL;
2547     }
2548
2549   edir->tls_mask |= eind->tls_mask;
2550
2551   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2552 }
2553
2554 static bfd_boolean
2555 microblaze_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2556                                       struct elf_link_hash_entry *h)
2557 {
2558   struct elf32_mb_link_hash_table *htab;
2559   struct elf32_mb_link_hash_entry * eh;
2560   struct elf32_mb_dyn_relocs *p;
2561   asection *s, *srel;
2562   unsigned int power_of_two;
2563
2564   htab = elf32_mb_hash_table (info);
2565   if (htab == NULL)
2566     return FALSE;
2567
2568   /* If this is a function, put it in the procedure linkage table.  We
2569      will fill in the contents of the procedure linkage table later,
2570      when we know the address of the .got section.  */
2571   if (h->type == STT_FUNC
2572       || h->needs_plt)
2573     {
2574       if (h->plt.refcount <= 0
2575           || SYMBOL_CALLS_LOCAL (info, h)
2576           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2577               && h->root.type == bfd_link_hash_undefweak))
2578         {
2579           /* This case can occur if we saw a PLT reloc in an input
2580              file, but the symbol was never referred to by a dynamic
2581              object, or if all references were garbage collected.  In
2582              such a case, we don't actually need to build a procedure
2583              linkage table, and we can just do a PC32 reloc instead.  */
2584           h->plt.offset = (bfd_vma) -1;
2585           h->needs_plt = 0;
2586         }
2587
2588       return TRUE;
2589     }
2590   else
2591     /* It's possible that we incorrectly decided a .plt reloc was
2592        needed for an R_MICROBLAZE_64_PCREL reloc to a non-function sym in
2593        check_relocs.  We can't decide accurately between function and
2594        non-function syms in check-relocs;  Objects loaded later in
2595        the link may change h->type.  So fix it now.  */
2596     h->plt.offset = (bfd_vma) -1;
2597
2598   /* If this is a weak symbol, and there is a real definition, the
2599      processor independent code will have arranged for us to see the
2600      real definition first, and we can just use the same value.  */
2601   if (h->u.weakdef != NULL)
2602     {
2603       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2604                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2605       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2606       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2607       return TRUE;
2608     }
2609
2610   /* This is a reference to a symbol defined by a dynamic object which
2611      is not a function.  */
2612
2613   /* If we are creating a shared library, we must presume that the
2614      only references to the symbol are via the global offset table.
2615      For such cases we need not do anything here; the relocations will
2616      be handled correctly by relocate_section.  */
2617   if (bfd_link_pic (info))
2618     return TRUE;
2619
2620   /* If there are no references to this symbol that do not use the
2621      GOT, we don't need to generate a copy reloc.  */
2622   if (!h->non_got_ref)
2623     return TRUE;
2624
2625   /* If -z nocopyreloc was given, we won't generate them either.  */
2626   if (info->nocopyreloc)
2627     {
2628       h->non_got_ref = 0;
2629       return TRUE;
2630     }
2631
2632   eh = (struct elf32_mb_link_hash_entry *) h;
2633   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2634     {
2635       s = p->sec->output_section;
2636       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2637         break;
2638     }
2639
2640   /* If we didn't find any dynamic relocs in read-only sections, then
2641      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2642   if (p == NULL)
2643     {
2644       h->non_got_ref = 0;
2645       return TRUE;
2646     }
2647
2648   /* We must allocate the symbol in our .dynbss section, which will
2649      become part of the .bss section of the executable.  There will be
2650      an entry for this symbol in the .dynsym section.  The dynamic
2651      object will contain position independent code, so all references
2652      from the dynamic object to this symbol will go through the global
2653      offset table.  The dynamic linker will use the .dynsym entry to
2654      determine the address it must put in the global offset table, so
2655      both the dynamic object and the regular object will refer to the
2656      same memory location for the variable.  */
2657
2658   /* We must generate a R_MICROBLAZE_COPY reloc to tell the dynamic linker
2659      to copy the initial value out of the dynamic object and into the
2660      runtime process image.  */
2661   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2662     {
2663       s = htab->elf.sdynrelro;
2664       srel = htab->elf.sreldynrelro;
2665     }
2666   else
2667     {
2668       s = htab->elf.sdynbss;
2669       srel = htab->elf.srelbss;
2670     }
2671   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2672     {
2673       srel->size += sizeof (Elf32_External_Rela);
2674       h->needs_copy = 1;
2675     }
2676
2677   /* We need to figure out the alignment required for this symbol.  I
2678      have no idea how ELF linkers handle this.  */
2679   power_of_two = bfd_log2 (h->size);
2680   if (power_of_two > 3)
2681     power_of_two = 3;
2682
2683   /* Apply the required alignment.  */
2684   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
2685   if (power_of_two > s->alignment_power)
2686     {
2687       if (!bfd_set_section_alignment (s->owner, s, power_of_two))
2688         return FALSE;
2689     }
2690
2691   /* Define the symbol as being at this point in the section.  */
2692   h->root.u.def.section = s;
2693   h->root.u.def.value = s->size;
2694
2695   /* Increment the section size to make room for the symbol.  */
2696   s->size += h->size;
2697   return TRUE;
2698 }
2699
2700 /* Allocate space in .plt, .got and associated reloc sections for
2701    dynamic relocs.  */
2702
2703 static bfd_boolean
2704 allocate_dynrelocs (struct elf_link_hash_entry *h, void * dat)
2705 {
2706   struct bfd_link_info *info;
2707   struct elf32_mb_link_hash_table *htab;
2708   struct elf32_mb_link_hash_entry *eh;
2709   struct elf32_mb_dyn_relocs *p;
2710
2711   if (h->root.type == bfd_link_hash_indirect)
2712     return TRUE;
2713
2714   info = (struct bfd_link_info *) dat;
2715   htab = elf32_mb_hash_table (info);
2716   if (htab == NULL)
2717     return FALSE;
2718
2719   if (htab->elf.dynamic_sections_created
2720       && h->plt.refcount > 0)
2721     {
2722       /* Make sure this symbol is output as a dynamic symbol.
2723          Undefined weak syms won't yet be marked as dynamic.  */
2724       if (h->dynindx == -1
2725           && !h->forced_local)
2726         {
2727           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2728             return FALSE;
2729         }
2730
2731       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
2732         {
2733           asection *s = htab->elf.splt;
2734
2735           /* The first entry in .plt is reserved.  */
2736           if (s->size == 0)
2737             s->size = PLT_ENTRY_SIZE;
2738
2739           h->plt.offset = s->size;
2740
2741           /* If this symbol is not defined in a regular file, and we are
2742              not generating a shared library, then set the symbol to this
2743              location in the .plt.  This is required to make function
2744              pointers compare as equal between the normal executable and
2745              the shared library.  */
2746           if (! bfd_link_pic (info)
2747               && !h->def_regular)
2748             {
2749               h->root.u.def.section = s;
2750               h->root.u.def.value = h->plt.offset;
2751             }
2752
2753           /* Make room for this entry.  */
2754           s->size += PLT_ENTRY_SIZE;
2755
2756           /* We also need to make an entry in the .got.plt section, which
2757              will be placed in the .got section by the linker script.  */
2758           htab->elf.sgotplt->size += 4;
2759
2760           /* We also need to make an entry in the .rel.plt section.  */
2761           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
2762         }
2763       else
2764         {
2765           h->plt.offset = (bfd_vma) -1;
2766           h->needs_plt = 0;
2767         }
2768     }
2769   else
2770     {
2771       h->plt.offset = (bfd_vma) -1;
2772       h->needs_plt = 0;
2773     }
2774
2775   eh = (struct elf32_mb_link_hash_entry *) h;
2776   if (h->got.refcount > 0)
2777     {
2778       unsigned int need;
2779       asection *s;
2780
2781       /* Make sure this symbol is output as a dynamic symbol.
2782          Undefined weak syms won't yet be marked as dynamic.  */
2783       if (h->dynindx == -1
2784           && !h->forced_local)
2785         {
2786           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2787             return FALSE;
2788         }
2789
2790       need = 0;
2791       if ((eh->tls_mask & TLS_TLS) != 0)
2792         {
2793           /* Handle TLS Symbol */
2794           if ((eh->tls_mask & TLS_LD) != 0)
2795             {
2796               if (!eh->elf.def_dynamic)
2797                 /* We'll just use htab->tlsld_got.offset.  This should
2798                    always be the case.  It's a little odd if we have
2799                    a local dynamic reloc against a non-local symbol.  */
2800                 htab->tlsld_got.refcount += 1;
2801               else
2802                 need += 8;
2803             }
2804           if ((eh->tls_mask & TLS_GD) != 0)
2805             need += 8;
2806         }
2807       else
2808         {
2809           /* Regular (non-TLS) symbol */
2810           need += 4;
2811         }
2812       if (need == 0)
2813         {
2814           h->got.offset = (bfd_vma) -1;
2815         }
2816       else
2817         {
2818           s = htab->elf.sgot;
2819           h->got.offset = s->size;
2820           s->size += need;
2821           htab->elf.srelgot->size += need * (sizeof (Elf32_External_Rela) / 4);
2822         }
2823     }
2824   else
2825     h->got.offset = (bfd_vma) -1;
2826
2827   if (eh->dyn_relocs == NULL)
2828     return TRUE;
2829
2830   /* In the shared -Bsymbolic case, discard space allocated for
2831      dynamic pc-relative relocs against symbols which turn out to be
2832      defined in regular objects.  For the normal shared case, discard
2833      space for pc-relative relocs that have become local due to symbol
2834      visibility changes.  */
2835
2836   if (bfd_link_pic (info))
2837     {
2838       if (h->def_regular
2839           && (h->forced_local
2840               || info->symbolic))
2841         {
2842           struct elf32_mb_dyn_relocs **pp;
2843
2844           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2845             {
2846               p->count -= p->pc_count;
2847               p->pc_count = 0;
2848               if (p->count == 0)
2849                 *pp = p->next;
2850               else
2851                 pp = &p->next;
2852             }
2853         }
2854     }
2855   else
2856     {
2857       /* For the non-shared case, discard space for relocs against
2858          symbols which turn out to need copy relocs or are not
2859          dynamic.  */
2860
2861       if (!h->non_got_ref
2862           && ((h->def_dynamic
2863                && !h->def_regular)
2864               || (htab->elf.dynamic_sections_created
2865                   && (h->root.type == bfd_link_hash_undefweak
2866                       || h->root.type == bfd_link_hash_undefined))))
2867         {
2868           /* Make sure this symbol is output as a dynamic symbol.
2869              Undefined weak syms won't yet be marked as dynamic.  */
2870           if (h->dynindx == -1
2871               && !h->forced_local)
2872             {
2873               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2874                 return FALSE;
2875             }
2876
2877           /* If that succeeded, we know we'll be keeping all the
2878              relocs.  */
2879           if (h->dynindx != -1)
2880             goto keep;
2881         }
2882
2883       eh->dyn_relocs = NULL;
2884
2885     keep: ;
2886     }
2887
2888   /* Finally, allocate space.  */
2889   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2890     {
2891       asection *sreloc = elf_section_data (p->sec)->sreloc;
2892       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2893     }
2894
2895   return TRUE;
2896 }
2897
2898 /* Set the sizes of the dynamic sections.  */
2899
2900 static bfd_boolean
2901 microblaze_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2902                                       struct bfd_link_info *info)
2903 {
2904   struct elf32_mb_link_hash_table *htab;
2905   bfd *dynobj;
2906   asection *s;
2907   bfd *ibfd;
2908
2909   htab = elf32_mb_hash_table (info);
2910   if (htab == NULL)
2911     return FALSE;
2912
2913   dynobj = htab->elf.dynobj;
2914   BFD_ASSERT (dynobj != NULL);
2915
2916   /* Set up .got offsets for local syms, and space for local dynamic
2917      relocs.  */
2918   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2919     {
2920       bfd_signed_vma *local_got;
2921       bfd_signed_vma *end_local_got;
2922       bfd_size_type locsymcount;
2923       Elf_Internal_Shdr *symtab_hdr;
2924       unsigned char *lgot_masks;
2925       asection *srel;
2926
2927       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2928         continue;
2929
2930       for (s = ibfd->sections; s != NULL; s = s->next)
2931         {
2932           struct elf32_mb_dyn_relocs *p;
2933
2934           for (p = ((struct elf32_mb_dyn_relocs *)
2935                     elf_section_data (s)->local_dynrel);
2936                p != NULL;
2937                p = p->next)
2938             {
2939               if (!bfd_is_abs_section (p->sec)
2940                   && bfd_is_abs_section (p->sec->output_section))
2941                 {
2942                   /* Input section has been discarded, either because
2943                      it is a copy of a linkonce section or due to
2944                      linker script /DISCARD/, so we'll be discarding
2945                      the relocs too.  */
2946                 }
2947               else if (p->count != 0)
2948                 {
2949                   srel = elf_section_data (p->sec)->sreloc;
2950                   srel->size += p->count * sizeof (Elf32_External_Rela);
2951                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2952                     info->flags |= DF_TEXTREL;
2953                 }
2954             }
2955         }
2956
2957       local_got = elf_local_got_refcounts (ibfd);
2958       if (!local_got)
2959         continue;
2960
2961       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2962       locsymcount = symtab_hdr->sh_info;
2963       end_local_got = local_got + locsymcount;
2964       lgot_masks = (unsigned char *) end_local_got;
2965       s = htab->elf.sgot;
2966       srel = htab->elf.srelgot;
2967
2968       for (; local_got < end_local_got; ++local_got, ++lgot_masks)
2969         {
2970           if (*local_got > 0)
2971             {
2972               unsigned int need = 0;
2973               if ((*lgot_masks & TLS_TLS) != 0)
2974                 {
2975                   if ((*lgot_masks & TLS_GD) != 0)
2976                     need += 8;
2977                   if ((*lgot_masks & TLS_LD) != 0)
2978                     htab->tlsld_got.refcount += 1;
2979                 }
2980               else
2981                 need += 4;
2982
2983               if (need == 0)
2984                 {
2985                   *local_got = (bfd_vma) -1;
2986                 }
2987               else
2988                 {
2989                   *local_got = s->size;
2990                   s->size += need;
2991                   if (bfd_link_pic (info))
2992                     srel->size += need * (sizeof (Elf32_External_Rela) / 4);
2993                 }
2994             }
2995           else
2996             *local_got = (bfd_vma) -1;
2997         }
2998     }
2999
3000   /* Allocate global sym .plt and .got entries, and space for global
3001      sym dynamic relocs.  */
3002   elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info);
3003
3004   if (htab->tlsld_got.refcount > 0)
3005     {
3006       htab->tlsld_got.offset = htab->elf.sgot->size;
3007       htab->elf.sgot->size += 8;
3008       if (bfd_link_pic (info))
3009         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
3010     }
3011   else
3012     htab->tlsld_got.offset = (bfd_vma) -1;
3013
3014   if (elf_hash_table (info)->dynamic_sections_created)
3015     {
3016       /* Make space for the trailing nop in .plt.  */
3017       if (htab->elf.splt->size > 0)
3018         htab->elf.splt->size += 4;
3019     }
3020
3021   /* The check_relocs and adjust_dynamic_symbol entry points have
3022      determined the sizes of the various dynamic sections.  Allocate
3023      memory for them.  */
3024   for (s = dynobj->sections; s != NULL; s = s->next)
3025     {
3026       const char *name;
3027       bfd_boolean strip = FALSE;
3028
3029       if ((s->flags & SEC_LINKER_CREATED) == 0)
3030         continue;
3031
3032       /* It's OK to base decisions on the section name, because none
3033          of the dynobj section names depend upon the input files.  */
3034       name = bfd_get_section_name (dynobj, s);
3035
3036       if (strncmp (name, ".rela", 5) == 0)
3037         {
3038           if (s->size == 0)
3039             {
3040               /* If we don't need this section, strip it from the
3041                  output file.  This is to handle .rela.bss and
3042                  .rela.plt.  We must create it in
3043                  create_dynamic_sections, because it must be created
3044                  before the linker maps input sections to output
3045                  sections.  The linker does that before
3046                  adjust_dynamic_symbol is called, and it is that
3047                  function which decides whether anything needs to go
3048                  into these sections.  */
3049               strip = TRUE;
3050             }
3051           else
3052             {
3053               /* We use the reloc_count field as a counter if we need
3054                  to copy relocs into the output file.  */
3055               s->reloc_count = 0;
3056             }
3057         }
3058       else if (s != htab->elf.splt
3059                && s != htab->elf.sgot
3060                && s != htab->elf.sgotplt
3061                && s != htab->elf.sdynbss
3062                && s != htab->elf.sdynrelro)
3063         {
3064           /* It's not one of our sections, so don't allocate space.  */
3065           continue;
3066         }
3067
3068       if (strip)
3069         {
3070           s->flags |= SEC_EXCLUDE;
3071           continue;
3072         }
3073
3074       /* Allocate memory for the section contents.  */
3075       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3076          Unused entries should be reclaimed before the section's contents
3077          are written out, but at the moment this does not happen.  Thus in
3078          order to prevent writing out garbage, we initialise the section's
3079          contents to zero.  */
3080       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3081       if (s->contents == NULL && s->size != 0)
3082         return FALSE;
3083     }
3084
3085   if (elf_hash_table (info)->dynamic_sections_created)
3086     {
3087       /* Add some entries to the .dynamic section.  We fill in the
3088          values later, in microblaze_elf_finish_dynamic_sections, but we
3089          must add the entries now so that we get the correct size for
3090          the .dynamic section.  The DT_DEBUG entry is filled in by the
3091          dynamic linker and used by the debugger.  */
3092 #define add_dynamic_entry(TAG, VAL)                     \
3093       _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3094
3095       if (bfd_link_executable (info))
3096         {
3097           if (!add_dynamic_entry (DT_DEBUG, 0))
3098             return FALSE;
3099         }
3100
3101       if (!add_dynamic_entry (DT_RELA, 0)
3102           || !add_dynamic_entry (DT_RELASZ, 0)
3103           || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3104         return FALSE;
3105
3106       if (htab->elf.splt->size != 0)
3107         {
3108           if (!add_dynamic_entry (DT_PLTGOT, 0)
3109               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3110               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3111               || !add_dynamic_entry (DT_JMPREL, 0)
3112               || !add_dynamic_entry (DT_BIND_NOW, 1))
3113             return FALSE;
3114         }
3115
3116       if (info->flags & DF_TEXTREL)
3117         {
3118           if (!add_dynamic_entry (DT_TEXTREL, 0))
3119             return FALSE;
3120         }
3121     }
3122 #undef add_dynamic_entry
3123   return TRUE;
3124 }
3125
3126 /* Finish up dynamic symbol handling.  We set the contents of various
3127    dynamic sections here.  */
3128
3129 static bfd_boolean
3130 microblaze_elf_finish_dynamic_symbol (bfd *output_bfd,
3131                                       struct bfd_link_info *info,
3132                                       struct elf_link_hash_entry *h,
3133                                       Elf_Internal_Sym *sym)
3134 {
3135   struct elf32_mb_link_hash_table *htab;
3136   struct elf32_mb_link_hash_entry *eh = elf32_mb_hash_entry(h);
3137
3138   htab = elf32_mb_hash_table (info);
3139   if (htab == NULL)
3140     return FALSE;
3141
3142   if (h->plt.offset != (bfd_vma) -1)
3143     {
3144       asection *splt;
3145       asection *srela;
3146       asection *sgotplt;
3147       Elf_Internal_Rela rela;
3148       bfd_byte *loc;
3149       bfd_vma plt_index;
3150       bfd_vma got_offset;
3151       bfd_vma got_addr;
3152
3153       /* This symbol has an entry in the procedure linkage table.  Set
3154          it up.  */
3155       BFD_ASSERT (h->dynindx != -1);
3156
3157       splt = htab->elf.splt;
3158       srela = htab->elf.srelplt;
3159       sgotplt = htab->elf.sgotplt;
3160       BFD_ASSERT (splt != NULL && srela != NULL && sgotplt != NULL);
3161
3162       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; /* first entry reserved.  */
3163       got_offset = (plt_index + 3) * 4; /* 3 reserved ???  */
3164       got_addr = got_offset;
3165
3166       /* For non-PIC objects we need absolute address of the GOT entry.  */
3167       if (!bfd_link_pic (info))
3168         got_addr += sgotplt->output_section->vma + sgotplt->output_offset;
3169
3170       /* Fill in the entry in the procedure linkage table.  */
3171       bfd_put_32 (output_bfd, PLT_ENTRY_WORD_0 + ((got_addr >> 16) & 0xffff),
3172                   splt->contents + h->plt.offset);
3173       if (bfd_link_pic (info))
3174         bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1 + (got_addr & 0xffff),
3175                     splt->contents + h->plt.offset + 4);
3176       else
3177         bfd_put_32 (output_bfd, PLT_ENTRY_WORD_1_NOPIC + (got_addr & 0xffff),
3178                     splt->contents + h->plt.offset + 4);
3179       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_2,
3180                   splt->contents + h->plt.offset + 8);
3181       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD_3,
3182                   splt->contents + h->plt.offset + 12);
3183
3184       /* Any additions to the .got section??? */
3185       /*      bfd_put_32 (output_bfd,
3186               splt->output_section->vma + splt->output_offset + h->plt.offset + 4,
3187               sgotplt->contents + got_offset); */
3188
3189       /* Fill in the entry in the .rela.plt section.  */
3190       rela.r_offset = (sgotplt->output_section->vma
3191                        + sgotplt->output_offset
3192                        + got_offset);
3193       rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_JUMP_SLOT);
3194       rela.r_addend = 0;
3195       loc = srela->contents;
3196       loc += plt_index * sizeof (Elf32_External_Rela);
3197       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3198
3199       if (!h->def_regular)
3200         {
3201           /* Mark the symbol as undefined, rather than as defined in
3202              the .plt section.  Zero the value.  */
3203           sym->st_shndx = SHN_UNDEF;
3204           sym->st_value = 0;
3205         }
3206     }
3207
3208   /* h->got.refcount to be checked ? */
3209   if (h->got.offset != (bfd_vma) -1 &&
3210       ! ((h->got.offset & 1) ||
3211           IS_TLS_LD(eh->tls_mask) || IS_TLS_GD(eh->tls_mask)))
3212     {
3213       asection *sgot;
3214       asection *srela;
3215       bfd_vma offset;
3216
3217       /* This symbol has an entry in the global offset table.  Set it
3218          up.  */
3219
3220       sgot = htab->elf.sgot;
3221       srela = htab->elf.srelgot;
3222       BFD_ASSERT (sgot != NULL && srela != NULL);
3223
3224       offset = (sgot->output_section->vma + sgot->output_offset
3225                 + (h->got.offset &~ (bfd_vma) 1));
3226
3227       /* If this is a -Bsymbolic link, and the symbol is defined
3228          locally, we just want to emit a RELATIVE reloc.  Likewise if
3229          the symbol was forced to be local because of a version file.
3230          The entry in the global offset table will already have been
3231          initialized in the relocate_section function.  */
3232       if (bfd_link_pic (info)
3233           && ((info->symbolic && h->def_regular)
3234               || h->dynindx == -1))
3235         {
3236           asection *sec = h->root.u.def.section;
3237           bfd_vma value;
3238
3239           value = h->root.u.def.value;
3240           if (sec->output_section != NULL)
3241             /* PR 21180: If the output section is NULL, then the symbol is no
3242                longer needed, and in theory the GOT entry is redundant.  But
3243                it is too late to change our minds now...  */
3244             value += sec->output_section->vma + sec->output_offset;
3245
3246           microblaze_elf_output_dynamic_relocation (output_bfd,
3247                                                     srela, srela->reloc_count++,
3248                                                     /* symindex= */ 0,
3249                                                     R_MICROBLAZE_REL, offset,
3250                                                     value);
3251         }
3252       else
3253         {
3254           microblaze_elf_output_dynamic_relocation (output_bfd,
3255                                                     srela, srela->reloc_count++,
3256                                                     h->dynindx,
3257                                                     R_MICROBLAZE_GLOB_DAT,
3258                                                     offset, 0);
3259         }
3260
3261       bfd_put_32 (output_bfd, (bfd_vma) 0,
3262                   sgot->contents + (h->got.offset &~ (bfd_vma) 1));
3263     }
3264
3265   if (h->needs_copy)
3266     {
3267       asection *s;
3268       Elf_Internal_Rela rela;
3269       bfd_byte *loc;
3270
3271       /* This symbols needs a copy reloc.  Set it up.  */
3272
3273       BFD_ASSERT (h->dynindx != -1);
3274
3275       rela.r_offset = (h->root.u.def.value
3276                        + h->root.u.def.section->output_section->vma
3277                        + h->root.u.def.section->output_offset);
3278       rela.r_info = ELF32_R_INFO (h->dynindx, R_MICROBLAZE_COPY);
3279       rela.r_addend = 0;
3280       if (h->root.u.def.section == htab->elf.sdynrelro)
3281         s = htab->elf.sreldynrelro;
3282       else
3283         s = htab->elf.srelbss;
3284       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3285       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3286     }
3287
3288   /* Mark some specially defined symbols as absolute.  */
3289   if (h == htab->elf.hdynamic
3290       || h == htab->elf.hgot
3291       || h == htab->elf.hplt)
3292     sym->st_shndx = SHN_ABS;
3293
3294   return TRUE;
3295 }
3296
3297
3298 /* Finish up the dynamic sections.  */
3299
3300 static bfd_boolean
3301 microblaze_elf_finish_dynamic_sections (bfd *output_bfd,
3302                                         struct bfd_link_info *info)
3303 {
3304   bfd *dynobj;
3305   asection *sdyn, *sgot;
3306   struct elf32_mb_link_hash_table *htab;
3307
3308   htab = elf32_mb_hash_table (info);
3309   if (htab == NULL)
3310     return FALSE;
3311
3312   dynobj = htab->elf.dynobj;
3313
3314   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3315
3316   if (htab->elf.dynamic_sections_created)
3317     {
3318       asection *splt;
3319       Elf32_External_Dyn *dyncon, *dynconend;
3320
3321       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3322       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3323       for (; dyncon < dynconend; dyncon++)
3324         {
3325           Elf_Internal_Dyn dyn;
3326           asection *s;
3327           bfd_boolean size;
3328
3329           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3330
3331           switch (dyn.d_tag)
3332             {
3333             case DT_PLTGOT:
3334               s = htab->elf.sgotplt;
3335               size = FALSE;
3336               break;
3337
3338             case DT_PLTRELSZ:
3339               s = htab->elf.srelplt;
3340               size = TRUE;
3341               break;
3342
3343             case DT_JMPREL:
3344               s = htab->elf.srelplt;
3345               size = FALSE;
3346               break;
3347
3348             default:
3349               continue;
3350             }
3351
3352           if (s == NULL)
3353             dyn.d_un.d_val = 0;
3354           else
3355             {
3356               if (!size)
3357                 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3358               else
3359                 dyn.d_un.d_val = s->size;
3360             }
3361           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3362         }
3363
3364       splt = htab->elf.splt;
3365       BFD_ASSERT (splt != NULL && sdyn != NULL);
3366
3367       /* Clear the first entry in the procedure linkage table,
3368          and put a nop in the last four bytes.  */
3369       if (splt->size > 0)
3370         {
3371           memset (splt->contents, 0, PLT_ENTRY_SIZE);
3372           bfd_put_32 (output_bfd, (bfd_vma) 0x80000000 /* nop.  */,
3373                       splt->contents + splt->size - 4);
3374         }
3375
3376       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3377     }
3378
3379   /* Set the first entry in the global offset table to the address of
3380      the dynamic section.  */
3381   sgot = htab->elf.sgotplt;
3382   if (sgot && sgot->size > 0)
3383     {
3384       if (sdyn == NULL)
3385         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3386       else
3387         bfd_put_32 (output_bfd,
3388                     sdyn->output_section->vma + sdyn->output_offset,
3389                     sgot->contents);
3390       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3391     }
3392
3393   if (htab->elf.sgot && htab->elf.sgot->size > 0)
3394     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4;
3395
3396   return TRUE;
3397 }
3398
3399 /* Hook called by the linker routine which adds symbols from an object
3400    file.  We use it to put .comm items in .sbss, and not .bss.  */
3401
3402 static bfd_boolean
3403 microblaze_elf_add_symbol_hook (bfd *abfd,
3404                                 struct bfd_link_info *info,
3405                                 Elf_Internal_Sym *sym,
3406                                 const char **namep ATTRIBUTE_UNUSED,
3407                                 flagword *flagsp ATTRIBUTE_UNUSED,
3408                                 asection **secp,
3409                                 bfd_vma *valp)
3410 {
3411   if (sym->st_shndx == SHN_COMMON
3412       && !bfd_link_relocatable (info)
3413       && sym->st_size <= elf_gp_size (abfd))
3414     {
3415       /* Common symbols less than or equal to -G nn bytes are automatically
3416          put into .sbss.  */
3417       *secp = bfd_make_section_old_way (abfd, ".sbss");
3418       if (*secp == NULL
3419           || ! bfd_set_section_flags (abfd, *secp, SEC_IS_COMMON))
3420         return FALSE;
3421
3422       *valp = sym->st_size;
3423     }
3424
3425   return TRUE;
3426 }
3427
3428 #define TARGET_LITTLE_SYM      microblaze_elf32_le_vec
3429 #define TARGET_LITTLE_NAME     "elf32-microblazeel"
3430
3431 #define TARGET_BIG_SYM          microblaze_elf32_vec
3432 #define TARGET_BIG_NAME         "elf32-microblaze"
3433
3434 #define ELF_ARCH                bfd_arch_microblaze
3435 #define ELF_TARGET_ID           MICROBLAZE_ELF_DATA
3436 #define ELF_MACHINE_CODE        EM_MICROBLAZE
3437 #define ELF_MACHINE_ALT1        EM_MICROBLAZE_OLD
3438 #define ELF_MAXPAGESIZE         0x1000
3439 #define elf_info_to_howto       microblaze_elf_info_to_howto
3440 #define elf_info_to_howto_rel   NULL
3441
3442 #define bfd_elf32_bfd_reloc_type_lookup         microblaze_elf_reloc_type_lookup
3443 #define bfd_elf32_bfd_is_local_label_name       microblaze_elf_is_local_label_name
3444 #define elf_backend_relocate_section            microblaze_elf_relocate_section
3445 #define bfd_elf32_bfd_relax_section             microblaze_elf_relax_section
3446 #define bfd_elf32_bfd_merge_private_bfd_data    _bfd_generic_verify_endian_match
3447 #define bfd_elf32_bfd_reloc_name_lookup         microblaze_elf_reloc_name_lookup
3448
3449 #define elf_backend_gc_mark_hook                microblaze_elf_gc_mark_hook
3450 #define elf_backend_gc_sweep_hook               microblaze_elf_gc_sweep_hook
3451 #define elf_backend_check_relocs                microblaze_elf_check_relocs
3452 #define elf_backend_copy_indirect_symbol        microblaze_elf_copy_indirect_symbol
3453 #define bfd_elf32_bfd_link_hash_table_create    microblaze_elf_link_hash_table_create
3454 #define elf_backend_can_gc_sections             1
3455 #define elf_backend_can_refcount                1
3456 #define elf_backend_want_got_plt                1
3457 #define elf_backend_plt_readonly                1
3458 #define elf_backend_got_header_size             12
3459 #define elf_backend_want_dynrelro               1
3460 #define elf_backend_rela_normal                 1
3461 #define elf_backend_dtrel_excludes_plt          1
3462
3463 #define elf_backend_adjust_dynamic_symbol       microblaze_elf_adjust_dynamic_symbol
3464 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3465 #define elf_backend_finish_dynamic_sections     microblaze_elf_finish_dynamic_sections
3466 #define elf_backend_finish_dynamic_symbol       microblaze_elf_finish_dynamic_symbol
3467 #define elf_backend_size_dynamic_sections       microblaze_elf_size_dynamic_sections
3468 #define elf_backend_add_symbol_hook             microblaze_elf_add_symbol_hook
3469
3470 #include "elf32-target.h"