bfd/elf32-nios2.c

   1 /* 32-bit ELF support for Nios II.
   2    Copyright (C) 2012-2020 Free Software Foundation, Inc.
   3    Contributed by Nigel Gray ([email protected]).
   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 #include "elf32-nios2.h"
  34 #include "libiberty.h"
  35
  36 /* Use RELA relocations.  */
  37 #ifndef USE_RELA
  38 #define USE_RELA
  39 #endif
  40
  41 #ifdef USE_REL
  42 #undef USE_REL
  43 #endif
  44
  45 /* Forward declarations.  */
  46 static bfd_reloc_status_type nios2_elf32_ignore_reloc
  47   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  48 static bfd_reloc_status_type nios2_elf32_hi16_relocate
  49   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  50 static bfd_reloc_status_type nios2_elf32_lo16_relocate
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
  53   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  54 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
  55   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  56 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
  57   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  58 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
  59   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  60 static bfd_reloc_status_type nios2_elf32_call26_relocate
  61   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  62 static bfd_reloc_status_type nios2_elf32_gprel_relocate
  63   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  64 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
  65   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  66 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
  67   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  68 static bfd_reloc_status_type nios2_elf32_callr_relocate
  69   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  70
  71 /* Target vector.  */
  72 extern const bfd_target nios2_elf32_le_vec;
  73 extern const bfd_target nios2_elf32_be_vec;
  74
  75 /* Offset of tp and dtp pointers from start of TLS block.  */
  76 #define TP_OFFSET       0x7000
  77 #define DTP_OFFSET      0x8000
  78
  79 /* The relocation tables used for SHT_REL sections.  There are separate
  80    tables for R1 and R2 encodings.  */
  81 static reloc_howto_type elf_nios2_r1_howto_table_rel[] = {
  82   /* No relocation.  */
  83   HOWTO (R_NIOS2_NONE,          /* type */
  84          0,                     /* rightshift */
  85          3,                     /* size (0 = byte, 1 = short, 2 = long) */
  86          0,                     /* bitsize */
  87          FALSE,                 /* pc_relative */
  88          0,                     /* bitpos */
  89          complain_overflow_dont,        /* complain_on_overflow */
  90          bfd_elf_generic_reloc, /* special_function */
  91          "R_NIOS2_NONE",        /* name */
  92          FALSE,                 /* partial_inplace */
  93          0,                     /* src_mask */
  94          0,                     /* dst_mask */
  95          FALSE),                /* pcrel_offset */
  96
  97   /* 16-bit signed immediate relocation.  */
  98   HOWTO (R_NIOS2_S16,           /* type */
  99          0,                     /* rightshift */
 100          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 101          16,                    /* bitsize */
 102          FALSE,                 /* pc_relative */
 103          6,                     /* bitpos */
 104          complain_overflow_signed,      /* complain on overflow */
 105          bfd_elf_generic_reloc, /* special function */
 106          "R_NIOS2_S16",         /* name */
 107          FALSE,                 /* partial_inplace */
 108          0x003fffc0,            /* src_mask */
 109          0x003fffc0,            /* dest_mask */
 110          FALSE),                /* pcrel_offset */
 111
 112   /* 16-bit unsigned immediate relocation.  */
 113   HOWTO (R_NIOS2_U16,           /* type */
 114          0,                     /* rightshift */
 115          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 116          16,                    /* bitsize */
 117          FALSE,                 /* pc_relative */
 118          6,                     /* bitpos */
 119          complain_overflow_unsigned,    /* complain on overflow */
 120          bfd_elf_generic_reloc, /* special function */
 121          "R_NIOS2_U16",         /* name */
 122          FALSE,                 /* partial_inplace */
 123          0x003fffc0,            /* src_mask */
 124          0x003fffc0,            /* dest_mask */
 125          FALSE),                /* pcrel_offset */
 126
 127   HOWTO (R_NIOS2_PCREL16,       /* type */
 128          0,                     /* rightshift */
 129          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 130          16,                    /* bitsize */
 131          TRUE,                  /* pc_relative */
 132          6,                     /* bitpos */
 133          complain_overflow_signed,      /* complain on overflow */
 134          nios2_elf32_pcrel16_relocate,  /* special function */
 135          "R_NIOS2_PCREL16",     /* name */
 136          FALSE,                 /* partial_inplace */
 137          0x003fffc0,            /* src_mask */
 138          0x003fffc0,            /* dest_mask */
 139          TRUE),                 /* pcrel_offset */
 140
 141   HOWTO (R_NIOS2_CALL26,        /* type */
 142          2,                     /* rightshift */
 143          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 144          26,                    /* bitsize */
 145          FALSE,                 /* pc_relative */
 146          6,                     /* bitpos */
 147          complain_overflow_dont,        /* complain on overflow */
 148          nios2_elf32_call26_relocate,   /* special function */
 149          "R_NIOS2_CALL26",      /* name */
 150          FALSE,                 /* partial_inplace */
 151          0xffffffc0,            /* src_mask */
 152          0xffffffc0,            /* dst_mask */
 153          FALSE),                /* pcrel_offset */
 154
 155   HOWTO (R_NIOS2_IMM5,
 156          0,
 157          2,
 158          5,
 159          FALSE,
 160          6,
 161          complain_overflow_bitfield,
 162          bfd_elf_generic_reloc,
 163          "R_NIOS2_IMM5",
 164          FALSE,
 165          0x000007c0,
 166          0x000007c0,
 167          FALSE),
 168
 169   HOWTO (R_NIOS2_CACHE_OPX,
 170          0,
 171          2,
 172          5,
 173          FALSE,
 174          22,
 175          complain_overflow_bitfield,
 176          bfd_elf_generic_reloc,
 177          "R_NIOS2_CACHE_OPX",
 178          FALSE,
 179          0x07c00000,
 180          0x07c00000,
 181          FALSE),
 182
 183   HOWTO (R_NIOS2_IMM6,
 184          0,
 185          2,
 186          6,
 187          FALSE,
 188          6,
 189          complain_overflow_bitfield,
 190          bfd_elf_generic_reloc,
 191          "R_NIOS2_IMM6",
 192          FALSE,
 193          0x00000fc0,
 194          0x00000fc0,
 195          FALSE),
 196
 197   HOWTO (R_NIOS2_IMM8,
 198          0,
 199          2,
 200          8,
 201          FALSE,
 202          6,
 203          complain_overflow_bitfield,
 204          bfd_elf_generic_reloc,
 205          "R_NIOS2_IMM8",
 206          FALSE,
 207          0x00003fc0,
 208          0x00003fc0,
 209          FALSE),
 210
 211   HOWTO (R_NIOS2_HI16,
 212          0,
 213          2,
 214          32,
 215          FALSE,
 216          6,
 217          complain_overflow_dont,
 218          nios2_elf32_hi16_relocate,
 219          "R_NIOS2_HI16",
 220          FALSE,
 221          0x003fffc0,
 222          0x003fffc0,
 223          FALSE),
 224
 225   HOWTO (R_NIOS2_LO16,
 226          0,
 227          2,
 228          32,
 229          FALSE,
 230          6,
 231          complain_overflow_dont,
 232          nios2_elf32_lo16_relocate,
 233          "R_NIOS2_LO16",
 234          FALSE,
 235          0x003fffc0,
 236          0x003fffc0,
 237          FALSE),
 238
 239   HOWTO (R_NIOS2_HIADJ16,
 240          0,
 241          2,
 242          32,
 243          FALSE,
 244          6,
 245          complain_overflow_dont,
 246          nios2_elf32_hiadj16_relocate,
 247          "R_NIOS2_HIADJ16",
 248          FALSE,
 249          0x003fffc0,
 250          0x003fffc0,
 251          FALSE),
 252
 253   HOWTO (R_NIOS2_BFD_RELOC_32,
 254          0,
 255          2,                     /* long */
 256          32,
 257          FALSE,
 258          0,
 259          complain_overflow_dont,
 260          bfd_elf_generic_reloc,
 261          "R_NIOS2_BFD_RELOC32",
 262          FALSE,
 263          0xffffffff,
 264          0xffffffff,
 265          FALSE),
 266
 267   HOWTO (R_NIOS2_BFD_RELOC_16,
 268          0,
 269          1,                     /* short */
 270          16,
 271          FALSE,
 272          0,
 273          complain_overflow_bitfield,
 274          bfd_elf_generic_reloc,
 275          "R_NIOS2_BFD_RELOC16",
 276          FALSE,
 277          0x0000ffff,
 278          0x0000ffff,
 279          FALSE),
 280
 281   HOWTO (R_NIOS2_BFD_RELOC_8,
 282          0,
 283          0,                     /* byte */
 284          8,
 285          FALSE,
 286          0,
 287          complain_overflow_bitfield,
 288          bfd_elf_generic_reloc,
 289          "R_NIOS2_BFD_RELOC8",
 290          FALSE,
 291          0x000000ff,
 292          0x000000ff,
 293          FALSE),
 294
 295   HOWTO (R_NIOS2_GPREL,
 296          0,
 297          2,
 298          32,
 299          FALSE,
 300          6,
 301          complain_overflow_dont,
 302          nios2_elf32_gprel_relocate,
 303          "R_NIOS2_GPREL",
 304          FALSE,
 305          0x003fffc0,
 306          0x003fffc0,
 307          FALSE),
 308
 309   HOWTO (R_NIOS2_GNU_VTINHERIT,
 310          0,
 311          2,                     /* short */
 312          0,
 313          FALSE,
 314          0,
 315          complain_overflow_dont,
 316          NULL,
 317          "R_NIOS2_GNU_VTINHERIT",
 318          FALSE,
 319          0,
 320          0,
 321          FALSE),
 322
 323   HOWTO (R_NIOS2_GNU_VTENTRY,
 324          0,
 325          2,                     /* byte */
 326          0,
 327          FALSE,
 328          0,
 329          complain_overflow_dont,
 330          _bfd_elf_rel_vtable_reloc_fn,
 331          "R_NIOS2_GNU_VTENTRY",
 332          FALSE,
 333          0,
 334          0,
 335          FALSE),
 336
 337   HOWTO (R_NIOS2_UJMP,
 338          0,
 339          2,
 340          32,
 341          FALSE,
 342          6,
 343          complain_overflow_dont,
 344          nios2_elf32_ujmp_relocate,
 345          "R_NIOS2_UJMP",
 346          FALSE,
 347          0x003fffc0,
 348          0x003fffc0,
 349          FALSE),
 350
 351   HOWTO (R_NIOS2_CJMP,
 352          0,
 353          2,
 354          32,
 355          FALSE,
 356          6,
 357          complain_overflow_dont,
 358          nios2_elf32_cjmp_relocate,
 359          "R_NIOS2_CJMP",
 360          FALSE,
 361          0x003fffc0,
 362          0x003fffc0,
 363          FALSE),
 364
 365   HOWTO (R_NIOS2_CALLR,
 366          0,
 367          2,
 368          32,
 369          FALSE,
 370          6,
 371          complain_overflow_dont,
 372          nios2_elf32_callr_relocate,
 373          "R_NIOS2_CALLR",
 374          FALSE,
 375          0x003fffc0,
 376          0x003fffc0,
 377          FALSE),
 378
 379   HOWTO (R_NIOS2_ALIGN,
 380          0,
 381          2,
 382          0,
 383          FALSE,
 384          0,
 385          complain_overflow_dont,
 386          nios2_elf32_ignore_reloc,
 387          "R_NIOS2_ALIGN",
 388          FALSE,
 389          0,
 390          0,
 391          TRUE),
 392
 393
 394   HOWTO (R_NIOS2_GOT16,
 395          0,
 396          2,
 397          16,
 398          FALSE,
 399          6,
 400          complain_overflow_bitfield,
 401          bfd_elf_generic_reloc,
 402          "R_NIOS2_GOT16",
 403          FALSE,
 404          0x003fffc0,
 405          0x003fffc0,
 406          FALSE),
 407
 408   HOWTO (R_NIOS2_CALL16,
 409          0,
 410          2,
 411          16,
 412          FALSE,
 413          6,
 414          complain_overflow_bitfield,
 415          bfd_elf_generic_reloc,
 416          "R_NIOS2_CALL16",
 417          FALSE,
 418          0x003fffc0,
 419          0x003fffc0,
 420          FALSE),
 421
 422   HOWTO (R_NIOS2_GOTOFF_LO,
 423          0,
 424          2,
 425          16,
 426          FALSE,
 427          6,
 428          complain_overflow_dont,
 429          bfd_elf_generic_reloc,
 430          "R_NIOS2_GOTOFF_LO",
 431          FALSE,
 432          0x003fffc0,
 433          0x003fffc0,
 434          FALSE),
 435
 436   HOWTO (R_NIOS2_GOTOFF_HA,
 437          0,
 438          2,
 439          16,
 440          FALSE,
 441          6,
 442          complain_overflow_dont,
 443          bfd_elf_generic_reloc,
 444          "R_NIOS2_GOTOFF_HA",
 445          FALSE,
 446          0x003fffc0,
 447          0x003fffc0,
 448          FALSE),
 449
 450   HOWTO (R_NIOS2_PCREL_LO,
 451          0,
 452          2,
 453          16,
 454          TRUE,
 455          6,
 456          complain_overflow_dont,
 457          nios2_elf32_pcrel_lo16_relocate,
 458          "R_NIOS2_PCREL_LO",
 459          FALSE,
 460          0x003fffc0,
 461          0x003fffc0,
 462          TRUE),
 463
 464   HOWTO (R_NIOS2_PCREL_HA,
 465          0,
 466          2,
 467          16,
 468          FALSE, /* This is a PC-relative relocation, but we need to subtract
 469                    PC ourselves before the HIADJ.  */
 470          6,
 471          complain_overflow_dont,
 472          nios2_elf32_pcrel_hiadj16_relocate,
 473          "R_NIOS2_PCREL_HA",
 474          FALSE,
 475          0x003fffc0,
 476          0x003fffc0,
 477          TRUE),
 478
 479   HOWTO (R_NIOS2_TLS_GD16,
 480          0,
 481          2,
 482          16,
 483          FALSE,
 484          6,
 485          complain_overflow_bitfield,
 486          bfd_elf_generic_reloc,
 487          "R_NIOS2_TLS_GD16",
 488          FALSE,
 489          0x003fffc0,
 490          0x003fffc0,
 491          FALSE),
 492
 493   HOWTO (R_NIOS2_TLS_LDM16,
 494          0,
 495          2,
 496          16,
 497          FALSE,
 498          6,
 499          complain_overflow_bitfield,
 500          bfd_elf_generic_reloc,
 501          "R_NIOS2_TLS_LDM16",
 502          FALSE,
 503          0x003fffc0,
 504          0x003fffc0,
 505          FALSE),
 506
 507   HOWTO (R_NIOS2_TLS_LDO16,
 508          0,
 509          2,
 510          16,
 511          FALSE,
 512          6,
 513          complain_overflow_bitfield,
 514          bfd_elf_generic_reloc,
 515          "R_NIOS2_TLS_LDO16",
 516          FALSE,
 517          0x003fffc0,
 518          0x003fffc0,
 519          FALSE),
 520
 521   HOWTO (R_NIOS2_TLS_IE16,
 522          0,
 523          2,
 524          16,
 525          FALSE,
 526          6,
 527          complain_overflow_bitfield,
 528          bfd_elf_generic_reloc,
 529          "R_NIOS2_TLS_IE16",
 530          FALSE,
 531          0x003fffc0,
 532          0x003fffc0,
 533          FALSE),
 534
 535   HOWTO (R_NIOS2_TLS_LE16,
 536          0,
 537          2,
 538          16,
 539          FALSE,
 540          6,
 541          complain_overflow_bitfield,
 542          bfd_elf_generic_reloc,
 543          "R_NIOS2_TLS_LE16",
 544          FALSE,
 545          0x003fffc0,
 546          0x003fffc0,
 547          FALSE),
 548
 549   HOWTO (R_NIOS2_TLS_DTPMOD,
 550          0,
 551          2,
 552          32,
 553          FALSE,
 554          0,
 555          complain_overflow_dont,
 556          bfd_elf_generic_reloc,
 557          "R_NIOS2_TLS_DTPMOD",
 558          FALSE,
 559          0xffffffff,
 560          0xffffffff,
 561          FALSE),
 562
 563   HOWTO (R_NIOS2_TLS_DTPREL,
 564          0,
 565          2,
 566          32,
 567          FALSE,
 568          0,
 569          complain_overflow_dont,
 570          bfd_elf_generic_reloc,
 571          "R_NIOS2_TLS_DTPREL",
 572          FALSE,
 573          0xffffffff,
 574          0xffffffff,
 575          FALSE),
 576
 577   HOWTO (R_NIOS2_TLS_TPREL,
 578          0,
 579          2,
 580          32,
 581          FALSE,
 582          0,
 583          complain_overflow_dont,
 584          bfd_elf_generic_reloc,
 585          "R_NIOS2_TLS_TPREL",
 586          FALSE,
 587          0xffffffff,
 588          0xffffffff,
 589          FALSE),
 590
 591   HOWTO (R_NIOS2_COPY,
 592          0,
 593          2,
 594          32,
 595          FALSE,
 596          0,
 597          complain_overflow_dont,
 598          bfd_elf_generic_reloc,
 599          "R_NIOS2_COPY",
 600          FALSE,
 601          0,
 602          0,
 603          FALSE),
 604
 605   HOWTO (R_NIOS2_GLOB_DAT,
 606          0,
 607          2,
 608          32,
 609          FALSE,
 610          0,
 611          complain_overflow_dont,
 612          bfd_elf_generic_reloc,
 613          "R_NIOS2_GLOB_DAT",
 614          FALSE,
 615          0xffffffff,
 616          0xffffffff,
 617          FALSE),
 618
 619   HOWTO (R_NIOS2_JUMP_SLOT,
 620          0,
 621          2,
 622          32,
 623          FALSE,
 624          0,
 625          complain_overflow_dont,
 626          bfd_elf_generic_reloc,
 627          "R_NIOS2_JUMP_SLOT",
 628          FALSE,
 629          0xffffffff,
 630          0xffffffff,
 631          FALSE),
 632
 633   HOWTO (R_NIOS2_RELATIVE,
 634          0,
 635          2,
 636          32,
 637          FALSE,
 638          0,
 639          complain_overflow_dont,
 640          bfd_elf_generic_reloc,
 641          "R_NIOS2_RELATIVE",
 642          FALSE,
 643          0xffffffff,
 644          0xffffffff,
 645          FALSE),
 646
 647   HOWTO (R_NIOS2_GOTOFF,
 648          0,
 649          2,
 650          32,
 651          FALSE,
 652          0,
 653          complain_overflow_dont,
 654          bfd_elf_generic_reloc,
 655          "R_NIOS2_GOTOFF",
 656          FALSE,
 657          0xffffffff,
 658          0xffffffff,
 659          FALSE),
 660
 661   HOWTO (R_NIOS2_CALL26_NOAT,   /* type */
 662          2,                     /* rightshift */
 663          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 664          26,                    /* bitsize */
 665          FALSE,                 /* pc_relative */
 666          6,                     /* bitpos */
 667          complain_overflow_dont,        /* complain on overflow */
 668          nios2_elf32_call26_relocate,   /* special function */
 669          "R_NIOS2_CALL26_NOAT", /* name */
 670          FALSE,                 /* partial_inplace */
 671          0xffffffc0,            /* src_mask */
 672          0xffffffc0,            /* dst_mask */
 673          FALSE),                /* pcrel_offset */
 674
 675   HOWTO (R_NIOS2_GOT_LO,
 676          0,
 677          2,
 678          16,
 679          FALSE,
 680          6,
 681          complain_overflow_dont,
 682          bfd_elf_generic_reloc,
 683          "R_NIOS2_GOT_LO",
 684          FALSE,
 685          0x003fffc0,
 686          0x003fffc0,
 687          FALSE),
 688
 689   HOWTO (R_NIOS2_GOT_HA,
 690          0,
 691          2,
 692          16,
 693          FALSE,
 694          6,
 695          complain_overflow_dont,
 696          bfd_elf_generic_reloc,
 697          "R_NIOS2_GOT_HA",
 698          FALSE,
 699          0x003fffc0,
 700          0x003fffc0,
 701          FALSE),
 702
 703   HOWTO (R_NIOS2_CALL_LO,
 704          0,
 705          2,
 706          16,
 707          FALSE,
 708          6,
 709          complain_overflow_dont,
 710          bfd_elf_generic_reloc,
 711          "R_NIOS2_CALL_LO",
 712          FALSE,
 713          0x003fffc0,
 714          0x003fffc0,
 715          FALSE),
 716
 717   HOWTO (R_NIOS2_CALL_HA,
 718          0,
 719          2,
 720          16,
 721          FALSE,
 722          6,
 723          complain_overflow_dont,
 724          bfd_elf_generic_reloc,
 725          "R_NIOS2_CALL_HA",
 726          FALSE,
 727          0x003fffc0,
 728          0x003fffc0,
 729          FALSE),
 730
 731 /* Add other relocations here.  */
 732 };
 733
 734 static reloc_howto_type elf_nios2_r2_howto_table_rel[] = {
 735   /* No relocation.  */
 736   HOWTO (R_NIOS2_NONE,          /* type */
 737          0,                     /* rightshift */
 738          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          0,                     /* bitsize */
 740          FALSE,                 /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_dont,        /* complain_on_overflow */
 743          bfd_elf_generic_reloc, /* special_function */
 744          "R_NIOS2_NONE",        /* name */
 745          FALSE,                 /* partial_inplace */
 746          0,                     /* src_mask */
 747          0,                     /* dst_mask */
 748          FALSE),                /* pcrel_offset */
 749
 750   /* 16-bit signed immediate relocation.  */
 751   HOWTO (R_NIOS2_S16,           /* type */
 752          0,                     /* rightshift */
 753          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 754          16,                    /* bitsize */
 755          FALSE,                 /* pc_relative */
 756          16,                    /* bitpos */
 757          complain_overflow_signed,      /* complain on overflow */
 758          bfd_elf_generic_reloc, /* special function */
 759          "R_NIOS2_S16",         /* name */
 760          FALSE,                 /* partial_inplace */
 761          0xffff0000,            /* src_mask */
 762          0xffff0000,            /* dest_mask */
 763          FALSE),                /* pcrel_offset */
 764
 765   /* 16-bit unsigned immediate relocation.  */
 766   HOWTO (R_NIOS2_U16,           /* type */
 767          0,                     /* rightshift */
 768          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 769          16,                    /* bitsize */
 770          FALSE,                 /* pc_relative */
 771          16,                    /* bitpos */
 772          complain_overflow_unsigned,    /* complain on overflow */
 773          bfd_elf_generic_reloc, /* special function */
 774          "R_NIOS2_U16",         /* name */
 775          FALSE,                 /* partial_inplace */
 776          0xffff0000,            /* src_mask */
 777          0xffff0000,            /* dest_mask */
 778          FALSE),                /* pcrel_offset */
 779
 780   HOWTO (R_NIOS2_PCREL16,       /* type */
 781          0,                     /* rightshift */
 782          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 783          16,                    /* bitsize */
 784          TRUE,                  /* pc_relative */
 785          16,                    /* bitpos */
 786          complain_overflow_signed,      /* complain on overflow */
 787          nios2_elf32_pcrel16_relocate,  /* special function */
 788          "R_NIOS2_PCREL16",     /* name */
 789          FALSE,                 /* partial_inplace */
 790          0xffff0000,            /* src_mask */
 791          0xffff0000,            /* dest_mask */
 792          TRUE),                 /* pcrel_offset */
 793
 794   HOWTO (R_NIOS2_CALL26,        /* type */
 795          2,                     /* rightshift */
 796          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 797          26,                    /* bitsize */
 798          FALSE,                 /* pc_relative */
 799          6,                     /* bitpos */
 800          complain_overflow_dont,        /* complain on overflow */
 801          nios2_elf32_call26_relocate,   /* special function */
 802          "R_NIOS2_CALL26",      /* name */
 803          FALSE,                 /* partial_inplace */
 804          0xffffffc0,            /* src_mask */
 805          0xffffffc0,            /* dst_mask */
 806          FALSE),                /* pcrel_offset */
 807
 808   HOWTO (R_NIOS2_IMM5,
 809          0,
 810          2,
 811          5,
 812          FALSE,
 813          21,
 814          complain_overflow_bitfield,
 815          bfd_elf_generic_reloc,
 816          "R_NIOS2_IMM5",
 817          FALSE,
 818          0x03e00000,
 819          0x03e00000,
 820          FALSE),
 821
 822   HOWTO (R_NIOS2_CACHE_OPX,
 823          0,
 824          2,
 825          5,
 826          FALSE,
 827          11,
 828          complain_overflow_bitfield,
 829          bfd_elf_generic_reloc,
 830          "R_NIOS2_CACHE_OPX",
 831          FALSE,
 832          0x0000f800,
 833          0x0000f800,
 834          FALSE),
 835
 836   HOWTO (R_NIOS2_IMM6,
 837          0,
 838          2,
 839          6,
 840          FALSE,
 841          26,
 842          complain_overflow_bitfield,
 843          bfd_elf_generic_reloc,
 844          "R_NIOS2_IMM6",
 845          FALSE,
 846          0xfc000000,
 847          0xfc000000,
 848          FALSE),
 849
 850   HOWTO (R_NIOS2_IMM8,
 851          0,
 852          2,
 853          8,
 854          FALSE,
 855          24,
 856          complain_overflow_bitfield,
 857          bfd_elf_generic_reloc,
 858          "R_NIOS2_IMM8",
 859          FALSE,
 860          0xff000000,
 861          0xff000000,
 862          FALSE),
 863
 864   HOWTO (R_NIOS2_HI16,
 865          0,
 866          2,
 867          32,
 868          FALSE,
 869          16,
 870          complain_overflow_dont,
 871          nios2_elf32_hi16_relocate,
 872          "R_NIOS2_HI16",
 873          FALSE,
 874          0xffff0000,
 875          0xffff0000,
 876          FALSE),
 877
 878   HOWTO (R_NIOS2_LO16,
 879          0,
 880          2,
 881          32,
 882          FALSE,
 883          16,
 884          complain_overflow_dont,
 885          nios2_elf32_lo16_relocate,
 886          "R_NIOS2_LO16",
 887          FALSE,
 888          0xffff0000,
 889          0xffff0000,
 890          FALSE),
 891
 892   HOWTO (R_NIOS2_HIADJ16,
 893          0,
 894          2,
 895          32,
 896          FALSE,
 897          16,
 898          complain_overflow_dont,
 899          nios2_elf32_hiadj16_relocate,
 900          "R_NIOS2_HIADJ16",
 901          FALSE,
 902          0xffff0000,
 903          0xffff0000,
 904          FALSE),
 905
 906   HOWTO (R_NIOS2_BFD_RELOC_32,
 907          0,
 908          2,                     /* long */
 909          32,
 910          FALSE,
 911          0,
 912          complain_overflow_dont,
 913          bfd_elf_generic_reloc,
 914          "R_NIOS2_BFD_RELOC32",
 915          FALSE,
 916          0xffffffff,
 917          0xffffffff,
 918          FALSE),
 919
 920   HOWTO (R_NIOS2_BFD_RELOC_16,
 921          0,
 922          1,                     /* short */
 923          16,
 924          FALSE,
 925          0,
 926          complain_overflow_bitfield,
 927          bfd_elf_generic_reloc,
 928          "R_NIOS2_BFD_RELOC16",
 929          FALSE,
 930          0x0000ffff,
 931          0x0000ffff,
 932          FALSE),
 933
 934   HOWTO (R_NIOS2_BFD_RELOC_8,
 935          0,
 936          0,                     /* byte */
 937          8,
 938          FALSE,
 939          0,
 940          complain_overflow_bitfield,
 941          bfd_elf_generic_reloc,
 942          "R_NIOS2_BFD_RELOC8",
 943          FALSE,
 944          0x000000ff,
 945          0x000000ff,
 946          FALSE),
 947
 948   HOWTO (R_NIOS2_GPREL,
 949          0,
 950          2,
 951          32,
 952          FALSE,
 953          16,
 954          complain_overflow_dont,
 955          nios2_elf32_gprel_relocate,
 956          "R_NIOS2_GPREL",
 957          FALSE,
 958          0xffff0000,
 959          0xffff0000,
 960          FALSE),
 961
 962   HOWTO (R_NIOS2_GNU_VTINHERIT,
 963          0,
 964          2,                     /* short */
 965          0,
 966          FALSE,
 967          0,
 968          complain_overflow_dont,
 969          NULL,
 970          "R_NIOS2_GNU_VTINHERIT",
 971          FALSE,
 972          0,
 973          0,
 974          FALSE),
 975
 976   HOWTO (R_NIOS2_GNU_VTENTRY,
 977          0,
 978          2,                     /* byte */
 979          0,
 980          FALSE,
 981          0,
 982          complain_overflow_dont,
 983          _bfd_elf_rel_vtable_reloc_fn,
 984          "R_NIOS2_GNU_VTENTRY",
 985          FALSE,
 986          0,
 987          0,
 988          FALSE),
 989
 990   HOWTO (R_NIOS2_UJMP,
 991          0,
 992          2,
 993          32,
 994          FALSE,
 995          16,
 996          complain_overflow_dont,
 997          nios2_elf32_ujmp_relocate,
 998          "R_NIOS2_UJMP",
 999          FALSE,
1000          0xffff0000,
1001          0xffff0000,
1002          FALSE),
1003
1004   HOWTO (R_NIOS2_CJMP,
1005          0,
1006          2,
1007          32,
1008          FALSE,
1009          16,
1010          complain_overflow_dont,
1011          nios2_elf32_cjmp_relocate,
1012          "R_NIOS2_CJMP",
1013          FALSE,
1014          0xffff0000,
1015          0xffff0000,
1016          FALSE),
1017
1018   HOWTO (R_NIOS2_CALLR,
1019          0,
1020          2,
1021          32,
1022          FALSE,
1023          16,
1024          complain_overflow_dont,
1025          nios2_elf32_callr_relocate,
1026          "R_NIOS2_CALLR",
1027          FALSE,
1028          0xffff0000,
1029          0xffff0000,
1030          FALSE),
1031
1032   HOWTO (R_NIOS2_ALIGN,
1033          0,
1034          2,
1035          0,
1036          FALSE,
1037          0,
1038          complain_overflow_dont,
1039          nios2_elf32_ignore_reloc,
1040          "R_NIOS2_ALIGN",
1041          FALSE,
1042          0,
1043          0,
1044          TRUE),
1045
1046   HOWTO (R_NIOS2_GOT16,
1047          0,
1048          2,
1049          16,
1050          FALSE,
1051          16,
1052          complain_overflow_bitfield,
1053          bfd_elf_generic_reloc,
1054          "R_NIOS2_GOT16",
1055          FALSE,
1056          0xffff0000,
1057          0xffff0000,
1058          FALSE),
1059
1060   HOWTO (R_NIOS2_CALL16,
1061          0,
1062          2,
1063          16,
1064          FALSE,
1065          16,
1066          complain_overflow_bitfield,
1067          bfd_elf_generic_reloc,
1068          "R_NIOS2_CALL16",
1069          FALSE,
1070          0xffff0000,
1071          0xffff0000,
1072          FALSE),
1073
1074   HOWTO (R_NIOS2_GOTOFF_LO,
1075          0,
1076          2,
1077          16,
1078          FALSE,
1079          16,
1080          complain_overflow_dont,
1081          bfd_elf_generic_reloc,
1082          "R_NIOS2_GOTOFF_LO",
1083          FALSE,
1084          0xffff0000,
1085          0xffff0000,
1086          FALSE),
1087
1088   HOWTO (R_NIOS2_GOTOFF_HA,
1089          0,
1090          2,
1091          16,
1092          FALSE,
1093          16,
1094          complain_overflow_dont,
1095          bfd_elf_generic_reloc,
1096          "R_NIOS2_GOTOFF_HA",
1097          FALSE,
1098          0xffff0000,
1099          0xffff0000,
1100          FALSE),
1101
1102   HOWTO (R_NIOS2_PCREL_LO,
1103          0,
1104          2,
1105          16,
1106          TRUE,
1107          16,
1108          complain_overflow_dont,
1109          nios2_elf32_pcrel_lo16_relocate,
1110          "R_NIOS2_PCREL_LO",
1111          FALSE,
1112          0xffff0000,
1113          0xffff0000,
1114          TRUE),
1115
1116   HOWTO (R_NIOS2_PCREL_HA,
1117          0,
1118          2,
1119          16,
1120          FALSE, /* This is a PC-relative relocation, but we need to subtract
1121                    PC ourselves before the HIADJ.  */
1122          16,
1123          complain_overflow_dont,
1124          nios2_elf32_pcrel_hiadj16_relocate,
1125          "R_NIOS2_PCREL_HA",
1126          FALSE,
1127          0xffff0000,
1128          0xffff0000,
1129          TRUE),
1130
1131   HOWTO (R_NIOS2_TLS_GD16,
1132          0,
1133          2,
1134          16,
1135          FALSE,
1136          16,
1137          complain_overflow_bitfield,
1138          bfd_elf_generic_reloc,
1139          "R_NIOS2_TLS_GD16",
1140          FALSE,
1141          0xffff0000,
1142          0xffff0000,
1143          FALSE),
1144
1145   HOWTO (R_NIOS2_TLS_LDM16,
1146          0,
1147          2,
1148          16,
1149          FALSE,
1150          16,
1151          complain_overflow_bitfield,
1152          bfd_elf_generic_reloc,
1153          "R_NIOS2_TLS_LDM16",
1154          FALSE,
1155          0xffff0000,
1156          0xffff0000,
1157          FALSE),
1158
1159   HOWTO (R_NIOS2_TLS_LDO16,
1160          0,
1161          2,
1162          16,
1163          FALSE,
1164          16,
1165          complain_overflow_bitfield,
1166          bfd_elf_generic_reloc,
1167          "R_NIOS2_TLS_LDO16",
1168          FALSE,
1169          0xffff0000,
1170          0xffff0000,
1171          FALSE),
1172
1173   HOWTO (R_NIOS2_TLS_IE16,
1174          0,
1175          2,
1176          16,
1177          FALSE,
1178          16,
1179          complain_overflow_bitfield,
1180          bfd_elf_generic_reloc,
1181          "R_NIOS2_TLS_IE16",
1182          FALSE,
1183          0xffff0000,
1184          0xffff0000,
1185          FALSE),
1186
1187   HOWTO (R_NIOS2_TLS_LE16,
1188          0,
1189          2,
1190          16,
1191          FALSE,
1192          16,
1193          complain_overflow_bitfield,
1194          bfd_elf_generic_reloc,
1195          "R_NIOS2_TLS_LE16",
1196          FALSE,
1197          0xffff0000,
1198          0xffff0000,
1199          FALSE),
1200
1201   HOWTO (R_NIOS2_TLS_DTPMOD,
1202          0,
1203          2,
1204          32,
1205          FALSE,
1206          0,
1207          complain_overflow_dont,
1208          bfd_elf_generic_reloc,
1209          "R_NIOS2_TLS_DTPMOD",
1210          FALSE,
1211          0xffffffff,
1212          0xffffffff,
1213          FALSE),
1214
1215   HOWTO (R_NIOS2_TLS_DTPREL,
1216          0,
1217          2,
1218          32,
1219          FALSE,
1220          0,
1221          complain_overflow_dont,
1222          bfd_elf_generic_reloc,
1223          "R_NIOS2_TLS_DTPREL",
1224          FALSE,
1225          0xffffffff,
1226          0xffffffff,
1227          FALSE),
1228
1229   HOWTO (R_NIOS2_TLS_TPREL,
1230          0,
1231          2,
1232          32,
1233          FALSE,
1234          0,
1235          complain_overflow_dont,
1236          bfd_elf_generic_reloc,
1237          "R_NIOS2_TLS_TPREL",
1238          FALSE,
1239          0xffffffff,
1240          0xffffffff,
1241          FALSE),
1242
1243   HOWTO (R_NIOS2_COPY,
1244          0,
1245          2,
1246          32,
1247          FALSE,
1248          0,
1249          complain_overflow_dont,
1250          bfd_elf_generic_reloc,
1251          "R_NIOS2_COPY",
1252          FALSE,
1253          0,
1254          0,
1255          FALSE),
1256
1257   HOWTO (R_NIOS2_GLOB_DAT,
1258          0,
1259          2,
1260          32,
1261          FALSE,
1262          0,
1263          complain_overflow_dont,
1264          bfd_elf_generic_reloc,
1265          "R_NIOS2_GLOB_DAT",
1266          FALSE,
1267          0xffffffff,
1268          0xffffffff,
1269          FALSE),
1270
1271   HOWTO (R_NIOS2_JUMP_SLOT,
1272          0,
1273          2,
1274          32,
1275          FALSE,
1276          0,
1277          complain_overflow_dont,
1278          bfd_elf_generic_reloc,
1279          "R_NIOS2_JUMP_SLOT",
1280          FALSE,
1281          0xffffffff,
1282          0xffffffff,
1283          FALSE),
1284
1285   HOWTO (R_NIOS2_RELATIVE,
1286          0,
1287          2,
1288          32,
1289          FALSE,
1290          0,
1291          complain_overflow_dont,
1292          bfd_elf_generic_reloc,
1293          "R_NIOS2_RELATIVE",
1294          FALSE,
1295          0xffffffff,
1296          0xffffffff,
1297          FALSE),
1298
1299   HOWTO (R_NIOS2_GOTOFF,
1300          0,
1301          2,
1302          32,
1303          FALSE,
1304          0,
1305          complain_overflow_dont,
1306          bfd_elf_generic_reloc,
1307          "R_NIOS2_GOTOFF",
1308          FALSE,
1309          0xffffffff,
1310          0xffffffff,
1311          FALSE),
1312
1313   HOWTO (R_NIOS2_CALL26_NOAT,   /* type */
1314          2,                     /* rightshift */
1315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          26,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          6,                     /* bitpos */
1319          complain_overflow_dont,        /* complain on overflow */
1320          nios2_elf32_call26_relocate,   /* special function */
1321          "R_NIOS2_CALL26_NOAT", /* name */
1322          FALSE,                 /* partial_inplace */
1323          0xffffffc0,            /* src_mask */
1324          0xffffffc0,            /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   HOWTO (R_NIOS2_GOT_LO,
1328          0,
1329          2,
1330          16,
1331          FALSE,
1332          16,
1333          complain_overflow_dont,
1334          bfd_elf_generic_reloc,
1335          "R_NIOS2_GOT_LO",
1336          FALSE,
1337          0xffff0000,
1338          0xffff0000,
1339          FALSE),
1340
1341   HOWTO (R_NIOS2_GOT_HA,
1342          0,
1343          2,
1344          16,
1345          FALSE,
1346          16,
1347          complain_overflow_dont,
1348          bfd_elf_generic_reloc,
1349          "R_NIOS2_GOT_HA",
1350          FALSE,
1351          0xffff0000,
1352          0xffff0000,
1353          FALSE),
1354
1355   HOWTO (R_NIOS2_CALL_LO,
1356          0,
1357          2,
1358          16,
1359          FALSE,
1360          16,
1361          complain_overflow_dont,
1362          bfd_elf_generic_reloc,
1363          "R_NIOS2_CALL_LO",
1364          FALSE,
1365          0xffff0000,
1366          0xffff0000,
1367          FALSE),
1368
1369   HOWTO (R_NIOS2_CALL_HA,
1370          0,
1371          2,
1372          16,
1373          FALSE,
1374          16,
1375          complain_overflow_dont,
1376          bfd_elf_generic_reloc,
1377          "R_NIOS2_CALL_HA",
1378          FALSE,
1379          0xffff0000,
1380          0xffff0000,
1381          FALSE),
1382
1383   HOWTO (R_NIOS2_R2_S12,
1384          0,
1385          2,
1386          12,
1387          FALSE,
1388          16,
1389          complain_overflow_signed,
1390          bfd_elf_generic_reloc,
1391          "R_NIOS2_R2_S12",
1392          FALSE,
1393          0x0fff0000,
1394          0x0fff0000,
1395          FALSE),
1396
1397   HOWTO (R_NIOS2_R2_I10_1_PCREL,
1398          1,
1399          1,
1400          10,
1401          TRUE,
1402          6,
1403          complain_overflow_signed,
1404          bfd_elf_generic_reloc,         /* FIXME? */
1405          "R_NIOS2_R2_I10_1_PCREL",
1406          FALSE,
1407          0xffc0,
1408          0xffc0,
1409          TRUE),
1410
1411   HOWTO (R_NIOS2_R2_T1I7_1_PCREL,
1412          1,
1413          1,
1414          7,
1415          TRUE,
1416          9,
1417          complain_overflow_signed,
1418          bfd_elf_generic_reloc,         /* FIXME? */
1419          "R_NIOS2_R2_T1I7_1_PCREL",
1420          FALSE,
1421          0xfe00,
1422          0xfe00,
1423          TRUE),
1424
1425   HOWTO (R_NIOS2_R2_T1I7_2,
1426          2,
1427          1,
1428          7,
1429          FALSE,
1430          9,
1431          complain_overflow_unsigned,
1432          bfd_elf_generic_reloc,
1433          "R_NIOS2_R2_T1I7_2",
1434          FALSE,
1435          0xfe00,
1436          0xfe00,
1437          FALSE),
1438
1439   HOWTO (R_NIOS2_R2_T2I4,
1440          0,
1441          1,
1442          4,
1443          FALSE,
1444          12,
1445          complain_overflow_unsigned,
1446          bfd_elf_generic_reloc,
1447          "R_NIOS2_R2_T2I4",
1448          FALSE,
1449          0xf000,
1450          0xf000,
1451          FALSE),
1452
1453   HOWTO (R_NIOS2_R2_T2I4_1,
1454          1,
1455          1,
1456          4,
1457          FALSE,
1458          12,
1459          complain_overflow_unsigned,
1460          bfd_elf_generic_reloc,
1461          "R_NIOS2_R2_T2I4_1",
1462          FALSE,
1463          0xf000,
1464          0xf000,
1465          FALSE),
1466
1467   HOWTO (R_NIOS2_R2_T2I4_2,
1468          2,
1469          1,
1470          4,
1471          FALSE,
1472          12,
1473          complain_overflow_unsigned,
1474          bfd_elf_generic_reloc,
1475          "R_NIOS2_R2_T2I4_2",
1476          FALSE,
1477          0xf000,
1478          0xf000,
1479          FALSE),
1480
1481   HOWTO (R_NIOS2_R2_X1I7_2,
1482          2,
1483          1,
1484          7,
1485          FALSE,
1486          6,
1487          complain_overflow_unsigned,
1488          bfd_elf_generic_reloc,
1489          "R_NIOS2_R2_X1I7_2",
1490          FALSE,
1491          0x1fc0,
1492          0x1fc0,
1493          FALSE),
1494
1495   HOWTO (R_NIOS2_R2_X2L5,
1496          0,
1497          1,
1498          5,
1499          FALSE,
1500          6,
1501          complain_overflow_unsigned,
1502          bfd_elf_generic_reloc,
1503          "R_NIOS2_R2_X2L5",
1504          FALSE,
1505          0x07c0,
1506          0x07c0,
1507          FALSE),
1508
1509   HOWTO (R_NIOS2_R2_F1I5_2,
1510          2,
1511          1,
1512          5,
1513          FALSE,
1514          6,
1515          complain_overflow_unsigned,
1516          bfd_elf_generic_reloc,
1517          "R_NIOS2_R2_F1L5_2",
1518          FALSE,
1519          0x07c0,
1520          0x07c0,
1521          FALSE),
1522
1523   HOWTO (R_NIOS2_R2_L5I4X1,
1524          2,
1525          1,
1526          4,
1527          FALSE,
1528          6,
1529          complain_overflow_unsigned,
1530          bfd_elf_generic_reloc,
1531          "R_NIOS2_R2_L5I4X1",
1532          FALSE,
1533          0x03c0,
1534          0x03c0,
1535          FALSE),
1536
1537   HOWTO (R_NIOS2_R2_T1X1I6,
1538          0,
1539          1,
1540          6,
1541          FALSE,
1542          9,
1543          complain_overflow_unsigned,
1544          bfd_elf_generic_reloc,
1545          "R_NIOS2_R2_T1X1I6",
1546          FALSE,
1547          0x7e00,
1548          0x7e00,
1549          FALSE),
1550
1551   HOWTO (R_NIOS2_R2_T1X1I6_2,
1552          2,
1553          2,
1554          6,
1555          FALSE,
1556          9,
1557          complain_overflow_unsigned,
1558          bfd_elf_generic_reloc,
1559          "R_NIOS2_R2_T1I1X6_2",
1560          FALSE,
1561          0x7e00,
1562          0x7e00,
1563          FALSE),
1564
1565 /* Add other relocations here.  */
1566 };
1567
1568 static unsigned char elf_code_to_howto_index[R_NIOS2_ILLEGAL + 1];
1569
1570
1571 /* Return true if producing output for a R2 BFD.  */
1572 #define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1573
1574 /* Return the howto for relocation RTYPE.  */
1575 static reloc_howto_type *
1576 lookup_howto (unsigned int rtype, bfd *abfd)
1577 {
1578   static int initialized = 0;
1579   int i;
1580   /* R2 relocations are a superset of R1, so use that for the lookup
1581      table.  */
1582   int r1_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
1583   int r2_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
1584
1585   if (!initialized)
1586     {
1587       initialized = 1;
1588       memset (elf_code_to_howto_index, 0xff,
1589               sizeof (elf_code_to_howto_index));
1590       for (i = 0; i < r2_howto_tbl_size; i++)
1591         {
1592           elf_code_to_howto_index[elf_nios2_r2_howto_table_rel[i].type] = i;
1593           if (i < r1_howto_tbl_size)
1594             BFD_ASSERT (elf_nios2_r2_howto_table_rel[i].type
1595                         == elf_nios2_r1_howto_table_rel[i].type);
1596         }
1597     }
1598
1599   if (rtype > R_NIOS2_ILLEGAL)
1600     return NULL;
1601   i = elf_code_to_howto_index[rtype];
1602   if (BFD_IS_R2 (abfd))
1603     {
1604       if (i >= r2_howto_tbl_size)
1605         return NULL;
1606       return elf_nios2_r2_howto_table_rel + i;
1607     }
1608   else
1609     {
1610       if (i >= r1_howto_tbl_size)
1611         return NULL;
1612       return elf_nios2_r1_howto_table_rel + i;
1613     }
1614 }
1615
1616 /* Map for converting BFD reloc types to Nios II reloc types.  */
1617 struct elf_reloc_map
1618 {
1619   bfd_reloc_code_real_type bfd_val;
1620   enum elf_nios2_reloc_type elf_val;
1621 };
1622
1623 static const struct elf_reloc_map nios2_reloc_map[] =
1624 {
1625   {BFD_RELOC_NONE, R_NIOS2_NONE},
1626   {BFD_RELOC_NIOS2_S16, R_NIOS2_S16},
1627   {BFD_RELOC_NIOS2_U16, R_NIOS2_U16},
1628   {BFD_RELOC_16_PCREL, R_NIOS2_PCREL16},
1629   {BFD_RELOC_NIOS2_CALL26, R_NIOS2_CALL26},
1630   {BFD_RELOC_NIOS2_IMM5, R_NIOS2_IMM5},
1631   {BFD_RELOC_NIOS2_CACHE_OPX, R_NIOS2_CACHE_OPX},
1632   {BFD_RELOC_NIOS2_IMM6, R_NIOS2_IMM6},
1633   {BFD_RELOC_NIOS2_IMM8, R_NIOS2_IMM8},
1634   {BFD_RELOC_NIOS2_HI16, R_NIOS2_HI16},
1635   {BFD_RELOC_NIOS2_LO16, R_NIOS2_LO16},
1636   {BFD_RELOC_NIOS2_HIADJ16, R_NIOS2_HIADJ16},
1637   {BFD_RELOC_32, R_NIOS2_BFD_RELOC_32},
1638   {BFD_RELOC_16, R_NIOS2_BFD_RELOC_16},
1639   {BFD_RELOC_8, R_NIOS2_BFD_RELOC_8},
1640   {BFD_RELOC_NIOS2_GPREL, R_NIOS2_GPREL},
1641   {BFD_RELOC_VTABLE_INHERIT, R_NIOS2_GNU_VTINHERIT},
1642   {BFD_RELOC_VTABLE_ENTRY, R_NIOS2_GNU_VTENTRY},
1643   {BFD_RELOC_NIOS2_UJMP, R_NIOS2_UJMP},
1644   {BFD_RELOC_NIOS2_CJMP, R_NIOS2_CJMP},
1645   {BFD_RELOC_NIOS2_CALLR, R_NIOS2_CALLR},
1646   {BFD_RELOC_NIOS2_ALIGN, R_NIOS2_ALIGN},
1647   {BFD_RELOC_NIOS2_GOT16, R_NIOS2_GOT16},
1648   {BFD_RELOC_NIOS2_CALL16, R_NIOS2_CALL16},
1649   {BFD_RELOC_NIOS2_GOTOFF_LO, R_NIOS2_GOTOFF_LO},
1650   {BFD_RELOC_NIOS2_GOTOFF_HA, R_NIOS2_GOTOFF_HA},
1651   {BFD_RELOC_NIOS2_PCREL_LO, R_NIOS2_PCREL_LO},
1652   {BFD_RELOC_NIOS2_PCREL_HA, R_NIOS2_PCREL_HA},
1653   {BFD_RELOC_NIOS2_TLS_GD16, R_NIOS2_TLS_GD16},
1654   {BFD_RELOC_NIOS2_TLS_LDM16, R_NIOS2_TLS_LDM16},
1655   {BFD_RELOC_NIOS2_TLS_LDO16, R_NIOS2_TLS_LDO16},
1656   {BFD_RELOC_NIOS2_TLS_IE16, R_NIOS2_TLS_IE16},
1657   {BFD_RELOC_NIOS2_TLS_LE16, R_NIOS2_TLS_LE16},
1658   {BFD_RELOC_NIOS2_TLS_DTPMOD, R_NIOS2_TLS_DTPMOD},
1659   {BFD_RELOC_NIOS2_TLS_DTPREL, R_NIOS2_TLS_DTPREL},
1660   {BFD_RELOC_NIOS2_TLS_TPREL, R_NIOS2_TLS_TPREL},
1661   {BFD_RELOC_NIOS2_COPY, R_NIOS2_COPY},
1662   {BFD_RELOC_NIOS2_GLOB_DAT, R_NIOS2_GLOB_DAT},
1663   {BFD_RELOC_NIOS2_JUMP_SLOT, R_NIOS2_JUMP_SLOT},
1664   {BFD_RELOC_NIOS2_RELATIVE, R_NIOS2_RELATIVE},
1665   {BFD_RELOC_NIOS2_GOTOFF, R_NIOS2_GOTOFF},
1666   {BFD_RELOC_NIOS2_CALL26_NOAT, R_NIOS2_CALL26_NOAT},
1667   {BFD_RELOC_NIOS2_GOT_LO, R_NIOS2_GOT_LO},
1668   {BFD_RELOC_NIOS2_GOT_HA, R_NIOS2_GOT_HA},
1669   {BFD_RELOC_NIOS2_CALL_LO, R_NIOS2_CALL_LO},
1670   {BFD_RELOC_NIOS2_CALL_HA, R_NIOS2_CALL_HA},
1671   {BFD_RELOC_NIOS2_R2_S12, R_NIOS2_R2_S12},
1672   {BFD_RELOC_NIOS2_R2_I10_1_PCREL, R_NIOS2_R2_I10_1_PCREL},
1673   {BFD_RELOC_NIOS2_R2_T1I7_1_PCREL, R_NIOS2_R2_T1I7_1_PCREL},
1674   {BFD_RELOC_NIOS2_R2_T1I7_2, R_NIOS2_R2_T1I7_2},
1675   {BFD_RELOC_NIOS2_R2_T2I4, R_NIOS2_R2_T2I4},
1676   {BFD_RELOC_NIOS2_R2_T2I4_1, R_NIOS2_R2_T2I4_1},
1677   {BFD_RELOC_NIOS2_R2_T2I4_2, R_NIOS2_R2_T2I4_2},
1678   {BFD_RELOC_NIOS2_R2_X1I7_2, R_NIOS2_R2_X1I7_2},
1679   {BFD_RELOC_NIOS2_R2_X2L5, R_NIOS2_R2_X2L5},
1680   {BFD_RELOC_NIOS2_R2_F1I5_2, R_NIOS2_R2_F1I5_2},
1681   {BFD_RELOC_NIOS2_R2_L5I4X1, R_NIOS2_R2_L5I4X1},
1682   {BFD_RELOC_NIOS2_R2_T1X1I6, R_NIOS2_R2_T1X1I6},
1683   {BFD_RELOC_NIOS2_R2_T1X1I6_2, R_NIOS2_R2_T1X1I6_2},
1684 };
1685
1686 enum elf32_nios2_stub_type
1687 {
1688   nios2_stub_call26_before,
1689   nios2_stub_call26_after,
1690   nios2_stub_none
1691 };
1692
1693 struct elf32_nios2_stub_hash_entry
1694 {
1695   /* Base hash table entry structure.  */
1696   struct bfd_hash_entry bh_root;
1697
1698   /* The stub section.  */
1699   asection *stub_sec;
1700
1701   /* Offset within stub_sec of the beginning of this stub.  */
1702   bfd_vma stub_offset;
1703
1704   /* Given the symbol's value and its section we can determine its final
1705      value when building the stubs (so the stub knows where to jump.  */
1706   bfd_vma target_value;
1707   asection *target_section;
1708
1709   enum elf32_nios2_stub_type stub_type;
1710
1711   /* The symbol table entry, if any, that this was derived from.  */
1712   struct elf32_nios2_link_hash_entry *hh;
1713
1714   /* And the reloc addend that this was derived from.  */
1715   bfd_vma addend;
1716
1717   /* Where this stub is being called from, or, in the case of combined
1718      stub sections, the first input section in the group.  */
1719   asection *id_sec;
1720 };
1721
1722 #define nios2_stub_hash_entry(ent) \
1723   ((struct elf32_nios2_stub_hash_entry *)(ent))
1724
1725 #define nios2_stub_hash_lookup(table, string, create, copy) \
1726   ((struct elf32_nios2_stub_hash_entry *) \
1727    bfd_hash_lookup ((table), (string), (create), (copy)))
1728
1729
1730 /* Nios II ELF linker hash entry.  */
1731
1732 struct elf32_nios2_link_hash_entry
1733 {
1734   struct elf_link_hash_entry root;
1735
1736   /* A pointer to the most recently used stub hash entry against this
1737      symbol.  */
1738   struct elf32_nios2_stub_hash_entry *hsh_cache;
1739
1740   /* Track dynamic relocs copied for this symbol.  */
1741   struct elf_dyn_relocs *dyn_relocs;
1742
1743 #define GOT_UNKNOWN     0
1744 #define GOT_NORMAL      1
1745 #define GOT_TLS_GD      2
1746 #define GOT_TLS_IE      4
1747   unsigned char tls_type;
1748
1749   /* We need to detect and take special action for symbols which are only
1750      referenced with %call() and not with %got().  Such symbols do not need
1751      a dynamic GOT reloc in shared objects, only a dynamic PLT reloc.  Lazy
1752      linking will not work if the dynamic GOT reloc exists.
1753      To check for this condition efficiently, we compare got_types_used against
1754      CALL_USED, meaning
1755      (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1756   */
1757 #define GOT_USED        1
1758 #define CALL_USED       2
1759   unsigned char got_types_used;
1760 };
1761
1762 #define elf32_nios2_hash_entry(ent) \
1763   ((struct elf32_nios2_link_hash_entry *) (ent))
1764
1765 /* Get the Nios II elf linker hash table from a link_info structure.  */
1766 #define elf32_nios2_hash_table(info) \
1767   ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1768
1769 /* Nios II ELF linker hash table.  */
1770 struct elf32_nios2_link_hash_table
1771   {
1772     /* The main hash table.  */
1773     struct elf_link_hash_table root;
1774
1775     /* The stub hash table.  */
1776     struct bfd_hash_table bstab;
1777
1778     /* Linker stub bfd.  */
1779     bfd *stub_bfd;
1780
1781     /* Linker call-backs.  */
1782     asection * (*add_stub_section) (const char *, asection *, bfd_boolean);
1783     void (*layout_sections_again) (void);
1784
1785     /* Array to keep track of which stub sections have been created, and
1786        information on stub grouping.  */
1787     struct map_stub
1788     {
1789       /* These are the section to which stubs in the group will be
1790          attached.  */
1791       asection *first_sec, *last_sec;
1792       /* The stub sections.  There might be stubs inserted either before
1793          or after the real section.*/
1794       asection *first_stub_sec, *last_stub_sec;
1795     } *stub_group;
1796
1797     /* Assorted information used by nios2_elf32_size_stubs.  */
1798     unsigned int bfd_count;
1799     unsigned int top_index;
1800     asection **input_list;
1801     Elf_Internal_Sym **all_local_syms;
1802
1803     /* Short-cuts to get to dynamic linker sections.  */
1804     asection *sbss;
1805
1806     /* GOT pointer symbol _gp_got.  */
1807     struct elf_link_hash_entry *h_gp_got;
1808
1809     union {
1810       bfd_signed_vma refcount;
1811       bfd_vma offset;
1812     } tls_ldm_got;
1813
1814     /* Small local sym cache.  */
1815     struct sym_cache sym_cache;
1816
1817     bfd_vma res_n_size;
1818   };
1819
1820 struct nios2_elf32_obj_tdata
1821 {
1822   struct elf_obj_tdata root;
1823
1824   /* tls_type for each local got entry.  */
1825   char *local_got_tls_type;
1826
1827   /* TRUE if TLS GD relocs have been seen for this object.  */
1828   bfd_boolean has_tlsgd;
1829 };
1830
1831 #define elf32_nios2_tdata(abfd) \
1832   ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1833
1834 #define elf32_nios2_local_got_tls_type(abfd) \
1835   (elf32_nios2_tdata (abfd)->local_got_tls_type)
1836
1837 /* The name of the dynamic interpreter.  This is put in the .interp
1838    section.  */
1839 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1840
1841 /* PLT implementation for position-dependent code.  */
1842 static const bfd_vma nios2_plt_entry[] = { /* .PLTn: */
1843   0x03c00034,   /* movhi r15, %hiadj(plt_got_slot_address) */
1844   0x7bc00017,   /* ldw r15, %lo(plt_got_slot_address)(r15) */
1845   0x7800683a    /* jmp r15 */
1846 };
1847
1848 static const bfd_vma nios2_plt0_entry[] = { /* .PLTresolve */
1849   0x03800034,   /* movhi r14, %hiadj(res_0) */
1850   0x73800004,   /* addi r14, r14, %lo(res_0) */
1851   0x7b9fc83a,   /* sub r15, r15, r14 */
1852   0x03400034,   /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1853   0x6b800017,   /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1854   0x6b400017,   /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1855   0x6800683a    /* jmp r13 */
1856 };
1857
1858 /* PLT implementation for position-independent code.  */
1859 static const bfd_vma nios2_so_plt_entry[] = { /* .PLTn */
1860   0x03c00034,   /* movhi r15, %hiadj(index * 4) */
1861   0x7bc00004,   /* addi r15, r15, %lo(index * 4) */
1862   0x00000006    /* br .PLTresolve */
1863 };
1864
1865 static const bfd_vma nios2_so_plt0_entry[] = { /* .PLTresolve */
1866   0x001ce03a,   /* nextpc r14 */
1867   0x03400034,   /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1868   0x6b9b883a,   /* add r13, r13, r14 */
1869   0x6b800017,   /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1870   0x6b400017,   /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1871   0x6800683a    /* jmp r13 */
1872 };
1873
1874 /* CALL26 stub.  */
1875 static const bfd_vma nios2_call26_stub_entry[] = {
1876   0x00400034,   /* orhi at, r0, %hiadj(dest) */
1877   0x08400004,   /* addi at, at, %lo(dest) */
1878   0x0800683a    /* jmp at */
1879 };
1880
1881 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC.  */
1882 static void
1883 nios2_elf32_install_imm16 (asection *sec, bfd_vma offset, bfd_vma value)
1884 {
1885   bfd_vma word = bfd_get_32 (sec->owner, sec->contents + offset);
1886
1887   BFD_ASSERT (value <= 0xffff || ((bfd_signed_vma) value) >= -0xffff);
1888
1889   bfd_put_32 (sec->owner, word | ((value & 0xffff) << 6),
1890               sec->contents + offset);
1891 }
1892
1893 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1894    section SEC. */
1895 static void
1896 nios2_elf32_install_data (asection *sec, const bfd_vma *data, bfd_vma offset,
1897                           int count)
1898 {
1899   while (count--)
1900     {
1901       bfd_put_32 (sec->owner, *data, sec->contents + offset);
1902       offset += 4;
1903       ++data;
1904     }
1905 }
1906
1907 /* The usual way of loading a 32-bit constant into a Nios II register is to
1908    load the high 16 bits in one instruction and then add the low 16 bits with
1909    a signed add. This means that the high halfword needs to be adjusted to
1910    compensate for the sign bit of the low halfword. This function returns the
1911    adjusted high halfword for a given 32-bit constant.  */
1912 static
1913 bfd_vma hiadj (bfd_vma symbol_value)
1914 {
1915   return ((symbol_value + 0x8000) >> 16) & 0xffff;
1916 }
1917
1918 /* Implement elf_backend_grok_prstatus:
1919    Support for core dump NOTE sections.  */
1920 static bfd_boolean
1921 nios2_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1922 {
1923   int offset;
1924   size_t size;
1925
1926   switch (note->descsz)
1927     {
1928     default:
1929       return FALSE;
1930
1931     case 212:         /* Linux/Nios II */
1932       /* pr_cursig */
1933       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1934
1935       /* pr_pid */
1936       elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
1937
1938       /* pr_reg */
1939       offset = 72;
1940       size = 136;
1941
1942       break;
1943     }
1944
1945   /* Make a ".reg/999" section.  */
1946   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1947                                           size, note->descpos + offset);
1948 }
1949
1950 /* Implement elf_backend_grok_psinfo.  */
1951 static bfd_boolean
1952 nios2_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1953 {
1954   switch (note->descsz)
1955     {
1956     default:
1957       return FALSE;
1958
1959     case 124:         /* Linux/Nios II elf_prpsinfo */
1960       elf_tdata (abfd)->core->program
1961         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1962       elf_tdata (abfd)->core->command
1963         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1964     }
1965
1966   /* Note that for some reason, a spurious space is tacked
1967      onto the end of the args in some (at least one anyway)
1968      implementations, so strip it off if it exists.  */
1969
1970   {
1971     char *command = elf_tdata (abfd)->core->command;
1972     int n = strlen (command);
1973
1974     if (0 < n && command[n - 1] == ' ')
1975       command[n - 1] = '\0';
1976   }
1977
1978   return TRUE;
1979 }
1980
1981 /* Assorted hash table functions.  */
1982
1983 /* Initialize an entry in the stub hash table.  */
1984 static struct bfd_hash_entry *
1985 stub_hash_newfunc (struct bfd_hash_entry *entry,
1986                    struct bfd_hash_table *table,
1987                    const char *string)
1988 {
1989   /* Allocate the structure if it has not already been allocated by a
1990      subclass.  */
1991   if (entry == NULL)
1992     {
1993       entry = bfd_hash_allocate (table,
1994                                  sizeof (struct elf32_nios2_stub_hash_entry));
1995       if (entry == NULL)
1996         return entry;
1997     }
1998
1999   /* Call the allocation method of the superclass.  */
2000   entry = bfd_hash_newfunc (entry, table, string);
2001   if (entry != NULL)
2002     {
2003       struct elf32_nios2_stub_hash_entry *hsh;
2004
2005       /* Initialize the local fields.  */
2006       hsh = (struct elf32_nios2_stub_hash_entry *) entry;
2007       hsh->stub_sec = NULL;
2008       hsh->stub_offset = 0;
2009       hsh->target_value = 0;
2010       hsh->target_section = NULL;
2011       hsh->stub_type = nios2_stub_none;
2012       hsh->hh = NULL;
2013       hsh->id_sec = NULL;
2014     }
2015
2016   return entry;
2017 }
2018
2019 /* Create an entry in a Nios II ELF linker hash table.  */
2020 static struct bfd_hash_entry *
2021 link_hash_newfunc (struct bfd_hash_entry *entry,
2022                    struct bfd_hash_table *table, const char *string)
2023 {
2024   /* Allocate the structure if it has not already been allocated by a
2025      subclass.  */
2026   if (entry == NULL)
2027     {
2028       entry = bfd_hash_allocate (table,
2029                                  sizeof (struct elf32_nios2_link_hash_entry));
2030       if (entry == NULL)
2031         return entry;
2032     }
2033
2034   /* Call the allocation method of the superclass.  */
2035   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2036   if (entry)
2037     {
2038       struct elf32_nios2_link_hash_entry *eh;
2039
2040       eh = (struct elf32_nios2_link_hash_entry *) entry;
2041       eh->hsh_cache = NULL;
2042       eh->dyn_relocs = NULL;
2043       eh->tls_type = GOT_UNKNOWN;
2044       eh->got_types_used = 0;
2045     }
2046
2047   return entry;
2048 }
2049
2050 /* Section name for stubs is the associated section name plus this
2051    string.  */
2052 #define STUB_SUFFIX ".stub"
2053
2054 /* Build a name for an entry in the stub hash table.  */
2055 static char *
2056 nios2_stub_name (const asection *input_section,
2057                  const asection *sym_sec,
2058                  const struct elf32_nios2_link_hash_entry *hh,
2059                  const Elf_Internal_Rela *rel,
2060                  enum elf32_nios2_stub_type stub_type)
2061 {
2062   char *stub_name;
2063   bfd_size_type len;
2064   char stubpos = (stub_type == nios2_stub_call26_before) ? 'b' : 'a';
2065
2066   if (hh)
2067     {
2068       len = 8 + 1 + 1 + 1+ strlen (hh->root.root.root.string) + 1 + 8 + 1;
2069       stub_name = bfd_malloc (len);
2070       if (stub_name != NULL)
2071         {
2072           sprintf (stub_name, "%08x_%c_%s+%x",
2073                    input_section->id & 0xffffffff,
2074                    stubpos,
2075                    hh->root.root.root.string,
2076                    (int) rel->r_addend & 0xffffffff);
2077         }
2078     }
2079   else
2080     {
2081       len = 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2082       stub_name = bfd_malloc (len);
2083       if (stub_name != NULL)
2084         {
2085           sprintf (stub_name, "%08x_%c_%x:%x+%x",
2086                    input_section->id & 0xffffffff,
2087                    stubpos,
2088                    sym_sec->id & 0xffffffff,
2089                    (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
2090                    (int) rel->r_addend & 0xffffffff);
2091         }
2092     }
2093   return stub_name;
2094 }
2095
2096 /* Look up an entry in the stub hash.  Stub entries are cached because
2097    creating the stub name takes a bit of time.  */
2098 static struct elf32_nios2_stub_hash_entry *
2099 nios2_get_stub_entry (const asection *input_section,
2100                       const asection *sym_sec,
2101                       struct elf32_nios2_link_hash_entry *hh,
2102                       const Elf_Internal_Rela *rel,
2103                       struct elf32_nios2_link_hash_table *htab,
2104                       enum elf32_nios2_stub_type stub_type)
2105 {
2106   struct elf32_nios2_stub_hash_entry *hsh;
2107   const asection *id_sec;
2108
2109   /* If this input section is part of a group of sections sharing one
2110      stub section, then use the id of the first/last section in the group,
2111      depending on the stub section placement relative to the group.
2112      Stub names need to include a section id, as there may well be
2113      more than one stub used to reach say, printf, and we need to
2114      distinguish between them.  */
2115   if (stub_type == nios2_stub_call26_before)
2116     id_sec = htab->stub_group[input_section->id].first_sec;
2117   else
2118     id_sec = htab->stub_group[input_section->id].last_sec;
2119
2120   if (hh != NULL && hh->hsh_cache != NULL
2121       && hh->hsh_cache->hh == hh
2122       && hh->hsh_cache->id_sec == id_sec
2123       && hh->hsh_cache->stub_type == stub_type)
2124     {
2125       hsh = hh->hsh_cache;
2126     }
2127   else
2128     {
2129       char *stub_name;
2130
2131       stub_name = nios2_stub_name (id_sec, sym_sec, hh, rel, stub_type);
2132       if (stub_name == NULL)
2133         return NULL;
2134
2135       hsh = nios2_stub_hash_lookup (&htab->bstab,
2136                                     stub_name, FALSE, FALSE);
2137
2138       if (hh != NULL)
2139         hh->hsh_cache = hsh;
2140
2141       free (stub_name);
2142     }
2143
2144   return hsh;
2145 }
2146
2147 /* Add a new stub entry to the stub hash.  Not all fields of the new
2148    stub entry are initialised.  */
2149 static struct elf32_nios2_stub_hash_entry *
2150 nios2_add_stub (const char *stub_name,
2151                 asection *section,
2152                 struct elf32_nios2_link_hash_table *htab,
2153                 enum elf32_nios2_stub_type stub_type)
2154 {
2155   asection *link_sec;
2156   asection *stub_sec;
2157   asection **secptr, **linkptr;
2158   struct elf32_nios2_stub_hash_entry *hsh;
2159   bfd_boolean afterp;
2160
2161   if (stub_type == nios2_stub_call26_before)
2162     {
2163       link_sec = htab->stub_group[section->id].first_sec;
2164       secptr = &(htab->stub_group[section->id].first_stub_sec);
2165       linkptr = &(htab->stub_group[link_sec->id].first_stub_sec);
2166       afterp = FALSE;
2167     }
2168   else
2169     {
2170       link_sec = htab->stub_group[section->id].last_sec;
2171       secptr = &(htab->stub_group[section->id].last_stub_sec);
2172       linkptr = &(htab->stub_group[link_sec->id].last_stub_sec);
2173       afterp = TRUE;
2174     }
2175   stub_sec = *secptr;
2176   if (stub_sec == NULL)
2177     {
2178       stub_sec = *linkptr;
2179       if (stub_sec == NULL)
2180         {
2181           size_t namelen;
2182           bfd_size_type len;
2183           char *s_name;
2184
2185           namelen = strlen (link_sec->name);
2186           len = namelen + sizeof (STUB_SUFFIX);
2187           s_name = bfd_alloc (htab->stub_bfd, len);
2188           if (s_name == NULL)
2189             return NULL;
2190
2191           memcpy (s_name, link_sec->name, namelen);
2192           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
2193
2194           stub_sec = (*htab->add_stub_section) (s_name, link_sec, afterp);
2195           if (stub_sec == NULL)
2196             return NULL;
2197           *linkptr = stub_sec;
2198         }
2199       *secptr = stub_sec;
2200     }
2201
2202   /* Enter this entry into the linker stub hash table.  */
2203   hsh = nios2_stub_hash_lookup (&htab->bstab, stub_name,
2204                                 TRUE, FALSE);
2205   if (hsh == NULL)
2206     {
2207       /* xgettext:c-format */
2208       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2209                           section->owner,
2210                           stub_name);
2211       return NULL;
2212     }
2213
2214   hsh->stub_sec = stub_sec;
2215   hsh->stub_offset = 0;
2216   hsh->id_sec = link_sec;
2217   return hsh;
2218 }
2219
2220 /* Set up various things so that we can make a list of input sections
2221    for each output section included in the link.  Returns -1 on error,
2222    0 when no stubs will be needed, and 1 on success.  */
2223 int
2224 nios2_elf32_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2225 {
2226   bfd *input_bfd;
2227   unsigned int bfd_count;
2228   unsigned int top_id, top_index;
2229   asection *section;
2230   asection **input_list, **list;
2231   size_t amt;
2232   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2233
2234   /* Count the number of input BFDs and find the top input section id.  */
2235   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2236        input_bfd != NULL;
2237        input_bfd = input_bfd->link.next)
2238     {
2239       bfd_count += 1;
2240       for (section = input_bfd->sections;
2241            section != NULL;
2242            section = section->next)
2243         {
2244           if (top_id < section->id)
2245             top_id = section->id;
2246         }
2247     }
2248
2249   htab->bfd_count = bfd_count;
2250
2251   amt = sizeof (struct map_stub) * (top_id + 1);
2252   htab->stub_group = bfd_zmalloc (amt);
2253   if (htab->stub_group == NULL)
2254     return -1;
2255
2256   /* We can't use output_bfd->section_count here to find the top output
2257      section index as some sections may have been removed, and
2258      strip_excluded_output_sections doesn't renumber the indices.  */
2259   for (section = output_bfd->sections, top_index = 0;
2260        section != NULL;
2261        section = section->next)
2262     {
2263       if (top_index < section->index)
2264         top_index = section->index;
2265     }
2266
2267   htab->top_index = top_index;
2268   amt = sizeof (asection *) * (top_index + 1);
2269   input_list = bfd_malloc (amt);
2270   htab->input_list = input_list;
2271   if (input_list == NULL)
2272     return -1;
2273
2274   /* For sections we aren't interested in, mark their entries with a
2275      value we can check later.  */
2276   list = input_list + top_index;
2277   do
2278     *list = bfd_abs_section_ptr;
2279   while (list-- != input_list);
2280
2281   for (section = output_bfd->sections;
2282        section != NULL;
2283        section = section->next)
2284     {
2285       /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2286        * have PC relative relocs in them but no code flag set.  */
2287       if (((section->flags & SEC_CODE) != 0) ||
2288           strcmp(".ctors", section->name) ||
2289           strcmp(".dtors", section->name))
2290         input_list[section->index] = NULL;
2291     }
2292
2293   return 1;
2294 }
2295
2296 /* The linker repeatedly calls this function for each input section,
2297    in the order that input sections are linked into output sections.
2298    Build lists of input sections to determine groupings between which
2299    we may insert linker stubs.  */
2300 void
2301 nios2_elf32_next_input_section (struct bfd_link_info *info, asection *isec)
2302 {
2303   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2304
2305   if (isec->output_section->index <= htab->top_index)
2306     {
2307       asection **list = htab->input_list + isec->output_section->index;
2308       if (*list != bfd_abs_section_ptr)
2309         {
2310           /* Steal the last_sec pointer for our list.
2311              This happens to make the list in reverse order,
2312              which is what we want.  */
2313           htab->stub_group[isec->id].last_sec = *list;
2314           *list = isec;
2315         }
2316     }
2317 }
2318
2319 /* Segment mask for CALL26 relocation relaxation.  */
2320 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2321
2322 /* Fudge factor for approximate maximum size of all stubs that might
2323    be inserted by the linker.  This does not actually limit the number
2324    of stubs that might be inserted, and only affects strategy for grouping
2325    and placement of stubs.  Perhaps this should be computed based on number
2326    of relocations seen, or be specifiable on the command line.  */
2327 #define MAX_STUB_SECTION_SIZE 0xffff
2328
2329 /* See whether we can group stub sections together.  Grouping stub
2330    sections may result in fewer stubs.  More importantly, we need to
2331    put all .init* and .fini* stubs at the end of the .init or
2332    .fini output sections respectively, because glibc splits the
2333    _init and _fini functions into multiple parts.  Putting a stub in
2334    the middle of a function is not a good idea.
2335    Rather than computing groups of a maximum fixed size, for Nios II
2336    CALL26 relaxation it makes more sense to compute the groups based on
2337    sections that fit within a 256MB address segment.  Also do not allow
2338    a group to span more than one output section, since different output
2339    sections might correspond to different memory banks on a bare-metal
2340    target, etc.  */
2341 static void
2342 group_sections (struct elf32_nios2_link_hash_table *htab)
2343 {
2344   asection **list = htab->input_list + htab->top_index;
2345   do
2346     {
2347       /* The list is in reverse order so we'll search backwards looking
2348          for the first section that begins in the same memory segment,
2349          marking sections along the way to point at the tail for this
2350          group.  */
2351       asection *tail = *list;
2352       if (tail == bfd_abs_section_ptr)
2353         continue;
2354       while (tail != NULL)
2355         {
2356           bfd_vma start = tail->output_section->vma + tail->output_offset;
2357           bfd_vma end = start + tail->size;
2358           bfd_vma segment = CALL26_SEGMENT (end);
2359           asection *prev;
2360
2361           if (segment != CALL26_SEGMENT (start)
2362               || segment != CALL26_SEGMENT (end + MAX_STUB_SECTION_SIZE))
2363             /* This section spans more than one memory segment, or is
2364                close enough to the end of the segment that adding stub
2365                sections before it might cause it to move so that it
2366                spans memory segments, or that stubs added at the end of
2367                this group might overflow into the next memory segment.
2368                Put it in a group by itself to localize the effects.  */
2369             {
2370               prev = htab->stub_group[tail->id].last_sec;
2371               htab->stub_group[tail->id].last_sec = tail;
2372               htab->stub_group[tail->id].first_sec = tail;
2373             }
2374           else
2375             /* Collect more sections for this group.  */
2376             {
2377               asection *curr, *first;
2378               for (curr = tail; ; curr = prev)
2379                 {
2380                   prev = htab->stub_group[curr->id].last_sec;
2381                   if (!prev
2382                       || tail->output_section != prev->output_section
2383                       || (CALL26_SEGMENT (prev->output_section->vma
2384                                           + prev->output_offset)
2385                           != segment))
2386                     break;
2387                 }
2388               first = curr;
2389               for (curr = tail; ; curr = prev)
2390                 {
2391                   prev = htab->stub_group[curr->id].last_sec;
2392                   htab->stub_group[curr->id].last_sec = tail;
2393                   htab->stub_group[curr->id].first_sec = first;
2394                   if (curr == first)
2395                     break;
2396                 }
2397             }
2398
2399           /* Reset tail for the next group.  */
2400           tail = prev;
2401         }
2402     }
2403   while (list-- != htab->input_list);
2404   free (htab->input_list);
2405 }
2406
2407 /* Determine the type of stub needed, if any, for a call.  */
2408 static enum elf32_nios2_stub_type
2409 nios2_type_of_stub (asection *input_sec,
2410                     const Elf_Internal_Rela *rel,
2411                     struct elf32_nios2_link_hash_entry *hh,
2412                     struct elf32_nios2_link_hash_table *htab,
2413                     bfd_vma destination,
2414                     struct bfd_link_info *info ATTRIBUTE_UNUSED)
2415 {
2416   bfd_vma location, segment, start, end;
2417   asection *s0, *s1, *s;
2418
2419   if (hh != NULL &&
2420       !(hh->root.root.type == bfd_link_hash_defined
2421         || hh->root.root.type == bfd_link_hash_defweak))
2422     return nios2_stub_none;
2423
2424   /* Determine where the call point is.  */
2425   location = (input_sec->output_section->vma
2426               + input_sec->output_offset + rel->r_offset);
2427   segment = CALL26_SEGMENT (location);
2428
2429   /* Nios II CALL and JMPI instructions can transfer control to addresses
2430      within the same 256MB segment as the PC.  */
2431   if (segment == CALL26_SEGMENT (destination))
2432     return nios2_stub_none;
2433
2434   /* Find the start and end addresses of the stub group.  Also account for
2435      any already-created stub sections for this group.  Note that for stubs
2436      in the end section, only the first instruction of the last stub
2437      (12 bytes long) needs to be within range.  */
2438   s0 = htab->stub_group[input_sec->id].first_sec;
2439   s = htab->stub_group[s0->id].first_stub_sec;
2440   if (s != NULL && s->size > 0)
2441     start = s->output_section->vma + s->output_offset;
2442   else
2443     start = s0->output_section->vma + s0->output_offset;
2444
2445   s1 = htab->stub_group[input_sec->id].last_sec;
2446   s = htab->stub_group[s1->id].last_stub_sec;
2447   if (s != NULL && s->size > 0)
2448     end = s->output_section->vma + s->output_offset + s->size - 8;
2449   else
2450     end = s1->output_section->vma + s1->output_offset + s1->size;
2451
2452   BFD_ASSERT (start < end);
2453   BFD_ASSERT (start <= location);
2454   BFD_ASSERT (location < end);
2455
2456   /* Put stubs at the end of the group unless that is not a valid
2457      location and the beginning of the group is.  It might be that
2458      neither the beginning nor end works if we have an input section
2459      so large that it spans multiple segment boundaries.  In that
2460      case, punt; the end result will be a relocation overflow error no
2461      matter what we do here.
2462
2463      Note that adding stubs pushes up the addresses of all subsequent
2464      sections, so that stubs allocated on one pass through the
2465      relaxation loop may not be valid on the next pass.  (E.g., we may
2466      allocate a stub at the beginning of the section on one pass and
2467      find that the call site has been bumped into the next memory
2468      segment on the next pass.)  The important thing to note is that
2469      we never try to reclaim the space allocated to such unused stubs,
2470      so code size and section addresses can only increase with each
2471      iteration.  Accounting for the start and end addresses of the
2472      already-created stub sections ensures that when the algorithm
2473      converges, it converges accurately, with the entire appropriate
2474      stub section accessible from the call site and not just the
2475      address at the start or end of the stub group proper.  */
2476
2477   if (segment == CALL26_SEGMENT (end))
2478     return nios2_stub_call26_after;
2479   else if (segment == CALL26_SEGMENT (start))
2480     return nios2_stub_call26_before;
2481   else
2482     /* Perhaps this should be a dedicated error code.  */
2483     return nios2_stub_none;
2484 }
2485
2486 static bfd_boolean
2487 nios2_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2488 {
2489   struct elf32_nios2_stub_hash_entry *hsh
2490     = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2491   asection *stub_sec = hsh->stub_sec;
2492   bfd_vma sym_value;
2493   struct bfd_link_info *info;
2494
2495   info = (struct bfd_link_info *) in_arg;
2496
2497   /* Fail if the target section could not be assigned to an output
2498      section.  The user should fix his linker script.  */
2499   if (hsh->target_section->output_section == NULL
2500       && info->non_contiguous_regions)
2501     info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
2502                               "Retry without --enable-non-contiguous-regions.\n"),
2503                             hsh->target_section);
2504
2505   /* Make a note of the offset within the stubs for this entry.  */
2506   hsh->stub_offset = stub_sec->size;
2507
2508   switch (hsh->stub_type)
2509     {
2510     case nios2_stub_call26_before:
2511     case nios2_stub_call26_after:
2512       /* A call26 stub looks like:
2513            orhi at, %hiadj(dest)
2514            addi at, at, %lo(dest)
2515            jmp at
2516          Note that call/jmpi instructions can't be used in PIC code
2517          so there is no reason for the stub to be PIC, either.  */
2518       sym_value = (hsh->target_value
2519                    + hsh->target_section->output_offset
2520                    + hsh->target_section->output_section->vma
2521                    + hsh->addend);
2522
2523       nios2_elf32_install_data (stub_sec, nios2_call26_stub_entry,
2524                                 hsh->stub_offset, 3);
2525       nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset,
2526                                  hiadj (sym_value));
2527       nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset + 4,
2528                                  (sym_value & 0xffff));
2529       stub_sec->size += 12;
2530       break;
2531     default:
2532       BFD_FAIL ();
2533       return FALSE;
2534     }
2535
2536   return TRUE;
2537 }
2538
2539 /* As above, but don't actually build the stub.  Just bump offset so
2540    we know stub section sizes.  */
2541 static bfd_boolean
2542 nios2_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2543 {
2544   struct elf32_nios2_stub_hash_entry *hsh
2545     = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2546
2547   switch (hsh->stub_type)
2548     {
2549     case nios2_stub_call26_before:
2550     case nios2_stub_call26_after:
2551       hsh->stub_sec->size += 12;
2552       break;
2553     default:
2554       BFD_FAIL ();
2555       return FALSE;
2556     }
2557   return TRUE;
2558 }
2559
2560 /* Read in all local syms for all input bfds.
2561    Returns -1 on error, 0 otherwise.  */
2562
2563 static int
2564 get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
2565                 struct bfd_link_info *info)
2566 {
2567   unsigned int bfd_indx;
2568   Elf_Internal_Sym *local_syms, **all_local_syms;
2569   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2570
2571   /* We want to read in symbol extension records only once.  To do this
2572      we need to read in the local symbols in parallel and save them for
2573      later use; so hold pointers to the local symbols in an array.  */
2574   size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2575   all_local_syms = bfd_zmalloc (amt);
2576   htab->all_local_syms = all_local_syms;
2577   if (all_local_syms == NULL)
2578     return -1;
2579
2580   /* Walk over all the input BFDs, swapping in local symbols.  */
2581   for (bfd_indx = 0;
2582        input_bfd != NULL;
2583        input_bfd = input_bfd->link.next, bfd_indx++)
2584     {
2585       Elf_Internal_Shdr *symtab_hdr;
2586
2587       /* We'll need the symbol table in a second.  */
2588       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2589       if (symtab_hdr->sh_info == 0)
2590         continue;
2591
2592       /* We need an array of the local symbols attached to the input bfd.  */
2593       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2594       if (local_syms == NULL)
2595         {
2596           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2597                                              symtab_hdr->sh_info, 0,
2598                                              NULL, NULL, NULL);
2599           /* Cache them for elf_link_input_bfd.  */
2600           symtab_hdr->contents = (unsigned char *) local_syms;
2601         }
2602       if (local_syms == NULL)
2603         return -1;
2604
2605       all_local_syms[bfd_indx] = local_syms;
2606     }
2607
2608   return 0;
2609 }
2610
2611 /* Determine and set the size of the stub section for a final link.  */
2612 bfd_boolean
2613 nios2_elf32_size_stubs (bfd *output_bfd, bfd *stub_bfd,
2614                         struct bfd_link_info *info,
2615                         asection *(*add_stub_section) (const char *,
2616                                                        asection *, bfd_boolean),
2617                         void (*layout_sections_again) (void))
2618 {
2619   bfd_boolean stub_changed = FALSE;
2620   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2621
2622   /* Stash our params away.  */
2623   htab->stub_bfd = stub_bfd;
2624   htab->add_stub_section = add_stub_section;
2625   htab->layout_sections_again = layout_sections_again;
2626
2627   /* FIXME: We only compute the section groups once.  This could cause
2628      problems if adding a large stub section causes following sections,
2629      or parts of them, to move into another segment.  However, this seems
2630      to be consistent with the way other back ends handle this....  */
2631   group_sections (htab);
2632
2633   if (get_local_syms (output_bfd, info->input_bfds, info))
2634     {
2635       if (htab->all_local_syms)
2636         goto error_ret_free_local;
2637       return FALSE;
2638     }
2639
2640   while (1)
2641     {
2642       bfd *input_bfd;
2643       unsigned int bfd_indx;
2644       asection *stub_sec;
2645
2646       for (input_bfd = info->input_bfds, bfd_indx = 0;
2647            input_bfd != NULL;
2648            input_bfd = input_bfd->link.next, bfd_indx++)
2649         {
2650           Elf_Internal_Shdr *symtab_hdr;
2651           asection *section;
2652           Elf_Internal_Sym *local_syms;
2653
2654           /* We'll need the symbol table in a second.  */
2655           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2656           if (symtab_hdr->sh_info == 0)
2657             continue;
2658
2659           local_syms = htab->all_local_syms[bfd_indx];
2660
2661           /* Walk over each section attached to the input bfd.  */
2662           for (section = input_bfd->sections;
2663                section != NULL;
2664                section = section->next)
2665             {
2666               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2667
2668               /* If there aren't any relocs, then there's nothing more
2669                  to do.  */
2670               if ((section->flags & SEC_RELOC) == 0
2671                   || section->reloc_count == 0)
2672                 continue;
2673
2674               /* If this section is a link-once section that will be
2675                  discarded, then don't create any stubs.  */
2676               if (section->output_section == NULL
2677                   || section->output_section->owner != output_bfd)
2678                 continue;
2679
2680               /* Get the relocs.  */
2681               internal_relocs
2682                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2683                                              info->keep_memory);
2684               if (internal_relocs == NULL)
2685                 goto error_ret_free_local;
2686
2687               /* Now examine each relocation.  */
2688               irela = internal_relocs;
2689               irelaend = irela + section->reloc_count;
2690               for (; irela < irelaend; irela++)
2691                 {
2692                   unsigned int r_type, r_indx;
2693                   enum elf32_nios2_stub_type stub_type;
2694                   struct elf32_nios2_stub_hash_entry *hsh;
2695                   asection *sym_sec;
2696                   bfd_vma sym_value;
2697                   bfd_vma destination;
2698                   struct elf32_nios2_link_hash_entry *hh;
2699                   char *stub_name;
2700                   const asection *id_sec;
2701
2702                   r_type = ELF32_R_TYPE (irela->r_info);
2703                   r_indx = ELF32_R_SYM (irela->r_info);
2704
2705                   if (r_type >= (unsigned int) R_NIOS2_ILLEGAL)
2706                     {
2707                       bfd_set_error (bfd_error_bad_value);
2708                     error_ret_free_internal:
2709                       if (elf_section_data (section)->relocs == NULL)
2710                         free (internal_relocs);
2711                       goto error_ret_free_local;
2712                     }
2713
2714                   /* Only look for stubs on CALL and JMPI instructions.  */
2715                   if (r_type != (unsigned int) R_NIOS2_CALL26)
2716                     continue;
2717
2718                   /* Now determine the call target, its name, value,
2719                      section.  */
2720                   sym_sec = NULL;
2721                   sym_value = 0;
2722                   destination = 0;
2723                   hh = NULL;
2724                   if (r_indx < symtab_hdr->sh_info)
2725                     {
2726                       /* It's a local symbol.  */
2727                       Elf_Internal_Sym *sym;
2728                       Elf_Internal_Shdr *hdr;
2729                       unsigned int shndx;
2730
2731                       sym = local_syms + r_indx;
2732                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2733                         sym_value = sym->st_value;
2734                       shndx = sym->st_shndx;
2735                       if (shndx < elf_numsections (input_bfd))
2736                         {
2737                           hdr = elf_elfsections (input_bfd)[shndx];
2738                           sym_sec = hdr->bfd_section;
2739                           destination = (sym_value + irela->r_addend
2740                                          + sym_sec->output_offset
2741                                          + sym_sec->output_section->vma);
2742                         }
2743                     }
2744                   else
2745                     {
2746                       /* It's an external symbol.  */
2747                       int e_indx;
2748
2749                       e_indx = r_indx - symtab_hdr->sh_info;
2750                       hh = ((struct elf32_nios2_link_hash_entry *)
2751                             elf_sym_hashes (input_bfd)[e_indx]);
2752
2753                       while (hh->root.root.type == bfd_link_hash_indirect
2754                              || hh->root.root.type == bfd_link_hash_warning)
2755                         hh = ((struct elf32_nios2_link_hash_entry *)
2756                               hh->root.root.u.i.link);
2757
2758                       if (hh->root.root.type == bfd_link_hash_defined
2759                           || hh->root.root.type == bfd_link_hash_defweak)
2760                         {
2761                           sym_sec = hh->root.root.u.def.section;
2762                           sym_value = hh->root.root.u.def.value;
2763
2764                           if (sym_sec->output_section != NULL)
2765                             destination = (sym_value + irela->r_addend
2766                                            + sym_sec->output_offset
2767                                            + sym_sec->output_section->vma);
2768                           else
2769                             continue;
2770                         }
2771                       else if (hh->root.root.type == bfd_link_hash_undefweak)
2772                         {
2773                           if (! bfd_link_pic (info))
2774                             continue;
2775                         }
2776                       else if (hh->root.root.type == bfd_link_hash_undefined)
2777                         {
2778                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2779                                  && (ELF_ST_VISIBILITY (hh->root.other)
2780                                      == STV_DEFAULT)))
2781                             continue;
2782                         }
2783                       else
2784                         {
2785                           bfd_set_error (bfd_error_bad_value);
2786                           goto error_ret_free_internal;
2787                         }
2788                     }
2789
2790                   /* Determine what (if any) linker stub is needed.  */
2791                   stub_type = nios2_type_of_stub (section, irela, hh, htab,
2792                                                   destination, info);
2793                   if (stub_type == nios2_stub_none)
2794                     continue;
2795
2796                   /* Support for grouping stub sections.  */
2797                   if (stub_type == nios2_stub_call26_before)
2798                     id_sec = htab->stub_group[section->id].first_sec;
2799                   else
2800                     id_sec = htab->stub_group[section->id].last_sec;
2801
2802                   /* Get the name of this stub.  */
2803                   stub_name = nios2_stub_name (id_sec, sym_sec, hh, irela,
2804                                                stub_type);
2805                   if (!stub_name)
2806                     goto error_ret_free_internal;
2807
2808                   hsh = nios2_stub_hash_lookup (&htab->bstab,
2809                                                 stub_name,
2810                                                 FALSE, FALSE);
2811                   if (hsh != NULL)
2812                     {
2813                       /* The proper stub has already been created.  */
2814                       free (stub_name);
2815                       continue;
2816                     }
2817
2818                   hsh = nios2_add_stub (stub_name, section, htab, stub_type);
2819                   if (hsh == NULL)
2820                     {
2821                       free (stub_name);
2822                       goto error_ret_free_internal;
2823                     }
2824                   hsh->target_value = sym_value;
2825                   hsh->target_section = sym_sec;
2826                   hsh->stub_type = stub_type;
2827                   hsh->hh = hh;
2828                   hsh->addend = irela->r_addend;
2829                   stub_changed = TRUE;
2830                 }
2831
2832               /* We're done with the internal relocs, free them.  */
2833               if (elf_section_data (section)->relocs == NULL)
2834                 free (internal_relocs);
2835             }
2836         }
2837
2838       if (!stub_changed)
2839         break;
2840
2841       /* OK, we've added some stubs.  Find out the new size of the
2842          stub sections.  */
2843       for (stub_sec = htab->stub_bfd->sections;
2844            stub_sec != NULL;
2845            stub_sec = stub_sec->next)
2846         stub_sec->size = 0;
2847
2848       bfd_hash_traverse (&htab->bstab, nios2_size_one_stub, htab);
2849
2850       /* Ask the linker to do its stuff.  */
2851       (*htab->layout_sections_again) ();
2852       stub_changed = FALSE;
2853     }
2854
2855   free (htab->all_local_syms);
2856   return TRUE;
2857
2858  error_ret_free_local:
2859   free (htab->all_local_syms);
2860   return FALSE;
2861 }
2862
2863 /* Build all the stubs associated with the current output file.  The
2864    stubs are kept in a hash table attached to the main linker hash
2865    table.  This function is called via nios2elf_finish in the linker.  */
2866 bfd_boolean
2867 nios2_elf32_build_stubs (struct bfd_link_info *info)
2868 {
2869   asection *stub_sec;
2870   struct bfd_hash_table *table;
2871   struct elf32_nios2_link_hash_table *htab;
2872
2873   htab = elf32_nios2_hash_table (info);
2874
2875   for (stub_sec = htab->stub_bfd->sections;
2876        stub_sec != NULL;
2877        stub_sec = stub_sec->next)
2878     /* The stub_bfd may contain non-stub sections if it is also the
2879        dynobj.  Any such non-stub sections are created with the
2880        SEC_LINKER_CREATED flag set, while stub sections do not
2881        have that flag.  Ignore any non-stub sections here.  */
2882     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
2883       {
2884         bfd_size_type size;
2885
2886         /* Allocate memory to hold the linker stubs.  */
2887         size = stub_sec->size;
2888         stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2889         if (stub_sec->contents == NULL && size != 0)
2890           return FALSE;
2891         stub_sec->size = 0;
2892       }
2893
2894   /* Build the stubs as directed by the stub hash table.  */
2895   table = &htab->bstab;
2896   bfd_hash_traverse (table, nios2_build_one_stub, info);
2897
2898   return TRUE;
2899 }
2900
2901
2902 #define is_nios2_elf(bfd) \
2903   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2904    && elf_object_id (bfd) == NIOS2_ELF_DATA)
2905
2906 /* Merge backend specific data from an object file to the output
2907    object file when linking.  */
2908
2909 static bfd_boolean
2910 nios2_elf32_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2911 {
2912   bfd *obfd = info->output_bfd;
2913   flagword old_flags;
2914   flagword new_flags;
2915
2916   if (!is_nios2_elf (ibfd) || !is_nios2_elf (obfd))
2917     return TRUE;
2918
2919   /* Check if we have the same endianness.  */
2920   if (! _bfd_generic_verify_endian_match (ibfd, info))
2921     return FALSE;
2922
2923   new_flags = elf_elfheader (ibfd)->e_flags;
2924   old_flags = elf_elfheader (obfd)->e_flags;
2925   if (!elf_flags_init (obfd))
2926     {
2927       /* First call, no flags set.  */
2928       elf_flags_init (obfd) = TRUE;
2929       elf_elfheader (obfd)->e_flags = new_flags;
2930
2931       switch (new_flags)
2932         {
2933         default:
2934         case EF_NIOS2_ARCH_R1:
2935           bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r1);
2936           break;
2937         case EF_NIOS2_ARCH_R2:
2938           if (bfd_big_endian (ibfd))
2939             {
2940               _bfd_error_handler
2941                 (_("error: %pB: big-endian R2 is not supported"), ibfd);
2942               bfd_set_error (bfd_error_bad_value);
2943               return FALSE;
2944             }
2945           bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r2);
2946           break;
2947         }
2948     }
2949
2950   /* Incompatible flags.  */
2951   else if (new_flags != old_flags)
2952     {
2953       /* So far, the only incompatible flags denote incompatible
2954          architectures.  */
2955       _bfd_error_handler
2956         /* xgettext:c-format */
2957         (_("error: %pB: conflicting CPU architectures %d/%d"),
2958          ibfd, new_flags, old_flags);
2959       bfd_set_error (bfd_error_bad_value);
2960       return FALSE;
2961     }
2962
2963   /* Merge Tag_compatibility attributes and any common GNU ones.  */
2964   _bfd_elf_merge_object_attributes (ibfd, info);
2965
2966   return TRUE;
2967 }
2968
2969 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2970    Given a BFD reloc type, return a howto structure.  */
2971
2972 static reloc_howto_type *
2973 nios2_elf32_bfd_reloc_type_lookup (bfd *abfd,
2974                                    bfd_reloc_code_real_type code)
2975 {
2976   int i;
2977
2978   for (i = 0; i < (int) ARRAY_SIZE (nios2_reloc_map); ++i)
2979     if (nios2_reloc_map[i].bfd_val == code)
2980       return lookup_howto (nios2_reloc_map[i].elf_val, abfd);
2981   return NULL;
2982 }
2983
2984 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2985    Given a reloc name, return a howto structure.  */
2986
2987 static reloc_howto_type *
2988 nios2_elf32_bfd_reloc_name_lookup (bfd *abfd,
2989                                    const char *r_name)
2990 {
2991   int i;
2992   reloc_howto_type *howto_tbl;
2993   int howto_tbl_size;
2994
2995   if (BFD_IS_R2 (abfd))
2996     {
2997       howto_tbl = elf_nios2_r2_howto_table_rel;
2998       howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
2999     }
3000   else
3001     {
3002       howto_tbl = elf_nios2_r1_howto_table_rel;
3003       howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
3004     }
3005
3006   for (i = 0; i < howto_tbl_size; i++)
3007     if (howto_tbl[i].name && strcasecmp (howto_tbl[i].name, r_name) == 0)
3008       return howto_tbl + i;
3009
3010   return NULL;
3011 }
3012
3013 /* Implement elf_info_to_howto:
3014    Given a ELF32 relocation, fill in a arelent structure.  */
3015
3016 static bfd_boolean
3017 nios2_elf32_info_to_howto (bfd *abfd, arelent *cache_ptr,
3018                            Elf_Internal_Rela *dst)
3019 {
3020   unsigned int r_type;
3021
3022   r_type = ELF32_R_TYPE (dst->r_info);
3023   if ((cache_ptr->howto = lookup_howto (r_type, abfd)) == NULL)
3024     {
3025       /* xgettext:c-format */
3026       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3027                           abfd, r_type);
3028       bfd_set_error (bfd_error_bad_value);
3029       return FALSE;
3030     }
3031   return TRUE;
3032 }
3033
3034 /* Return the base VMA address which should be subtracted from real addresses
3035    when resolving @dtpoff relocation.
3036    This is PT_TLS segment p_vaddr.  */
3037 static bfd_vma
3038 dtpoff_base (struct bfd_link_info *info)
3039 {
3040   /* If tls_sec is NULL, we should have signalled an error already.  */
3041   if (elf_hash_table (info)->tls_sec == NULL)
3042     return 0;
3043   return elf_hash_table (info)->tls_sec->vma;
3044 }
3045
3046 /* Return the relocation value for @tpoff relocation
3047    if STT_TLS virtual address is ADDRESS.  */
3048 static bfd_vma
3049 tpoff (struct bfd_link_info *info, bfd_vma address)
3050 {
3051   struct elf_link_hash_table *htab = elf_hash_table (info);
3052
3053   /* If tls_sec is NULL, we should have signalled an error already.  */
3054   if (htab->tls_sec == NULL)
3055     return 0;
3056   return address - htab->tls_sec->vma;
3057 }
3058
3059 /* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
3060    dangerous relocation.  */
3061 static bfd_boolean
3062 nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
3063 {
3064
3065   bfd_boolean gp_found;
3066   struct bfd_hash_entry *h;
3067   struct bfd_link_hash_entry *lh;
3068
3069   /* If we've already figured out what GP will be, just return it. */
3070   *pgp = _bfd_get_gp_value (output_bfd);
3071   if (*pgp)
3072     return TRUE;
3073
3074   h = bfd_hash_lookup (&info->hash->table, "_gp", FALSE, FALSE);
3075   lh = (struct bfd_link_hash_entry *) h;
3076  lookup:
3077   if (lh)
3078     {
3079       switch (lh->type)
3080         {
3081         case bfd_link_hash_undefined:
3082         case bfd_link_hash_undefweak:
3083         case bfd_link_hash_common:
3084           gp_found = FALSE;
3085           break;
3086         case bfd_link_hash_defined:
3087         case bfd_link_hash_defweak:
3088           gp_found = TRUE;
3089           {
3090             asection *sym_sec = lh->u.def.section;
3091             bfd_vma sym_value = lh->u.def.value;
3092
3093             if (sym_sec->output_section)
3094               sym_value = (sym_value + sym_sec->output_offset
3095                            + sym_sec->output_section->vma);
3096             *pgp = sym_value;
3097           }
3098           break;
3099         case bfd_link_hash_indirect:
3100         case bfd_link_hash_warning:
3101           lh = lh->u.i.link;
3102           /* @@FIXME  ignoring warning for now */
3103           goto lookup;
3104         case bfd_link_hash_new:
3105         default:
3106           abort ();
3107         }
3108     }
3109   else
3110     gp_found = FALSE;
3111
3112   if (!gp_found)
3113     {
3114       /* Only get the error once. */
3115       *pgp = 4;
3116       _bfd_set_gp_value (output_bfd, *pgp);
3117       return FALSE;
3118     }
3119
3120   _bfd_set_gp_value (output_bfd, *pgp);
3121
3122   return TRUE;
3123 }
3124
3125 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3126    if it's not available as we don't have a link_info pointer available here
3127    to look it up in the output symbol table.  We don't need to adjust the
3128    symbol value for an external symbol if we are producing relocatable
3129    output.  */
3130 static bfd_reloc_status_type
3131 nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
3132                     char **error_message, bfd_vma *pgp)
3133 {
3134   if (bfd_is_und_section (symbol->section) && !relocatable)
3135     {
3136       *pgp = 0;
3137       return bfd_reloc_undefined;
3138     }
3139
3140   *pgp = _bfd_get_gp_value (output_bfd);
3141   if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
3142     {
3143       if (relocatable)
3144         {
3145           /* Make up a value.  */
3146           *pgp = symbol->section->output_section->vma + 0x4000;
3147           _bfd_set_gp_value (output_bfd, *pgp);
3148         }
3149       else
3150         {
3151           *error_message
3152             = (char *) _("global pointer relative relocation when _gp not defined");
3153           return bfd_reloc_dangerous;
3154         }
3155     }
3156
3157   return bfd_reloc_ok;
3158 }
3159
3160 /* Do the relocations that require special handling.  */
3161 static bfd_reloc_status_type
3162 nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
3163                               asection *input_section,
3164                               bfd_byte *data, bfd_vma offset,
3165                               bfd_vma symbol_value, bfd_vma addend)
3166 {
3167   symbol_value = symbol_value + addend;
3168   addend = 0;
3169   symbol_value = (symbol_value >> 16) & 0xffff;
3170   return _bfd_final_link_relocate (howto, abfd, input_section,
3171                                    data, offset, symbol_value, addend);
3172 }
3173
3174 static bfd_reloc_status_type
3175 nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3176                               asection *input_section,
3177                               bfd_byte *data, bfd_vma offset,
3178                               bfd_vma symbol_value, bfd_vma addend)
3179 {
3180   symbol_value = symbol_value + addend;
3181   addend = 0;
3182   symbol_value = symbol_value & 0xffff;
3183   return _bfd_final_link_relocate (howto, abfd, input_section,
3184                                    data, offset, symbol_value, addend);
3185 }
3186
3187 static bfd_reloc_status_type
3188 nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3189                                  asection *input_section,
3190                                  bfd_byte *data, bfd_vma offset,
3191                                  bfd_vma symbol_value, bfd_vma addend)
3192 {
3193   symbol_value = symbol_value + addend;
3194   addend = 0;
3195   symbol_value = hiadj(symbol_value);
3196   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3197                                    symbol_value, addend);
3198 }
3199
3200 static bfd_reloc_status_type
3201 nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3202                                     asection *input_section,
3203                                     bfd_byte *data, bfd_vma offset,
3204                                     bfd_vma symbol_value, bfd_vma addend)
3205 {
3206   symbol_value = symbol_value + addend;
3207   addend = 0;
3208   symbol_value = symbol_value & 0xffff;
3209   return _bfd_final_link_relocate (howto, abfd, input_section,
3210                                    data, offset, symbol_value, addend);
3211 }
3212
3213 static bfd_reloc_status_type
3214 nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3215                                        asection *input_section,
3216                                        bfd_byte *data, bfd_vma offset,
3217                                        bfd_vma symbol_value, bfd_vma addend)
3218 {
3219   symbol_value = symbol_value + addend;
3220   symbol_value -= (input_section->output_section->vma
3221                    + input_section->output_offset);
3222   symbol_value -= offset;
3223   addend = 0;
3224   symbol_value = hiadj(symbol_value);
3225   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3226                                    symbol_value, addend);
3227 }
3228
3229 static bfd_reloc_status_type
3230 nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
3231                                  asection *input_section,
3232                                  bfd_byte *data, bfd_vma offset,
3233                                  bfd_vma symbol_value, bfd_vma addend)
3234 {
3235   /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3236      so we need to subtract 4 before doing a final_link_relocate. */
3237   symbol_value = symbol_value + addend - 4;
3238   addend = 0;
3239   return _bfd_final_link_relocate (howto, abfd, input_section,
3240                                    data, offset, symbol_value, addend);
3241 }
3242
3243 static bfd_reloc_status_type
3244 nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
3245                                 asection *input_section,
3246                                 bfd_byte *data, bfd_vma offset,
3247                                 bfd_vma symbol_value, bfd_vma addend)
3248 {
3249   /* Check that the relocation is in the same page as the current address.  */
3250   if (CALL26_SEGMENT (symbol_value + addend)
3251       != CALL26_SEGMENT (input_section->output_section->vma
3252                          + input_section->output_offset
3253                          + offset))
3254     return bfd_reloc_overflow;
3255
3256   /* Check that the target address is correctly aligned on a 4-byte
3257      boundary.  */
3258   if ((symbol_value + addend) & 0x3)
3259     return bfd_reloc_overflow;
3260
3261   return _bfd_final_link_relocate (howto, abfd, input_section,
3262                                    data, offset, symbol_value, addend);
3263 }
3264
3265 static bfd_reloc_status_type
3266 nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
3267                                asection *input_section,
3268                                bfd_byte *data, bfd_vma offset,
3269                                bfd_vma symbol_value, bfd_vma addend)
3270 {
3271   /* Because we need the output_bfd, the special handling is done
3272      in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate.  */
3273   return _bfd_final_link_relocate (howto, abfd, input_section,
3274                                    data, offset, symbol_value, addend);
3275 }
3276
3277 static bfd_reloc_status_type
3278 nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
3279                               asection *input_section,
3280                               bfd_byte *data, bfd_vma offset,
3281                               bfd_vma symbol_value, bfd_vma addend)
3282 {
3283   bfd_vma symbol_lo16, symbol_hi16;
3284   bfd_reloc_status_type r;
3285   symbol_value = symbol_value + addend;
3286   addend = 0;
3287   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3288   symbol_lo16 = symbol_value & 0xffff;
3289
3290   r = _bfd_final_link_relocate (howto, abfd, input_section,
3291                                 data, offset, symbol_hi16, addend);
3292
3293   if (r == bfd_reloc_ok)
3294     return _bfd_final_link_relocate (howto, abfd, input_section,
3295                                      data, offset + 4, symbol_lo16, addend);
3296
3297   return r;
3298 }
3299
3300 static bfd_reloc_status_type
3301 nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
3302                               asection *input_section,
3303                               bfd_byte *data, bfd_vma offset,
3304                               bfd_vma symbol_value, bfd_vma addend)
3305 {
3306   bfd_vma symbol_lo16, symbol_hi16;
3307   bfd_reloc_status_type r;
3308   symbol_value = symbol_value + addend;
3309   addend = 0;
3310   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3311   symbol_lo16 = symbol_value & 0xffff;
3312
3313   r = _bfd_final_link_relocate (howto, abfd, input_section,
3314                                 data, offset, symbol_hi16, addend);
3315
3316   if (r == bfd_reloc_ok)
3317     return _bfd_final_link_relocate (howto, abfd, input_section,
3318                                      data, offset + 4, symbol_lo16, addend);
3319
3320   return r;
3321 }
3322
3323 static bfd_reloc_status_type
3324 nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
3325                                asection *input_section,
3326                                bfd_byte *data, bfd_vma offset,
3327                                bfd_vma symbol_value, bfd_vma addend)
3328 {
3329   bfd_vma symbol_lo16, symbol_hi16;
3330   bfd_reloc_status_type r;
3331   symbol_value = symbol_value + addend;
3332   addend = 0;
3333   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3334   symbol_lo16 = symbol_value & 0xffff;
3335
3336   r = _bfd_final_link_relocate (howto, abfd, input_section,
3337                                 data, offset, symbol_hi16, addend);
3338
3339   if (r == bfd_reloc_ok)
3340     return _bfd_final_link_relocate (howto, abfd, input_section,
3341                                      data, offset + 4, symbol_lo16, addend);
3342
3343   return r;
3344 }
3345
3346 /* HOWTO handlers for relocations that require special handling.  */
3347
3348 /* This is for relocations used only when relaxing to ensure
3349    changes in size of section don't screw up .align.  */
3350 static bfd_reloc_status_type
3351 nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3352                           asymbol *symbol ATTRIBUTE_UNUSED,
3353                           void *data ATTRIBUTE_UNUSED, asection *input_section,
3354                           bfd *output_bfd,
3355                           char **error_message ATTRIBUTE_UNUSED)
3356 {
3357   if (output_bfd != NULL)
3358     reloc_entry->address += input_section->output_offset;
3359   return bfd_reloc_ok;
3360 }
3361
3362 static bfd_reloc_status_type
3363 nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3364                            void *data, asection *input_section,
3365                            bfd *output_bfd,
3366                            char **error_message ATTRIBUTE_UNUSED)
3367 {
3368   /* This part is from bfd_elf_generic_reloc.  */
3369   if (output_bfd != NULL
3370       && (symbol->flags & BSF_SECTION_SYM) == 0
3371       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3372     {
3373       reloc_entry->address += input_section->output_offset;
3374       return bfd_reloc_ok;
3375     }
3376
3377   if (output_bfd != NULL)
3378     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3379     return bfd_reloc_continue;
3380
3381   return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
3382                                        input_section,
3383                                        data, reloc_entry->address,
3384                                        (symbol->value
3385                                         + symbol->section->output_section->vma
3386                                         + symbol->section->output_offset),
3387                                        reloc_entry->addend);
3388 }
3389
3390 static bfd_reloc_status_type
3391 nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3392                            void *data, asection *input_section,
3393                            bfd *output_bfd,
3394                            char **error_message ATTRIBUTE_UNUSED)
3395 {
3396   /* This part is from bfd_elf_generic_reloc.  */
3397   if (output_bfd != NULL
3398       && (symbol->flags & BSF_SECTION_SYM) == 0
3399       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3400     {
3401       reloc_entry->address += input_section->output_offset;
3402       return bfd_reloc_ok;
3403     }
3404
3405   if (output_bfd != NULL)
3406     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3407     return bfd_reloc_continue;
3408
3409   return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
3410                                        input_section,
3411                                        data, reloc_entry->address,
3412                                        (symbol->value
3413                                         + symbol->section->output_section->vma
3414                                         + symbol->section->output_offset),
3415                                        reloc_entry->addend);
3416 }
3417
3418 static bfd_reloc_status_type
3419 nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3420                               void *data, asection *input_section,
3421                               bfd *output_bfd,
3422                               char **error_message ATTRIBUTE_UNUSED)
3423 {
3424   /* This part is from bfd_elf_generic_reloc.  */
3425   if (output_bfd != NULL
3426       && (symbol->flags & BSF_SECTION_SYM) == 0
3427       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3428     {
3429       reloc_entry->address += input_section->output_offset;
3430       return bfd_reloc_ok;
3431     }
3432
3433   if (output_bfd != NULL)
3434     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3435     return bfd_reloc_continue;
3436
3437   return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
3438                                           input_section,
3439                                           data, reloc_entry->address,
3440                                           (symbol->value
3441                                            + symbol->section->output_section->vma
3442                                            + symbol->section->output_offset),
3443                                           reloc_entry->addend);
3444 }
3445
3446 static bfd_reloc_status_type
3447 nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
3448                                  asymbol *symbol, void *data,
3449                                  asection *input_section, bfd *output_bfd,
3450                                  char **error_message ATTRIBUTE_UNUSED)
3451 {
3452   /* This part is from bfd_elf_generic_reloc.  */
3453   if (output_bfd != NULL
3454       && (symbol->flags & BSF_SECTION_SYM) == 0
3455       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3456     {
3457       reloc_entry->address += input_section->output_offset;
3458       return bfd_reloc_ok;
3459     }
3460
3461   if (output_bfd != NULL)
3462     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3463     return bfd_reloc_continue;
3464
3465   return nios2_elf32_do_pcrel_lo16_relocate (
3466     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3467     (symbol->value + symbol->section->output_section->vma
3468      + symbol->section->output_offset),
3469     reloc_entry->addend);
3470 }
3471
3472 static bfd_reloc_status_type
3473 nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
3474                                     asymbol *symbol, void *data,
3475                                     asection *input_section, bfd *output_bfd,
3476                                     char **error_message ATTRIBUTE_UNUSED)
3477 {
3478   /* This part is from bfd_elf_generic_reloc.  */
3479   if (output_bfd != NULL
3480       && (symbol->flags & BSF_SECTION_SYM) == 0
3481       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3482     {
3483       reloc_entry->address += input_section->output_offset;
3484       return bfd_reloc_ok;
3485     }
3486
3487   if (output_bfd != NULL)
3488     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3489     return bfd_reloc_continue;
3490
3491   return nios2_elf32_do_pcrel_hiadj16_relocate (
3492     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3493     (symbol->value + symbol->section->output_section->vma
3494      + symbol->section->output_offset),
3495     reloc_entry->addend);
3496 }
3497
3498 static bfd_reloc_status_type
3499 nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3500                               void *data, asection *input_section,
3501                               bfd *output_bfd,
3502                               char **error_message ATTRIBUTE_UNUSED)
3503 {
3504   /* This part is from bfd_elf_generic_reloc.  */
3505   if (output_bfd != NULL
3506       && (symbol->flags & BSF_SECTION_SYM) == 0
3507       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3508     {
3509       reloc_entry->address += input_section->output_offset;
3510       return bfd_reloc_ok;
3511     }
3512
3513   if (output_bfd != NULL)
3514     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3515     return bfd_reloc_continue;
3516
3517   return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
3518                                           input_section,
3519                                           data, reloc_entry->address,
3520                                           (symbol->value
3521                                            + symbol->section->output_section->vma
3522                                            + symbol->section->output_offset),
3523                                           reloc_entry->addend);
3524 }
3525
3526 static bfd_reloc_status_type
3527 nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3528                              void *data, asection *input_section,
3529                              bfd *output_bfd,
3530                              char **error_message ATTRIBUTE_UNUSED)
3531 {
3532   /* This part is from bfd_elf_generic_reloc.  */
3533   if (output_bfd != NULL
3534       && (symbol->flags & BSF_SECTION_SYM) == 0
3535       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3536     {
3537       reloc_entry->address += input_section->output_offset;
3538       return bfd_reloc_ok;
3539     }
3540
3541   if (output_bfd != NULL)
3542     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3543     return bfd_reloc_continue;
3544
3545   return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
3546                                          input_section,
3547                                          data, reloc_entry->address,
3548                                          (symbol->value
3549                                           + symbol->section->output_section->vma
3550                                           + symbol->section->output_offset),
3551                                          reloc_entry->addend);
3552 }
3553
3554 static bfd_reloc_status_type
3555 nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3556                             void *data, asection *input_section,
3557                             bfd *output_bfd, char **msg)
3558 {
3559   bfd_vma relocation;
3560   bfd_vma gp;
3561   bfd_reloc_status_type r;
3562
3563
3564   /* This part is from bfd_elf_generic_reloc.  */
3565   if (output_bfd != NULL
3566       && (symbol->flags & BSF_SECTION_SYM) == 0
3567       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3568     {
3569       reloc_entry->address += input_section->output_offset;
3570       return bfd_reloc_ok;
3571     }
3572
3573   if (output_bfd != NULL)
3574     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3575     return bfd_reloc_continue;
3576
3577   relocation = (symbol->value
3578                 + symbol->section->output_section->vma
3579                 + symbol->section->output_offset);
3580
3581   /* This assumes we've already cached the _gp symbol.  */
3582   r = nios2_elf_final_gp (abfd, symbol, FALSE, msg, &gp);
3583   if (r == bfd_reloc_ok)
3584     {
3585       relocation = relocation + reloc_entry->addend - gp;
3586       reloc_entry->addend = 0;
3587       if ((signed) relocation < -32768 || (signed) relocation > 32767)
3588         {
3589           *msg = _("global pointer relative address out of range");
3590           r = bfd_reloc_outofrange;
3591         }
3592       else
3593         r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
3594                                            input_section,
3595                                            data, reloc_entry->address,
3596                                            relocation, reloc_entry->addend);
3597     }
3598
3599   return r;
3600 }
3601
3602 static bfd_reloc_status_type
3603 nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3604                            void *data, asection *input_section,
3605                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3606 {
3607   /* This part is from bfd_elf_generic_reloc.  */
3608   if (output_bfd != NULL
3609       && (symbol->flags & BSF_SECTION_SYM) == 0
3610       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3611     {
3612       reloc_entry->address += input_section->output_offset;
3613       return bfd_reloc_ok;
3614     }
3615
3616   if (output_bfd != NULL)
3617     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3618     return bfd_reloc_continue;
3619
3620   return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
3621                                        input_section,
3622                                        data, reloc_entry->address,
3623                                        (symbol->value
3624                                         + symbol->section->output_section->vma
3625                                         + symbol->section->output_offset),
3626                                        reloc_entry->addend);
3627 }
3628
3629 static bfd_reloc_status_type
3630 nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3631                            void *data, asection *input_section,
3632                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3633 {
3634   /* This part is from bfd_elf_generic_reloc.  */
3635   if (output_bfd != NULL
3636       && (symbol->flags & BSF_SECTION_SYM) == 0
3637       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3638     {
3639       reloc_entry->address += input_section->output_offset;
3640       return bfd_reloc_ok;
3641     }
3642
3643   if (output_bfd != NULL)
3644     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3645     return bfd_reloc_continue;
3646
3647   return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
3648                                        input_section,
3649                                        data, reloc_entry->address,
3650                                        (symbol->value
3651                                         + symbol->section->output_section->vma
3652                                         + symbol->section->output_offset),
3653                                        reloc_entry->addend);
3654 }
3655
3656 static bfd_reloc_status_type
3657 nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3658                             void *data, asection *input_section,
3659                             bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3660 {
3661   /* This part is from bfd_elf_generic_reloc.  */
3662   if (output_bfd != NULL
3663       && (symbol->flags & BSF_SECTION_SYM) == 0
3664       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3665     {
3666       reloc_entry->address += input_section->output_offset;
3667       return bfd_reloc_ok;
3668     }
3669
3670   if (output_bfd != NULL)
3671     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3672     return bfd_reloc_continue;
3673
3674   return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
3675                                         input_section,
3676                                         data, reloc_entry->address,
3677                                         (symbol->value
3678                                          + symbol->section->output_section->vma
3679                                          + symbol->section->output_offset),
3680                                         reloc_entry->addend);
3681 }
3682
3683
3684 /* Implement elf_backend_relocate_section.  */
3685 static bfd_boolean
3686 nios2_elf32_relocate_section (bfd *output_bfd,
3687                               struct bfd_link_info *info,
3688                               bfd *input_bfd,
3689                               asection *input_section,
3690                               bfd_byte *contents,
3691                               Elf_Internal_Rela *relocs,
3692                               Elf_Internal_Sym *local_syms,
3693                               asection **local_sections)
3694 {
3695   Elf_Internal_Shdr *symtab_hdr;
3696   struct elf_link_hash_entry **sym_hashes;
3697   Elf_Internal_Rela *rel;
3698   Elf_Internal_Rela *relend;
3699   struct elf32_nios2_link_hash_table *htab;
3700   asection *sgot;
3701   asection *splt;
3702   asection *sreloc = NULL;
3703   bfd_vma *local_got_offsets;
3704   bfd_vma got_base;
3705
3706   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3707   sym_hashes = elf_sym_hashes (input_bfd);
3708   relend = relocs + input_section->reloc_count;
3709
3710   htab = elf32_nios2_hash_table (info);
3711   sgot = htab->root.sgot;
3712   splt = htab->root.splt;
3713   local_got_offsets = elf_local_got_offsets (input_bfd);
3714
3715   if (htab->h_gp_got == NULL)
3716     got_base = 0;
3717   else
3718     got_base = htab->h_gp_got->root.u.def.value;
3719
3720   for (rel = relocs; rel < relend; rel++)
3721     {
3722       reloc_howto_type *howto;
3723       unsigned long r_symndx;
3724       Elf_Internal_Sym *sym;
3725       asection *sec;
3726       struct elf_link_hash_entry *h;
3727       struct elf32_nios2_link_hash_entry *eh;
3728       bfd_vma relocation;
3729       bfd_vma gp;
3730       bfd_reloc_status_type r = bfd_reloc_ok;
3731       const char *name = NULL;
3732       int r_type;
3733       const char *format;
3734       char *msgbuf = NULL;
3735       char *msg = NULL;
3736       bfd_boolean unresolved_reloc;
3737       bfd_vma off;
3738       int use_plt;
3739
3740       r_type = ELF32_R_TYPE (rel->r_info);
3741       r_symndx = ELF32_R_SYM (rel->r_info);
3742
3743       howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info), output_bfd);
3744       h = NULL;
3745       sym = NULL;
3746       sec = NULL;
3747
3748       if (r_symndx < symtab_hdr->sh_info)
3749         {
3750           sym = local_syms + r_symndx;
3751           sec = local_sections[r_symndx];
3752           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3753         }
3754       else
3755         {
3756           bfd_boolean warned, ignored;
3757
3758           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3759                                    r_symndx, symtab_hdr, sym_hashes,
3760                                    h, sec, relocation,
3761                                    unresolved_reloc, warned, ignored);
3762         }
3763
3764       if (sec && discarded_section (sec))
3765         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3766                                          rel, 1, relend, howto, 0, contents);
3767
3768       /* Nothing more to do unless this is a final link.  */
3769       if (bfd_link_relocatable (info))
3770         continue;
3771
3772       if (howto)
3773         {
3774           bfd_boolean resolved_to_zero;
3775
3776           resolved_to_zero = (h != NULL
3777                               && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
3778           switch (howto->type)
3779             {
3780             case R_NIOS2_HI16:
3781               r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
3782                                                 input_section,
3783                                                 contents, rel->r_offset,
3784                                                 relocation, rel->r_addend);
3785               break;
3786             case R_NIOS2_LO16:
3787               r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
3788                                                 input_section,
3789                                                 contents, rel->r_offset,
3790                                                 relocation, rel->r_addend);
3791               break;
3792             case R_NIOS2_PCREL_LO:
3793               r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
3794                                                       input_section,
3795                                                       contents,
3796                                                       rel->r_offset,
3797                                                       relocation,
3798                                                       rel->r_addend);
3799               break;
3800             case R_NIOS2_HIADJ16:
3801               r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
3802                                                    input_section, contents,
3803                                                    rel->r_offset, relocation,
3804                                                    rel->r_addend);
3805               break;
3806             case R_NIOS2_PCREL_HA:
3807               r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
3808                                                          input_section,
3809                                                          contents,
3810                                                          rel->r_offset,
3811                                                          relocation,
3812                                                          rel->r_addend);
3813               break;
3814             case R_NIOS2_PCREL16:
3815               r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
3816                                                    input_section, contents,
3817                                                    rel->r_offset, relocation,
3818                                                    rel->r_addend);
3819               break;
3820             case R_NIOS2_GPREL:
3821               /* Turns an absolute address into a gp-relative address.  */
3822               if (!nios2_elf_assign_gp (output_bfd, &gp, info))
3823                 {
3824                   bfd_vma reloc_address;
3825
3826                   if (sec && sec->output_section)
3827                     reloc_address = (sec->output_section->vma
3828                                      + sec->output_offset
3829                                      + rel->r_offset);
3830                   else
3831                     reloc_address = 0;
3832
3833                   format = _("global pointer relative relocation at address "
3834                              "%#" PRIx64 " when _gp not defined\n");
3835                   if (asprintf (&msgbuf, format,
3836                                 (uint64_t) reloc_address) == -1)
3837                     msgbuf = NULL;
3838                   msg = msgbuf;
3839                   r = bfd_reloc_dangerous;
3840                 }
3841               else
3842                 {
3843                   bfd_vma symbol_address = rel->r_addend + relocation;
3844                   relocation = symbol_address - gp;
3845                   rel->r_addend = 0;
3846                   if (((signed) relocation < -32768
3847                        || (signed) relocation > 32767)
3848                       && (!h
3849                           || h->root.type == bfd_link_hash_defined
3850                           || h->root.type == bfd_link_hash_defweak))
3851                     {
3852                       if (h)
3853                         name = h->root.root.string;
3854                       else
3855                         {
3856                           name = (bfd_elf_string_from_elf_section
3857                                   (input_bfd, symtab_hdr->sh_link,
3858                                    sym->st_name));
3859                           if (name == NULL || *name == '\0')
3860                             name = bfd_section_name (sec);
3861                         }
3862                       /* xgettext:c-format */
3863                       format = _("unable to reach %s (at %#" PRIx64 ") from "
3864                                  "the global pointer (at %#" PRIx64 ") "
3865                                  "because the offset (%" PRId64 ") is out of "
3866                                  "the allowed range, -32678 to 32767\n" );
3867                       if (asprintf (&msgbuf, format, name,
3868                                     (uint64_t) symbol_address, (uint64_t) gp,
3869                                     (int64_t) relocation) == -1)
3870                         msgbuf = NULL;
3871                       msg = msgbuf;
3872                       r = bfd_reloc_outofrange;
3873                     }
3874                   else
3875                     r = _bfd_final_link_relocate (howto, input_bfd,
3876                                                   input_section, contents,
3877                                                   rel->r_offset, relocation,
3878                                                   rel->r_addend);
3879                 }
3880               break;
3881             case R_NIOS2_UJMP:
3882               r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
3883                                                 input_section,
3884                                                 contents, rel->r_offset,
3885                                                 relocation, rel->r_addend);
3886               break;
3887             case R_NIOS2_CJMP:
3888               r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
3889                                                 input_section,
3890                                                 contents, rel->r_offset,
3891                                                 relocation, rel->r_addend);
3892               break;
3893             case R_NIOS2_CALLR:
3894               r = nios2_elf32_do_callr_relocate (input_bfd, howto,
3895                                                  input_section, contents,
3896                                                  rel->r_offset, relocation,
3897                                                  rel->r_addend);
3898               break;
3899             case R_NIOS2_CALL26:
3900             case R_NIOS2_CALL26_NOAT:
3901               /* If we have a call to an undefined weak symbol, we just want
3902                  to stuff a zero in the bits of the call instruction and
3903                  bypass the normal call26 relocation handling, because it'll
3904                  diagnose an overflow error if address 0 isn't in the same
3905                  256MB segment as the call site.  Presumably the call
3906                  should be guarded by a null check anyway.  */
3907               if (h != NULL && h->root.type == bfd_link_hash_undefweak)
3908                 {
3909                   BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
3910                   r = _bfd_final_link_relocate (howto, input_bfd,
3911                                                 input_section, contents,
3912                                                 rel->r_offset, relocation,
3913                                                 rel->r_addend);
3914                   break;
3915                 }
3916               /* Handle relocations which should use the PLT entry.
3917                  NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3918                  which may point to a PLT entry, but we don't need to handle
3919                  that here.  If we created a PLT entry, all branches in this
3920                  object should go to it.  */
3921               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3922                 {
3923                   /* If we've created a .plt section, and assigned a PLT entry
3924                      to this function, it should not be known to bind locally.
3925                      If it were, we would have cleared the PLT entry.  */
3926                   BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3927
3928                   relocation = (splt->output_section->vma
3929                                 + splt->output_offset
3930                                 + h->plt.offset);
3931
3932                   unresolved_reloc = FALSE;
3933                 }
3934               /* Detect R_NIOS2_CALL26 relocations that would overflow the
3935                  256MB segment.  Replace the target with a reference to a
3936                  trampoline instead.
3937                  Note that htab->stub_group is null if relaxation has been
3938                  disabled by the --no-relax linker command-line option, so
3939                  we can use that to skip this processing entirely.  */
3940               if (howto->type == R_NIOS2_CALL26 && htab->stub_group)
3941                 {
3942                   bfd_vma dest = relocation + rel->r_addend;
3943                   enum elf32_nios2_stub_type stub_type;
3944
3945                   eh = (struct elf32_nios2_link_hash_entry *)h;
3946                   stub_type = nios2_type_of_stub (input_section, rel, eh,
3947                                                   htab, dest, NULL);
3948
3949                   if (stub_type != nios2_stub_none)
3950                     {
3951                       struct elf32_nios2_stub_hash_entry *hsh;
3952
3953                       hsh = nios2_get_stub_entry (input_section, sec,
3954                                                   eh, rel, htab, stub_type);
3955                       if (hsh == NULL)
3956                         {
3957                           r = bfd_reloc_undefined;
3958                           break;
3959                         }
3960
3961                       dest = (hsh->stub_offset
3962                               + hsh->stub_sec->output_offset
3963                               + hsh->stub_sec->output_section->vma);
3964                       r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3965                                                           input_section,
3966                                                           contents,
3967                                                           rel->r_offset,
3968                                                           dest, 0);
3969                       break;
3970                     }
3971                 }
3972
3973               /* Normal case.  */
3974               r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3975                                                   input_section, contents,
3976                                                   rel->r_offset, relocation,
3977                                                   rel->r_addend);
3978               break;
3979             case R_NIOS2_ALIGN:
3980               r = bfd_reloc_ok;
3981               /* For symmetry this would be
3982                  r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3983                                                   input_section, contents,
3984                                                   rel->r_offset, relocation,
3985                                                   rel->r_addend);
3986                 but do_ignore_reloc would do no more than return
3987                 bfd_reloc_ok. */
3988               break;
3989
3990             case R_NIOS2_GOT16:
3991             case R_NIOS2_CALL16:
3992             case R_NIOS2_GOT_LO:
3993             case R_NIOS2_GOT_HA:
3994             case R_NIOS2_CALL_LO:
3995             case R_NIOS2_CALL_HA:
3996               /* Relocation is to the entry for this symbol in the
3997                  global offset table.  */
3998               if (sgot == NULL)
3999                 {
4000                   r = bfd_reloc_notsupported;
4001                   break;
4002                 }
4003
4004               use_plt = 0;
4005
4006               if (h != NULL)
4007                 {
4008                   bfd_boolean dyn;
4009
4010                   eh = (struct elf32_nios2_link_hash_entry *)h;
4011                   use_plt = (eh->got_types_used == CALL_USED
4012                              && h->plt.offset != (bfd_vma) -1);
4013
4014                   off = h->got.offset;
4015                   BFD_ASSERT (off != (bfd_vma) -1);
4016                   dyn = htab->root.dynamic_sections_created;
4017                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4018                                                          bfd_link_pic (info),
4019                                                          h)
4020                       || (bfd_link_pic (info)
4021                           && SYMBOL_REFERENCES_LOCAL (info, h))
4022                       || ((ELF_ST_VISIBILITY (h->other)
4023                            || resolved_to_zero)
4024                           && h->root.type == bfd_link_hash_undefweak))
4025                     {
4026                       /* This is actually a static link, or it is a -Bsymbolic
4027                          link and the symbol is defined locally.  We must
4028                          initialize this entry in the global offset table.
4029                          Since the offset must always be a multiple of 4, we
4030                          use the least significant bit to record whether we
4031                          have initialized it already.
4032
4033                          When doing a dynamic link, we create a .rela.got
4034                          relocation entry to initialize the value.  This is
4035                          done in the finish_dynamic_symbol routine.  */
4036                       if ((off & 1) != 0)
4037                         off &= ~1;
4038                       else
4039                         {
4040                           bfd_put_32 (output_bfd, relocation,
4041                                       sgot->contents + off);
4042                           h->got.offset |= 1;
4043                         }
4044                     }
4045                   else
4046                     unresolved_reloc = FALSE;
4047                 }
4048               else
4049                 {
4050                   BFD_ASSERT (local_got_offsets != NULL
4051                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
4052
4053                   off = local_got_offsets[r_symndx];
4054
4055                   /* The offset must always be a multiple of 4.  We use the
4056                      least significant bit to record whether we have already
4057                      generated the necessary reloc.  */
4058                   if ((off & 1) != 0)
4059                     off &= ~1;
4060                   else
4061                     {
4062                       bfd_put_32 (output_bfd, relocation,
4063                                   sgot->contents + off);
4064
4065                       if (bfd_link_pic (info))
4066                         {
4067                           asection *srelgot;
4068                           Elf_Internal_Rela outrel;
4069                           bfd_byte *loc;
4070
4071                           srelgot = htab->root.srelgot;
4072                           BFD_ASSERT (srelgot != NULL);
4073
4074                           outrel.r_addend = relocation;
4075                           outrel.r_offset = (sgot->output_section->vma
4076                                              + sgot->output_offset
4077                                              + off);
4078                           outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4079                           loc = srelgot->contents;
4080                           loc += (srelgot->reloc_count++ *
4081                                   sizeof (Elf32_External_Rela));
4082                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4083                         }
4084
4085                       local_got_offsets[r_symndx] |= 1;
4086                     }
4087                 }
4088
4089               if (use_plt && bfd_link_pic (info))
4090                 {
4091                   off = ((h->plt.offset - 24) / 12 + 3) * 4;
4092                   relocation = (htab->root.sgotplt->output_offset + off
4093                                 - got_base);
4094                 }
4095               else
4096                 relocation = sgot->output_offset + off - got_base;
4097
4098               /* This relocation does not use the addend.  */
4099               rel->r_addend = 0;
4100
4101               switch (howto->type)
4102                 {
4103                 case R_NIOS2_GOT_LO:
4104                 case R_NIOS2_CALL_LO:
4105                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4106                                                     input_section, contents,
4107                                                     rel->r_offset, relocation,
4108                                                     rel->r_addend);
4109                   break;
4110                 case R_NIOS2_GOT_HA:
4111                 case R_NIOS2_CALL_HA:
4112                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4113                                                        input_section, contents,
4114                                                        rel->r_offset,
4115                                                        relocation,
4116                                                        rel->r_addend);
4117                   break;
4118                 default:
4119                   r = _bfd_final_link_relocate (howto, input_bfd,
4120                                                 input_section, contents,
4121                                                 rel->r_offset, relocation,
4122                                                 rel->r_addend);
4123                   break;
4124                 }
4125               break;
4126
4127             case R_NIOS2_GOTOFF_LO:
4128             case R_NIOS2_GOTOFF_HA:
4129             case R_NIOS2_GOTOFF:
4130               /* Relocation is relative to the global offset table pointer.  */
4131
4132               BFD_ASSERT (sgot != NULL);
4133               if (sgot == NULL)
4134                 {
4135                   r = bfd_reloc_notsupported;
4136                   break;
4137                 }
4138
4139               /* Note that sgot->output_offset is not involved in this
4140                  calculation.  We always want the start of .got.  */
4141               relocation -= sgot->output_section->vma;
4142
4143               /* Now we adjust the relocation to be relative to the GOT pointer
4144                  (the _gp_got symbol), which possibly contains the 0x8000 bias.  */
4145               relocation -= got_base;
4146
4147               switch (howto->type)
4148                 {
4149                 case R_NIOS2_GOTOFF_LO:
4150                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4151                                                     input_section, contents,
4152                                                     rel->r_offset, relocation,
4153                                                     rel->r_addend);
4154                   break;
4155                 case R_NIOS2_GOTOFF_HA:
4156                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4157                                                        input_section, contents,
4158                                                        rel->r_offset,
4159                                                        relocation,
4160                                                        rel->r_addend);
4161                   break;
4162                 default:
4163                   r = _bfd_final_link_relocate (howto, input_bfd,
4164                                                 input_section, contents,
4165                                                 rel->r_offset, relocation,
4166                                                 rel->r_addend);
4167                   break;
4168                 }
4169               break;
4170
4171             case R_NIOS2_TLS_LDO16:
4172               relocation -= dtpoff_base (info) + DTP_OFFSET;
4173
4174               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4175                                             contents, rel->r_offset,
4176                                             relocation, rel->r_addend);
4177               break;
4178             case R_NIOS2_TLS_LDM16:
4179               if (htab->root.sgot == NULL)
4180                 abort ();
4181
4182               off = htab->tls_ldm_got.offset;
4183
4184               if ((off & 1) != 0)
4185                 off &= ~1;
4186               else
4187                 {
4188                   /* If we don't know the module number, create a relocation
4189                      for it.  */
4190                   if (bfd_link_pic (info))
4191                     {
4192                       Elf_Internal_Rela outrel;
4193                       bfd_byte *loc;
4194
4195                       if (htab->root.srelgot == NULL)
4196                         abort ();
4197
4198                       outrel.r_addend = 0;
4199                       outrel.r_offset = (htab->root.sgot->output_section->vma
4200                                          + htab->root.sgot->output_offset
4201                                          + off);
4202                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
4203
4204                       loc = htab->root.srelgot->contents;
4205                       loc += (htab->root.srelgot->reloc_count++
4206                               * sizeof (Elf32_External_Rela));
4207                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4208                     }
4209                   else
4210                     bfd_put_32 (output_bfd, 1,
4211                                 htab->root.sgot->contents + off);
4212
4213                   htab->tls_ldm_got.offset |= 1;
4214                 }
4215
4216               relocation = htab->root.sgot->output_offset + off - got_base;
4217
4218               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4219                                             contents, rel->r_offset,
4220                                             relocation, rel->r_addend);
4221
4222               break;
4223             case R_NIOS2_TLS_GD16:
4224             case R_NIOS2_TLS_IE16:
4225               {
4226                 int indx;
4227                 char tls_type;
4228
4229                 if (htab->root.sgot == NULL)
4230                   abort ();
4231
4232                 indx = 0;
4233                 if (h != NULL)
4234                   {
4235                     bfd_boolean dyn;
4236                     dyn = htab->root.dynamic_sections_created;
4237                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4238                                                          bfd_link_pic (info),
4239                                                          h)
4240                         && (!bfd_link_pic (info)
4241                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
4242                       {
4243                         unresolved_reloc = FALSE;
4244                         indx = h->dynindx;
4245                       }
4246                     off = h->got.offset;
4247                     tls_type = (((struct elf32_nios2_link_hash_entry *) h)
4248                                 ->tls_type);
4249                   }
4250                 else
4251                   {
4252                     if (local_got_offsets == NULL)
4253                       abort ();
4254                     off = local_got_offsets[r_symndx];
4255                     tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
4256                                 [r_symndx]);
4257                   }
4258
4259                 if (tls_type == GOT_UNKNOWN)
4260                   abort ();
4261
4262                 if ((off & 1) != 0)
4263                   off &= ~1;
4264                 else
4265                   {
4266                     bfd_boolean need_relocs = FALSE;
4267                     Elf_Internal_Rela outrel;
4268                     bfd_byte *loc = NULL;
4269                     int cur_off = off;
4270
4271                     /* The GOT entries have not been initialized yet.  Do it
4272                        now, and emit any relocations.  If both an IE GOT and a
4273                        GD GOT are necessary, we emit the GD first.  */
4274
4275                     if ((bfd_link_pic (info) || indx != 0)
4276                         && (h == NULL
4277                             || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4278                                 && !resolved_to_zero)
4279                             || h->root.type != bfd_link_hash_undefweak))
4280                       {
4281                         need_relocs = TRUE;
4282                         if (htab->root.srelgot == NULL)
4283                           abort ();
4284                         loc = htab->root.srelgot->contents;
4285                         loc += (htab->root.srelgot->reloc_count *
4286                                 sizeof (Elf32_External_Rela));
4287                       }
4288
4289                     if (tls_type & GOT_TLS_GD)
4290                       {
4291                         if (need_relocs)
4292                           {
4293                             outrel.r_addend = 0;
4294                             outrel.r_offset = (htab->root.sgot->output_section->vma
4295                                                + htab->root.sgot->output_offset
4296                                                + cur_off);
4297                             outrel.r_info = ELF32_R_INFO (indx,
4298                                                           R_NIOS2_TLS_DTPMOD);
4299
4300                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4301                                                        loc);
4302                             htab->root.srelgot->reloc_count++;
4303                             loc += sizeof (Elf32_External_Rela);
4304
4305                             if (indx == 0)
4306                               bfd_put_32 (output_bfd,
4307                                           (relocation - dtpoff_base (info) -
4308                                            DTP_OFFSET),
4309                                           htab->root.sgot->contents + cur_off + 4);
4310                             else
4311                               {
4312                                 outrel.r_addend = 0;
4313                                 outrel.r_info = ELF32_R_INFO (indx,
4314                                   R_NIOS2_TLS_DTPREL);
4315                                 outrel.r_offset += 4;
4316
4317                                 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4318                                                            loc);
4319                                 htab->root.srelgot->reloc_count++;
4320                                 loc += sizeof (Elf32_External_Rela);
4321                               }
4322                           }
4323                         else
4324                           {
4325                             /* If we are not emitting relocations for a
4326                                general dynamic reference, then we must be in a
4327                                static link or an executable link with the
4328                                symbol binding locally.  Mark it as belonging
4329                                to module 1, the executable.  */
4330                             bfd_put_32 (output_bfd, 1,
4331                                         htab->root.sgot->contents + cur_off);
4332                             bfd_put_32 (output_bfd, (relocation -
4333                                                      dtpoff_base (info) -
4334                                                      DTP_OFFSET),
4335                                         htab->root.sgot->contents + cur_off + 4);
4336                           }
4337
4338                         cur_off += 8;
4339                       }
4340
4341                     if (tls_type & GOT_TLS_IE)
4342                       {
4343                         if (need_relocs)
4344                           {
4345                             if (indx == 0)
4346                               outrel.r_addend = (relocation -
4347                                                  dtpoff_base (info));
4348                             else
4349                               outrel.r_addend = 0;
4350                             outrel.r_offset = (htab->root.sgot->output_section->vma
4351                                                + htab->root.sgot->output_offset
4352                                                + cur_off);
4353                             outrel.r_info = ELF32_R_INFO (indx,
4354                                                           R_NIOS2_TLS_TPREL);
4355
4356                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4357                                                        loc);
4358                             htab->root.srelgot->reloc_count++;
4359                             loc += sizeof (Elf32_External_Rela);
4360                           }
4361                         else
4362                           bfd_put_32 (output_bfd, (tpoff (info, relocation)
4363                                                    - TP_OFFSET),
4364                                       htab->root.sgot->contents + cur_off);
4365                         cur_off += 4;
4366                       }
4367
4368                     if (h != NULL)
4369                       h->got.offset |= 1;
4370                     else
4371                       local_got_offsets[r_symndx] |= 1;
4372                   }
4373
4374                 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
4375                   off += 8;
4376                 relocation = htab->root.sgot->output_offset + off - got_base;
4377
4378                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4379                                               contents, rel->r_offset,
4380                                               relocation, rel->r_addend);
4381               }
4382
4383               break;
4384             case R_NIOS2_TLS_LE16:
4385               if (bfd_link_dll (info))
4386                 {
4387                   _bfd_error_handler
4388                     /* xgettext:c-format */
4389                     (_("%pB(%pA+%#" PRIx64 "): %s relocation not "
4390                        "permitted in shared object"),
4391                      input_bfd, input_section,
4392                      (uint64_t) rel->r_offset, howto->name);
4393                   return FALSE;
4394                 }
4395               else
4396                 relocation = tpoff (info, relocation) - TP_OFFSET;
4397
4398               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4399                                             contents, rel->r_offset,
4400                                             relocation, rel->r_addend);
4401               break;
4402
4403             case R_NIOS2_BFD_RELOC_32:
4404               if (bfd_link_pic (info)
4405                   && (input_section->flags & SEC_ALLOC) != 0
4406                   && (h == NULL
4407                       || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4408                           && !resolved_to_zero)
4409                       || h->root.type != bfd_link_hash_undefweak))
4410                 {
4411                   Elf_Internal_Rela outrel;
4412                   bfd_byte *loc;
4413                   bfd_boolean skip, relocate;
4414
4415                   /* When generating a shared object, these relocations
4416                      are copied into the output file to be resolved at run
4417                      time.  */
4418
4419                   skip = FALSE;
4420                   relocate = FALSE;
4421
4422                   outrel.r_offset
4423                     = _bfd_elf_section_offset (output_bfd, info,
4424                                                input_section, rel->r_offset);
4425                   if (outrel.r_offset == (bfd_vma) -1)
4426                     skip = TRUE;
4427                   else if (outrel.r_offset == (bfd_vma) -2)
4428                     skip = TRUE, relocate = TRUE;
4429                   outrel.r_offset += (input_section->output_section->vma
4430                                       + input_section->output_offset);
4431
4432                   if (skip)
4433                     memset (&outrel, 0, sizeof outrel);
4434                   else if (h != NULL
4435                            && h->dynindx != -1
4436                            && (!bfd_link_pic (info)
4437                                || !SYMBOLIC_BIND (info, h)
4438                                || !h->def_regular))
4439                     {
4440                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4441                       outrel.r_addend = rel->r_addend;
4442                     }
4443                   else
4444                     {
4445                       /* This symbol is local, or marked to become local.  */
4446                       outrel.r_addend = relocation + rel->r_addend;
4447                       relocate = TRUE;
4448                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4449                     }
4450
4451                   sreloc = elf_section_data (input_section)->sreloc;
4452                   if (sreloc == NULL)
4453                     abort ();
4454
4455                   loc = sreloc->contents;
4456                   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4457                   bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4458
4459                   /* This reloc will be computed at runtime, so there's no
4460                      need to do anything now, except for R_NIOS2_BFD_RELOC_32
4461                      relocations that have been turned into
4462                      R_NIOS2_RELATIVE.  */
4463                   if (!relocate)
4464                     break;
4465                 }
4466
4467               r = _bfd_final_link_relocate (howto, input_bfd,
4468                                             input_section, contents,
4469                                             rel->r_offset, relocation,
4470                                             rel->r_addend);
4471               break;
4472
4473             case R_NIOS2_TLS_DTPREL:
4474               relocation -= dtpoff_base (info);
4475               /* Fall through.  */
4476
4477             default:
4478               r = _bfd_final_link_relocate (howto, input_bfd,
4479                                             input_section, contents,
4480                                             rel->r_offset, relocation,
4481                                             rel->r_addend);
4482               break;
4483             }
4484         }
4485       else
4486         r = bfd_reloc_notsupported;
4487
4488       if (r != bfd_reloc_ok)
4489         {
4490           if (h != NULL)
4491             name = h->root.root.string;
4492           else
4493             {
4494               name = bfd_elf_string_from_elf_section (input_bfd,
4495                                                       symtab_hdr->sh_link,
4496                                                       sym->st_name);
4497               if (name == NULL || *name == '\0')
4498                 name = bfd_section_name (sec);
4499             }
4500
4501           switch (r)
4502             {
4503             case bfd_reloc_overflow:
4504               (*info->callbacks->reloc_overflow) (info, NULL, name,
4505                                                   howto->name, (bfd_vma) 0,
4506                                                   input_bfd, input_section,
4507                                                   rel->r_offset);
4508               break;
4509
4510             case bfd_reloc_undefined:
4511               (*info->callbacks->undefined_symbol) (info, name, input_bfd,
4512                                                     input_section,
4513                                                     rel->r_offset, TRUE);
4514               break;
4515
4516             case bfd_reloc_outofrange:
4517               if (msg == NULL)
4518                 msg = _("relocation out of range");
4519               break;
4520
4521             case bfd_reloc_notsupported:
4522               if (msg == NULL)
4523                 msg = _("unsupported relocation");
4524               break;
4525
4526             case bfd_reloc_dangerous:
4527               if (msg == NULL)
4528                 msg = _("dangerous relocation");
4529               break;
4530
4531             default:
4532               if (msg == NULL)
4533                 msg = _("unknown error");
4534               break;
4535             }
4536
4537           if (msg)
4538             {
4539               (*info->callbacks->warning) (info, msg, name, input_bfd,
4540                                            input_section, rel->r_offset);
4541               if (msgbuf)
4542                 free (msgbuf);
4543               return FALSE;
4544             }
4545         }
4546     }
4547   return TRUE;
4548 }
4549
4550 /* Implement elf-backend_section_flags:
4551    Convert NIOS2 specific section flags to bfd internal section flags.  */
4552 static bfd_boolean
4553 nios2_elf32_section_flags (const Elf_Internal_Shdr *hdr)
4554 {
4555   if (hdr->sh_flags & SHF_NIOS2_GPREL)
4556     hdr->bfd_section->flags |= SEC_SMALL_DATA;
4557
4558   return TRUE;
4559 }
4560
4561 /* Implement elf_backend_fake_sections:
4562    Set the correct type for an NIOS2 ELF section.  We do this by the
4563    section name, which is a hack, but ought to work.  */
4564 static bfd_boolean
4565 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
4566                            Elf_Internal_Shdr *hdr, asection *sec)
4567 {
4568   const char *name = bfd_section_name (sec);
4569
4570   if ((sec->flags & SEC_SMALL_DATA)
4571       || strcmp (name, ".sdata") == 0
4572       || strcmp (name, ".sbss") == 0
4573       || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
4574     hdr->sh_flags |= SHF_NIOS2_GPREL;
4575
4576   return TRUE;
4577 }
4578
4579 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4580    shortcuts to them in our hash table.  */
4581 static bfd_boolean
4582 create_got_section (bfd *dynobj, struct bfd_link_info *info)
4583 {
4584   struct elf32_nios2_link_hash_table *htab;
4585   struct elf_link_hash_entry *h;
4586
4587   htab = elf32_nios2_hash_table (info);
4588
4589   if (! _bfd_elf_create_got_section (dynobj, info))
4590     return FALSE;
4591
4592   /* In order for the two loads in .PLTresolve to share the same %hiadj,
4593      _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary.  */
4594   if (!bfd_set_section_alignment (htab->root.sgotplt, 4))
4595     return FALSE;
4596
4597   /* The Nios II ABI specifies that GOT-relative relocations are relative
4598      to the linker-created symbol _gp_got, rather than using
4599      _GLOBAL_OFFSET_TABLE_ directly.  In particular, the latter always
4600      points to the base of the GOT while _gp_got may include a bias.  */
4601   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.sgotplt,
4602                                    "_gp_got");
4603   htab->h_gp_got = h;
4604   if (h == NULL)
4605     return FALSE;
4606
4607   return TRUE;
4608 }
4609
4610 /* Implement elf_backend_create_dynamic_sections:
4611    Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4612    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4613    hash table.  */
4614 static bfd_boolean
4615 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4616 {
4617   struct elf32_nios2_link_hash_table *htab;
4618
4619   htab = elf32_nios2_hash_table (info);
4620   if (!htab->root.sgot && !create_got_section (dynobj, info))
4621     return FALSE;
4622
4623   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4624     return FALSE;
4625
4626   /* In order for the two loads in a shared object .PLTresolve to share the
4627      same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4628      to a 16-byte boundary.  This is because the addresses for these loads
4629      include the -(.plt+4) PIC correction.  */
4630   return bfd_set_section_alignment (htab->root.splt, 4);
4631 }
4632
4633 /* Implement elf_backend_copy_indirect_symbol:
4634    Copy the extra info we tack onto an elf_link_hash_entry.  */
4635 static void
4636 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
4637                                   struct elf_link_hash_entry *dir,
4638                                   struct elf_link_hash_entry *ind)
4639 {
4640   struct elf32_nios2_link_hash_entry *edir, *eind;
4641
4642   edir = (struct elf32_nios2_link_hash_entry *) dir;
4643   eind = (struct elf32_nios2_link_hash_entry *) ind;
4644
4645   if (eind->dyn_relocs != NULL)
4646     {
4647       if (edir->dyn_relocs != NULL)
4648         {
4649           struct elf_dyn_relocs **pp;
4650           struct elf_dyn_relocs *p;
4651
4652           /* Add reloc counts against the indirect sym to the direct sym
4653              list.  Merge any entries against the same section.  */
4654           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4655             {
4656               struct elf_dyn_relocs *q;
4657
4658               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4659                 if (q->sec == p->sec)
4660                   {
4661                     q->pc_count += p->pc_count;
4662                     q->count += p->count;
4663                     *pp = p->next;
4664                     break;
4665                   }
4666               if (q == NULL)
4667                 pp = &p->next;
4668             }
4669           *pp = edir->dyn_relocs;
4670         }
4671
4672       edir->dyn_relocs = eind->dyn_relocs;
4673       eind->dyn_relocs = NULL;
4674     }
4675
4676   if (ind->root.type == bfd_link_hash_indirect
4677       && dir->got.refcount <= 0)
4678     {
4679       edir->tls_type = eind->tls_type;
4680       eind->tls_type = GOT_UNKNOWN;
4681     }
4682
4683   edir->got_types_used |= eind->got_types_used;
4684
4685   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4686 }
4687
4688 /* Set the right machine number for a NIOS2 ELF file.  */
4689
4690 static bfd_boolean
4691 nios2_elf32_object_p (bfd *abfd)
4692 {
4693   unsigned long mach;
4694
4695   mach = elf_elfheader (abfd)->e_flags;
4696
4697   switch (mach)
4698     {
4699     default:
4700     case EF_NIOS2_ARCH_R1:
4701       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r1);
4702       break;
4703     case EF_NIOS2_ARCH_R2:
4704       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r2);
4705       break;
4706     }
4707
4708   return TRUE;
4709 }
4710
4711 /* Implement elf_backend_check_relocs:
4712    Look through the relocs for a section during the first phase.  */
4713 static bfd_boolean
4714 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
4715                           asection *sec, const Elf_Internal_Rela *relocs)
4716 {
4717   Elf_Internal_Shdr *symtab_hdr;
4718   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4719   const Elf_Internal_Rela *rel;
4720   const Elf_Internal_Rela *rel_end;
4721   struct elf32_nios2_link_hash_table *htab;
4722   asection *sreloc = NULL;
4723   bfd_signed_vma *local_got_refcounts;
4724
4725   if (bfd_link_relocatable (info))
4726     return TRUE;
4727
4728   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4729   sym_hashes = elf_sym_hashes (abfd);
4730   sym_hashes_end = (sym_hashes
4731                     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
4732   if (!elf_bad_symtab (abfd))
4733     sym_hashes_end -= symtab_hdr->sh_info;
4734   local_got_refcounts = elf_local_got_refcounts (abfd);
4735
4736   htab = elf32_nios2_hash_table (info);
4737
4738   rel_end = relocs + sec->reloc_count;
4739   for (rel = relocs; rel < rel_end; rel++)
4740     {
4741       unsigned int r_type;
4742       struct elf_link_hash_entry *h;
4743       unsigned long r_symndx;
4744
4745       r_symndx = ELF32_R_SYM (rel->r_info);
4746       if (r_symndx < symtab_hdr->sh_info)
4747         h = NULL;
4748       else
4749         {
4750           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4751           while (h->root.type == bfd_link_hash_indirect
4752                  || h->root.type == bfd_link_hash_warning)
4753             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4754         }
4755
4756       r_type = ELF32_R_TYPE (rel->r_info);
4757
4758       switch (r_type)
4759         {
4760         case R_NIOS2_GOT16:
4761         case R_NIOS2_GOT_LO:
4762         case R_NIOS2_GOT_HA:
4763         case R_NIOS2_CALL16:
4764         case R_NIOS2_CALL_LO:
4765         case R_NIOS2_CALL_HA:
4766         case R_NIOS2_TLS_GD16:
4767         case R_NIOS2_TLS_IE16:
4768           /* This symbol requires a global offset table entry.  */
4769           {
4770             int tls_type, old_tls_type;
4771
4772             switch (r_type)
4773               {
4774               default:
4775               case R_NIOS2_GOT16:
4776               case R_NIOS2_GOT_LO:
4777               case R_NIOS2_GOT_HA:
4778               case R_NIOS2_CALL16:
4779               case R_NIOS2_CALL_LO:
4780               case R_NIOS2_CALL_HA:
4781                 tls_type = GOT_NORMAL;
4782                 break;
4783               case R_NIOS2_TLS_GD16:
4784                 tls_type = GOT_TLS_GD;
4785                 break;
4786               case R_NIOS2_TLS_IE16:
4787                 tls_type = GOT_TLS_IE;
4788                 break;
4789               }
4790
4791             if (h != NULL)
4792               {
4793                 struct elf32_nios2_link_hash_entry *eh
4794                   = (struct elf32_nios2_link_hash_entry *)h;
4795                 h->got.refcount++;
4796                 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
4797                 if (r_type == R_NIOS2_CALL16
4798                     || r_type == R_NIOS2_CALL_LO
4799                     || r_type == R_NIOS2_CALL_HA)
4800                   {
4801                     /* Make sure a plt entry is created for this symbol if
4802                        it turns out to be a function defined by a dynamic
4803                        object.  */
4804                     h->plt.refcount++;
4805                     h->needs_plt = 1;
4806                     h->type = STT_FUNC;
4807                     eh->got_types_used |= CALL_USED;
4808                   }
4809                 else
4810                   eh->got_types_used |= GOT_USED;
4811               }
4812             else
4813               {
4814                 /* This is a global offset table entry for a local symbol.  */
4815                 if (local_got_refcounts == NULL)
4816                   {
4817                     bfd_size_type size;
4818
4819                     size = symtab_hdr->sh_info;
4820                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
4821                     local_got_refcounts
4822                       = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
4823                     if (local_got_refcounts == NULL)
4824                       return FALSE;
4825                     elf_local_got_refcounts (abfd) = local_got_refcounts;
4826                     elf32_nios2_local_got_tls_type (abfd)
4827                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4828                   }
4829                 local_got_refcounts[r_symndx]++;
4830                 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
4831               }
4832
4833             /* We will already have issued an error message if there is a
4834                TLS / non-TLS mismatch, based on the symbol type.  We don't
4835                support any linker relaxations.  So just combine any TLS
4836                types needed.  */
4837             if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4838                 && tls_type != GOT_NORMAL)
4839               tls_type |= old_tls_type;
4840
4841             if (old_tls_type != tls_type)
4842               {
4843                 if (h != NULL)
4844                   elf32_nios2_hash_entry (h)->tls_type = tls_type;
4845                 else
4846                   elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
4847               }
4848           }
4849         make_got:
4850           if (htab->root.sgot == NULL)
4851             {
4852               if (htab->root.dynobj == NULL)
4853                 htab->root.dynobj = abfd;
4854               if (!create_got_section (htab->root.dynobj, info))
4855                 return FALSE;
4856             }
4857           break;
4858
4859         case R_NIOS2_TLS_LDM16:
4860           htab->tls_ldm_got.refcount++;
4861           goto make_got;
4862
4863           /* This relocation describes the C++ object vtable hierarchy.
4864              Reconstruct it for later use during GC.  */
4865         case R_NIOS2_GNU_VTINHERIT:
4866           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4867             return FALSE;
4868           break;
4869
4870           /* This relocation describes which C++ vtable entries are actually
4871              used.  Record for later use during GC.  */
4872         case R_NIOS2_GNU_VTENTRY:
4873           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4874             return FALSE;
4875           break;
4876
4877         case R_NIOS2_BFD_RELOC_32:
4878         case R_NIOS2_CALL26:
4879         case R_NIOS2_CALL26_NOAT:
4880         case R_NIOS2_HIADJ16:
4881         case R_NIOS2_LO16:
4882
4883           if (h != NULL)
4884             {
4885               /* If this reloc is in a read-only section, we might
4886                    need a copy reloc.  We can't check reliably at this
4887                    stage whether the section is read-only, as input
4888                    sections have not yet been mapped to output sections.
4889                    Tentatively set the flag for now, and correct in
4890                    adjust_dynamic_symbol.  */
4891               if (!bfd_link_pic (info))
4892                 h->non_got_ref = 1;
4893
4894               /* Make sure a plt entry is created for this symbol if it
4895                  turns out to be a function defined by a dynamic object.  */
4896               h->plt.refcount++;
4897
4898               if (r_type == R_NIOS2_CALL26 || r_type == R_NIOS2_CALL26_NOAT)
4899                 h->needs_plt = 1;
4900             }
4901
4902           /* If we are creating a shared library, we need to copy the
4903              reloc into the shared library.  */
4904           if (bfd_link_pic (info)
4905               && (sec->flags & SEC_ALLOC) != 0
4906               && (r_type == R_NIOS2_BFD_RELOC_32
4907                   || (h != NULL && ! h->needs_plt
4908                       && (! SYMBOLIC_BIND (info, h) || ! h->def_regular))))
4909             {
4910               struct elf_dyn_relocs *p;
4911               struct elf_dyn_relocs **head;
4912
4913               /* When creating a shared object, we must copy these
4914                  reloc types into the output file.  We create a reloc
4915                  section in dynobj and make room for this reloc.  */
4916               if (sreloc == NULL)
4917                 {
4918                   if (htab->root.dynobj == NULL)
4919                     htab->root.dynobj = abfd;
4920
4921                   sreloc = _bfd_elf_make_dynamic_reloc_section
4922                     (sec, htab->root.dynobj, 2, abfd, TRUE);
4923                   if (sreloc == NULL)
4924                     return FALSE;
4925                 }
4926
4927               /* If this is a global symbol, we count the number of
4928                  relocations we need for this symbol.  */
4929               if (h != NULL)
4930                 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
4931               else
4932                 {
4933                   /* Track dynamic relocs needed for local syms too.
4934                      We really need local syms available to do this
4935                      easily.  Oh well.  */
4936
4937                   asection *s;
4938                   void *vpp;
4939                   Elf_Internal_Sym *isym;
4940
4941                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4942                                                 abfd, r_symndx);
4943                   if (isym == NULL)
4944                     return FALSE;
4945
4946                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4947                   if (s == NULL)
4948                     s = sec;
4949
4950                   vpp = &elf_section_data (s)->local_dynrel;
4951                   head = (struct elf_dyn_relocs **) vpp;
4952                 }
4953
4954               p = *head;
4955               if (p == NULL || p->sec != sec)
4956                 {
4957                   size_t amt = sizeof *p;
4958                   p = ((struct elf_dyn_relocs *)
4959                        bfd_alloc (htab->root.dynobj, amt));
4960                   if (p == NULL)
4961                     return FALSE;
4962                   p->next = *head;
4963                   *head = p;
4964                   p->sec = sec;
4965                   p->count = 0;
4966                   p->pc_count = 0;
4967                 }
4968
4969               p->count += 1;
4970
4971             }
4972           break;
4973         }
4974     }
4975
4976   return TRUE;
4977 }
4978
4979
4980 /* Implement elf_backend_gc_mark_hook:
4981    Return the section that should be marked against GC for a given
4982    relocation.  */
4983 static asection *
4984 nios2_elf32_gc_mark_hook (asection *sec,
4985                           struct bfd_link_info *info,
4986                           Elf_Internal_Rela *rel,
4987                           struct elf_link_hash_entry *h,
4988                           Elf_Internal_Sym *sym)
4989 {
4990   if (h != NULL)
4991     switch (ELF32_R_TYPE (rel->r_info))
4992       {
4993       case R_NIOS2_GNU_VTINHERIT:
4994       case R_NIOS2_GNU_VTENTRY:
4995         return NULL;
4996       }
4997   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4998 }
4999
5000 /* Implement elf_backend_finish_dynamic_symbols:
5001    Finish up dynamic symbol handling.  We set the contents of various
5002    dynamic sections here.  */
5003 static bfd_boolean
5004 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
5005                                    struct bfd_link_info *info,
5006                                    struct elf_link_hash_entry *h,
5007                                    Elf_Internal_Sym *sym)
5008 {
5009   struct elf32_nios2_link_hash_table *htab;
5010   struct elf32_nios2_link_hash_entry *eh
5011     = (struct elf32_nios2_link_hash_entry *)h;
5012   int use_plt;
5013
5014   htab = elf32_nios2_hash_table (info);
5015
5016   if (h->plt.offset != (bfd_vma) -1)
5017     {
5018       asection *splt;
5019       asection *sgotplt;
5020       asection *srela;
5021       bfd_vma plt_index;
5022       bfd_vma got_offset;
5023       Elf_Internal_Rela rela;
5024       bfd_byte *loc;
5025       bfd_vma got_address;
5026
5027       /* This symbol has an entry in the procedure linkage table.  Set
5028          it up.  */
5029       BFD_ASSERT (h->dynindx != -1);
5030       splt = htab->root.splt;
5031       sgotplt = htab->root.sgotplt;
5032       srela = htab->root.srelplt;
5033       BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
5034
5035       /* Emit the PLT entry.  */
5036       if (bfd_link_pic (info))
5037         {
5038           nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
5039                                     3);
5040           plt_index = (h->plt.offset - 24) / 12;
5041           got_offset = (plt_index + 3) * 4;
5042           nios2_elf32_install_imm16 (splt, h->plt.offset,
5043                                      hiadj(plt_index * 4));
5044           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5045                                      (plt_index * 4) & 0xffff);
5046           nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
5047                                      0xfff4 - h->plt.offset);
5048           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5049                          + got_offset);
5050
5051           /* Fill in the entry in the global offset table.  There are no
5052              res_n slots for a shared object PLT, instead the .got.plt entries
5053              point to the PLT entries.  */
5054           bfd_put_32 (output_bfd,
5055                       splt->output_section->vma + splt->output_offset
5056                       + h->plt.offset, sgotplt->contents + got_offset);
5057         }
5058       else
5059         {
5060           plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
5061           got_offset = (plt_index + 3) * 4;
5062
5063           nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
5064           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5065                          + got_offset);
5066           nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
5067           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5068                                      got_address & 0xffff);
5069
5070           /* Fill in the entry in the global offset table.  */
5071           bfd_put_32 (output_bfd,
5072                       splt->output_section->vma + splt->output_offset
5073                       + plt_index * 4, sgotplt->contents + got_offset);
5074         }
5075
5076       /* Fill in the entry in the .rela.plt section.  */
5077       rela.r_offset = got_address;
5078       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
5079       rela.r_addend = 0;
5080       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
5081       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5082
5083       if (!h->def_regular)
5084         {
5085           /* Mark the symbol as undefined, rather than as defined in
5086              the .plt section.  Leave the value alone.  */
5087           sym->st_shndx = SHN_UNDEF;
5088           /* If the symbol is weak, we do need to clear the value.
5089              Otherwise, the PLT entry would provide a definition for
5090              the symbol even if the symbol wasn't defined anywhere,
5091              and so the symbol would never be NULL.  */
5092           if (!h->ref_regular_nonweak)
5093             sym->st_value = 0;
5094         }
5095     }
5096
5097   use_plt = (eh->got_types_used == CALL_USED
5098              && h->plt.offset != (bfd_vma) -1);
5099
5100   if (!use_plt && h->got.offset != (bfd_vma) -1
5101       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5102       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5103     {
5104       asection *sgot;
5105       asection *srela;
5106       Elf_Internal_Rela rela;
5107       bfd_byte *loc;
5108       bfd_vma offset;
5109
5110       /* This symbol has an entry in the global offset table.  Set it
5111          up.  */
5112       sgot = htab->root.sgot;
5113       srela = htab->root.srelgot;
5114       BFD_ASSERT (sgot != NULL && srela != NULL);
5115
5116       offset = (h->got.offset & ~(bfd_vma) 1);
5117       rela.r_offset = (sgot->output_section->vma
5118                        + sgot->output_offset + offset);
5119
5120       /* If this is a -Bsymbolic link, and the symbol is defined
5121          locally, we just want to emit a RELATIVE reloc.  Likewise if
5122          the symbol was forced to be local because of a version file.
5123          The entry in the global offset table will already have been
5124          initialized in the relocate_section function.  */
5125
5126       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
5127         {
5128           rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
5129           rela.r_addend = bfd_get_signed_32 (output_bfd,
5130                                              (sgot->contents + offset));
5131           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
5132         }
5133       else
5134         {
5135           bfd_put_32 (output_bfd, (bfd_vma) 0,
5136                       sgot->contents + offset);
5137           rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
5138           rela.r_addend = 0;
5139         }
5140
5141       loc = srela->contents;
5142       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5143       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5144     }
5145
5146   if (use_plt && h->got.offset != (bfd_vma) -1)
5147     {
5148       bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
5149       asection *sgot = htab->root.sgot;
5150       asection *splt = htab->root.splt;
5151       bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
5152                                + h->plt.offset),
5153                   sgot->contents + offset);
5154     }
5155
5156   if (h->needs_copy)
5157     {
5158       asection *s;
5159       Elf_Internal_Rela rela;
5160       bfd_byte *loc;
5161
5162       /* This symbol needs a copy reloc.  Set it up.  */
5163       BFD_ASSERT (h->dynindx != -1
5164                   && (h->root.type == bfd_link_hash_defined
5165                       || h->root.type == bfd_link_hash_defweak));
5166
5167       rela.r_offset = (h->root.u.def.value
5168                        + h->root.u.def.section->output_section->vma
5169                        + h->root.u.def.section->output_offset);
5170       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
5171       rela.r_addend = 0;
5172       if (h->root.u.def.section == htab->root.sdynrelro)
5173         s = htab->root.sreldynrelro;
5174       else
5175         s = htab->root.srelbss;
5176       BFD_ASSERT (s != NULL);
5177       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5178       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5179     }
5180
5181   /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute.  */
5182   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5183       || h == htab->root.hgot
5184       || h == htab->h_gp_got)
5185     sym->st_shndx = SHN_ABS;
5186
5187   return TRUE;
5188 }
5189
5190 /* Implement elf_backend_finish_dynamic_sections.  */
5191 static bfd_boolean
5192 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
5193                                      struct bfd_link_info *info)
5194 {
5195   asection *sgotplt;
5196   asection *sdyn;
5197   struct elf32_nios2_link_hash_table *htab;
5198
5199   htab = elf32_nios2_hash_table (info);
5200   sgotplt = htab->root.sgotplt;
5201   sdyn = NULL;
5202
5203   if (htab->root.dynamic_sections_created)
5204     {
5205       asection *splt;
5206       Elf32_External_Dyn *dyncon, *dynconend;
5207
5208       splt = htab->root.splt;
5209       sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
5210       BFD_ASSERT (splt != NULL && sdyn != NULL && sgotplt != NULL);
5211
5212       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5213       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5214       for (; dyncon < dynconend; dyncon++)
5215         {
5216           Elf_Internal_Dyn dyn;
5217           asection *s;
5218
5219           bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
5220
5221           switch (dyn.d_tag)
5222             {
5223             default:
5224               break;
5225
5226             case DT_PLTGOT:
5227               s = htab->root.sgotplt;
5228               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5229               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5230               break;
5231
5232             case DT_JMPREL:
5233               s = htab->root.srelplt;
5234               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5235               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5236               break;
5237
5238             case DT_PLTRELSZ:
5239               s = htab->root.srelplt;
5240               dyn.d_un.d_val = s->size;
5241               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5242               break;
5243
5244             case DT_NIOS2_GP:
5245               s = htab->root.sgotplt;
5246               dyn.d_un.d_ptr
5247                 = s->output_section->vma + s->output_offset + 0x7ff0;
5248               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5249               break;
5250             }
5251         }
5252
5253       /* Fill in the first entry in the procedure linkage table.  */
5254       if (splt->size > 0)
5255         {
5256           bfd_vma got_address = (sgotplt->output_section->vma
5257                                  + sgotplt->output_offset);
5258           if (bfd_link_pic (info))
5259             {
5260               bfd_vma got_pcrel = got_address - (splt->output_section->vma
5261                                                  + splt->output_offset);
5262               /* Both GOT and PLT must be aligned to a 16-byte boundary
5263                  for the two loads to share the %hiadj part.  The 4-byte
5264                  offset for nextpc is accounted for in the %lo offsets
5265                  on the loads.  */
5266               BFD_ASSERT ((got_pcrel & 0xf) == 0);
5267               nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
5268               nios2_elf32_install_imm16 (splt, 4, hiadj (got_pcrel));
5269               nios2_elf32_install_imm16 (splt, 12, got_pcrel & 0xffff);
5270               nios2_elf32_install_imm16 (splt, 16, (got_pcrel + 4) & 0xffff);
5271             }
5272           else
5273             {
5274               /* Divide by 4 here, not 3 because we already corrected for the
5275                  res_N branches.  */
5276               bfd_vma res_size = (splt->size - 28) / 4;
5277               bfd_vma res_start = (splt->output_section->vma
5278                                    + splt->output_offset);
5279               bfd_vma res_offset;
5280
5281               for (res_offset = 0; res_offset < res_size; res_offset += 4)
5282                 bfd_put_32 (output_bfd,
5283                             6 | ((res_size - (res_offset + 4)) << 6),
5284                             splt->contents + res_offset);
5285
5286               /* The GOT must be aligned to a 16-byte boundary for the
5287                  two loads to share the same %hiadj part.  */
5288               BFD_ASSERT ((got_address & 0xf) == 0);
5289
5290               nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
5291               nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
5292               nios2_elf32_install_imm16 (splt, res_size + 4,
5293                                          res_start & 0xffff);
5294               nios2_elf32_install_imm16 (splt, res_size + 12,
5295                                          hiadj (got_address));
5296               nios2_elf32_install_imm16 (splt, res_size + 16,
5297                                          (got_address + 4) & 0xffff);
5298               nios2_elf32_install_imm16 (splt, res_size + 20,
5299                                          (got_address + 8) & 0xffff);
5300             }
5301         }
5302     }
5303
5304   /* Fill in the first three entries in the global offset table.  */
5305   if (sgotplt != NULL && sgotplt->size > 0)
5306     {
5307       if (sdyn == NULL)
5308         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
5309       else
5310         bfd_put_32 (output_bfd,
5311                     sdyn->output_section->vma + sdyn->output_offset,
5312                     sgotplt->contents);
5313       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
5314       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
5315
5316       if (sgotplt->output_section != bfd_abs_section_ptr)
5317         elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
5318     }
5319
5320   return TRUE;
5321 }
5322
5323 /* Implement elf_backend_adjust_dynamic_symbol:
5324    Adjust a symbol defined by a dynamic object and referenced by a
5325    regular object.  The current definition is in some section of the
5326    dynamic object, but we're not including those sections.  We have to
5327    change the definition to something the rest of the link can
5328    understand.  */
5329 static bfd_boolean
5330 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
5331                                    struct elf_link_hash_entry *h)
5332 {
5333   struct elf32_nios2_link_hash_table *htab;
5334   bfd *dynobj;
5335   asection *s, *srel;
5336   unsigned align2;
5337
5338   htab = elf32_nios2_hash_table (info);
5339   dynobj = htab->root.dynobj;
5340
5341   /* Make sure we know what is going on here.  */
5342   BFD_ASSERT (dynobj != NULL
5343               && (h->needs_plt
5344                   || h->is_weakalias
5345                   || (h->def_dynamic
5346                       && h->ref_regular
5347                       && !h->def_regular)));
5348
5349   /* If this is a function, put it in the procedure linkage table.  We
5350      will fill in the contents of the procedure linkage table later,
5351      when we know the address of the .got section.  */
5352   if (h->type == STT_FUNC || h->needs_plt)
5353     {
5354       if (h->plt.refcount <= 0
5355           || SYMBOL_CALLS_LOCAL (info, h)
5356           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5357               && h->root.type == bfd_link_hash_undefweak))
5358         {
5359           /* This case can occur if we saw a PLT reloc in an input
5360              file, but the symbol was never referred to by a dynamic
5361              object, or if all references were garbage collected.  In
5362              such a case, we don't actually need to build a procedure
5363              linkage table, and we can just do a PCREL reloc instead.  */
5364           h->plt.offset = (bfd_vma) -1;
5365           h->needs_plt = 0;
5366         }
5367
5368       return TRUE;
5369     }
5370
5371   /* Reinitialize the plt offset now that it is not used as a reference
5372      count any more.  */
5373   h->plt.offset = (bfd_vma) -1;
5374
5375   /* If this is a weak symbol, and there is a real definition, the
5376      processor independent code will have arranged for us to see the
5377      real definition first, and we can just use the same value.  */
5378   if (h->is_weakalias)
5379     {
5380       struct elf_link_hash_entry *def = weakdef (h);
5381       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
5382       h->root.u.def.section = def->root.u.def.section;
5383       h->root.u.def.value = def->root.u.def.value;
5384       return TRUE;
5385     }
5386
5387   /* If there are no non-GOT references, we do not need a copy
5388      relocation.  */
5389   if (!h->non_got_ref)
5390     return TRUE;
5391
5392   /* This is a reference to a symbol defined by a dynamic object which
5393      is not a function.
5394      If we are creating a shared library, we must presume that the
5395      only references to the symbol are via the global offset table.
5396      For such cases we need not do anything here; the relocations will
5397      be handled correctly by relocate_section.  */
5398   if (bfd_link_pic (info))
5399     return TRUE;
5400
5401   if (h->size == 0)
5402     {
5403       _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5404                           h->root.root.string);
5405       return TRUE;
5406     }
5407
5408   /* We must allocate the symbol in our .dynbss section, which will
5409      become part of the .bss section of the executable.  There will be
5410      an entry for this symbol in the .dynsym section.  The dynamic
5411      object will contain position independent code, so all references
5412      from the dynamic object to this symbol will go through the global
5413      offset table.  The dynamic linker will use the .dynsym entry to
5414      determine the address it must put in the global offset table, so
5415      both the dynamic object and the regular object will refer to the
5416      same memory location for the variable.  */
5417   /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5418      copy the initial value out of the dynamic object and into the
5419      runtime process image.  We need to remember the offset into the
5420      .rela.bss section we are going to use.  */
5421   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5422     {
5423       s = htab->root.sdynrelro;
5424       srel = htab->root.sreldynrelro;
5425     }
5426   else
5427     {
5428       s = htab->root.sdynbss;
5429       srel = htab->root.srelbss;
5430     }
5431   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5432     {
5433       srel->size += sizeof (Elf32_External_Rela);
5434       h->needs_copy = 1;
5435     }
5436
5437   align2 = bfd_log2 (h->size);
5438   if (align2 > h->root.u.def.section->alignment_power)
5439     align2 = h->root.u.def.section->alignment_power;
5440
5441   /* Align dynbss.  */
5442   s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
5443   if (align2 > bfd_section_alignment (s)
5444       && !bfd_set_section_alignment (s, align2))
5445     return FALSE;
5446
5447   /* Define the symbol as being at this point in the section.  */
5448   h->root.u.def.section = s;
5449   h->root.u.def.value = s->size;
5450
5451   /* Increment the section size to make room for the symbol.  */
5452   s->size += h->size;
5453
5454   return TRUE;
5455 }
5456
5457 /* Worker function for nios2_elf32_size_dynamic_sections.  */
5458 static bfd_boolean
5459 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5460 {
5461   struct bfd_link_info *info;
5462   struct elf32_nios2_link_hash_table *htab;
5463
5464   if (h->root.type == bfd_link_hash_indirect)
5465     return TRUE;
5466
5467   if (h->root.type == bfd_link_hash_warning)
5468     /* When warning symbols are created, they **replace** the "real"
5469        entry in the hash table, thus we never get to see the real
5470        symbol in a hash traversal.  So look at it now.  */
5471     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5472
5473   info = (struct bfd_link_info *) inf;
5474   htab = elf32_nios2_hash_table (info);
5475
5476   if (h->plt.offset != (bfd_vma)-1)
5477     h->plt.offset += htab->res_n_size;
5478   if (htab->root.splt == h->root.u.def.section)
5479     h->root.u.def.value += htab->res_n_size;
5480
5481   return TRUE;
5482 }
5483
5484 /* Another worker function for nios2_elf32_size_dynamic_sections.
5485    Allocate space in .plt, .got and associated reloc sections for
5486    dynamic relocs.  */
5487 static bfd_boolean
5488 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5489 {
5490   struct bfd_link_info *info;
5491   struct elf32_nios2_link_hash_table *htab;
5492   struct elf32_nios2_link_hash_entry *eh;
5493   struct elf_dyn_relocs *p;
5494   int use_plt;
5495
5496   if (h->root.type == bfd_link_hash_indirect)
5497     return TRUE;
5498
5499   if (h->root.type == bfd_link_hash_warning)
5500     /* When warning symbols are created, they **replace** the "real"
5501        entry in the hash table, thus we never get to see the real
5502        symbol in a hash traversal.  So look at it now.  */
5503     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5504
5505   info = (struct bfd_link_info *) inf;
5506   htab = elf32_nios2_hash_table (info);
5507
5508   if (htab->root.dynamic_sections_created
5509       && h->plt.refcount > 0)
5510     {
5511       /* Make sure this symbol is output as a dynamic symbol.
5512          Undefined weak syms won't yet be marked as dynamic.  */
5513       if (h->dynindx == -1
5514           && !h->forced_local
5515           && !bfd_elf_link_record_dynamic_symbol (info, h))
5516         return FALSE;
5517
5518       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
5519         {
5520           asection *s = htab->root.splt;
5521
5522           /* Allocate room for the header.  */
5523           if (s->size == 0)
5524             {
5525               if (bfd_link_pic (info))
5526                 s->size = 24;
5527               else
5528                 s->size = 28;
5529             }
5530
5531           h->plt.offset = s->size;
5532
5533           /* If this symbol is not defined in a regular file, and we are
5534              not generating a shared library, then set the symbol to this
5535              location in the .plt.  This is required to make function
5536              pointers compare as equal between the normal executable and
5537              the shared library.  */
5538           if (! bfd_link_pic (info)
5539               && !h->def_regular)
5540             {
5541               h->root.u.def.section = s;
5542               h->root.u.def.value = h->plt.offset;
5543             }
5544
5545           /* Make room for this entry.  */
5546           s->size += 12;
5547
5548           /* We also need to make an entry in the .rela.plt section.  */
5549           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
5550
5551           /* And the .got.plt section.  */
5552           htab->root.sgotplt->size += 4;
5553         }
5554       else
5555         {
5556           h->plt.offset = (bfd_vma) -1;
5557           h->needs_plt = 0;
5558         }
5559     }
5560   else
5561     {
5562       h->plt.offset = (bfd_vma) -1;
5563       h->needs_plt = 0;
5564     }
5565
5566   eh = (struct elf32_nios2_link_hash_entry *) h;
5567   use_plt = (eh->got_types_used == CALL_USED
5568              && h->plt.offset != (bfd_vma) -1);
5569
5570   if (h->got.refcount > 0)
5571     {
5572       asection *s;
5573       bfd_boolean dyn;
5574       int tls_type = eh->tls_type;
5575       int indx;
5576
5577       /* Make sure this symbol is output as a dynamic symbol.
5578          Undefined weak syms won't yet be marked as dynamic.  */
5579       if (h->dynindx == -1
5580           && !h->forced_local
5581           && !bfd_elf_link_record_dynamic_symbol (info, h))
5582         return FALSE;
5583
5584       s = htab->root.sgot;
5585       h->got.offset = s->size;
5586
5587       if (tls_type == GOT_UNKNOWN)
5588         abort ();
5589
5590       if (tls_type == GOT_NORMAL)
5591         /* Non-TLS symbols need one GOT slot.  */
5592         s->size += 4;
5593       else
5594         {
5595           if (tls_type & GOT_TLS_GD)
5596             /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots.  */
5597             s->size += 8;
5598           if (tls_type & GOT_TLS_IE)
5599             /* R_NIOS2_TLS_IE16 needs one GOT slot.  */
5600             s->size += 4;
5601         }
5602
5603       dyn = htab->root.dynamic_sections_created;
5604
5605       indx = 0;
5606       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5607           && (!bfd_link_pic (info)
5608               || !SYMBOL_REFERENCES_LOCAL (info, h)))
5609         indx = h->dynindx;
5610
5611       if (tls_type != GOT_NORMAL
5612           && (bfd_link_pic (info) || indx != 0)
5613           && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5614               || h->root.type != bfd_link_hash_undefweak))
5615         {
5616           if (tls_type & GOT_TLS_IE)
5617             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5618
5619           if (tls_type & GOT_TLS_GD)
5620             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5621
5622           if ((tls_type & GOT_TLS_GD) && indx != 0)
5623             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5624         }
5625       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5626                 || h->root.type != bfd_link_hash_undefweak)
5627                && !use_plt
5628                && (bfd_link_pic (info)
5629                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5630         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5631     }
5632   else
5633     h->got.offset = (bfd_vma) -1;
5634
5635   if (eh->dyn_relocs == NULL)
5636     return TRUE;
5637
5638   /* In the shared -Bsymbolic case, discard space allocated for
5639      dynamic pc-relative relocs against symbols which turn out to be
5640      defined in regular objects.  For the normal shared case, discard
5641      space for pc-relative relocs that have become local due to symbol
5642      visibility changes.  */
5643
5644   if (bfd_link_pic (info))
5645     {
5646       if (h->def_regular
5647           && (h->forced_local || SYMBOLIC_BIND (info, h)))
5648         {
5649           struct elf_dyn_relocs **pp;
5650
5651           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5652             {
5653               p->count -= p->pc_count;
5654               p->pc_count = 0;
5655               if (p->count == 0)
5656                 *pp = p->next;
5657               else
5658                 pp = &p->next;
5659             }
5660         }
5661
5662       /* Also discard relocs on undefined weak syms with non-default
5663          visibility.  */
5664       if (eh->dyn_relocs != NULL
5665           && h->root.type == bfd_link_hash_undefweak)
5666         {
5667           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5668               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5669             eh->dyn_relocs = NULL;
5670
5671           /* Make sure undefined weak symbols are output as a dynamic
5672              symbol in PIEs.  */
5673           else if (h->dynindx == -1
5674                    && !h->forced_local
5675                    && !bfd_elf_link_record_dynamic_symbol (info, h))
5676             return FALSE;
5677         }
5678     }
5679   else
5680     {
5681       /* For the non-shared case, discard space for relocs against
5682          symbols which turn out to need copy relocs or are not
5683          dynamic.  */
5684
5685       if (!h->non_got_ref
5686           && ((h->def_dynamic && !h->def_regular)
5687               || (htab->root.dynamic_sections_created
5688                   && (h->root.type == bfd_link_hash_undefweak
5689                       || h->root.type == bfd_link_hash_undefined))))
5690         {
5691           /* Make sure this symbol is output as a dynamic symbol.
5692              Undefined weak syms won't yet be marked as dynamic.  */
5693           if (h->dynindx == -1
5694               && !h->forced_local
5695               && !bfd_elf_link_record_dynamic_symbol (info, h))
5696             return FALSE;
5697
5698           /* If that succeeded, we know we'll be keeping all the
5699              relocs.  */
5700           if (h->dynindx != -1)
5701             goto keep;
5702         }
5703
5704       eh->dyn_relocs = NULL;
5705
5706     keep: ;
5707     }
5708
5709   /* Finally, allocate space.  */
5710   for (p = eh->dyn_relocs; p != NULL; p = p->next)
5711     {
5712       asection *sreloc = elf_section_data (p->sec)->sreloc;
5713       sreloc->size += p->count * sizeof (Elf32_External_Rela);
5714     }
5715
5716   return TRUE;
5717 }
5718
5719 /* Implement elf_backend_size_dynamic_sections:
5720    Set the sizes of the dynamic sections.  */
5721 static bfd_boolean
5722 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5723                                    struct bfd_link_info *info)
5724 {
5725   bfd *dynobj;
5726   asection *s;
5727   bfd_boolean relocs;
5728   bfd *ibfd;
5729   struct elf32_nios2_link_hash_table *htab;
5730
5731   htab = elf32_nios2_hash_table (info);
5732   dynobj = htab->root.dynobj;
5733   BFD_ASSERT (dynobj != NULL);
5734
5735   htab->res_n_size = 0;
5736   if (htab->root.dynamic_sections_created)
5737     {
5738       /* Set the contents of the .interp section to the interpreter.  */
5739       if (bfd_link_executable (info) && !info->nointerp)
5740         {
5741           s = bfd_get_linker_section (dynobj, ".interp");
5742           BFD_ASSERT (s != NULL);
5743           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5744           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5745         }
5746     }
5747   else
5748     {
5749       /* We may have created entries in the .rela.got section.
5750          However, if we are not creating the dynamic sections, we will
5751          not actually use these entries.  Reset the size of .rela.got,
5752          which will cause it to get stripped from the output file
5753          below.  */
5754       s = htab->root.srelgot;
5755       if (s != NULL)
5756         s->size = 0;
5757     }
5758
5759   /* Set up .got offsets for local syms, and space for local dynamic
5760      relocs.  */
5761   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5762     {
5763       bfd_signed_vma *local_got;
5764       bfd_signed_vma *end_local_got;
5765       char *local_tls_type;
5766       bfd_size_type locsymcount;
5767       Elf_Internal_Shdr *symtab_hdr;
5768       asection *srel;
5769
5770       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5771         continue;
5772
5773       for (s = ibfd->sections; s != NULL; s = s->next)
5774         {
5775           struct elf_dyn_relocs *p;
5776
5777           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
5778             {
5779               if (!bfd_is_abs_section (p->sec)
5780                   && bfd_is_abs_section (p->sec->output_section))
5781                 {
5782                   /* Input section has been discarded, either because
5783                      it is a copy of a linkonce section or due to
5784                      linker script /DISCARD/, so we'll be discarding
5785                      the relocs too.  */
5786                 }
5787               else if (p->count != 0)
5788                 {
5789                   srel = elf_section_data (p->sec)->sreloc;
5790                   srel->size += p->count * sizeof (Elf32_External_Rela);
5791                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
5792                     info->flags |= DF_TEXTREL;
5793                 }
5794             }
5795         }
5796
5797       local_got = elf_local_got_refcounts (ibfd);
5798       if (!local_got)
5799         continue;
5800
5801       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5802       locsymcount = symtab_hdr->sh_info;
5803       end_local_got = local_got + locsymcount;
5804       local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
5805       s = htab->root.sgot;
5806       srel = htab->root.srelgot;
5807       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5808         {
5809           if (*local_got > 0)
5810             {
5811               *local_got = s->size;
5812               if (*local_tls_type & GOT_TLS_GD)
5813                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5814                 s->size += 8;
5815               if (*local_tls_type & GOT_TLS_IE)
5816                 s->size += 4;
5817               if (*local_tls_type == GOT_NORMAL)
5818                 s->size += 4;
5819
5820               if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
5821                 srel->size += sizeof (Elf32_External_Rela);
5822             }
5823           else
5824             *local_got = (bfd_vma) -1;
5825         }
5826     }
5827
5828   if (htab->tls_ldm_got.refcount > 0)
5829     {
5830       /* Allocate two GOT entries and one dynamic relocation (if necessary)
5831          for R_NIOS2_TLS_LDM16 relocations.  */
5832       htab->tls_ldm_got.offset = htab->root.sgot->size;
5833       htab->root.sgot->size += 8;
5834       if (bfd_link_pic (info))
5835         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5836     }
5837   else
5838     htab->tls_ldm_got.offset = -1;
5839
5840   /* Allocate global sym .plt and .got entries, and space for global
5841      sym dynamic relocs.  */
5842   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5843
5844   if (htab->root.dynamic_sections_created)
5845     {
5846       /* If the .got section is more than 0x8000 bytes, we add
5847          0x8000 to the value of _gp_got, so that 16-bit relocations
5848          have a greater chance of working. */
5849       if (htab->root.sgot->size >= 0x8000
5850           && htab->h_gp_got->root.u.def.value == 0)
5851         htab->h_gp_got->root.u.def.value = 0x8000;
5852     }
5853
5854   /* The check_relocs and adjust_dynamic_symbol entry points have
5855      determined the sizes of the various dynamic sections.  Allocate
5856      memory for them.  */
5857   relocs = FALSE;
5858   for (s = dynobj->sections; s != NULL; s = s->next)
5859     {
5860       const char *name;
5861
5862       if ((s->flags & SEC_LINKER_CREATED) == 0)
5863         continue;
5864
5865       /* It's OK to base decisions on the section name, because none
5866          of the dynobj section names depend upon the input files.  */
5867       name = bfd_section_name (s);
5868
5869       if (CONST_STRNEQ (name, ".rela"))
5870         {
5871           if (s->size != 0)
5872             {
5873               if (s != htab->root.srelplt)
5874                 relocs = TRUE;
5875
5876               /* We use the reloc_count field as a counter if we need
5877                  to copy relocs into the output file.  */
5878               s->reloc_count = 0;
5879             }
5880         }
5881       else if (s == htab->root.splt)
5882         {
5883           /* Correct for the number of res_N branches.  */
5884           if (s->size != 0 && !bfd_link_pic (info))
5885             {
5886               htab->res_n_size = (s->size - 28) / 3;
5887               s->size += htab->res_n_size;
5888             }
5889         }
5890       else if (s != htab->sbss
5891                && s != htab->root.sgot
5892                && s != htab->root.sgotplt
5893                && s != htab->root.sdynbss
5894                && s != htab->root.sdynrelro)
5895         /* It's not one of our sections, so don't allocate space.  */
5896         continue;
5897
5898       if (s->size == 0)
5899         {
5900           s->flags |= SEC_EXCLUDE;
5901           continue;
5902         }
5903
5904       if ((s->flags & SEC_HAS_CONTENTS) == 0)
5905         continue;
5906
5907       /* Allocate memory for the section contents.  */
5908       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5909       if (s->contents == NULL)
5910         return FALSE;
5911     }
5912
5913   /* Adjust dynamic symbols that point to the plt to account for the
5914      now-known number of resN slots.  */
5915   if (htab->res_n_size)
5916     elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
5917
5918   if (htab->root.dynamic_sections_created)
5919     {
5920       /* Add some entries to the .dynamic section.  We fill in the
5921          values later, in elf_nios2_finish_dynamic_sections, but we
5922          must add the entries now so that we get the correct size for
5923          the .dynamic section.  The DT_DEBUG entry is filled in by the
5924          dynamic linker and used by the debugger.  */
5925 #define add_dynamic_entry(TAG, VAL) \
5926   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5927
5928       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_DEBUG, 0))
5929         return FALSE;
5930
5931       if (htab->root.sgotplt->size != 0
5932           && !add_dynamic_entry (DT_PLTGOT, 0))
5933         return FALSE;
5934
5935       if (htab->root.splt->size != 0
5936           && (!add_dynamic_entry (DT_PLTRELSZ, 0)
5937               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5938               || !add_dynamic_entry (DT_JMPREL, 0)))
5939         return FALSE;
5940
5941       if (relocs
5942           && (!add_dynamic_entry (DT_RELA, 0)
5943               || !add_dynamic_entry (DT_RELASZ, 0)
5944               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
5945         return FALSE;
5946
5947       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_NIOS2_GP, 0))
5948         return FALSE;
5949
5950       if ((info->flags & DF_TEXTREL) != 0
5951           && !add_dynamic_entry (DT_TEXTREL, 0))
5952         return FALSE;
5953     }
5954 #undef add_dynamic_entry
5955
5956   return TRUE;
5957 }
5958
5959 /* Free the derived linker hash table.  */
5960 static void
5961 nios2_elf32_link_hash_table_free (bfd *obfd)
5962 {
5963   struct elf32_nios2_link_hash_table *htab
5964     = (struct elf32_nios2_link_hash_table *) obfd->link.hash;
5965
5966   bfd_hash_table_free (&htab->bstab);
5967   _bfd_elf_link_hash_table_free (obfd);
5968 }
5969
5970 /* Implement bfd_elf32_bfd_link_hash_table_create.  */
5971 static struct bfd_link_hash_table *
5972 nios2_elf32_link_hash_table_create (bfd *abfd)
5973 {
5974   struct elf32_nios2_link_hash_table *ret;
5975   size_t amt = sizeof (struct elf32_nios2_link_hash_table);
5976
5977   ret = bfd_zmalloc (amt);
5978   if (ret == NULL)
5979     return NULL;
5980
5981   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5982                                       link_hash_newfunc,
5983                                       sizeof (struct
5984                                               elf32_nios2_link_hash_entry),
5985                                       NIOS2_ELF_DATA))
5986     {
5987       free (ret);
5988       return NULL;
5989     }
5990
5991   /* Init the stub hash table too.  */
5992   if (!bfd_hash_table_init (&ret->bstab, stub_hash_newfunc,
5993                             sizeof (struct elf32_nios2_stub_hash_entry)))
5994     {
5995       _bfd_elf_link_hash_table_free (abfd);
5996       return NULL;
5997     }
5998   ret->root.root.hash_table_free = nios2_elf32_link_hash_table_free;
5999
6000   return &ret->root.root;
6001 }
6002
6003 /* Implement elf_backend_reloc_type_class.  */
6004 static enum elf_reloc_type_class
6005 nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
6006                               const asection *rel_sec ATTRIBUTE_UNUSED,
6007                               const Elf_Internal_Rela *rela)
6008 {
6009   switch ((int) ELF32_R_TYPE (rela->r_info))
6010     {
6011     case R_NIOS2_RELATIVE:
6012       return reloc_class_relative;
6013     case R_NIOS2_JUMP_SLOT:
6014       return reloc_class_plt;
6015     case R_NIOS2_COPY:
6016       return reloc_class_copy;
6017     default:
6018       return reloc_class_normal;
6019     }
6020 }
6021
6022 /* Return 1 if target is one of ours.  */
6023 static bfd_boolean
6024 is_nios2_elf_target (const struct bfd_target *targ)
6025 {
6026   return (targ == &nios2_elf32_le_vec
6027           || targ == &nios2_elf32_be_vec);
6028 }
6029
6030 /* Implement elf_backend_add_symbol_hook.
6031    This hook is called by the linker when adding symbols from an object
6032    file.  We use it to put .comm items in .sbss, and not .bss.  */
6033 static bfd_boolean
6034 nios2_elf_add_symbol_hook (bfd *abfd,
6035                            struct bfd_link_info *info,
6036                            Elf_Internal_Sym *sym,
6037                            const char **namep ATTRIBUTE_UNUSED,
6038                            flagword *flagsp ATTRIBUTE_UNUSED,
6039                            asection **secp,
6040                            bfd_vma *valp)
6041 {
6042   if (sym->st_shndx == SHN_COMMON
6043       && !bfd_link_relocatable (info)
6044       && sym->st_size <= elf_gp_size (abfd)
6045       && is_nios2_elf_target (info->output_bfd->xvec))
6046     {
6047       /* Common symbols less than or equal to -G nn bytes are automatically
6048          put into .sbss.  */
6049       struct elf32_nios2_link_hash_table *htab;
6050
6051       htab = elf32_nios2_hash_table (info);
6052       if (htab->sbss == NULL)
6053         {
6054           flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
6055
6056           if (htab->root.dynobj == NULL)
6057             htab->root.dynobj = abfd;
6058
6059           htab->sbss = bfd_make_section_anyway_with_flags (htab->root.dynobj,
6060                                                            ".sbss", flags);
6061           if (htab->sbss == NULL)
6062             return FALSE;
6063         }
6064
6065       *secp = htab->sbss;
6066       *valp = sym->st_size;
6067     }
6068
6069   return TRUE;
6070 }
6071
6072 /* Implement elf_backend_can_make_relative_eh_frame:
6073    Decide whether to attempt to turn absptr or lsda encodings in
6074    shared libraries into pcrel within the given input section.  */
6075 static bfd_boolean
6076 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6077                                         struct bfd_link_info *info
6078                                         ATTRIBUTE_UNUSED,
6079                                         asection *eh_frame_section
6080                                         ATTRIBUTE_UNUSED)
6081 {
6082   /* We can't use PC-relative encodings in the .eh_frame section.  */
6083   return FALSE;
6084 }
6085
6086 /* Implement elf_backend_special_sections.  */
6087 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
6088 {
6089   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,
6090     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6091   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
6092     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6093   { NULL,                     0,  0, 0,              0 }
6094 };
6095
6096 #define ELF_ARCH                        bfd_arch_nios2
6097 #define ELF_TARGET_ID                   NIOS2_ELF_DATA
6098 #define ELF_MACHINE_CODE                EM_ALTERA_NIOS2
6099
6100 /* The Nios II MMU uses a 4K page size.  */
6101
6102 #define ELF_MAXPAGESIZE                 0x1000
6103
6104 #define bfd_elf32_bfd_link_hash_table_create \
6105                                           nios2_elf32_link_hash_table_create
6106
6107 #define bfd_elf32_bfd_merge_private_bfd_data \
6108                                           nios2_elf32_merge_private_bfd_data
6109
6110 /* Relocation table lookup macros.  */
6111
6112 #define bfd_elf32_bfd_reloc_type_lookup   nios2_elf32_bfd_reloc_type_lookup
6113 #define bfd_elf32_bfd_reloc_name_lookup   nios2_elf32_bfd_reloc_name_lookup
6114
6115 /* JUMP_TABLE_LINK macros.  */
6116
6117 /* elf_info_to_howto (using RELA relocations).  */
6118
6119 #define elf_info_to_howto                 nios2_elf32_info_to_howto
6120
6121 /* elf backend functions.  */
6122
6123 #define elf_backend_can_gc_sections     1
6124 #define elf_backend_can_refcount        1
6125 #define elf_backend_plt_readonly        1
6126 #define elf_backend_want_got_plt        1
6127 #define elf_backend_want_dynrelro       1
6128 #define elf_backend_rela_normal         1
6129 #define elf_backend_dtrel_excludes_plt  1
6130
6131 #define elf_backend_relocate_section      nios2_elf32_relocate_section
6132 #define elf_backend_section_flags         nios2_elf32_section_flags
6133 #define elf_backend_fake_sections         nios2_elf32_fake_sections
6134 #define elf_backend_check_relocs          nios2_elf32_check_relocs
6135
6136 #define elf_backend_gc_mark_hook          nios2_elf32_gc_mark_hook
6137 #define elf_backend_create_dynamic_sections \
6138                                           nios2_elf32_create_dynamic_sections
6139 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6140 #define elf_backend_finish_dynamic_sections \
6141                                           nios2_elf32_finish_dynamic_sections
6142 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6143 #define elf_backend_reloc_type_class      nios2_elf32_reloc_type_class
6144 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6145 #define elf_backend_add_symbol_hook       nios2_elf_add_symbol_hook
6146 #define elf_backend_copy_indirect_symbol  nios2_elf32_copy_indirect_symbol
6147 #define elf_backend_object_p              nios2_elf32_object_p
6148
6149 #define elf_backend_grok_prstatus         nios2_grok_prstatus
6150 #define elf_backend_grok_psinfo           nios2_grok_psinfo
6151
6152 #undef elf_backend_can_make_relative_eh_frame
6153 #define elf_backend_can_make_relative_eh_frame \
6154                                           nios2_elf32_can_make_relative_eh_frame
6155
6156 #define elf_backend_special_sections      elf32_nios2_special_sections
6157
6158 #define TARGET_LITTLE_SYM               nios2_elf32_le_vec
6159 #define TARGET_LITTLE_NAME              "elf32-littlenios2"
6160 #define TARGET_BIG_SYM                  nios2_elf32_be_vec
6161 #define TARGET_BIG_NAME                 "elf32-bignios2"
6162
6163 #define elf_backend_got_header_size     12
6164 #define elf_backend_default_execstack   0
6165
6166 #include "elf32-target.h"