bfd/elf32-microblaze.c

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