bfd/elf32-microblaze.c

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