bfd/elf32-microblaze.c

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