bfd/elf32-microblaze.c

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