bfd/elf32-nios2.c

   1 /* 32-bit ELF support for Nios II.
   2    Copyright (C) 2012, 2013 Free Software Foundation, Inc.
   3    Contributed by Nigel Gray (ngray@altera.com).
   4    Contributed by Mentor Graphics, Inc.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 /* This file handles Altera Nios II ELF targets.  */
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "libbfd.h"
  28 #include "bfdlink.h"
  29 #include "genlink.h"
  30 #include "elf-bfd.h"
  31 #include "elf/nios2.h"
  32 #include "opcode/nios2.h"
  33
  34 /* Use RELA relocations.  */
  35 #ifndef USE_RELA
  36 #define USE_RELA
  37 #endif
  38
  39 #ifdef USE_REL
  40 #undef USE_REL
  41 #endif
  42
  43 /* Forward declarations.  */
  44 static bfd_reloc_status_type nios2_elf32_ignore_reloc
  45   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  46 static bfd_reloc_status_type nios2_elf32_hi16_relocate
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type nios2_elf32_lo16_relocate
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
  57   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  58 static bfd_reloc_status_type nios2_elf32_call26_relocate
  59   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  60 static bfd_reloc_status_type nios2_elf32_gprel_relocate
  61   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  62 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
  63   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  64 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
  65   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  66 static bfd_reloc_status_type nios2_elf32_callr_relocate
  67   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  68
  69 /* Target vector.  */
  70 extern const bfd_target bfd_elf32_littlenios2_vec;
  71 extern const bfd_target bfd_elf32_bignios2_vec;
  72
  73 /* Offset of tp and dtp pointers from start of TLS block.  */
  74 #define TP_OFFSET       0x7000
  75 #define DTP_OFFSET      0x8000
  76
  77 /* The relocation table used for SHT_REL sections.  */
  78 static reloc_howto_type elf_nios2_howto_table_rel[] = {
  79   /* No relocation.  */
  80   HOWTO (R_NIOS2_NONE,          /* type */
  81          0,                     /* rightshift */
  82          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          0,                     /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_dont,        /* complain_on_overflow */
  87          bfd_elf_generic_reloc, /* special_function */
  88          "R_NIOS2_NONE",        /* name */
  89          FALSE,                 /* partial_inplace */
  90          0,                     /* src_mask */
  91          0,                     /* dst_mask */
  92          FALSE),                /* pcrel_offset */
  93
  94   /* 16-bit signed immediate relocation.  */
  95   HOWTO (R_NIOS2_S16,           /* type */
  96          0,                     /* rightshift */
  97          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  98          16,                    /* bitsize */
  99          FALSE,                 /* pc_relative */
 100          6,                     /* bitpos */
 101          complain_overflow_signed,      /* complain on overflow */
 102          bfd_elf_generic_reloc, /* special function */
 103          "R_NIOS2_S16",         /* name */
 104          FALSE,                 /* partial_inplace */
 105          0x003fffc0,            /* src_mask */
 106          0x003fffc0,            /* dest_mask */
 107          FALSE),                /* pcrel_offset */
 108
 109   /* 16-bit unsigned immediate relocation.  */
 110   HOWTO (R_NIOS2_U16,           /* type */
 111          0,                     /* rightshift */
 112          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 113          16,                    /* bitsize */
 114          FALSE,                 /* pc_relative */
 115          6,                     /* bitpos */
 116          complain_overflow_unsigned,    /* complain on overflow */
 117          bfd_elf_generic_reloc, /* special function */
 118          "R_NIOS2_U16",         /* name */
 119          FALSE,                 /* partial_inplace */
 120          0x003fffc0,            /* src_mask */
 121          0x003fffc0,            /* dest_mask */
 122          FALSE),                /* pcrel_offset */
 123
 124   HOWTO (R_NIOS2_PCREL16,       /* type */
 125          0,                     /* rightshift */
 126          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 127          16,                    /* bitsize */
 128          TRUE,                  /* pc_relative */
 129          6,                     /* bitpos */
 130          complain_overflow_signed,      /* complain on overflow */
 131          nios2_elf32_pcrel16_relocate,  /* special function */
 132          "R_NIOS2_PCREL16",     /* name */
 133          FALSE,                 /* partial_inplace */
 134          0x003fffc0,            /* src_mask */
 135          0x003fffc0,            /* dest_mask */
 136          TRUE),                 /* pcrel_offset */
 137
 138   HOWTO (R_NIOS2_CALL26,        /* type */
 139          2,                     /* rightshift */
 140          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 141          26,                    /* bitsize */
 142          FALSE,                 /* pc_relative */
 143          6,                     /* bitpos */
 144          complain_overflow_dont,        /* complain on overflow */
 145          nios2_elf32_call26_relocate,   /* special function */
 146          "R_NIOS2_CALL26",      /* name */
 147          FALSE,                 /* partial_inplace */
 148          0xffffffc0,            /* src_mask */
 149          0xffffffc0,            /* dst_mask */
 150          FALSE),                /* pcrel_offset */
 151
 152   HOWTO (R_NIOS2_IMM5,
 153          0,
 154          2,
 155          5,
 156          FALSE,
 157          6,
 158          complain_overflow_bitfield,
 159          bfd_elf_generic_reloc,
 160          "R_NIOS2_IMM5",
 161          FALSE,
 162          0x000007c0,
 163          0x000007c0,
 164          FALSE),
 165
 166   HOWTO (R_NIOS2_CACHE_OPX,
 167          0,
 168          2,
 169          5,
 170          FALSE,
 171          22,
 172          complain_overflow_bitfield,
 173          bfd_elf_generic_reloc,
 174          "R_NIOS2_CACHE_OPX",
 175          FALSE,
 176          0x07c00000,
 177          0x07c00000,
 178          FALSE),
 179
 180   HOWTO (R_NIOS2_IMM6,
 181          0,
 182          2,
 183          6,
 184          FALSE,
 185          6,
 186          complain_overflow_bitfield,
 187          bfd_elf_generic_reloc,
 188          "R_NIOS2_IMM6",
 189          FALSE,
 190          0x00000fc0,
 191          0x00000fc0,
 192          FALSE),
 193
 194   HOWTO (R_NIOS2_IMM8,
 195          0,
 196          2,
 197          8,
 198          FALSE,
 199          6,
 200          complain_overflow_bitfield,
 201          bfd_elf_generic_reloc,
 202          "R_NIOS2_IMM8",
 203          FALSE,
 204          0x00003fc0,
 205          0x00003fc0,
 206          FALSE),
 207
 208   HOWTO (R_NIOS2_HI16,
 209          0,
 210          2,
 211          32,
 212          FALSE,
 213          6,
 214          complain_overflow_dont,
 215          nios2_elf32_hi16_relocate,
 216          "R_NIOS2_HI16",
 217          FALSE,
 218          0x003fffc0,
 219          0x003fffc0,
 220          FALSE),
 221
 222   HOWTO (R_NIOS2_LO16,
 223          0,
 224          2,
 225          32,
 226          FALSE,
 227          6,
 228          complain_overflow_dont,
 229          nios2_elf32_lo16_relocate,
 230          "R_NIOS2_LO16",
 231          FALSE,
 232          0x003fffc0,
 233          0x003fffc0,
 234          FALSE),
 235
 236   HOWTO (R_NIOS2_HIADJ16,
 237          0,
 238          2,
 239          32,
 240          FALSE,
 241          6,
 242          complain_overflow_dont,
 243          nios2_elf32_hiadj16_relocate,
 244          "R_NIOS2_HIADJ16",
 245          FALSE,
 246          0x003fffc0,
 247          0x003fffc0,
 248          FALSE),
 249
 250   HOWTO (R_NIOS2_BFD_RELOC_32,
 251          0,
 252          2,                     /* long */
 253          32,
 254          FALSE,
 255          0,
 256          complain_overflow_dont,
 257          bfd_elf_generic_reloc,
 258          "R_NIOS2_BFD_RELOC32",
 259          FALSE,
 260          0xffffffff,
 261          0xffffffff,
 262          FALSE),
 263
 264   HOWTO (R_NIOS2_BFD_RELOC_16,
 265          0,
 266          1,                     /* short */
 267          16,
 268          FALSE,
 269          0,
 270          complain_overflow_bitfield,
 271          bfd_elf_generic_reloc,
 272          "R_NIOS2_BFD_RELOC16",
 273          FALSE,
 274          0x0000ffff,
 275          0x0000ffff,
 276          FALSE),
 277
 278   HOWTO (R_NIOS2_BFD_RELOC_8,
 279          0,
 280          0,                     /* byte */
 281          8,
 282          FALSE,
 283          0,
 284          complain_overflow_bitfield,
 285          bfd_elf_generic_reloc,
 286          "R_NIOS2_BFD_RELOC8",
 287          FALSE,
 288          0x000000ff,
 289          0x000000ff,
 290          FALSE),
 291
 292   HOWTO (R_NIOS2_GPREL,
 293          0,
 294          2,
 295          32,
 296          FALSE,
 297          6,
 298          complain_overflow_dont,
 299          nios2_elf32_gprel_relocate,
 300          "R_NIOS2_GPREL",
 301          FALSE,
 302          0x003fffc0,
 303          0x003fffc0,
 304          FALSE),
 305
 306   HOWTO (R_NIOS2_GNU_VTINHERIT,
 307          0,
 308          2,                     /* short */
 309          0,
 310          FALSE,
 311          0,
 312          complain_overflow_dont,
 313          NULL,
 314          "R_NIOS2_GNU_VTINHERIT",
 315          FALSE,
 316          0,
 317          0,
 318          FALSE),
 319
 320   HOWTO (R_NIOS2_GNU_VTENTRY,
 321          0,
 322          2,                     /* byte */
 323          0,
 324          FALSE,
 325          0,
 326          complain_overflow_dont,
 327          _bfd_elf_rel_vtable_reloc_fn,
 328          "R_NIOS2_GNU_VTENTRY",
 329          FALSE,
 330          0,
 331          0,
 332          FALSE),
 333
 334   HOWTO (R_NIOS2_UJMP,
 335          0,
 336          2,
 337          32,
 338          FALSE,
 339          6,
 340          complain_overflow_dont,
 341          nios2_elf32_ujmp_relocate,
 342          "R_NIOS2_UJMP",
 343          FALSE,
 344          0x003fffc0,
 345          0x003fffc0,
 346          FALSE),
 347
 348   HOWTO (R_NIOS2_CJMP,
 349          0,
 350          2,
 351          32,
 352          FALSE,
 353          6,
 354          complain_overflow_dont,
 355          nios2_elf32_cjmp_relocate,
 356          "R_NIOS2_CJMP",
 357          FALSE,
 358          0x003fffc0,
 359          0x003fffc0,
 360          FALSE),
 361
 362   HOWTO (R_NIOS2_CALLR,
 363          0,
 364          2,
 365          32,
 366          FALSE,
 367          6,
 368          complain_overflow_dont,
 369          nios2_elf32_callr_relocate,
 370          "R_NIOS2_CALLR",
 371          FALSE,
 372          0x003fffc0,
 373          0x003fffc0,
 374          FALSE),
 375
 376   HOWTO (R_NIOS2_ALIGN,
 377          0,
 378          2,
 379          0,
 380          FALSE,
 381          0,
 382          complain_overflow_dont,
 383          nios2_elf32_ignore_reloc,
 384          "R_NIOS2_ALIGN",
 385          FALSE,
 386          0,
 387          0,
 388          TRUE),
 389
 390
 391   HOWTO (R_NIOS2_GOT16,
 392          0,
 393          2,
 394          16,
 395          FALSE,
 396          6,
 397          complain_overflow_bitfield,
 398          bfd_elf_generic_reloc,
 399          "R_NIOS2_GOT16",
 400          FALSE,
 401          0x003fffc0,
 402          0x003fffc0,
 403          FALSE),
 404
 405   HOWTO (R_NIOS2_CALL16,
 406          0,
 407          2,
 408          16,
 409          FALSE,
 410          6,
 411          complain_overflow_bitfield,
 412          bfd_elf_generic_reloc,
 413          "R_NIOS2_CALL16",
 414          FALSE,
 415          0x003fffc0,
 416          0x003fffc0,
 417          FALSE),
 418
 419   HOWTO (R_NIOS2_GOTOFF_LO,
 420          0,
 421          2,
 422          16,
 423          FALSE,
 424          6,
 425          complain_overflow_dont,
 426          bfd_elf_generic_reloc,
 427          "R_NIOS2_GOTOFF_LO",
 428          FALSE,
 429          0x003fffc0,
 430          0x003fffc0,
 431          FALSE),
 432
 433   HOWTO (R_NIOS2_GOTOFF_HA,
 434          0,
 435          2,
 436          16,
 437          FALSE,
 438          6,
 439          complain_overflow_dont,
 440          bfd_elf_generic_reloc,
 441          "R_NIOS2_GOTOFF_HA",
 442          FALSE,
 443          0x003fffc0,
 444          0x003fffc0,
 445          FALSE),
 446
 447   HOWTO (R_NIOS2_PCREL_LO,
 448          0,
 449          2,
 450          16,
 451          TRUE,
 452          6,
 453          complain_overflow_dont,
 454          nios2_elf32_pcrel_lo16_relocate,
 455          "R_NIOS2_PCREL_LO",
 456          FALSE,
 457          0x003fffc0,
 458          0x003fffc0,
 459          TRUE),
 460
 461   HOWTO (R_NIOS2_PCREL_HA,
 462          0,
 463          2,
 464          16,
 465          FALSE, /* This is a PC-relative relocation, but we need to subtract
 466                    PC ourselves before the HIADJ.  */
 467          6,
 468          complain_overflow_dont,
 469          nios2_elf32_pcrel_hiadj16_relocate,
 470          "R_NIOS2_PCREL_HA",
 471          FALSE,
 472          0x003fffc0,
 473          0x003fffc0,
 474          TRUE),
 475
 476   HOWTO (R_NIOS2_TLS_GD16,
 477          0,
 478          2,
 479          16,
 480          FALSE,
 481          6,
 482          complain_overflow_bitfield,
 483          bfd_elf_generic_reloc,
 484          "R_NIOS2_TLS_GD16",
 485          FALSE,
 486          0x003fffc0,
 487          0x003fffc0,
 488          FALSE),
 489
 490   HOWTO (R_NIOS2_TLS_LDM16,
 491          0,
 492          2,
 493          16,
 494          FALSE,
 495          6,
 496          complain_overflow_bitfield,
 497          bfd_elf_generic_reloc,
 498          "R_NIOS2_TLS_LDM16",
 499          FALSE,
 500          0x003fffc0,
 501          0x003fffc0,
 502          FALSE),
 503
 504   HOWTO (R_NIOS2_TLS_LDO16,
 505          0,
 506          2,
 507          16,
 508          FALSE,
 509          6,
 510          complain_overflow_bitfield,
 511          bfd_elf_generic_reloc,
 512          "R_NIOS2_TLS_LDO16",
 513          FALSE,
 514          0x003fffc0,
 515          0x003fffc0,
 516          FALSE),
 517
 518   HOWTO (R_NIOS2_TLS_IE16,
 519          0,
 520          2,
 521          16,
 522          FALSE,
 523          6,
 524          complain_overflow_bitfield,
 525          bfd_elf_generic_reloc,
 526          "R_NIOS2_TLS_IE16",
 527          FALSE,
 528          0x003fffc0,
 529          0x003fffc0,
 530          FALSE),
 531
 532   HOWTO (R_NIOS2_TLS_LE16,
 533          0,
 534          2,
 535          16,
 536          FALSE,
 537          6,
 538          complain_overflow_bitfield,
 539          bfd_elf_generic_reloc,
 540          "R_NIOS2_TLS_LE16",
 541          FALSE,
 542          0x003fffc0,
 543          0x003fffc0,
 544          FALSE),
 545
 546   HOWTO (R_NIOS2_TLS_DTPMOD,
 547          0,
 548          2,
 549          32,
 550          FALSE,
 551          0,
 552          complain_overflow_dont,
 553          bfd_elf_generic_reloc,
 554          "R_NIOS2_TLS_DTPMOD",
 555          FALSE,
 556          0xffffffff,
 557          0xffffffff,
 558          FALSE),
 559
 560   HOWTO (R_NIOS2_TLS_DTPREL,
 561          0,
 562          2,
 563          32,
 564          FALSE,
 565          0,
 566          complain_overflow_dont,
 567          bfd_elf_generic_reloc,
 568          "R_NIOS2_TLS_DTPREL",
 569          FALSE,
 570          0xffffffff,
 571          0xffffffff,
 572          FALSE),
 573
 574   HOWTO (R_NIOS2_TLS_TPREL,
 575          0,
 576          2,
 577          32,
 578          FALSE,
 579          0,
 580          complain_overflow_dont,
 581          bfd_elf_generic_reloc,
 582          "R_NIOS2_TLS_TPREL",
 583          FALSE,
 584          0xffffffff,
 585          0xffffffff,
 586          FALSE),
 587
 588   HOWTO (R_NIOS2_COPY,
 589          0,
 590          2,
 591          32,
 592          FALSE,
 593          0,
 594          complain_overflow_dont,
 595          bfd_elf_generic_reloc,
 596          "R_NIOS2_COPY",
 597          FALSE,
 598          0,
 599          0,
 600          FALSE),
 601
 602   HOWTO (R_NIOS2_GLOB_DAT,
 603          0,
 604          2,
 605          32,
 606          FALSE,
 607          0,
 608          complain_overflow_dont,
 609          bfd_elf_generic_reloc,
 610          "R_NIOS2_GLOB_DAT",
 611          FALSE,
 612          0xffffffff,
 613          0xffffffff,
 614          FALSE),
 615
 616   HOWTO (R_NIOS2_JUMP_SLOT,
 617          0,
 618          2,
 619          32,
 620          FALSE,
 621          0,
 622          complain_overflow_dont,
 623          bfd_elf_generic_reloc,
 624          "R_NIOS2_JUMP_SLOT",
 625          FALSE,
 626          0xffffffff,
 627          0xffffffff,
 628          FALSE),
 629
 630   HOWTO (R_NIOS2_RELATIVE,
 631          0,
 632          2,
 633          32,
 634          FALSE,
 635          0,
 636          complain_overflow_dont,
 637          bfd_elf_generic_reloc,
 638          "R_NIOS2_RELATIVE",
 639          FALSE,
 640          0xffffffff,
 641          0xffffffff,
 642          FALSE),
 643
 644   HOWTO (R_NIOS2_GOTOFF,
 645          0,
 646          2,
 647          32,
 648          FALSE,
 649          0,
 650          complain_overflow_dont,
 651          bfd_elf_generic_reloc,
 652          "R_NIOS2_GOTOFF",
 653          FALSE,
 654          0xffffffff,
 655          0xffffffff,
 656          FALSE),
 657
 658 /* Add other relocations here.  */
 659 };
 660
 661 static unsigned char elf_code_to_howto_index[R_NIOS2_ILLEGAL + 1];
 662
 663 /* Return the howto for relocation RTYPE.  */
 664 static reloc_howto_type *
 665 lookup_howto (unsigned int rtype)
 666 {
 667   static int initialized = 0;
 668   int i;
 669   int howto_tbl_size = (int) (sizeof (elf_nios2_howto_table_rel)
 670                               / sizeof (elf_nios2_howto_table_rel[0]));
 671
 672   if (!initialized)
 673     {
 674       initialized = 1;
 675       memset (elf_code_to_howto_index, 0xff,
 676               sizeof (elf_code_to_howto_index));
 677       for (i = 0; i < howto_tbl_size; i++)
 678         elf_code_to_howto_index[elf_nios2_howto_table_rel[i].type] = i;
 679     }
 680
 681   BFD_ASSERT (rtype <= R_NIOS2_ILLEGAL);
 682   i = elf_code_to_howto_index[rtype];
 683   if (i >= howto_tbl_size)
 684     return 0;
 685   return elf_nios2_howto_table_rel + i;
 686 }
 687
 688 /* Map for converting BFD reloc types to Nios II reloc types.  */
 689 struct elf_reloc_map
 690 {
 691   bfd_reloc_code_real_type bfd_val;
 692   enum elf_nios2_reloc_type elf_val;
 693 };
 694
 695 static const struct elf_reloc_map nios2_reloc_map[] = {
 696   {BFD_RELOC_NIOS2_S16, R_NIOS2_S16},
 697   {BFD_RELOC_NIOS2_U16, R_NIOS2_U16},
 698   {BFD_RELOC_16_PCREL, R_NIOS2_PCREL16},
 699   {BFD_RELOC_NIOS2_CALL26, R_NIOS2_CALL26},
 700   {BFD_RELOC_NIOS2_IMM5, R_NIOS2_IMM5},
 701   {BFD_RELOC_NIOS2_CACHE_OPX, R_NIOS2_CACHE_OPX},
 702   {BFD_RELOC_NIOS2_IMM6, R_NIOS2_IMM6},
 703   {BFD_RELOC_NIOS2_IMM8, R_NIOS2_IMM8},
 704   {BFD_RELOC_NIOS2_HI16, R_NIOS2_HI16},
 705   {BFD_RELOC_NIOS2_LO16, R_NIOS2_LO16},
 706   {BFD_RELOC_NIOS2_HIADJ16, R_NIOS2_HIADJ16},
 707   {BFD_RELOC_32, R_NIOS2_BFD_RELOC_32},
 708   {BFD_RELOC_16, R_NIOS2_BFD_RELOC_16},
 709   {BFD_RELOC_8, R_NIOS2_BFD_RELOC_8},
 710   {BFD_RELOC_NIOS2_GPREL, R_NIOS2_GPREL},
 711   {BFD_RELOC_VTABLE_INHERIT, R_NIOS2_GNU_VTINHERIT},
 712   {BFD_RELOC_VTABLE_ENTRY, R_NIOS2_GNU_VTENTRY},
 713   {BFD_RELOC_NIOS2_UJMP, R_NIOS2_UJMP},
 714   {BFD_RELOC_NIOS2_CJMP, R_NIOS2_CJMP},
 715   {BFD_RELOC_NIOS2_CALLR, R_NIOS2_CALLR},
 716   {BFD_RELOC_NIOS2_ALIGN, R_NIOS2_ALIGN},
 717   {BFD_RELOC_NIOS2_GOT16, R_NIOS2_GOT16},
 718   {BFD_RELOC_NIOS2_CALL16, R_NIOS2_CALL16},
 719   {BFD_RELOC_NIOS2_GOTOFF_LO, R_NIOS2_GOTOFF_LO},
 720   {BFD_RELOC_NIOS2_GOTOFF_HA, R_NIOS2_GOTOFF_HA},
 721   {BFD_RELOC_NIOS2_PCREL_LO, R_NIOS2_PCREL_LO},
 722   {BFD_RELOC_NIOS2_PCREL_HA, R_NIOS2_PCREL_HA},
 723   {BFD_RELOC_NIOS2_TLS_GD16, R_NIOS2_TLS_GD16},
 724   {BFD_RELOC_NIOS2_TLS_LDM16, R_NIOS2_TLS_LDM16},
 725   {BFD_RELOC_NIOS2_TLS_LDO16, R_NIOS2_TLS_LDO16},
 726   {BFD_RELOC_NIOS2_TLS_IE16, R_NIOS2_TLS_IE16},
 727   {BFD_RELOC_NIOS2_TLS_LE16, R_NIOS2_TLS_LE16},
 728   {BFD_RELOC_NIOS2_TLS_DTPMOD, R_NIOS2_TLS_DTPMOD},
 729   {BFD_RELOC_NIOS2_TLS_DTPREL, R_NIOS2_TLS_DTPREL},
 730   {BFD_RELOC_NIOS2_TLS_TPREL, R_NIOS2_TLS_TPREL},
 731   {BFD_RELOC_NIOS2_COPY, R_NIOS2_COPY},
 732   {BFD_RELOC_NIOS2_GLOB_DAT, R_NIOS2_GLOB_DAT},
 733   {BFD_RELOC_NIOS2_JUMP_SLOT, R_NIOS2_JUMP_SLOT},
 734   {BFD_RELOC_NIOS2_RELATIVE, R_NIOS2_RELATIVE},
 735   {BFD_RELOC_NIOS2_GOTOFF, R_NIOS2_GOTOFF}
 736 };
 737
 738 /* The Nios II linker needs to keep track of the number of relocs that it
 739    decides to copy as dynamic relocs in check_relocs for each symbol.
 740    This is so that it can later discard them if they are found to be
 741    unnecessary.  We store the information in a field extending the
 742    regular ELF linker hash table.  */
 743
 744 struct elf32_nios2_dyn_relocs
 745 {
 746   struct elf32_nios2_dyn_relocs *next;
 747
 748   /* The input section of the reloc.  */
 749   asection *sec;
 750
 751   /* Total number of relocs copied for the input section.  */
 752   bfd_size_type count;
 753
 754   /* Number of pc-relative relocs copied for the input section.  */
 755   bfd_size_type pc_count;
 756 };
 757
 758 /* Nios II ELF linker hash entry.  */
 759
 760 struct elf32_nios2_link_hash_entry
 761 {
 762   struct elf_link_hash_entry root;
 763
 764   /* Track dynamic relocs copied for this symbol.  */
 765   struct elf32_nios2_dyn_relocs *dyn_relocs;
 766
 767 #define GOT_UNKNOWN     0
 768 #define GOT_NORMAL      1
 769 #define GOT_TLS_GD      2
 770 #define GOT_TLS_IE      4
 771   unsigned char tls_type;
 772
 773   /* We need to detect and take special action for symbols which are only
 774      referenced with %call() and not with %got().  Such symbols do not need
 775      a dynamic GOT reloc in shared objects, only a dynamic PLT reloc.  Lazy
 776      linking will not work if the dynamic GOT reloc exists.
 777      To check for this condition efficiently, we compare got_types_used against
 778      CALL16_USED, meaning
 779      (got_types_used & (GOT16_USED | CALL16_USED)) == CALL16_USED.  */
 780 #define GOT16_USED      1
 781 #define CALL16_USED     2
 782   unsigned char got_types_used;
 783 };
 784
 785 #define elf32_nios2_hash_entry(ent) \
 786   ((struct elf32_nios2_link_hash_entry *) (ent))
 787
 788 /* Get the Nios II elf linker hash table from a link_info structure.  */
 789 #define elf32_nios2_hash_table(info) \
 790   ((struct elf32_nios2_link_hash_table *) ((info)->hash))
 791
 792 /* Nios II ELF linker hash table.  */
 793 struct elf32_nios2_link_hash_table
 794   {
 795     /* The main hash table.  */
 796     struct elf_link_hash_table root;
 797
 798     /* Short-cuts to get to dynamic linker sections.  */
 799     asection *sdynbss;
 800     asection *srelbss;
 801     asection *sbss;
 802
 803     union {
 804       bfd_signed_vma refcount;
 805       bfd_vma offset;
 806     } tls_ldm_got;
 807
 808     /* Small local sym cache.  */
 809     struct sym_cache sym_cache;
 810
 811     bfd_vma res_n_size;
 812   };
 813
 814 struct nios2_elf32_obj_tdata
 815 {
 816   struct elf_obj_tdata root;
 817
 818   /* tls_type for each local got entry.  */
 819   char *local_got_tls_type;
 820
 821   /* TRUE if TLS GD relocs have been seen for this object.  */
 822   bfd_boolean has_tlsgd;
 823 };
 824
 825 #define elf32_nios2_tdata(abfd) \
 826   ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
 827
 828 #define elf32_nios2_local_got_tls_type(abfd) \
 829   (elf32_nios2_tdata (abfd)->local_got_tls_type)
 830
 831 /* The name of the dynamic interpreter.  This is put in the .interp
 832    section.  */
 833 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 834
 835 /* PLT implementation for position-dependent code.  */
 836 static const bfd_vma nios2_plt_entry[] = { /* .PLTn: */
 837   0x03c00034,   /* movhi r15, %hiadj(plt_got_slot_address) */
 838   0x7bc00017,   /* ldw r15, %lo(plt_got_slot_address)(r15) */
 839   0x7800683a    /* jmp r15 */
 840 };
 841
 842 static const bfd_vma nios2_plt0_entry[] = { /* .PLTresolve */
 843   0x03800034,   /* movhi r14, %hiadj(res_0) */
 844   0x73800004,   /* addi r14, r14, %lo(res_0) */
 845   0x7b9fc83a,   /* sub r15, r15, r14 */
 846   0x03400034,   /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
 847   0x6b800017,   /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
 848   0x6b400017,   /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
 849   0x6800683a    /* jmp r13 */
 850 };
 851
 852 /* PLT implementation for position-independent code.  */
 853 static const bfd_vma nios2_so_plt_entry[] = { /* .PLTn */
 854   0x03c00034,   /* movhi r15, %hiadj(index * 4) */
 855   0x7bc00004,   /* addi r15, r15, %lo(index * 4) */
 856   0x00000006    /* br .PLTresolve */
 857 };
 858
 859 static const bfd_vma nios2_so_plt0_entry[] = { /* .PLTresolve */
 860   0x001ce03a,   /* nextpc r14 */
 861   0x03400034,   /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
 862   0x6b9b883a,   /* add r13, r13, r14 */
 863   0x6b800017,   /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
 864   0x6b400017,   /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
 865   0x6800683a    /* jmp r13 */
 866 };
 867
 868 /* Implement elf_backend_grok_prstatus:
 869    Support for core dump NOTE sections.  */
 870 static bfd_boolean
 871 nios2_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 872 {
 873   int offset;
 874   size_t size;
 875
 876   switch (note->descsz)
 877     {
 878     default:
 879       return FALSE;
 880
 881     case 212:         /* Linux/Nios II */
 882       /* pr_cursig */
 883       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
 884
 885       /* pr_pid */
 886       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
 887
 888       /* pr_reg */
 889       offset = 72;
 890       size = 136;
 891
 892       break;
 893     }
 894
 895   /* Make a ".reg/999" section.  */
 896   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 897                                           size, note->descpos + offset);
 898 }
 899
 900 /* Implement elf_backend_grok_psinfo.  */
 901 static bfd_boolean
 902 nios2_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 903 {
 904   switch (note->descsz)
 905     {
 906     default:
 907       return FALSE;
 908
 909     case 124:         /* Linux/Nios II elf_prpsinfo */
 910       elf_tdata (abfd)->core->program
 911         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 912       elf_tdata (abfd)->core->command
 913         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 914     }
 915
 916   /* Note that for some reason, a spurious space is tacked
 917      onto the end of the args in some (at least one anyway)
 918      implementations, so strip it off if it exists.  */
 919
 920   {
 921     char *command = elf_tdata (abfd)->core->command;
 922     int n = strlen (command);
 923
 924     if (0 < n && command[n - 1] == ' ')
 925       command[n - 1] = '\0';
 926   }
 927
 928   return TRUE;
 929 }
 930
 931 /* Create an entry in a Nios II ELF linker hash table.  */
 932 static struct bfd_hash_entry *
 933 link_hash_newfunc (struct bfd_hash_entry *entry,
 934                    struct bfd_hash_table *table, const char *string)
 935 {
 936   /* Allocate the structure if it has not already been allocated by a
 937      subclass.  */
 938   if (entry == NULL)
 939     {
 940       entry = bfd_hash_allocate (table,
 941                                  sizeof (struct elf32_nios2_link_hash_entry));
 942       if (entry == NULL)
 943         return entry;
 944     }
 945
 946   /* Call the allocation method of the superclass.  */
 947   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 948   if (entry)
 949     {
 950       struct elf32_nios2_link_hash_entry *eh;
 951
 952       eh = (struct elf32_nios2_link_hash_entry *) entry;
 953       eh->dyn_relocs = NULL;
 954       eh->tls_type = GOT_UNKNOWN;
 955       eh->got_types_used = 0;
 956     }
 957
 958   return entry;
 959 }
 960
 961 /* Implement bfd_elf32_bfd_reloc_type_lookup:
 962    Given a BFD reloc type, return a howto structure.  */
 963 static reloc_howto_type *
 964 nios2_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 965                                    bfd_reloc_code_real_type code)
 966 {
 967   int i;
 968   for (i = 0;
 969        i < (int) (sizeof (nios2_reloc_map) / sizeof (struct elf_reloc_map));
 970        ++i)
 971     if (nios2_reloc_map[i].bfd_val == code)
 972       return &elf_nios2_howto_table_rel[(int) nios2_reloc_map[i].elf_val];
 973   return NULL;
 974 }
 975
 976 /* Implement bfd_elf32_bfd_reloc_name_lookup:
 977    Given a reloc name, return a howto structure.  */
 978 static reloc_howto_type *
 979 nios2_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 980                                    const char *r_name)
 981 {
 982   unsigned int i;
 983   for (i = 0;
 984        i < (sizeof (elf_nios2_howto_table_rel)
 985             / sizeof (elf_nios2_howto_table_rel[0]));
 986        i++)
 987     if (elf_nios2_howto_table_rel[i].name
 988         && strcasecmp (elf_nios2_howto_table_rel[i].name, r_name) == 0)
 989       return &elf_nios2_howto_table_rel[i];
 990
 991   return NULL;
 992 }
 993
 994 /* Implement elf_info_to_howto:
 995    Given a ELF32 relocation, fill in a arelent structure.  */
 996 static void
 997 nios2_elf32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 998                            Elf_Internal_Rela *dst)
 999 {
1000   unsigned int r_type;
1001
1002   r_type = ELF32_R_TYPE (dst->r_info);
1003   BFD_ASSERT (r_type < R_NIOS2_ILLEGAL);
1004   cache_ptr->howto = &elf_nios2_howto_table_rel[r_type];
1005 }
1006
1007 /* Return the base VMA address which should be subtracted from real addresses
1008    when resolving @dtpoff relocation.
1009    This is PT_TLS segment p_vaddr.  */
1010 static bfd_vma
1011 dtpoff_base (struct bfd_link_info *info)
1012 {
1013   /* If tls_sec is NULL, we should have signalled an error already.  */
1014   if (elf_hash_table (info)->tls_sec == NULL)
1015     return 0;
1016   return elf_hash_table (info)->tls_sec->vma;
1017 }
1018
1019 /* Return the relocation value for @tpoff relocation
1020    if STT_TLS virtual address is ADDRESS.  */
1021 static bfd_vma
1022 tpoff (struct bfd_link_info *info, bfd_vma address)
1023 {
1024   struct elf_link_hash_table *htab = elf_hash_table (info);
1025
1026   /* If tls_sec is NULL, we should have signalled an error already.  */
1027   if (htab->tls_sec == NULL)
1028     return 0;
1029   return address - htab->tls_sec->vma;
1030 }
1031
1032 /* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
1033    dangerous relocation.  */
1034 static bfd_boolean
1035 nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
1036 {
1037
1038   bfd_boolean gp_found;
1039   struct bfd_hash_entry *h;
1040   struct bfd_link_hash_entry *lh;
1041
1042   /* If we've already figured out what GP will be, just return it. */
1043   *pgp = _bfd_get_gp_value (output_bfd);
1044   if (*pgp)
1045     return TRUE;
1046
1047   h = bfd_hash_lookup (&info->hash->table, "_gp", FALSE, FALSE);
1048   lh = (struct bfd_link_hash_entry *) h;
1049 lookup:
1050   if (lh)
1051     {
1052       switch (lh->type)
1053         {
1054         case bfd_link_hash_undefined:
1055         case bfd_link_hash_undefweak:
1056         case bfd_link_hash_common:
1057           gp_found = FALSE;
1058           break;
1059         case bfd_link_hash_defined:
1060         case bfd_link_hash_defweak:
1061           gp_found = TRUE;
1062           *pgp = lh->u.def.value;
1063           break;
1064         case bfd_link_hash_indirect:
1065         case bfd_link_hash_warning:
1066           lh = lh->u.i.link;
1067           /* @@FIXME  ignoring warning for now */
1068           goto lookup;
1069         case bfd_link_hash_new:
1070         default:
1071           abort ();
1072         }
1073     }
1074   else
1075     gp_found = FALSE;
1076
1077   if (!gp_found)
1078     {
1079       /* Only get the error once. */
1080       *pgp = 4;
1081       _bfd_set_gp_value (output_bfd, *pgp);
1082       return FALSE;
1083     }
1084
1085   _bfd_set_gp_value (output_bfd, *pgp);
1086
1087   return TRUE;
1088 }
1089
1090 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
1091    if it's not available as we don't have a link_info pointer available here
1092    to look it up in the output symbol table.  We don't need to adjust the
1093    symbol value for an external symbol if we are producing relocatable
1094    output.  */
1095 static bfd_reloc_status_type
1096 nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
1097                     char **error_message, bfd_vma *pgp)
1098 {
1099   if (bfd_is_und_section (symbol->section) && !relocatable)
1100     {
1101       *pgp = 0;
1102       return bfd_reloc_undefined;
1103     }
1104
1105   *pgp = _bfd_get_gp_value (output_bfd);
1106   if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
1107     {
1108       if (relocatable)
1109         {
1110           /* Make up a value.  */
1111           *pgp = symbol->section->output_section->vma + 0x4000;
1112           _bfd_set_gp_value (output_bfd, *pgp);
1113         }
1114       else
1115         {
1116           *error_message
1117             = (char *) _("global pointer relative relocation when _gp not defined");
1118           return bfd_reloc_dangerous;
1119         }
1120     }
1121
1122   return bfd_reloc_ok;
1123 }
1124
1125 /* The usual way of loading a 32-bit constant into a Nios II register is to
1126    load the high 16 bits in one instruction and then add the low 16 bits with
1127    a signed add. This means that the high halfword needs to be adjusted to
1128    compensate for the sign bit of the low halfword. This function returns the
1129    adjusted high halfword for a given 32-bit constant.  */
1130 static
1131 bfd_vma hiadj (bfd_vma symbol_value)
1132 {
1133   return ((symbol_value + 0x8000) >> 16) & 0xffff;
1134 }
1135
1136 /* Do the relocations that require special handling.  */
1137 static bfd_reloc_status_type
1138 nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
1139                               asection *input_section,
1140                               bfd_byte *data, bfd_vma offset,
1141                               bfd_vma symbol_value, bfd_vma addend)
1142 {
1143   symbol_value = symbol_value + addend;
1144   addend = 0;
1145   symbol_value = (symbol_value >> 16) & 0xffff;
1146   return _bfd_final_link_relocate (howto, abfd, input_section,
1147                                    data, offset, symbol_value, addend);
1148 }
1149
1150 static bfd_reloc_status_type
1151 nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
1152                               asection *input_section,
1153                               bfd_byte *data, bfd_vma offset,
1154                               bfd_vma symbol_value, bfd_vma addend)
1155 {
1156   symbol_value = symbol_value + addend;
1157   addend = 0;
1158   symbol_value = symbol_value & 0xffff;
1159   return _bfd_final_link_relocate (howto, abfd, input_section,
1160                                    data, offset, symbol_value, addend);
1161 }
1162
1163 static bfd_reloc_status_type
1164 nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
1165                                  asection *input_section,
1166                                  bfd_byte *data, bfd_vma offset,
1167                                  bfd_vma symbol_value, bfd_vma addend)
1168 {
1169   symbol_value = symbol_value + addend;
1170   addend = 0;
1171   symbol_value = hiadj(symbol_value);
1172   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
1173                                    symbol_value, addend);
1174 }
1175
1176 static bfd_reloc_status_type
1177 nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
1178                                     asection *input_section,
1179                                     bfd_byte *data, bfd_vma offset,
1180                                     bfd_vma symbol_value, bfd_vma addend)
1181 {
1182   symbol_value = symbol_value + addend;
1183   addend = 0;
1184   symbol_value = symbol_value & 0xffff;
1185   return _bfd_final_link_relocate (howto, abfd, input_section,
1186                                    data, offset, symbol_value, addend);
1187 }
1188
1189 static bfd_reloc_status_type
1190 nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
1191                                        asection *input_section,
1192                                        bfd_byte *data, bfd_vma offset,
1193                                        bfd_vma symbol_value, bfd_vma addend)
1194 {
1195   symbol_value = symbol_value + addend;
1196   symbol_value -= (input_section->output_section->vma
1197                    + input_section->output_offset);
1198   symbol_value -= offset;
1199   addend = 0;
1200   symbol_value = hiadj(symbol_value);
1201   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
1202                                    symbol_value, addend);
1203 }
1204
1205 static bfd_reloc_status_type
1206 nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
1207                                  asection *input_section,
1208                                  bfd_byte *data, bfd_vma offset,
1209                                  bfd_vma symbol_value, bfd_vma addend)
1210 {
1211   /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
1212      so we need to subtract 4 before doing a final_link_relocate. */
1213   symbol_value = symbol_value + addend - 4;
1214   addend = 0;
1215   return _bfd_final_link_relocate (howto, abfd, input_section,
1216                                    data, offset, symbol_value, addend);
1217 }
1218
1219 static bfd_reloc_status_type
1220 nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
1221                                 asection *input_section,
1222                                 bfd_byte *data, bfd_vma offset,
1223                                 bfd_vma symbol_value, bfd_vma addend)
1224 {
1225   /* Check that the relocation is in the same page as the current address.  */
1226   if (((symbol_value + addend) & 0xf0000000)
1227       != ((input_section->output_section->vma + offset) & 0xf0000000))
1228     return bfd_reloc_overflow;
1229
1230   return _bfd_final_link_relocate (howto, abfd, input_section,
1231                                    data, offset, symbol_value, addend);
1232 }
1233
1234 static bfd_reloc_status_type
1235 nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
1236                                asection *input_section,
1237                                bfd_byte *data, bfd_vma offset,
1238                                bfd_vma symbol_value, bfd_vma addend)
1239 {
1240   /* Because we need the output_bfd, the special handling is done
1241      in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate.  */
1242   return _bfd_final_link_relocate (howto, abfd, input_section,
1243                                    data, offset, symbol_value, addend);
1244 }
1245
1246 static bfd_reloc_status_type
1247 nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
1248                               asection *input_section,
1249                               bfd_byte *data, bfd_vma offset,
1250                               bfd_vma symbol_value, bfd_vma addend)
1251 {
1252   bfd_vma symbol_lo16, symbol_hi16;
1253   bfd_reloc_status_type r;
1254   symbol_value = symbol_value + addend;
1255   addend = 0;
1256   symbol_hi16 = (symbol_value >> 16) & 0xffff;
1257   symbol_lo16 = symbol_value & 0xffff;
1258
1259   r = _bfd_final_link_relocate (howto, abfd, input_section,
1260                                 data, offset, symbol_hi16, addend);
1261
1262   if (r == bfd_reloc_ok)
1263     return _bfd_final_link_relocate (howto, abfd, input_section,
1264                                      data, offset + 4, symbol_lo16, addend);
1265
1266   return r;
1267 }
1268
1269 static bfd_reloc_status_type
1270 nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
1271                               asection *input_section,
1272                               bfd_byte *data, bfd_vma offset,
1273                               bfd_vma symbol_value, bfd_vma addend)
1274 {
1275   bfd_vma symbol_lo16, symbol_hi16;
1276   bfd_reloc_status_type r;
1277   symbol_value = symbol_value + addend;
1278   addend = 0;
1279   symbol_hi16 = (symbol_value >> 16) & 0xffff;
1280   symbol_lo16 = symbol_value & 0xffff;
1281
1282   r = _bfd_final_link_relocate (howto, abfd, input_section,
1283                                 data, offset, symbol_hi16, addend);
1284
1285   if (r == bfd_reloc_ok)
1286     return _bfd_final_link_relocate (howto, abfd, input_section,
1287                                      data, offset + 4, symbol_lo16, addend);
1288
1289   return r;
1290 }
1291
1292 static bfd_reloc_status_type
1293 nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
1294                                asection *input_section,
1295                                bfd_byte *data, bfd_vma offset,
1296                                bfd_vma symbol_value, bfd_vma addend)
1297 {
1298   bfd_vma symbol_lo16, symbol_hi16;
1299   bfd_reloc_status_type r;
1300   symbol_value = symbol_value + addend;
1301   addend = 0;
1302   symbol_hi16 = (symbol_value >> 16) & 0xffff;
1303   symbol_lo16 = symbol_value & 0xffff;
1304
1305   r = _bfd_final_link_relocate (howto, abfd, input_section,
1306                                 data, offset, symbol_hi16, addend);
1307
1308   if (r == bfd_reloc_ok)
1309     return _bfd_final_link_relocate (howto, abfd, input_section,
1310                                      data, offset + 4, symbol_lo16, addend);
1311
1312   return r;
1313 }
1314
1315 /* HOWTO handlers for relocations that require special handling.  */
1316
1317 /* This is for relocations used only when relaxing to ensure
1318    changes in size of section don't screw up .align.  */
1319 static bfd_reloc_status_type
1320 nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1321                           asymbol *symbol ATTRIBUTE_UNUSED,
1322                           void *data ATTRIBUTE_UNUSED, asection *input_section,
1323                           bfd *output_bfd,
1324                           char **error_message ATTRIBUTE_UNUSED)
1325 {
1326   if (output_bfd != NULL)
1327     reloc_entry->address += input_section->output_offset;
1328   return bfd_reloc_ok;
1329 }
1330
1331 static bfd_reloc_status_type
1332 nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1333                            void *data, asection *input_section,
1334                            bfd *output_bfd,
1335                            char **error_message ATTRIBUTE_UNUSED)
1336 {
1337   /* This part is from bfd_elf_generic_reloc.  */
1338   if (output_bfd != NULL
1339       && (symbol->flags & BSF_SECTION_SYM) == 0
1340       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1341     {
1342       reloc_entry->address += input_section->output_offset;
1343       return bfd_reloc_ok;
1344     }
1345
1346   if (output_bfd != NULL)
1347     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1348     return bfd_reloc_continue;
1349
1350   return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
1351                                        input_section,
1352                                        data, reloc_entry->address,
1353                                        (symbol->value
1354                                         + symbol->section->output_section->vma
1355                                         + symbol->section->output_offset),
1356                                        reloc_entry->addend);
1357 }
1358
1359 static bfd_reloc_status_type
1360 nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1361                            void *data, asection *input_section,
1362                            bfd *output_bfd,
1363                            char **error_message ATTRIBUTE_UNUSED)
1364 {
1365   /* This part is from bfd_elf_generic_reloc.  */
1366   if (output_bfd != NULL
1367       && (symbol->flags & BSF_SECTION_SYM) == 0
1368       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1369     {
1370       reloc_entry->address += input_section->output_offset;
1371       return bfd_reloc_ok;
1372     }
1373
1374   if (output_bfd != NULL)
1375     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1376     return bfd_reloc_continue;
1377
1378   return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
1379                                        input_section,
1380                                        data, reloc_entry->address,
1381                                        (symbol->value
1382                                         + symbol->section->output_section->vma
1383                                         + symbol->section->output_offset),
1384                                        reloc_entry->addend);
1385 }
1386
1387 static bfd_reloc_status_type
1388 nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1389                               void *data, asection *input_section,
1390                               bfd *output_bfd,
1391                               char **error_message ATTRIBUTE_UNUSED)
1392 {
1393   /* This part is from bfd_elf_generic_reloc.  */
1394   if (output_bfd != NULL
1395       && (symbol->flags & BSF_SECTION_SYM) == 0
1396       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1397     {
1398       reloc_entry->address += input_section->output_offset;
1399       return bfd_reloc_ok;
1400     }
1401
1402   if (output_bfd != NULL)
1403     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1404     return bfd_reloc_continue;
1405
1406   return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
1407                                           input_section,
1408                                           data, reloc_entry->address,
1409                                           (symbol->value
1410                                            + symbol->section->output_section->vma
1411                                            + symbol->section->output_offset),
1412                                           reloc_entry->addend);
1413 }
1414
1415 static bfd_reloc_status_type
1416 nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
1417                                  asymbol *symbol, void *data,
1418                                  asection *input_section, bfd *output_bfd,
1419                                  char **error_message ATTRIBUTE_UNUSED)
1420 {
1421   /* This part is from bfd_elf_generic_reloc.  */
1422   if (output_bfd != NULL
1423       && (symbol->flags & BSF_SECTION_SYM) == 0
1424       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1425     {
1426       reloc_entry->address += input_section->output_offset;
1427       return bfd_reloc_ok;
1428     }
1429
1430   if (output_bfd != NULL)
1431     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1432     return bfd_reloc_continue;
1433
1434   return nios2_elf32_do_pcrel_lo16_relocate (
1435     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
1436     (symbol->value + symbol->section->output_section->vma
1437      + symbol->section->output_offset),
1438     reloc_entry->addend);
1439 }
1440
1441 static bfd_reloc_status_type
1442 nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
1443                                     asymbol *symbol, void *data,
1444                                     asection *input_section, bfd *output_bfd,
1445                                     char **error_message ATTRIBUTE_UNUSED)
1446 {
1447   /* This part is from bfd_elf_generic_reloc.  */
1448   if (output_bfd != NULL
1449       && (symbol->flags & BSF_SECTION_SYM) == 0
1450       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1451     {
1452       reloc_entry->address += input_section->output_offset;
1453       return bfd_reloc_ok;
1454     }
1455
1456   if (output_bfd != NULL)
1457     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1458     return bfd_reloc_continue;
1459
1460   return nios2_elf32_do_pcrel_hiadj16_relocate (
1461     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
1462     (symbol->value + symbol->section->output_section->vma
1463      + symbol->section->output_offset),
1464     reloc_entry->addend);
1465 }
1466
1467 static bfd_reloc_status_type
1468 nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1469                               void *data, asection *input_section,
1470                               bfd *output_bfd,
1471                               char **error_message ATTRIBUTE_UNUSED)
1472 {
1473   /* This part is from bfd_elf_generic_reloc.  */
1474   if (output_bfd != NULL
1475       && (symbol->flags & BSF_SECTION_SYM) == 0
1476       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1477     {
1478       reloc_entry->address += input_section->output_offset;
1479       return bfd_reloc_ok;
1480     }
1481
1482   if (output_bfd != NULL)
1483     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1484     return bfd_reloc_continue;
1485
1486   return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
1487                                           input_section,
1488                                           data, reloc_entry->address,
1489                                           (symbol->value
1490                                            + symbol->section->output_section->vma
1491                                            + symbol->section->output_offset),
1492                                           reloc_entry->addend);
1493 }
1494
1495 static bfd_reloc_status_type
1496 nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1497                              void *data, asection *input_section,
1498                              bfd *output_bfd,
1499                              char **error_message ATTRIBUTE_UNUSED)
1500 {
1501   /* This part is from bfd_elf_generic_reloc.  */
1502   if (output_bfd != NULL
1503       && (symbol->flags & BSF_SECTION_SYM) == 0
1504       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1505     {
1506       reloc_entry->address += input_section->output_offset;
1507       return bfd_reloc_ok;
1508     }
1509
1510   if (output_bfd != NULL)
1511     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1512     return bfd_reloc_continue;
1513
1514   return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
1515                                          input_section,
1516                                          data, reloc_entry->address,
1517                                          (symbol->value
1518                                           + symbol->section->output_section->vma
1519                                           + symbol->section->output_offset),
1520                                          reloc_entry->addend);
1521 }
1522
1523 static bfd_reloc_status_type
1524 nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1525                             void *data, asection *input_section,
1526                             bfd *output_bfd, char **msg)
1527 {
1528   bfd_vma relocation;
1529   bfd_vma gp;
1530   bfd_reloc_status_type r;
1531
1532
1533   /* This part is from bfd_elf_generic_reloc.  */
1534   if (output_bfd != NULL
1535       && (symbol->flags & BSF_SECTION_SYM) == 0
1536       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1537     {
1538       reloc_entry->address += input_section->output_offset;
1539       return bfd_reloc_ok;
1540     }
1541
1542   if (output_bfd != NULL)
1543     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1544     return bfd_reloc_continue;
1545
1546   relocation = (symbol->value
1547                 + symbol->section->output_section->vma
1548                 + symbol->section->output_offset);
1549
1550   /* This assumes we've already cached the _gp symbol.  */
1551   r = nios2_elf_final_gp (abfd, symbol, FALSE, msg, &gp);
1552   if (r == bfd_reloc_ok)
1553     {
1554       relocation = relocation + reloc_entry->addend - gp;
1555       reloc_entry->addend = 0;
1556       if ((signed) relocation < -32768 || (signed) relocation > 32767)
1557         {
1558           *msg = _("global pointer relative address out of range");
1559           r = bfd_reloc_outofrange;
1560         }
1561       else
1562         r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
1563                                            input_section,
1564                                            data, reloc_entry->address,
1565                                            relocation, reloc_entry->addend);
1566     }
1567
1568   return r;
1569 }
1570
1571 static bfd_reloc_status_type
1572 nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1573                            void *data, asection *input_section,
1574                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1575 {
1576   /* This part is from bfd_elf_generic_reloc.  */
1577   if (output_bfd != NULL
1578       && (symbol->flags & BSF_SECTION_SYM) == 0
1579       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1580     {
1581       reloc_entry->address += input_section->output_offset;
1582       return bfd_reloc_ok;
1583     }
1584
1585   if (output_bfd != NULL)
1586     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1587     return bfd_reloc_continue;
1588
1589   return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
1590                                        input_section,
1591                                        data, reloc_entry->address,
1592                                        (symbol->value
1593                                         + symbol->section->output_section->vma
1594                                         + symbol->section->output_offset),
1595                                        reloc_entry->addend);
1596 }
1597
1598 static bfd_reloc_status_type
1599 nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1600                            void *data, asection *input_section,
1601                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1602 {
1603   /* This part is from bfd_elf_generic_reloc.  */
1604   if (output_bfd != NULL
1605       && (symbol->flags & BSF_SECTION_SYM) == 0
1606       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1607     {
1608       reloc_entry->address += input_section->output_offset;
1609       return bfd_reloc_ok;
1610     }
1611
1612   if (output_bfd != NULL)
1613     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1614     return bfd_reloc_continue;
1615
1616   return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
1617                                        input_section,
1618                                        data, reloc_entry->address,
1619                                        (symbol->value
1620                                         + symbol->section->output_section->vma
1621                                         + symbol->section->output_offset),
1622                                        reloc_entry->addend);
1623 }
1624
1625 static bfd_reloc_status_type
1626 nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1627                             void *data, asection *input_section,
1628                             bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1629 {
1630   /* This part is from bfd_elf_generic_reloc.  */
1631   if (output_bfd != NULL
1632       && (symbol->flags & BSF_SECTION_SYM) == 0
1633       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1634     {
1635       reloc_entry->address += input_section->output_offset;
1636       return bfd_reloc_ok;
1637     }
1638
1639   if (output_bfd != NULL)
1640     /* FIXME: See bfd_perform_relocation.  Is this right?  */
1641     return bfd_reloc_continue;
1642
1643   return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
1644                                         input_section,
1645                                         data, reloc_entry->address,
1646                                         (symbol->value
1647                                          + symbol->section->output_section->vma
1648                                          + symbol->section->output_offset),
1649                                         reloc_entry->addend);
1650 }
1651
1652
1653 /* Implement elf_backend_relocate_section.  */
1654 static bfd_boolean
1655 nios2_elf32_relocate_section (bfd *output_bfd,
1656                               struct bfd_link_info *info,
1657                               bfd *input_bfd,
1658                               asection *input_section,
1659                               bfd_byte *contents,
1660                               Elf_Internal_Rela *relocs,
1661                               Elf_Internal_Sym *local_syms,
1662                               asection **local_sections)
1663 {
1664   Elf_Internal_Shdr *symtab_hdr;
1665   struct elf_link_hash_entry **sym_hashes;
1666   Elf_Internal_Rela *rel;
1667   Elf_Internal_Rela *relend;
1668   struct elf32_nios2_link_hash_table *htab;
1669   asection *sgot;
1670   asection *splt;
1671   asection *sreloc = NULL;
1672   bfd_vma *local_got_offsets;
1673
1674   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1675   sym_hashes = elf_sym_hashes (input_bfd);
1676   relend = relocs + input_section->reloc_count;
1677
1678   htab = elf32_nios2_hash_table (info);
1679   sgot = htab->root.sgot;
1680   splt = htab->root.splt;
1681   local_got_offsets = elf_local_got_offsets (input_bfd);
1682
1683   for (rel = relocs; rel < relend; rel++)
1684     {
1685       reloc_howto_type *howto;
1686       unsigned long r_symndx;
1687       Elf_Internal_Sym *sym;
1688       asection *sec;
1689       struct elf_link_hash_entry *h;
1690       struct elf32_nios2_link_hash_entry *eh;
1691       bfd_vma relocation;
1692       bfd_vma gp;
1693       bfd_vma reloc_address;
1694       bfd_reloc_status_type r = bfd_reloc_ok;
1695       const char *name = NULL;
1696       int r_type;
1697       const char *format;
1698       char msgbuf[256];
1699       const char* msg = (const char*) NULL;
1700       bfd_boolean unresolved_reloc;
1701       bfd_vma off;
1702       int use_plt;
1703
1704       r_type = ELF32_R_TYPE (rel->r_info);
1705       r_symndx = ELF32_R_SYM (rel->r_info);
1706
1707       howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
1708       h = NULL;
1709       sym = NULL;
1710       sec = NULL;
1711
1712       if (r_symndx < symtab_hdr->sh_info)
1713         {
1714           sym = local_syms + r_symndx;
1715           sec = local_sections[r_symndx];
1716           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1717         }
1718       else
1719         {
1720           bfd_boolean warned, ignored;
1721
1722           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1723                                    r_symndx, symtab_hdr, sym_hashes,
1724                                    h, sec, relocation,
1725                                    unresolved_reloc, warned, ignored);
1726         }
1727
1728       if (sec && discarded_section (sec))
1729         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1730                                          rel, 1, relend, howto, 0, contents);
1731
1732       /* Nothing more to do unless this is a final link.  */
1733       if (info->relocatable)
1734         continue;
1735
1736       if (sec && sec->output_section)
1737         reloc_address = (sec->output_section->vma + sec->output_offset
1738                          + rel->r_offset);
1739       else
1740         reloc_address = 0;
1741
1742       if (howto)
1743         {
1744           switch (howto->type)
1745             {
1746             case R_NIOS2_HI16:
1747               r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
1748                                                 input_section,
1749                                                 contents, rel->r_offset,
1750                                                 relocation, rel->r_addend);
1751               break;
1752             case R_NIOS2_LO16:
1753               r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
1754                                                 input_section,
1755                                                 contents, rel->r_offset,
1756                                                 relocation, rel->r_addend);
1757               break;
1758             case R_NIOS2_PCREL_LO:
1759               r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
1760                                                       input_section,
1761                                                       contents,
1762                                                       rel->r_offset,
1763                                                       relocation,
1764                                                       rel->r_addend);
1765               break;
1766             case R_NIOS2_HIADJ16:
1767               r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
1768                                                    input_section, contents,
1769                                                    rel->r_offset, relocation,
1770                                                    rel->r_addend);
1771               break;
1772             case R_NIOS2_PCREL_HA:
1773               r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
1774                                                          input_section,
1775                                                          contents,
1776                                                          rel->r_offset,
1777                                                          relocation,
1778                                                          rel->r_addend);
1779               break;
1780             case R_NIOS2_PCREL16:
1781               r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
1782                                                    input_section, contents,
1783                                                    rel->r_offset, relocation,
1784                                                    rel->r_addend);
1785               break;
1786             case R_NIOS2_GPREL:
1787               /* Turns an absolute address into a gp-relative address.  */
1788               if (!nios2_elf_assign_gp (output_bfd, &gp, info))
1789                 {
1790                   format = _("global pointer relative relocation at address "
1791                              "0x%08x when _gp not defined\n");
1792                   sprintf (msgbuf, format, reloc_address);
1793                   msg = msgbuf;
1794                   r = bfd_reloc_dangerous;
1795                 }
1796               else
1797                 {
1798                   bfd_vma symbol_address = rel->r_addend + relocation;
1799                   relocation = relocation + rel->r_addend - gp;
1800                   rel->r_addend = 0;
1801                   if (((signed) relocation < -32768
1802                        || (signed) relocation > 32767)
1803                       && (!h
1804                           || h->root.type == bfd_link_hash_defined
1805                           || h->root.type == bfd_link_hash_defweak))
1806                     {
1807                       format = _("Unable to reach %s (at 0x%08x) from the "
1808                                  "global pointer (at 0x%08x) because the "
1809                                  "offset (%d) is out of the allowed range, "
1810                                  "-32678 to 32767.\n" );
1811                       sprintf (msgbuf, format, name, symbol_address, gp,
1812                                (signed)relocation);
1813                       msg = msgbuf;
1814                       r = bfd_reloc_outofrange;
1815                     }
1816                   else
1817                     r = _bfd_final_link_relocate (howto, input_bfd,
1818                                                   input_section, contents,
1819                                                   rel->r_offset, relocation,
1820                                                   rel->r_addend);
1821                 }
1822
1823               break;
1824             case R_NIOS2_UJMP:
1825               r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
1826                                                 input_section,
1827                                                 contents, rel->r_offset,
1828                                                 relocation, rel->r_addend);
1829               break;
1830             case R_NIOS2_CJMP:
1831               r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
1832                                                 input_section,
1833                                                 contents, rel->r_offset,
1834                                                 relocation, rel->r_addend);
1835               break;
1836             case R_NIOS2_CALLR:
1837               r = nios2_elf32_do_callr_relocate (input_bfd, howto,
1838                                                  input_section, contents,
1839                                                  rel->r_offset, relocation,
1840                                                  rel->r_addend);
1841               break;
1842             case R_NIOS2_CALL26:
1843               /* If we have a call to an undefined weak symbol, we just want
1844                  to stuff a zero in the bits of the call instruction and
1845                  bypass the normal call26 relocation handling, because it'll
1846                  diagnose an overflow error if address 0 isn't in the same
1847                  256MB segment as the call site.  Presumably the call
1848                  should be guarded by a null check anyway.  */
1849               if (h != NULL && h->root.type == bfd_link_hash_undefweak)
1850                 {
1851                   BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
1852                   r = _bfd_final_link_relocate (howto, input_bfd,
1853                                                 input_section, contents,
1854                                                 rel->r_offset, relocation,
1855                                                 rel->r_addend);
1856                   break;
1857                 }
1858               /* Handle relocations which should use the PLT entry.
1859                  NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
1860                  which may point to a PLT entry, but we don't need to handle
1861                  that here.  If we created a PLT entry, all branches in this
1862                  object should go to it.  */
1863               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
1864                 {
1865                   /* If we've created a .plt section, and assigned a PLT entry
1866                      to this function, it should not be known to bind locally.
1867                      If it were, we would have cleared the PLT entry.  */
1868                   BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
1869
1870                   relocation = (splt->output_section->vma
1871                                 + splt->output_offset
1872                                 + h->plt.offset);
1873
1874                   unresolved_reloc = FALSE;
1875                 }
1876               r = nios2_elf32_do_call26_relocate (input_bfd, howto,
1877                                                   input_section, contents,
1878                                                   rel->r_offset, relocation,
1879                                                   rel->r_addend);
1880               break;
1881             case R_NIOS2_ALIGN:
1882               r = bfd_reloc_ok;
1883               /* For symmetry this would be
1884                  r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
1885                                                   input_section, contents,
1886                                                   rel->r_offset, relocation,
1887                                                   rel->r_addend);
1888                 but do_ignore_reloc would do no more than return
1889                 bfd_reloc_ok. */
1890               break;
1891
1892             case R_NIOS2_GOT16:
1893             case R_NIOS2_CALL16:
1894               /* Relocation is to the entry for this symbol in the
1895                  global offset table.  */
1896               if (sgot == NULL)
1897                 {
1898                   r = bfd_reloc_notsupported;
1899                   break;
1900                 }
1901
1902               use_plt = 0;
1903
1904               if (h != NULL)
1905                 {
1906                   bfd_boolean dyn;
1907
1908                   eh = (struct elf32_nios2_link_hash_entry *)h;
1909                   use_plt = (eh->got_types_used == CALL16_USED
1910                              && h->plt.offset != (bfd_vma) -1);
1911
1912                   off = h->got.offset;
1913                   BFD_ASSERT (off != (bfd_vma) -1);
1914                   dyn = elf_hash_table (info)->dynamic_sections_created;
1915                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1916                       || (info->shared
1917                           && SYMBOL_REFERENCES_LOCAL (info, h))
1918                       || (ELF_ST_VISIBILITY (h->other)
1919                           && h->root.type == bfd_link_hash_undefweak))
1920                     {
1921                       /* This is actually a static link, or it is a -Bsymbolic
1922                          link and the symbol is defined locally.  We must
1923                          initialize this entry in the global offset table.
1924                          Since the offset must always be a multiple of 4, we
1925                          use the least significant bit to record whether we
1926                          have initialized it already.
1927
1928                          When doing a dynamic link, we create a .rela.got
1929                          relocation entry to initialize the value.  This is
1930                          done in the finish_dynamic_symbol routine.  */
1931                       if ((off & 1) != 0)
1932                         off &= ~1;
1933                       else
1934                         {
1935                           bfd_put_32 (output_bfd, relocation,
1936                                       sgot->contents + off);
1937                           h->got.offset |= 1;
1938                         }
1939                     }
1940                   else
1941                     unresolved_reloc = FALSE;
1942                 }
1943               else
1944                 {
1945                   BFD_ASSERT (local_got_offsets != NULL
1946                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
1947
1948                   off = local_got_offsets[r_symndx];
1949
1950                   /* The offset must always be a multiple of 4.  We use the
1951                      least significant bit to record whether we have already
1952                      generated the necessary reloc.  */
1953                   if ((off & 1) != 0)
1954                     off &= ~1;
1955                   else
1956                     {
1957                       bfd_put_32 (output_bfd, relocation,
1958                                   sgot->contents + off);
1959
1960                       if (info->shared)
1961                         {
1962                           asection *srelgot;
1963                           Elf_Internal_Rela outrel;
1964                           bfd_byte *loc;
1965
1966                           srelgot = htab->root.srelgot;
1967                           BFD_ASSERT (srelgot != NULL);
1968
1969                           outrel.r_addend = relocation;
1970                           outrel.r_offset = (sgot->output_section->vma
1971                                              + sgot->output_offset
1972                                              + off);
1973                           outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
1974                           loc = srelgot->contents;
1975                           loc += (srelgot->reloc_count++ *
1976                                   sizeof (Elf32_External_Rela));
1977                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1978                         }
1979
1980                       local_got_offsets[r_symndx] |= 1;
1981                     }
1982                 }
1983
1984               if (use_plt && info->shared)
1985                 {
1986                   off = ((h->plt.offset - 24) / 12 + 3) * 4;
1987                   relocation = htab->root.sgotplt->output_offset + off;
1988                 }
1989               else
1990                 relocation = sgot->output_offset + off;
1991
1992               /* This relocation does not use the addend.  */
1993               rel->r_addend = 0;
1994
1995               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1996                                             contents, rel->r_offset,
1997                                             relocation, rel->r_addend);
1998               break;
1999
2000             case R_NIOS2_GOTOFF_LO:
2001             case R_NIOS2_GOTOFF_HA:
2002             case R_NIOS2_GOTOFF:
2003               /* Relocation is relative to the start of the
2004                  global offset table.  */
2005
2006               BFD_ASSERT (sgot != NULL);
2007               if (sgot == NULL)
2008                 {
2009                   r = bfd_reloc_notsupported;
2010                   break;
2011                 }
2012
2013               /* Note that sgot->output_offset is not involved in this
2014                  calculation.  We always want the start of .got.  If we
2015                  define _GLOBAL_OFFSET_TABLE in a different way, as is
2016                  permitted by the ABI, we might have to change this
2017                  calculation.  */
2018               relocation -= sgot->output_section->vma;
2019               switch (howto->type)
2020                 {
2021                 case R_NIOS2_GOTOFF_LO:
2022                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
2023                                                     input_section, contents,
2024                                                     rel->r_offset, relocation,
2025                                                     rel->r_addend);
2026                   break;
2027                 case R_NIOS2_GOTOFF_HA:
2028                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
2029                                                        input_section, contents,
2030                                                        rel->r_offset,
2031                                                        relocation,
2032                                                        rel->r_addend);
2033                   break;
2034                 default:
2035                   r = _bfd_final_link_relocate (howto, input_bfd,
2036                                                 input_section, contents,
2037                                                 rel->r_offset, relocation,
2038                                                 rel->r_addend);
2039                   break;
2040                 }
2041               break;
2042
2043             case R_NIOS2_TLS_LDO16:
2044               relocation -= dtpoff_base (info) + DTP_OFFSET;
2045
2046               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2047                                             contents, rel->r_offset,
2048                                             relocation, rel->r_addend);
2049               break;
2050             case R_NIOS2_TLS_LDM16:
2051               if (htab->root.sgot == NULL)
2052                 abort ();
2053
2054               off = htab->tls_ldm_got.offset;
2055
2056               if ((off & 1) != 0)
2057                 off &= ~1;
2058               else
2059                 {
2060                   /* If we don't know the module number, create a relocation
2061                      for it.  */
2062                   if (info->shared)
2063                     {
2064                       Elf_Internal_Rela outrel;
2065                       bfd_byte *loc;
2066
2067                       if (htab->root.srelgot == NULL)
2068                         abort ();
2069
2070                       outrel.r_addend = 0;
2071                       outrel.r_offset = (htab->root.sgot->output_section->vma
2072                                          + htab->root.sgot->output_offset
2073                                          + off);
2074                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
2075
2076                       loc = htab->root.srelgot->contents;
2077                       loc += (htab->root.srelgot->reloc_count++
2078                               * sizeof (Elf32_External_Rela));
2079                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2080                     }
2081                   else
2082                     bfd_put_32 (output_bfd, 1,
2083                                 htab->root.sgot->contents + off);
2084
2085                   htab->tls_ldm_got.offset |= 1;
2086                 }
2087
2088               relocation = (htab->root.sgot->output_offset + off);
2089
2090               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2091                                             contents, rel->r_offset,
2092                                             relocation, rel->r_addend);
2093
2094               break;
2095             case R_NIOS2_TLS_GD16:
2096             case R_NIOS2_TLS_IE16:
2097               {
2098                 int indx;
2099                 char tls_type;
2100
2101                 if (htab->root.sgot == NULL)
2102                   abort ();
2103
2104                 indx = 0;
2105                 if (h != NULL)
2106                   {
2107                     bfd_boolean dyn;
2108                     dyn = htab->root.dynamic_sections_created;
2109                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2110                         && (!info->shared
2111                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
2112                       {
2113                         unresolved_reloc = FALSE;
2114                         indx = h->dynindx;
2115                       }
2116                     off = h->got.offset;
2117                     tls_type = (((struct elf32_nios2_link_hash_entry *) h)
2118                                 ->tls_type);
2119                   }
2120                 else
2121                   {
2122                     if (local_got_offsets == NULL)
2123                       abort ();
2124                     off = local_got_offsets[r_symndx];
2125                     tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
2126                                 [r_symndx]);
2127                   }
2128
2129                 if (tls_type == GOT_UNKNOWN)
2130                   abort ();
2131
2132                 if ((off & 1) != 0)
2133                   off &= ~1;
2134                 else
2135                   {
2136                     bfd_boolean need_relocs = FALSE;
2137                     Elf_Internal_Rela outrel;
2138                     bfd_byte *loc = NULL;
2139                     int cur_off = off;
2140
2141                     /* The GOT entries have not been initialized yet.  Do it
2142                        now, and emit any relocations.  If both an IE GOT and a
2143                        GD GOT are necessary, we emit the GD first.  */
2144
2145                     if ((info->shared || indx != 0)
2146                         && (h == NULL
2147                             || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2148                             || h->root.type != bfd_link_hash_undefweak))
2149                       {
2150                         need_relocs = TRUE;
2151                         if (htab->root.srelgot == NULL)
2152                           abort ();
2153                         loc = htab->root.srelgot->contents;
2154                         loc += (htab->root.srelgot->reloc_count *
2155                                 sizeof (Elf32_External_Rela));
2156                       }
2157
2158                     if (tls_type & GOT_TLS_GD)
2159                       {
2160                         if (need_relocs)
2161                           {
2162                             outrel.r_addend = 0;
2163                             outrel.r_offset = (htab->root.sgot->output_section->vma
2164                                                + htab->root.sgot->output_offset
2165                                                + cur_off);
2166                             outrel.r_info = ELF32_R_INFO (indx,
2167                                                           R_NIOS2_TLS_DTPMOD);
2168
2169                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2170                                                        loc);
2171                             htab->root.srelgot->reloc_count++;
2172                             loc += sizeof (Elf32_External_Rela);
2173
2174                             if (indx == 0)
2175                               bfd_put_32 (output_bfd,
2176                                           (relocation - dtpoff_base (info) -
2177                                            DTP_OFFSET),
2178                                           htab->root.sgot->contents + cur_off + 4);
2179                             else
2180                               {
2181                                 outrel.r_addend = 0;
2182                                 outrel.r_info = ELF32_R_INFO (indx,
2183                                   R_NIOS2_TLS_DTPREL);
2184                                 outrel.r_offset += 4;
2185
2186                                 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2187                                                            loc);
2188                                 htab->root.srelgot->reloc_count++;
2189                                 loc += sizeof (Elf32_External_Rela);
2190                               }
2191                           }
2192                         else
2193                           {
2194                             /* If we are not emitting relocations for a
2195                                general dynamic reference, then we must be in a
2196                                static link or an executable link with the
2197                                symbol binding locally.  Mark it as belonging
2198                                to module 1, the executable.  */
2199                             bfd_put_32 (output_bfd, 1,
2200                                         htab->root.sgot->contents + cur_off);
2201                             bfd_put_32 (output_bfd, (relocation -
2202                                                      dtpoff_base (info) -
2203                                                      DTP_OFFSET),
2204                                         htab->root.sgot->contents + cur_off + 4);
2205                           }
2206
2207                         cur_off += 8;
2208                       }
2209
2210                     if (tls_type & GOT_TLS_IE)
2211                       {
2212                         if (need_relocs)
2213                           {
2214                             if (indx == 0)
2215                               outrel.r_addend = (relocation -
2216                                                  dtpoff_base (info));
2217                             else
2218                               outrel.r_addend = 0;
2219                             outrel.r_offset = (htab->root.sgot->output_section->vma
2220                                                + htab->root.sgot->output_offset
2221                                                + cur_off);
2222                             outrel.r_info = ELF32_R_INFO (indx,
2223                                                           R_NIOS2_TLS_TPREL);
2224
2225                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2226                                                        loc);
2227                             htab->root.srelgot->reloc_count++;
2228                             loc += sizeof (Elf32_External_Rela);
2229                           }
2230                         else
2231                           bfd_put_32 (output_bfd, (tpoff (info, relocation)
2232                                                    - TP_OFFSET),
2233                                       htab->root.sgot->contents + cur_off);
2234                         cur_off += 4;
2235                       }
2236
2237                     if (h != NULL)
2238                       h->got.offset |= 1;
2239                     else
2240                       local_got_offsets[r_symndx] |= 1;
2241                   }
2242
2243                 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
2244                   off += 8;
2245                 relocation = (htab->root.sgot->output_offset + off);
2246
2247                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2248                                               contents, rel->r_offset,
2249                                               relocation, rel->r_addend);
2250               }
2251
2252               break;
2253             case R_NIOS2_TLS_LE16:
2254               if (info->shared && !info->pie)
2255                 {
2256                   (*_bfd_error_handler)
2257                     (_("%B(%A+0x%lx): R_NIOS2_TLS_LE16 relocation not "
2258                        "permitted in shared object"),
2259                      input_bfd, input_section,
2260                      (long) rel->r_offset, howto->name);
2261                   return FALSE;
2262                 }
2263               else
2264                 relocation = tpoff (info, relocation) - TP_OFFSET;
2265
2266               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2267                                             contents, rel->r_offset,
2268                                             relocation, rel->r_addend);
2269               break;
2270
2271             case R_NIOS2_BFD_RELOC_32:
2272               if (info->shared
2273                   && (input_section->flags & SEC_ALLOC) != 0
2274                   && (h == NULL
2275                       || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2276                       || h->root.type != bfd_link_hash_undefweak))
2277                 {
2278                   Elf_Internal_Rela outrel;
2279                   bfd_byte *loc;
2280                   bfd_boolean skip, relocate;
2281
2282                   /* When generating a shared object, these relocations
2283                      are copied into the output file to be resolved at run
2284                      time.  */
2285
2286                   skip = FALSE;
2287                   relocate = FALSE;
2288
2289                   outrel.r_offset
2290                     = _bfd_elf_section_offset (output_bfd, info,
2291                                                input_section, rel->r_offset);
2292                   if (outrel.r_offset == (bfd_vma) -1)
2293                     skip = TRUE;
2294                   else if (outrel.r_offset == (bfd_vma) -2)
2295                     skip = TRUE, relocate = TRUE;
2296                   outrel.r_offset += (input_section->output_section->vma
2297                                       + input_section->output_offset);
2298
2299                   if (skip)
2300                     memset (&outrel, 0, sizeof outrel);
2301                   else if (h != NULL
2302                            && h->dynindx != -1
2303                            && (!info->shared
2304                                || !info->symbolic
2305                                || !h->def_regular))
2306                     {
2307                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2308                       outrel.r_addend = rel->r_addend;
2309                     }
2310                   else
2311                     {
2312                       /* This symbol is local, or marked to become local.  */
2313                       outrel.r_addend = relocation + rel->r_addend;
2314                       relocate = TRUE;
2315                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
2316                     }
2317
2318                   sreloc = elf_section_data (input_section)->sreloc;
2319                   if (sreloc == NULL)
2320                     abort ();
2321
2322                   loc = sreloc->contents;
2323                   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2324                   bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2325
2326                   /* This reloc will be computed at runtime, so there's no
2327                      need to do anything now, except for R_NIOS2_BFD_RELOC_32
2328                      relocations that have been turned into
2329                      R_NIOS2_RELATIVE.  */
2330                   if (!relocate)
2331                     break;
2332                 }
2333
2334               r = _bfd_final_link_relocate (howto, input_bfd,
2335                                             input_section, contents,
2336                                             rel->r_offset, relocation,
2337                                             rel->r_addend);
2338               break;
2339
2340             case R_NIOS2_TLS_DTPREL:
2341               relocation -= dtpoff_base (info);
2342               /* Fall through.  */
2343
2344             default:
2345               r = _bfd_final_link_relocate (howto, input_bfd,
2346                                             input_section, contents,
2347                                             rel->r_offset, relocation,
2348                                             rel->r_addend);
2349               break;
2350             }
2351         }
2352       else
2353         r = bfd_reloc_notsupported;
2354
2355       if (r != bfd_reloc_ok)
2356         {
2357           if (h != NULL)
2358             name = h->root.root.string;
2359           else
2360             {
2361               name = bfd_elf_string_from_elf_section (input_bfd,
2362                                                       symtab_hdr->sh_link,
2363                                                       sym->st_name);
2364               if (name == NULL || *name == '\0')
2365                 name = bfd_section_name (input_bfd, sec);
2366             }
2367
2368           switch (r)
2369             {
2370             case bfd_reloc_overflow:
2371               r = info->callbacks->reloc_overflow (info, NULL, name,
2372                                                    howto->name, (bfd_vma) 0,
2373                                                    input_bfd, input_section,
2374                                                    rel->r_offset);
2375               break;
2376
2377             case bfd_reloc_undefined:
2378               r = info->callbacks->undefined_symbol (info, name, input_bfd,
2379                                                      input_section,
2380                                                      rel->r_offset, TRUE);
2381               break;
2382
2383             case bfd_reloc_outofrange:
2384               if (msg == NULL)
2385                 msg = _("relocation out of range");
2386               break;
2387
2388             case bfd_reloc_notsupported:
2389               if (msg == NULL)
2390                 msg = _("unsupported relocation");
2391               break;
2392
2393             case bfd_reloc_dangerous:
2394               if (msg == NULL)
2395                 msg = _("dangerous relocation");
2396               break;
2397
2398             default:
2399               if (msg == NULL)
2400                 msg = _("unknown error");
2401               break;
2402             }
2403
2404           if (msg)
2405             {
2406               r = info->callbacks->warning
2407                 (info, msg, name, input_bfd, input_section, rel->r_offset);
2408               return FALSE;
2409             }
2410         }
2411     }
2412   return TRUE;
2413 }
2414
2415 /* Implement elf-backend_section_flags:
2416    Convert NIOS2 specific section flags to bfd internal section flags.  */
2417 static bfd_boolean
2418 nios2_elf32_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
2419 {
2420   if (hdr->sh_flags & SHF_NIOS2_GPREL)
2421     *flags |= SEC_SMALL_DATA;
2422
2423   return TRUE;
2424 }
2425
2426 /* Implement elf_backend_fake_sections:
2427    Set the correct type for an NIOS2 ELF section.  We do this by the
2428    section name, which is a hack, but ought to work.  */
2429 static bfd_boolean
2430 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2431                            Elf_Internal_Shdr *hdr, asection *sec)
2432 {
2433   register const char *name = bfd_get_section_name (abfd, sec);
2434
2435   if ((sec->flags & SEC_SMALL_DATA)
2436       || strcmp (name, ".sdata") == 0
2437       || strcmp (name, ".sbss") == 0
2438       || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
2439     hdr->sh_flags |= SHF_NIOS2_GPREL;
2440
2441   return TRUE;
2442 }
2443
2444 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2445    shortcuts to them in our hash table.  */
2446 static bfd_boolean
2447 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2448 {
2449   struct elf32_nios2_link_hash_table *htab;
2450
2451   htab = elf32_nios2_hash_table (info);
2452
2453   if (! _bfd_elf_create_got_section (dynobj, info))
2454     return FALSE;
2455
2456   /* In order for the two loads in .PLTresolve to share the same %hiadj,
2457      _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary.  */
2458   if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt, 4))
2459     return FALSE;
2460
2461   return TRUE;
2462 }
2463
2464 /* Implement elf_backend_create_dynamic_sections:
2465    Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
2466    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
2467    hash table.  */
2468 static bfd_boolean
2469 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2470 {
2471   struct elf32_nios2_link_hash_table *htab;
2472
2473   htab = elf32_nios2_hash_table (info);
2474   if (!htab->root.sgot && !create_got_section (dynobj, info))
2475     return FALSE;
2476
2477   _bfd_elf_create_dynamic_sections (dynobj, info);
2478
2479   /* In order for the two loads in a shared object .PLTresolve to share the
2480      same %hiadj, the start of the PLT (as well as the GOT) must be aligned
2481      to a 16-byte boundary.  This is because the addresses for these loads
2482      include the -(.plt+4) PIC correction.  */
2483   if (!bfd_set_section_alignment (dynobj, htab->root.splt, 4))
2484     return FALSE;
2485
2486   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
2487   if (!htab->sdynbss)
2488     return FALSE;
2489   if (!info->shared)
2490     {
2491       htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
2492       if (!htab->srelbss)
2493         return FALSE;
2494     }
2495
2496   return TRUE;
2497 }
2498
2499 /* Implement elf_backend_copy_indirect_symbol:
2500    Copy the extra info we tack onto an elf_link_hash_entry.  */
2501 static void
2502 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
2503                                   struct elf_link_hash_entry *dir,
2504                                   struct elf_link_hash_entry *ind)
2505 {
2506   struct elf32_nios2_link_hash_entry *edir, *eind;
2507
2508   edir = (struct elf32_nios2_link_hash_entry *) dir;
2509   eind = (struct elf32_nios2_link_hash_entry *) ind;
2510
2511   if (eind->dyn_relocs != NULL)
2512     {
2513       if (edir->dyn_relocs != NULL)
2514         {
2515           struct elf32_nios2_dyn_relocs **pp;
2516           struct elf32_nios2_dyn_relocs *p;
2517
2518           /* Add reloc counts against the indirect sym to the direct sym
2519              list.  Merge any entries against the same section.  */
2520           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2521             {
2522               struct elf32_nios2_dyn_relocs *q;
2523
2524               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2525                 if (q->sec == p->sec)
2526                   {
2527                     q->pc_count += p->pc_count;
2528                     q->count += p->count;
2529                     *pp = p->next;
2530                     break;
2531                   }
2532               if (q == NULL)
2533                 pp = &p->next;
2534             }
2535           *pp = edir->dyn_relocs;
2536         }
2537
2538       edir->dyn_relocs = eind->dyn_relocs;
2539       eind->dyn_relocs = NULL;
2540     }
2541
2542   if (ind->root.type == bfd_link_hash_indirect
2543       && dir->got.refcount <= 0)
2544     {
2545       edir->tls_type = eind->tls_type;
2546       eind->tls_type = GOT_UNKNOWN;
2547     }
2548
2549   edir->got_types_used |= eind->got_types_used;
2550
2551   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2552 }
2553
2554 /* Implement elf_backend_check_relocs:
2555    Look through the relocs for a section during the first phase.  */
2556 static bfd_boolean
2557 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
2558                           asection *sec, const Elf_Internal_Rela *relocs)
2559 {
2560   bfd *dynobj;
2561   Elf_Internal_Shdr *symtab_hdr;
2562   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2563   const Elf_Internal_Rela *rel;
2564   const Elf_Internal_Rela *rel_end;
2565   struct elf32_nios2_link_hash_table *htab;
2566   asection *sgot;
2567   asection *srelgot;
2568   asection *sreloc = NULL;
2569   bfd_signed_vma *local_got_refcounts;
2570
2571   if (info->relocatable)
2572     return TRUE;
2573
2574   dynobj = elf_hash_table (info)->dynobj;
2575   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2576   sym_hashes = elf_sym_hashes (abfd);
2577   sym_hashes_end = (sym_hashes
2578                     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2579   if (!elf_bad_symtab (abfd))
2580     sym_hashes_end -= symtab_hdr->sh_info;
2581   local_got_refcounts = elf_local_got_refcounts (abfd);
2582
2583   htab = elf32_nios2_hash_table (info);
2584   sgot = htab->root.sgot;
2585   srelgot = htab->root.srelgot;
2586
2587   rel_end = relocs + sec->reloc_count;
2588   for (rel = relocs; rel < rel_end; rel++)
2589     {
2590       unsigned int r_type;
2591       struct elf_link_hash_entry *h;
2592       unsigned long r_symndx;
2593
2594       r_symndx = ELF32_R_SYM (rel->r_info);
2595       if (r_symndx < symtab_hdr->sh_info)
2596         h = NULL;
2597       else
2598         {
2599           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2600           while (h->root.type == bfd_link_hash_indirect
2601                  || h->root.type == bfd_link_hash_warning)
2602             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2603
2604           /* PR15323, ref flags aren't set for references in the same
2605              object.  */
2606           h->root.non_ir_ref = 1;
2607         }
2608
2609       r_type = ELF32_R_TYPE (rel->r_info);
2610
2611       switch (r_type)
2612         {
2613         case R_NIOS2_GOT16:
2614         case R_NIOS2_CALL16:
2615         case R_NIOS2_TLS_GD16:
2616         case R_NIOS2_TLS_IE16:
2617           /* This symbol requires a global offset table entry.  */
2618           {
2619             int tls_type, old_tls_type;
2620
2621             switch (r_type)
2622               {
2623               default:
2624               case R_NIOS2_GOT16:
2625               case R_NIOS2_CALL16:
2626                 tls_type = GOT_NORMAL;
2627                 break;
2628               case R_NIOS2_TLS_GD16:
2629                 tls_type = GOT_TLS_GD;
2630                 break;
2631               case R_NIOS2_TLS_IE16:
2632                 tls_type = GOT_TLS_IE;
2633                 break;
2634               }
2635
2636             if (dynobj == NULL)
2637               {
2638                 /* Create the .got section.  */
2639                 elf_hash_table (info)->dynobj = dynobj = abfd;
2640                 nios2_elf32_create_dynamic_sections (dynobj, info);
2641               }
2642
2643             if (sgot == NULL)
2644               {
2645                 sgot = htab->root.sgot;
2646                 BFD_ASSERT (sgot != NULL);
2647               }
2648
2649             if (srelgot == NULL
2650                 && (h != NULL || info->shared))
2651               {
2652                 srelgot = htab->root.srelgot;
2653                 BFD_ASSERT (srelgot != NULL);
2654               }
2655
2656             if (h != NULL)
2657               {
2658                 struct elf32_nios2_link_hash_entry *eh
2659                   = (struct elf32_nios2_link_hash_entry *)h;
2660                 h->got.refcount++;
2661                 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
2662                 if (r_type == R_NIOS2_CALL16)
2663                   {
2664                     /* Make sure a plt entry is created for this symbol if
2665                        it turns out to be a function defined by a dynamic
2666                        object.  */
2667                     h->plt.refcount++;
2668                     h->needs_plt = 1;
2669                     h->type = STT_FUNC;
2670                     eh->got_types_used |= CALL16_USED;
2671                   }
2672                 else
2673                   eh->got_types_used |= GOT16_USED;
2674               }
2675             else
2676               {
2677                 /* This is a global offset table entry for a local symbol.  */
2678                 if (local_got_refcounts == NULL)
2679                   {
2680                     bfd_size_type size;
2681
2682                     size = symtab_hdr->sh_info;
2683                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
2684                     local_got_refcounts
2685                       = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
2686                     if (local_got_refcounts == NULL)
2687                       return FALSE;
2688                     elf_local_got_refcounts (abfd) = local_got_refcounts;
2689                     elf32_nios2_local_got_tls_type (abfd)
2690                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
2691                   }
2692                 local_got_refcounts[r_symndx]++;
2693                 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
2694               }
2695
2696             /* We will already have issued an error message if there is a
2697                TLS / non-TLS mismatch, based on the symbol type.  We don't
2698                support any linker relaxations.  So just combine any TLS
2699                types needed.  */
2700             if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
2701                 && tls_type != GOT_NORMAL)
2702               tls_type |= old_tls_type;
2703
2704             if (old_tls_type != tls_type)
2705               {
2706                 if (h != NULL)
2707                   elf32_nios2_hash_entry (h)->tls_type = tls_type;
2708                 else
2709                   elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
2710               }
2711           }
2712           /* Fall through */
2713         case R_NIOS2_TLS_LDM16:
2714           if (r_type == R_NIOS2_TLS_LDM16)
2715             htab->tls_ldm_got.refcount++;
2716
2717           if (htab->root.sgot == NULL)
2718             {
2719               if (htab->root.dynobj == NULL)
2720                 htab->root.dynobj = abfd;
2721               if (!create_got_section (htab->root.dynobj, info))
2722                 return FALSE;
2723             }
2724           break;
2725
2726           /* This relocation describes the C++ object vtable hierarchy.
2727              Reconstruct it for later use during GC.  */
2728         case R_NIOS2_GNU_VTINHERIT:
2729           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2730             return FALSE;
2731           break;
2732
2733           /* This relocation describes which C++ vtable entries are actually
2734              used.  Record for later use during GC.  */
2735         case R_NIOS2_GNU_VTENTRY:
2736           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2737             return FALSE;
2738           break;
2739
2740         case R_NIOS2_BFD_RELOC_32:
2741         case R_NIOS2_CALL26:
2742         case R_NIOS2_HIADJ16:
2743         case R_NIOS2_LO16:
2744
2745           if (h != NULL)
2746             {
2747               /* If this reloc is in a read-only section, we might
2748                    need a copy reloc.  We can't check reliably at this
2749                    stage whether the section is read-only, as input
2750                    sections have not yet been mapped to output sections.
2751                    Tentatively set the flag for now, and correct in
2752                    adjust_dynamic_symbol.  */
2753               if (!info->shared)
2754                 h->non_got_ref = 1;
2755
2756               /* Make sure a plt entry is created for this symbol if it
2757                  turns out to be a function defined by a dynamic object.  */
2758               h->plt.refcount++;
2759
2760               if (r_type == R_NIOS2_CALL26)
2761                 h->needs_plt = 1;
2762             }
2763
2764           /* If we are creating a shared library, we need to copy the
2765              reloc into the shared library.  */
2766           if (info->shared
2767               && (sec->flags & SEC_ALLOC) != 0
2768               && (r_type == R_NIOS2_BFD_RELOC_32
2769                   || (h != NULL && ! h->needs_plt
2770                       && (! info->symbolic || ! h->def_regular))))
2771             {
2772               struct elf32_nios2_dyn_relocs *p;
2773               struct elf32_nios2_dyn_relocs **head;
2774
2775               /* When creating a shared object, we must copy these
2776                  reloc types into the output file.  We create a reloc
2777                  section in dynobj and make room for this reloc.  */
2778               if (sreloc == NULL)
2779                 {
2780                   sreloc = _bfd_elf_make_dynamic_reloc_section
2781                     (sec, dynobj, 2, abfd, TRUE);
2782                   if (sreloc == NULL)
2783                     return FALSE;
2784                 }
2785
2786               /* If this is a global symbol, we count the number of
2787                  relocations we need for this symbol.  */
2788               if (h != NULL)
2789                 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
2790               else
2791                 {
2792                   /* Track dynamic relocs needed for local syms too.
2793                      We really need local syms available to do this
2794                      easily.  Oh well.  */
2795
2796                   asection *s;
2797                   void *vpp;
2798                   Elf_Internal_Sym *isym;
2799
2800                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2801                                                 abfd, r_symndx);
2802                   if (isym == NULL)
2803                     return FALSE;
2804
2805                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2806                   if (s == NULL)
2807                     s = sec;
2808
2809                   vpp = &elf_section_data (s)->local_dynrel;
2810                   head = (struct elf32_nios2_dyn_relocs **) vpp;
2811                 }
2812
2813               p = *head;
2814               if (p == NULL || p->sec != sec)
2815                 {
2816                   bfd_size_type amt = sizeof *p;
2817                   p = ((struct elf32_nios2_dyn_relocs *)
2818                        bfd_alloc (htab->root.dynobj, amt));
2819                   if (p == NULL)
2820                     return FALSE;
2821                   p->next = *head;
2822                   *head = p;
2823                   p->sec = sec;
2824                   p->count = 0;
2825                   p->pc_count = 0;
2826                 }
2827
2828               p->count += 1;
2829
2830             }
2831           break;
2832         }
2833     }
2834
2835   return TRUE;
2836 }
2837
2838
2839 /* Implement elf_backend_gc_mark_hook:
2840    Return the section that should be marked against GC for a given
2841    relocation.  */
2842 static asection *
2843 nios2_elf32_gc_mark_hook (asection *sec,
2844                           struct bfd_link_info *info,
2845                           Elf_Internal_Rela *rel,
2846                           struct elf_link_hash_entry *h,
2847                           Elf_Internal_Sym *sym)
2848 {
2849   if (h != NULL)
2850     switch (ELF32_R_TYPE (rel->r_info))
2851       {
2852       case R_NIOS2_GNU_VTINHERIT:
2853       case R_NIOS2_GNU_VTENTRY:
2854         return NULL;
2855       }
2856   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2857 }
2858
2859 /* Implement elf_backend_gc_sweep_hook:
2860    Update the got entry reference counts for the section being removed.  */
2861 static bfd_boolean
2862 nios2_elf32_gc_sweep_hook (bfd *abfd,
2863                            struct bfd_link_info *info,
2864                            asection *sec,
2865                            const Elf_Internal_Rela *relocs)
2866 {
2867   Elf_Internal_Shdr *symtab_hdr;
2868   struct elf_link_hash_entry **sym_hashes;
2869   bfd_signed_vma *local_got_refcounts;
2870   const Elf_Internal_Rela *rel, *relend;
2871   bfd *dynobj;
2872
2873   if (info->relocatable)
2874     return TRUE;
2875
2876   elf_section_data (sec)->local_dynrel = NULL;
2877
2878   dynobj = elf_hash_table (info)->dynobj;
2879   if (dynobj == NULL)
2880     return TRUE;
2881
2882   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2883   sym_hashes = elf_sym_hashes (abfd);
2884   local_got_refcounts = elf_local_got_refcounts (abfd);
2885
2886   relend = relocs + sec->reloc_count;
2887   for (rel = relocs; rel < relend; rel++)
2888     {
2889       unsigned long r_symndx;
2890       struct elf_link_hash_entry *h = NULL;
2891       int r_type;
2892
2893       r_symndx = ELF32_R_SYM (rel->r_info);
2894       if (r_symndx >= symtab_hdr->sh_info)
2895         {
2896           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2897           while (h->root.type == bfd_link_hash_indirect
2898                  || h->root.type == bfd_link_hash_warning)
2899             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2900         }
2901
2902       r_type = ELF32_R_TYPE (rel->r_info);
2903       switch (r_type)
2904         {
2905         case R_NIOS2_GOT16:
2906         case R_NIOS2_CALL16:
2907           if (h != NULL)
2908             {
2909               if (h->got.refcount > 0)
2910                 --h->got.refcount;
2911             }
2912           else if (local_got_refcounts != NULL)
2913             {
2914               if (local_got_refcounts[r_symndx] > 0)
2915                 --local_got_refcounts[r_symndx];
2916             }
2917           break;
2918
2919         case R_NIOS2_PCREL_LO:
2920         case R_NIOS2_PCREL_HA:
2921         case R_NIOS2_BFD_RELOC_32:
2922         case R_NIOS2_CALL26:
2923           if (h != NULL)
2924             {
2925               struct elf32_nios2_link_hash_entry *eh;
2926               struct elf32_nios2_dyn_relocs **pp;
2927               struct elf32_nios2_dyn_relocs *p;
2928
2929               eh = (struct elf32_nios2_link_hash_entry *) h;
2930
2931               if (h->plt.refcount > 0)
2932                 --h->plt.refcount;
2933
2934               if (r_type == R_NIOS2_PCREL_LO || r_type == R_NIOS2_PCREL_HA
2935                   || r_type == R_NIOS2_BFD_RELOC_32)
2936                 {
2937                   for (pp = &eh->dyn_relocs; (p = *pp) != NULL;
2938                        pp = &p->next)
2939                     if (p->sec == sec)
2940                       {
2941                         p->count -= 1;
2942                         if (p->count == 0)
2943                           *pp = p->next;
2944                         break;
2945                       }
2946                 }
2947             }
2948           break;
2949
2950         default:
2951           break;
2952         }
2953     }
2954
2955   return TRUE;
2956 }
2957
2958 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC.  */
2959 static void
2960 nios2_elf32_install_imm16 (asection *sec, bfd_vma offset, bfd_vma value)
2961 {
2962   bfd_vma word = bfd_get_32 (sec->owner, sec->contents + offset);
2963
2964   BFD_ASSERT(value <= 0xffff);
2965
2966   bfd_put_32 (sec->owner, word | ((value & 0xffff) << 6),
2967               sec->contents + offset);
2968 }
2969
2970 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
2971    section SEC. */
2972 static void
2973 nios2_elf32_install_data (asection *sec, const bfd_vma *data, bfd_vma offset,
2974                           int count)
2975 {
2976   while (count--)
2977     {
2978       bfd_put_32 (sec->owner, *data, sec->contents + offset);
2979       offset += 4;
2980       ++data;
2981     }
2982 }
2983
2984 /* Implement elf_backend_finish_dynamic_symbols:
2985    Finish up dynamic symbol handling.  We set the contents of various
2986    dynamic sections here.  */
2987 static bfd_boolean
2988 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
2989                                    struct bfd_link_info *info,
2990                                    struct elf_link_hash_entry *h,
2991                                    Elf_Internal_Sym *sym)
2992 {
2993   struct elf32_nios2_link_hash_table *htab;
2994   struct elf32_nios2_link_hash_entry *eh
2995     = (struct elf32_nios2_link_hash_entry *)h;
2996   int use_plt;
2997
2998   htab = elf32_nios2_hash_table (info);
2999
3000   if (h->plt.offset != (bfd_vma) -1)
3001     {
3002       asection *splt;
3003       asection *sgotplt;
3004       asection *srela;
3005       bfd_vma plt_index;
3006       bfd_vma got_offset;
3007       Elf_Internal_Rela rela;
3008       bfd_byte *loc;
3009       bfd_vma got_address;
3010
3011       /* This symbol has an entry in the procedure linkage table.  Set
3012          it up.  */
3013       BFD_ASSERT (h->dynindx != -1);
3014       splt = htab->root.splt;
3015       sgotplt = htab->root.sgotplt;
3016       srela = htab->root.srelplt;
3017       BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
3018
3019       /* Emit the PLT entry.  */
3020       if (info->shared)
3021         {
3022           nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
3023                                     3);
3024           plt_index = (h->plt.offset - 24) / 12;
3025           got_offset = (plt_index + 3) * 4;
3026           nios2_elf32_install_imm16 (splt, h->plt.offset,
3027                                      hiadj(plt_index * 4));
3028           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
3029                                      (plt_index * 4) & 0xffff);
3030           nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
3031                                      0xfff4 - h->plt.offset);
3032           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
3033                          + got_offset);
3034
3035           /* Fill in the entry in the global offset table.  There are no
3036              res_n slots for a shared object PLT, instead the .got.plt entries
3037              point to the PLT entries.  */
3038           bfd_put_32 (output_bfd,
3039                       splt->output_section->vma + splt->output_offset
3040                       + h->plt.offset, sgotplt->contents + got_offset);
3041         }
3042       else
3043         {
3044           plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
3045           got_offset = (plt_index + 3) * 4;
3046
3047           nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
3048           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
3049                          + got_offset);
3050           nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
3051           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
3052                                      got_address & 0xffff);
3053
3054           /* Fill in the entry in the global offset table.  */
3055           bfd_put_32 (output_bfd,
3056                       splt->output_section->vma + splt->output_offset
3057                       + plt_index * 4, sgotplt->contents + got_offset);
3058         }
3059
3060       /* Fill in the entry in the .rela.plt section.  */
3061       rela.r_offset = got_address;
3062       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
3063       rela.r_addend = 0;
3064       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
3065       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3066
3067       if (!h->def_regular)
3068         {
3069           /* Mark the symbol as undefined, rather than as defined in
3070              the .plt section.  Leave the value alone.  */
3071           sym->st_shndx = SHN_UNDEF;
3072           /* If the symbol is weak, we do need to clear the value.
3073              Otherwise, the PLT entry would provide a definition for
3074              the symbol even if the symbol wasn't defined anywhere,
3075              and so the symbol would never be NULL.  */
3076           if (!h->ref_regular_nonweak)
3077             sym->st_value = 0;
3078         }
3079     }
3080
3081   use_plt = (eh->got_types_used == CALL16_USED
3082              && h->plt.offset != (bfd_vma) -1);
3083
3084   if (!use_plt && h->got.offset != (bfd_vma) -1
3085       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
3086       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
3087     {
3088       asection *sgot;
3089       asection *srela;
3090       Elf_Internal_Rela rela;
3091       bfd_byte *loc;
3092       bfd_vma offset;
3093
3094       /* This symbol has an entry in the global offset table.  Set it
3095          up.  */
3096       sgot = htab->root.sgot;
3097       srela = htab->root.srelgot;
3098       BFD_ASSERT (sgot != NULL && srela != NULL);
3099
3100       offset = (h->got.offset & ~(bfd_vma) 1);
3101       rela.r_offset = (sgot->output_section->vma
3102                        + sgot->output_offset + offset);
3103
3104       /* If this is a -Bsymbolic link, and the symbol is defined
3105          locally, we just want to emit a RELATIVE reloc.  Likewise if
3106          the symbol was forced to be local because of a version file.
3107          The entry in the global offset table will already have been
3108          initialized in the relocate_section function.  */
3109
3110       if (info->shared && SYMBOL_REFERENCES_LOCAL (info, h))
3111         {
3112           rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
3113           rela.r_addend = bfd_get_signed_32 (output_bfd,
3114                                              (sgot->contents + offset));
3115           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
3116         }
3117       else
3118         {
3119           bfd_put_32 (output_bfd, (bfd_vma) 0,
3120                       sgot->contents + offset);
3121           rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
3122           rela.r_addend = 0;
3123         }
3124
3125       loc = srela->contents;
3126       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3127       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3128     }
3129
3130   if (use_plt && h->got.offset != (bfd_vma) -1)
3131     {
3132       bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
3133       asection *sgot = htab->root.sgot;
3134       asection *splt = htab->root.splt;
3135       bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
3136                                + h->plt.offset),
3137                   sgot->contents + offset);
3138     }
3139
3140   if (h->needs_copy)
3141     {
3142       asection *s;
3143       Elf_Internal_Rela rela;
3144       bfd_byte *loc;
3145
3146       /* This symbol needs a copy reloc.  Set it up.  */
3147       BFD_ASSERT (h->dynindx != -1
3148                   && (h->root.type == bfd_link_hash_defined
3149                       || h->root.type == bfd_link_hash_defweak));
3150
3151       s = htab->srelbss;
3152       BFD_ASSERT (s != NULL);
3153
3154       rela.r_offset = (h->root.u.def.value
3155                        + h->root.u.def.section->output_section->vma
3156                        + h->root.u.def.section->output_offset);
3157       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
3158       rela.r_addend = 0;
3159       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3160       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3161     }
3162
3163   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3164   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3165       || h == elf_hash_table (info)->hgot)
3166     sym->st_shndx = SHN_ABS;
3167
3168   return TRUE;
3169 }
3170
3171 /* Implement elf_backend_finish_dynamic_sections.  */
3172 static bfd_boolean
3173 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
3174                                      struct bfd_link_info *info)
3175 {
3176   bfd *dynobj;
3177   asection *sgotplt;
3178   asection *sdyn;
3179   struct elf32_nios2_link_hash_table *htab;
3180
3181   htab = elf32_nios2_hash_table (info);
3182   dynobj = elf_hash_table (info)->dynobj;
3183   sgotplt = htab->root.sgotplt;
3184   BFD_ASSERT (sgotplt != NULL);
3185   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3186
3187   if (elf_hash_table (info)->dynamic_sections_created)
3188     {
3189       asection *splt;
3190       Elf32_External_Dyn *dyncon, *dynconend;
3191
3192       splt = htab->root.splt;
3193       BFD_ASSERT (splt != NULL && sdyn != NULL);
3194
3195       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3196       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3197       for (; dyncon < dynconend; dyncon++)
3198         {
3199           Elf_Internal_Dyn dyn;
3200           asection *s;
3201
3202           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3203
3204           switch (dyn.d_tag)
3205             {
3206             default:
3207               break;
3208
3209             case DT_PLTGOT:
3210               s = htab->root.sgot;
3211               BFD_ASSERT (s != NULL);
3212               dyn.d_un.d_ptr = s->output_section->vma;
3213               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3214               break;
3215
3216             case DT_JMPREL:
3217               s = htab->root.srelplt;
3218               BFD_ASSERT (s != NULL);
3219               dyn.d_un.d_ptr = s->output_section->vma;
3220               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3221               break;
3222
3223             case DT_PLTRELSZ:
3224               s = htab->root.srelplt;
3225               BFD_ASSERT (s != NULL);
3226               dyn.d_un.d_val = s->size;
3227               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3228               break;
3229
3230             case DT_RELASZ:
3231               /* The procedure linkage table relocs (DT_JMPREL) should
3232                  not be included in the overall relocs (DT_RELA).
3233                  Therefore, we override the DT_RELASZ entry here to
3234                  make it not include the JMPREL relocs.  Since the
3235                  linker script arranges for .rela.plt to follow all
3236                  other relocation sections, we don't have to worry
3237                  about changing the DT_RELA entry.  */
3238               s = htab->root.srelplt;
3239               if (s != NULL)
3240                 dyn.d_un.d_val -= s->size;
3241               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3242               break;
3243
3244             case DT_NIOS2_GP:
3245               s = htab->root.sgot;
3246               BFD_ASSERT (s != NULL);
3247               dyn.d_un.d_ptr = s->output_section->vma + 0x7ff0;
3248               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3249               break;
3250             }
3251         }
3252
3253       /* Fill in the first entry in the procedure linkage table.  */
3254       if (splt->size > 0)
3255         {
3256           bfd_vma got_address = (sgotplt->output_section->vma
3257                                  + sgotplt->output_offset);
3258           if (info->shared)
3259             {
3260               bfd_vma corrected = got_address - (splt->output_section->vma
3261                                                  + splt->output_offset + 4);
3262               nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
3263               nios2_elf32_install_imm16 (splt, 4, hiadj (corrected));
3264               nios2_elf32_install_imm16 (splt, 12, (corrected & 0xffff) + 4);
3265               nios2_elf32_install_imm16 (splt, 16, (corrected & 0xffff) + 8);
3266             }
3267           else
3268             {
3269               /* Divide by 4 here, not 3 because we already corrected for the
3270                  res_N branches.  */
3271               bfd_vma res_size = (splt->size - 28) / 4;
3272               bfd_vma res_start = (splt->output_section->vma
3273                                    + splt->output_offset);
3274               bfd_vma res_offset;
3275
3276               for (res_offset = 0; res_offset < res_size; res_offset += 4)
3277                 bfd_put_32 (output_bfd,
3278                             6 | ((res_size - (res_offset + 4)) << 6),
3279                             splt->contents + res_offset);
3280
3281               nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
3282               nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
3283               nios2_elf32_install_imm16 (splt, res_size + 4,
3284                                          res_start & 0xffff);
3285               nios2_elf32_install_imm16 (splt, res_size + 12,
3286                                          hiadj (got_address));
3287               nios2_elf32_install_imm16 (splt, res_size + 16,
3288                                          (got_address & 0xffff) + 4);
3289               nios2_elf32_install_imm16 (splt, res_size + 20,
3290                                          (got_address & 0xffff) + 8);
3291             }
3292         }
3293     }
3294   /* Fill in the first three entries in the global offset table.  */
3295   if (sgotplt->size > 0)
3296     {
3297       if (sdyn == NULL)
3298         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
3299       else
3300         bfd_put_32 (output_bfd,
3301                     sdyn->output_section->vma + sdyn->output_offset,
3302                     sgotplt->contents);
3303       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
3304       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
3305     }
3306
3307   elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
3308
3309   return TRUE;
3310 }
3311
3312 /* Implement elf_backend_adjust_dynamic_symbol:
3313    Adjust a symbol defined by a dynamic object and referenced by a
3314    regular object.  The current definition is in some section of the
3315    dynamic object, but we're not including those sections.  We have to
3316    change the definition to something the rest of the link can
3317    understand.  */
3318 static bfd_boolean
3319 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
3320                                    struct elf_link_hash_entry *h)
3321 {
3322   struct elf32_nios2_link_hash_table *htab;
3323   bfd *dynobj;
3324   asection *s;
3325   unsigned align2;
3326
3327   htab = elf32_nios2_hash_table (info);
3328   dynobj = elf_hash_table (info)->dynobj;
3329
3330   /* Make sure we know what is going on here.  */
3331   BFD_ASSERT (dynobj != NULL
3332               && (h->needs_plt
3333                   || h->u.weakdef != NULL
3334                   || (h->def_dynamic
3335                       && h->ref_regular
3336                       && !h->def_regular)));
3337
3338   /* If this is a function, put it in the procedure linkage table.  We
3339      will fill in the contents of the procedure linkage table later,
3340      when we know the address of the .got section.  */
3341   if (h->type == STT_FUNC || h->needs_plt)
3342     {
3343       if (h->plt.refcount <= 0
3344           || SYMBOL_CALLS_LOCAL (info, h)
3345           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3346               && h->root.type == bfd_link_hash_undefweak))
3347         {
3348           /* This case can occur if we saw a PLT reloc in an input
3349              file, but the symbol was never referred to by a dynamic
3350              object, or if all references were garbage collected.  In
3351              such a case, we don't actually need to build a procedure
3352              linkage table, and we can just do a PCREL reloc instead.  */
3353           h->plt.offset = (bfd_vma) -1;
3354           h->needs_plt = 0;
3355         }
3356
3357       return TRUE;
3358     }
3359
3360   /* Reinitialize the plt offset now that it is not used as a reference
3361      count any more.  */
3362   h->plt.offset = (bfd_vma) -1;
3363
3364   /* If this is a weak symbol, and there is a real definition, the
3365      processor independent code will have arranged for us to see the
3366      real definition first, and we can just use the same value.  */
3367   if (h->u.weakdef != NULL)
3368     {
3369       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3370                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3371       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3372       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3373       return TRUE;
3374     }
3375
3376   /* If there are no non-GOT references, we do not need a copy
3377      relocation.  */
3378   if (!h->non_got_ref)
3379     return TRUE;
3380
3381   /* This is a reference to a symbol defined by a dynamic object which
3382      is not a function.
3383      If we are creating a shared library, we must presume that the
3384      only references to the symbol are via the global offset table.
3385      For such cases we need not do anything here; the relocations will
3386      be handled correctly by relocate_section.  */
3387   if (info->shared)
3388     return TRUE;
3389
3390   if (h->size == 0)
3391     {
3392       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3393                              h->root.root.string);
3394       return TRUE;
3395     }
3396
3397   /* We must allocate the symbol in our .dynbss section, which will
3398      become part of the .bss section of the executable.  There will be
3399      an entry for this symbol in the .dynsym section.  The dynamic
3400      object will contain position independent code, so all references
3401      from the dynamic object to this symbol will go through the global
3402      offset table.  The dynamic linker will use the .dynsym entry to
3403      determine the address it must put in the global offset table, so
3404      both the dynamic object and the regular object will refer to the
3405      same memory location for the variable.  */
3406   s = htab->sdynbss;
3407   BFD_ASSERT (s != NULL);
3408
3409   /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
3410      copy the initial value out of the dynamic object and into the
3411      runtime process image.  We need to remember the offset into the
3412      .rela.bss section we are going to use.  */
3413   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3414     {
3415       asection *srel;
3416
3417       srel = htab->srelbss;
3418       BFD_ASSERT (srel != NULL);
3419       srel->size += sizeof (Elf32_External_Rela);
3420       h->needs_copy = 1;
3421     }
3422
3423   align2 = bfd_log2 (h->size);
3424   if (align2 > h->root.u.def.section->alignment_power)
3425     align2 = h->root.u.def.section->alignment_power;
3426
3427   /* Align dynbss.  */
3428   s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
3429   if (align2 > bfd_get_section_alignment (dynobj, s)
3430       && !bfd_set_section_alignment (dynobj, s, align2))
3431     return FALSE;
3432
3433   /* Define the symbol as being at this point in the section.  */
3434   h->root.u.def.section = s;
3435   h->root.u.def.value = s->size;
3436
3437   /* Increment the section size to make room for the symbol.  */
3438   s->size += h->size;
3439
3440   return TRUE;
3441 }
3442
3443 /* Worker function for nios2_elf32_size_dynamic_sections.  */
3444 static bfd_boolean
3445 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
3446 {
3447   struct bfd_link_info *info;
3448   struct elf32_nios2_link_hash_table *htab;
3449
3450   if (h->root.type == bfd_link_hash_indirect)
3451     return TRUE;
3452
3453   if (h->root.type == bfd_link_hash_warning)
3454     /* When warning symbols are created, they **replace** the "real"
3455        entry in the hash table, thus we never get to see the real
3456        symbol in a hash traversal.  So look at it now.  */
3457     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3458
3459   info = (struct bfd_link_info *) inf;
3460   htab = elf32_nios2_hash_table (info);
3461
3462   if (h->plt.offset != (bfd_vma)-1)
3463     h->plt.offset += htab->res_n_size;
3464   if (htab->root.splt == h->root.u.def.section)
3465     h->root.u.def.value += htab->res_n_size;
3466
3467   return TRUE;
3468 }
3469
3470 /* Another worker function for nios2_elf32_size_dynamic_sections.
3471    Allocate space in .plt, .got and associated reloc sections for
3472    dynamic relocs.  */
3473 static bfd_boolean
3474 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
3475 {
3476   struct bfd_link_info *info;
3477   struct elf32_nios2_link_hash_table *htab;
3478   struct elf32_nios2_link_hash_entry *eh;
3479   struct elf32_nios2_dyn_relocs *p;
3480   int use_plt;
3481
3482   if (h->root.type == bfd_link_hash_indirect)
3483     return TRUE;
3484
3485   if (h->root.type == bfd_link_hash_warning)
3486     /* When warning symbols are created, they **replace** the "real"
3487        entry in the hash table, thus we never get to see the real
3488        symbol in a hash traversal.  So look at it now.  */
3489     h = (struct elf_link_hash_entry *) h->root.u.i.link;
3490
3491   info = (struct bfd_link_info *) inf;
3492   htab = elf32_nios2_hash_table (info);
3493
3494   if (htab->root.dynamic_sections_created
3495       && h->plt.refcount > 0)
3496     {
3497       /* Make sure this symbol is output as a dynamic symbol.
3498          Undefined weak syms won't yet be marked as dynamic.  */
3499       if (h->dynindx == -1
3500           && !h->forced_local
3501           && !bfd_elf_link_record_dynamic_symbol (info, h))
3502         return FALSE;
3503
3504       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
3505         {
3506           asection *s = htab->root.splt;
3507
3508           /* Allocate room for the header.  */
3509           if (s->size == 0)
3510             {
3511               if (info->shared)
3512                 s->size = 24;
3513               else
3514                 s->size = 28;
3515             }
3516
3517           h->plt.offset = s->size;
3518
3519           /* If this symbol is not defined in a regular file, and we are
3520              not generating a shared library, then set the symbol to this
3521              location in the .plt.  This is required to make function
3522              pointers compare as equal between the normal executable and
3523              the shared library.  */
3524           if (! info->shared
3525               && !h->def_regular)
3526             {
3527               h->root.u.def.section = s;
3528               h->root.u.def.value = h->plt.offset;
3529             }
3530
3531           /* Make room for this entry.  */
3532           s->size += 12;
3533
3534           /* We also need to make an entry in the .rela.plt section.  */
3535           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
3536
3537           /* And the .got.plt section.  */
3538           htab->root.sgotplt->size += 4;
3539         }
3540       else
3541         {
3542           h->plt.offset = (bfd_vma) -1;
3543           h->needs_plt = 0;
3544         }
3545     }
3546   else
3547     {
3548       h->plt.offset = (bfd_vma) -1;
3549       h->needs_plt = 0;
3550     }
3551
3552   eh = (struct elf32_nios2_link_hash_entry *) h;
3553   use_plt = (eh->got_types_used == CALL16_USED
3554              && h->plt.offset != (bfd_vma) -1);
3555
3556   if (h->got.refcount > 0)
3557     {
3558       asection *s;
3559       bfd_boolean dyn;
3560       int tls_type = eh->tls_type;
3561       int indx;
3562
3563       /* Make sure this symbol is output as a dynamic symbol.
3564          Undefined weak syms won't yet be marked as dynamic.  */
3565       if (h->dynindx == -1
3566           && !h->forced_local
3567           && !bfd_elf_link_record_dynamic_symbol (info, h))
3568         return FALSE;
3569
3570       s = htab->root.sgot;
3571       h->got.offset = s->size;
3572
3573       if (tls_type == GOT_UNKNOWN)
3574         abort ();
3575
3576       if (tls_type == GOT_NORMAL)
3577         /* Non-TLS symbols need one GOT slot.  */
3578         s->size += 4;
3579       else
3580         {
3581           if (tls_type & GOT_TLS_GD)
3582             /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots.  */
3583             s->size += 8;
3584           if (tls_type & GOT_TLS_IE)
3585             /* R_NIOS2_TLS_IE16 needs one GOT slot.  */
3586             s->size += 4;
3587         }
3588
3589       dyn = htab->root.dynamic_sections_created;
3590
3591       indx = 0;
3592       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3593           && (!info->shared
3594               || !SYMBOL_REFERENCES_LOCAL (info, h)))
3595         indx = h->dynindx;
3596
3597       if (tls_type != GOT_NORMAL
3598           && (info->shared || indx != 0)
3599           && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3600               || h->root.type != bfd_link_hash_undefweak))
3601         {
3602           if (tls_type & GOT_TLS_IE)
3603             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3604
3605           if (tls_type & GOT_TLS_GD)
3606             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3607
3608           if ((tls_type & GOT_TLS_GD) && indx != 0)
3609             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3610         }
3611       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3612                 || h->root.type != bfd_link_hash_undefweak)
3613                && !use_plt
3614                && (info->shared
3615                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3616         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3617     }
3618   else
3619     h->got.offset = (bfd_vma) -1;
3620
3621   if (eh->dyn_relocs == NULL)
3622     return TRUE;
3623
3624   /* In the shared -Bsymbolic case, discard space allocated for
3625      dynamic pc-relative relocs against symbols which turn out to be
3626      defined in regular objects.  For the normal shared case, discard
3627      space for pc-relative relocs that have become local due to symbol
3628      visibility changes.  */
3629
3630   if (info->shared)
3631     {
3632       if (h->def_regular
3633           && (h->forced_local || info->symbolic))
3634         {
3635           struct elf32_nios2_dyn_relocs **pp;
3636
3637           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3638             {
3639               p->count -= p->pc_count;
3640               p->pc_count = 0;
3641               if (p->count == 0)
3642                 *pp = p->next;
3643               else
3644                 pp = &p->next;
3645             }
3646         }
3647
3648       /* Also discard relocs on undefined weak syms with non-default
3649          visibility.  */
3650       if (eh->dyn_relocs != NULL
3651           && h->root.type == bfd_link_hash_undefweak)
3652         {
3653           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3654             eh->dyn_relocs = NULL;
3655
3656           /* Make sure undefined weak symbols are output as a dynamic
3657              symbol in PIEs.  */
3658           else if (h->dynindx == -1
3659                    && !h->forced_local
3660                    && !bfd_elf_link_record_dynamic_symbol (info, h))
3661             return FALSE;
3662         }
3663     }
3664   else
3665     {
3666       /* For the non-shared case, discard space for relocs against
3667          symbols which turn out to need copy relocs or are not
3668          dynamic.  */
3669
3670       if (!h->non_got_ref
3671           && ((h->def_dynamic && !h->def_regular)
3672               || (htab->root.dynamic_sections_created
3673                   && (h->root.type == bfd_link_hash_undefweak
3674                       || h->root.type == bfd_link_hash_undefined))))
3675         {
3676           /* Make sure this symbol is output as a dynamic symbol.
3677              Undefined weak syms won't yet be marked as dynamic.  */
3678           if (h->dynindx == -1
3679               && !h->forced_local
3680               && !bfd_elf_link_record_dynamic_symbol (info, h))
3681             return FALSE;
3682
3683           /* If that succeeded, we know we'll be keeping all the
3684              relocs.  */
3685           if (h->dynindx != -1)
3686             goto keep;
3687         }
3688
3689       eh->dyn_relocs = NULL;
3690
3691     keep: ;
3692     }
3693
3694   /* Finally, allocate space.  */
3695   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3696     {
3697       asection *sreloc = elf_section_data (p->sec)->sreloc;
3698       sreloc->size += p->count * sizeof (Elf32_External_Rela);
3699     }
3700
3701   return TRUE;
3702 }
3703
3704 /* Implement elf_backend_size_dynamic_sections:
3705    Set the sizes of the dynamic sections.  */
3706 static bfd_boolean
3707 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3708                                    struct bfd_link_info *info)
3709 {
3710   bfd *dynobj;
3711   asection *s;
3712   bfd_boolean plt;
3713   bfd_boolean got;
3714   bfd_boolean relocs;
3715   bfd *ibfd;
3716   struct elf32_nios2_link_hash_table *htab;
3717
3718   htab = elf32_nios2_hash_table (info);
3719   dynobj = elf_hash_table (info)->dynobj;
3720   BFD_ASSERT (dynobj != NULL);
3721
3722   htab->res_n_size = 0;
3723   if (elf_hash_table (info)->dynamic_sections_created)
3724     {
3725       /* Set the contents of the .interp section to the interpreter.  */
3726       if (info->executable)
3727         {
3728           s = bfd_get_linker_section (dynobj, ".interp");
3729           BFD_ASSERT (s != NULL);
3730           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3731           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3732         }
3733     }
3734   else
3735     {
3736       /* We may have created entries in the .rela.got section.
3737          However, if we are not creating the dynamic sections, we will
3738          not actually use these entries.  Reset the size of .rela.got,
3739          which will cause it to get stripped from the output file
3740          below.  */
3741       s = htab->root.srelgot;
3742       if (s != NULL)
3743         s->size = 0;
3744     }
3745
3746   /* Set up .got offsets for local syms, and space for local dynamic
3747      relocs.  */
3748   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3749     {
3750       bfd_signed_vma *local_got;
3751       bfd_signed_vma *end_local_got;
3752       char *local_tls_type;
3753       bfd_size_type locsymcount;
3754       Elf_Internal_Shdr *symtab_hdr;
3755       asection *srel;
3756
3757       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3758         continue;
3759
3760       for (s = ibfd->sections; s != NULL; s = s->next)
3761         {
3762           struct elf32_nios2_dyn_relocs *p;
3763
3764           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
3765             {
3766               if (!bfd_is_abs_section (p->sec)
3767                   && bfd_is_abs_section (p->sec->output_section))
3768                 {
3769                   /* Input section has been discarded, either because
3770                      it is a copy of a linkonce section or due to
3771                      linker script /DISCARD/, so we'll be discarding
3772                      the relocs too.  */
3773                 }
3774               else if (p->count != 0)
3775                 {
3776                   srel = elf_section_data (p->sec)->sreloc;
3777                   srel->size += p->count * sizeof (Elf32_External_Rela);
3778                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3779                     info->flags |= DF_TEXTREL;
3780                 }
3781             }
3782         }
3783
3784       local_got = elf_local_got_refcounts (ibfd);
3785       if (!local_got)
3786         continue;
3787
3788       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3789       locsymcount = symtab_hdr->sh_info;
3790       end_local_got = local_got + locsymcount;
3791       local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
3792       s = htab->root.sgot;
3793       srel = htab->root.srelgot;
3794       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
3795         {
3796           if (*local_got > 0)
3797             {
3798               *local_got = s->size;
3799               if (*local_tls_type & GOT_TLS_GD)
3800                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
3801                 s->size += 8;
3802               if (*local_tls_type & GOT_TLS_IE)
3803                 s->size += 4;
3804               if (*local_tls_type == GOT_NORMAL)
3805                 s->size += 4;
3806
3807               if (info->shared || *local_tls_type == GOT_TLS_GD)
3808                 srel->size += sizeof (Elf32_External_Rela);
3809             }
3810           else
3811             *local_got = (bfd_vma) -1;
3812         }
3813     }
3814
3815   if (htab->tls_ldm_got.refcount > 0)
3816     {
3817       /* Allocate two GOT entries and one dynamic relocation (if necessary)
3818          for R_NIOS2_TLS_LDM16 relocations.  */
3819       htab->tls_ldm_got.offset = htab->root.sgot->size;
3820       htab->root.sgot->size += 8;
3821       if (info->shared)
3822         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3823     }
3824   else
3825     htab->tls_ldm_got.offset = -1;
3826
3827   /* Allocate global sym .plt and .got entries, and space for global
3828      sym dynamic relocs.  */
3829   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
3830
3831   /* The check_relocs and adjust_dynamic_symbol entry points have
3832      determined the sizes of the various dynamic sections.  Allocate
3833      memory for them.  */
3834   plt = FALSE;
3835   got = FALSE;
3836   relocs = FALSE;
3837   for (s = dynobj->sections; s != NULL; s = s->next)
3838     {
3839       const char *name;
3840
3841       if ((s->flags & SEC_LINKER_CREATED) == 0)
3842         continue;
3843
3844       /* It's OK to base decisions on the section name, because none
3845          of the dynobj section names depend upon the input files.  */
3846       name = bfd_get_section_name (dynobj, s);
3847
3848       if (strcmp (name, ".plt") == 0)
3849         {
3850           /* Remember whether there is a PLT.  */
3851           plt = s->size != 0;
3852
3853           /* Correct for the number of res_N branches.  */
3854           if (plt && !info->shared)
3855             {
3856               htab->res_n_size = (s->size-28) / 3;
3857               s->size += htab->res_n_size;
3858             }
3859         }
3860       else if (CONST_STRNEQ (name, ".rela"))
3861         {
3862           if (s->size != 0)
3863             {
3864               relocs = TRUE;
3865
3866               /* We use the reloc_count field as a counter if we need
3867                  to copy relocs into the output file.  */
3868               s->reloc_count = 0;
3869             }
3870         }
3871       else if (CONST_STRNEQ (name, ".got"))
3872         got = s->size != 0;
3873       else if (strcmp (name, ".dynbss") != 0)
3874         /* It's not one of our sections, so don't allocate space.  */
3875         continue;
3876
3877       if (s->size == 0)
3878         {
3879           /* If we don't need this section, strip it from the
3880              output file.  This is mostly to handle .rela.bss and
3881              .rela.plt.  We must create both sections in
3882              create_dynamic_sections, because they must be created
3883              before the linker maps input sections to output
3884              sections.  The linker does that before
3885              adjust_dynamic_symbol is called, and it is that
3886              function which decides whether anything needs to go
3887              into these sections.  */
3888           s->flags |= SEC_EXCLUDE;
3889           continue;
3890         }
3891
3892       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3893         continue;
3894
3895       /* Allocate memory for the section contents.  */
3896       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3897          Unused entries should be reclaimed before the section's contents
3898          are written out, but at the moment this does not happen.  Thus in
3899          order to prevent writing out garbage, we initialize the section's
3900          contents to zero.  */
3901       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3902       if (s->contents == NULL)
3903         return FALSE;
3904     }
3905
3906   /* Adjust dynamic symbols that point to the plt to account for the
3907      now-known number of resN slots.  */
3908   if (htab->res_n_size)
3909     elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
3910
3911   if (elf_hash_table (info)->dynamic_sections_created)
3912     {
3913       /* Add some entries to the .dynamic section.  We fill in the
3914          values later, in elf_nios2_finish_dynamic_sections, but we
3915          must add the entries now so that we get the correct size for
3916          the .dynamic section.  The DT_DEBUG entry is filled in by the
3917          dynamic linker and used by the debugger.  */
3918 #define add_dynamic_entry(TAG, VAL) \
3919   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3920
3921       if (!info->shared && !add_dynamic_entry (DT_DEBUG, 0))
3922         return FALSE;
3923
3924       if (got && !add_dynamic_entry (DT_PLTGOT, 0))
3925         return FALSE;
3926
3927       if (plt
3928           && (!add_dynamic_entry (DT_PLTRELSZ, 0)
3929               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3930               || !add_dynamic_entry (DT_JMPREL, 0)))
3931         return FALSE;
3932
3933       if (relocs
3934           && (!add_dynamic_entry (DT_RELA, 0)
3935               || !add_dynamic_entry (DT_RELASZ, 0)
3936               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
3937         return FALSE;
3938
3939       if (!info->shared && !add_dynamic_entry (DT_NIOS2_GP, 0))
3940         return FALSE;
3941
3942       if ((info->flags & DF_TEXTREL) != 0
3943           && !add_dynamic_entry (DT_TEXTREL, 0))
3944         return FALSE;
3945     }
3946 #undef add_dynamic_entry
3947
3948   return TRUE;
3949 }
3950
3951 /* Implement bfd_elf32_bfd_link_hash_table_create.  */
3952 static struct bfd_link_hash_table *
3953 nios2_elf32_link_hash_table_create (bfd *abfd)
3954 {
3955   struct elf32_nios2_link_hash_table *ret;
3956   bfd_size_type amt = sizeof (struct elf32_nios2_link_hash_table);
3957
3958   ret = bfd_zmalloc (amt);
3959   if (ret == NULL)
3960     return NULL;
3961
3962   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3963                                       link_hash_newfunc,
3964                                       sizeof (struct
3965                                               elf32_nios2_link_hash_entry),
3966                                       NIOS2_ELF_DATA))
3967     {
3968       free (ret);
3969       return NULL;
3970     }
3971
3972   return &ret->root.root;
3973 }
3974
3975 /* Implement elf_backend_reloc_type_class.  */
3976 static enum elf_reloc_type_class
3977 nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3978                               const asection *rel_sec ATTRIBUTE_UNUSED,
3979                               const Elf_Internal_Rela *rela)
3980 {
3981   switch ((int) ELF32_R_TYPE (rela->r_info))
3982     {
3983     case R_NIOS2_RELATIVE:
3984       return reloc_class_relative;
3985     case R_NIOS2_JUMP_SLOT:
3986       return reloc_class_plt;
3987     case R_NIOS2_COPY:
3988       return reloc_class_copy;
3989     default:
3990       return reloc_class_normal;
3991     }
3992 }
3993
3994 /* Return 1 if target is one of ours.  */
3995 static bfd_boolean
3996 is_nios2_elf_target (const struct bfd_target *targ)
3997 {
3998   return (targ == &bfd_elf32_littlenios2_vec
3999           || targ == &bfd_elf32_bignios2_vec);
4000 }
4001
4002 /* Implement elf_backend_add_symbol_hook.
4003    This hook is called by the linker when adding symbols from an object
4004    file.  We use it to put .comm items in .sbss, and not .bss.  */
4005 static bfd_boolean
4006 nios2_elf_add_symbol_hook (bfd *abfd,
4007                            struct bfd_link_info *info,
4008                            Elf_Internal_Sym *sym,
4009                            const char **namep ATTRIBUTE_UNUSED,
4010                            flagword *flagsp ATTRIBUTE_UNUSED,
4011                            asection **secp,
4012                            bfd_vma *valp)
4013 {
4014   bfd *dynobj;
4015
4016   if (sym->st_shndx == SHN_COMMON
4017       && !info->relocatable
4018       && sym->st_size <= elf_gp_size (abfd)
4019       && is_nios2_elf_target (info->output_bfd->xvec))
4020     {
4021       /* Common symbols less than or equal to -G nn bytes are automatically
4022          put into .sbss.  */
4023       struct elf32_nios2_link_hash_table *htab;
4024
4025       htab = elf32_nios2_hash_table (info);
4026       if (htab->sbss == NULL)
4027         {
4028           flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
4029
4030           dynobj = elf_hash_table (info)->dynobj;
4031           if (!dynobj)
4032             dynobj = abfd;
4033
4034           htab->sbss = bfd_make_section_anyway_with_flags (dynobj, ".sbss",
4035                                                            flags);
4036           if (htab->sbss == NULL)
4037             return FALSE;
4038         }
4039
4040       *secp = htab->sbss;
4041       *valp = sym->st_size;
4042     }
4043
4044   return TRUE;
4045 }
4046
4047 /* Implement elf_backend_can_make_relative_eh_frame:
4048    Decide whether to attempt to turn absptr or lsda encodings in
4049    shared libraries into pcrel within the given input section.  */
4050 static bfd_boolean
4051 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
4052                                         struct bfd_link_info *info
4053                                         ATTRIBUTE_UNUSED,
4054                                         asection *eh_frame_section
4055                                         ATTRIBUTE_UNUSED)
4056 {
4057   /* We can't use PC-relative encodings in the .eh_frame section.  */
4058   return FALSE;
4059 }
4060
4061 /* Implement elf_backend_special_sections.  */
4062 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
4063 {
4064   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,
4065     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
4066   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
4067     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
4068   { NULL,                     0,  0, 0,              0 }
4069 };
4070
4071 #define ELF_ARCH                        bfd_arch_nios2
4072 #define ELF_TARGET_ID                   NIOS2_ELF_DATA
4073 #define ELF_MACHINE_CODE                EM_ALTERA_NIOS2
4074
4075 /* The Nios II MMU uses a 4K page size.  */
4076
4077 #define ELF_MAXPAGESIZE                 0x1000
4078
4079 #define bfd_elf32_bfd_link_hash_table_create \
4080                                           nios2_elf32_link_hash_table_create
4081
4082 /* Relocation table lookup macros.  */
4083
4084 #define bfd_elf32_bfd_reloc_type_lookup   nios2_elf32_bfd_reloc_type_lookup
4085 #define bfd_elf32_bfd_reloc_name_lookup   nios2_elf32_bfd_reloc_name_lookup
4086
4087 /* JUMP_TABLE_LINK macros.  */
4088
4089 /* elf_info_to_howto (using RELA relocations).  */
4090
4091 #define elf_info_to_howto                 nios2_elf32_info_to_howto
4092
4093 /* elf backend functions.  */
4094
4095 #define elf_backend_can_gc_sections     1
4096 #define elf_backend_can_refcount        1
4097 #define elf_backend_plt_readonly        1
4098 #define elf_backend_want_got_plt        1
4099 #define elf_backend_rela_normal         1
4100
4101 #define elf_backend_relocate_section      nios2_elf32_relocate_section
4102 #define elf_backend_section_flags         nios2_elf32_section_flags
4103 #define elf_backend_fake_sections         nios2_elf32_fake_sections
4104 #define elf_backend_check_relocs          nios2_elf32_check_relocs
4105
4106 #define elf_backend_gc_mark_hook          nios2_elf32_gc_mark_hook
4107 #define elf_backend_gc_sweep_hook         nios2_elf32_gc_sweep_hook
4108 #define elf_backend_create_dynamic_sections \
4109                                           nios2_elf32_create_dynamic_sections
4110 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
4111 #define elf_backend_finish_dynamic_sections \
4112                                           nios2_elf32_finish_dynamic_sections
4113 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
4114 #define elf_backend_reloc_type_class      nios2_elf32_reloc_type_class
4115 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
4116 #define elf_backend_add_symbol_hook       nios2_elf_add_symbol_hook
4117 #define elf_backend_copy_indirect_symbol  nios2_elf32_copy_indirect_symbol
4118
4119 #define elf_backend_grok_prstatus         nios2_grok_prstatus
4120 #define elf_backend_grok_psinfo           nios2_grok_psinfo
4121
4122 #undef elf_backend_can_make_relative_eh_frame
4123 #define elf_backend_can_make_relative_eh_frame \
4124                                           nios2_elf32_can_make_relative_eh_frame
4125
4126 #define elf_backend_special_sections      elf32_nios2_special_sections
4127
4128 #define TARGET_LITTLE_SYM               bfd_elf32_littlenios2_vec
4129 #define TARGET_LITTLE_NAME              "elf32-littlenios2"
4130 #define TARGET_BIG_SYM                  bfd_elf32_bignios2_vec
4131 #define TARGET_BIG_NAME                 "elf32-bignios2"
4132
4133 #define elf_backend_got_header_size     12
4134
4135 #include "elf32-target.h"