bfd/elf32-microblaze.c

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