bfd/elf32-nios2.c

   1 /* 32-bit ELF support for Nios II.
   2    Copyright (C) 2012-2019 Free Software Foundation, Inc.
   3    Contributed by Nigel Gray (ngray@altera.com).
   4    Contributed by Mentor Graphics, Inc.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 /* This file handles Altera Nios II ELF targets.  */
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "libbfd.h"
  28 #include "bfdlink.h"
  29 #include "genlink.h"
  30 #include "elf-bfd.h"
  31 #include "elf/nios2.h"
  32 #include "opcode/nios2.h"
  33 #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   bfd_size_type 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
2494   /* Make a note of the offset within the stubs for this entry.  */
2495   hsh->stub_offset = stub_sec->size;
2496
2497   switch (hsh->stub_type)
2498     {
2499     case nios2_stub_call26_before:
2500     case nios2_stub_call26_after:
2501       /* A call26 stub looks like:
2502            orhi at, %hiadj(dest)
2503            addi at, at, %lo(dest)
2504            jmp at
2505          Note that call/jmpi instructions can't be used in PIC code
2506          so there is no reason for the stub to be PIC, either.  */
2507       sym_value = (hsh->target_value
2508                    + hsh->target_section->output_offset
2509                    + hsh->target_section->output_section->vma
2510                    + hsh->addend);
2511
2512       nios2_elf32_install_data (stub_sec, nios2_call26_stub_entry,
2513                                 hsh->stub_offset, 3);
2514       nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset,
2515                                  hiadj (sym_value));
2516       nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset + 4,
2517                                  (sym_value & 0xffff));
2518       stub_sec->size += 12;
2519       break;
2520     default:
2521       BFD_FAIL ();
2522       return FALSE;
2523     }
2524
2525   return TRUE;
2526 }
2527
2528 /* As above, but don't actually build the stub.  Just bump offset so
2529    we know stub section sizes.  */
2530 static bfd_boolean
2531 nios2_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2532 {
2533   struct elf32_nios2_stub_hash_entry *hsh
2534     = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2535
2536   switch (hsh->stub_type)
2537     {
2538     case nios2_stub_call26_before:
2539     case nios2_stub_call26_after:
2540       hsh->stub_sec->size += 12;
2541       break;
2542     default:
2543       BFD_FAIL ();
2544       return FALSE;
2545     }
2546   return TRUE;
2547 }
2548
2549 /* Read in all local syms for all input bfds.
2550    Returns -1 on error, 0 otherwise.  */
2551
2552 static int
2553 get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
2554                 struct bfd_link_info *info)
2555 {
2556   unsigned int bfd_indx;
2557   Elf_Internal_Sym *local_syms, **all_local_syms;
2558   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2559
2560   /* We want to read in symbol extension records only once.  To do this
2561      we need to read in the local symbols in parallel and save them for
2562      later use; so hold pointers to the local symbols in an array.  */
2563   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2564   all_local_syms = bfd_zmalloc (amt);
2565   htab->all_local_syms = all_local_syms;
2566   if (all_local_syms == NULL)
2567     return -1;
2568
2569   /* Walk over all the input BFDs, swapping in local symbols.  */
2570   for (bfd_indx = 0;
2571        input_bfd != NULL;
2572        input_bfd = input_bfd->link.next, bfd_indx++)
2573     {
2574       Elf_Internal_Shdr *symtab_hdr;
2575
2576       /* We'll need the symbol table in a second.  */
2577       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2578       if (symtab_hdr->sh_info == 0)
2579         continue;
2580
2581       /* We need an array of the local symbols attached to the input bfd.  */
2582       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2583       if (local_syms == NULL)
2584         {
2585           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2586                                              symtab_hdr->sh_info, 0,
2587                                              NULL, NULL, NULL);
2588           /* Cache them for elf_link_input_bfd.  */
2589           symtab_hdr->contents = (unsigned char *) local_syms;
2590         }
2591       if (local_syms == NULL)
2592         return -1;
2593
2594       all_local_syms[bfd_indx] = local_syms;
2595     }
2596
2597   return 0;
2598 }
2599
2600 /* Determine and set the size of the stub section for a final link.  */
2601 bfd_boolean
2602 nios2_elf32_size_stubs (bfd *output_bfd, bfd *stub_bfd,
2603                         struct bfd_link_info *info,
2604                         asection *(*add_stub_section) (const char *,
2605                                                        asection *, bfd_boolean),
2606                         void (*layout_sections_again) (void))
2607 {
2608   bfd_boolean stub_changed = FALSE;
2609   struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2610
2611   /* Stash our params away.  */
2612   htab->stub_bfd = stub_bfd;
2613   htab->add_stub_section = add_stub_section;
2614   htab->layout_sections_again = layout_sections_again;
2615
2616   /* FIXME: We only compute the section groups once.  This could cause
2617      problems if adding a large stub section causes following sections,
2618      or parts of them, to move into another segment.  However, this seems
2619      to be consistent with the way other back ends handle this....  */
2620   group_sections (htab);
2621
2622   if (get_local_syms (output_bfd, info->input_bfds, info))
2623     {
2624       if (htab->all_local_syms)
2625         goto error_ret_free_local;
2626       return FALSE;
2627     }
2628
2629   while (1)
2630     {
2631       bfd *input_bfd;
2632       unsigned int bfd_indx;
2633       asection *stub_sec;
2634
2635       for (input_bfd = info->input_bfds, bfd_indx = 0;
2636            input_bfd != NULL;
2637            input_bfd = input_bfd->link.next, bfd_indx++)
2638         {
2639           Elf_Internal_Shdr *symtab_hdr;
2640           asection *section;
2641           Elf_Internal_Sym *local_syms;
2642
2643           /* We'll need the symbol table in a second.  */
2644           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2645           if (symtab_hdr->sh_info == 0)
2646             continue;
2647
2648           local_syms = htab->all_local_syms[bfd_indx];
2649
2650           /* Walk over each section attached to the input bfd.  */
2651           for (section = input_bfd->sections;
2652                section != NULL;
2653                section = section->next)
2654             {
2655               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2656
2657               /* If there aren't any relocs, then there's nothing more
2658                  to do.  */
2659               if ((section->flags & SEC_RELOC) == 0
2660                   || section->reloc_count == 0)
2661                 continue;
2662
2663               /* If this section is a link-once section that will be
2664                  discarded, then don't create any stubs.  */
2665               if (section->output_section == NULL
2666                   || section->output_section->owner != output_bfd)
2667                 continue;
2668
2669               /* Get the relocs.  */
2670               internal_relocs
2671                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2672                                              info->keep_memory);
2673               if (internal_relocs == NULL)
2674                 goto error_ret_free_local;
2675
2676               /* Now examine each relocation.  */
2677               irela = internal_relocs;
2678               irelaend = irela + section->reloc_count;
2679               for (; irela < irelaend; irela++)
2680                 {
2681                   unsigned int r_type, r_indx;
2682                   enum elf32_nios2_stub_type stub_type;
2683                   struct elf32_nios2_stub_hash_entry *hsh;
2684                   asection *sym_sec;
2685                   bfd_vma sym_value;
2686                   bfd_vma destination;
2687                   struct elf32_nios2_link_hash_entry *hh;
2688                   char *stub_name;
2689                   const asection *id_sec;
2690
2691                   r_type = ELF32_R_TYPE (irela->r_info);
2692                   r_indx = ELF32_R_SYM (irela->r_info);
2693
2694                   if (r_type >= (unsigned int) R_NIOS2_ILLEGAL)
2695                     {
2696                       bfd_set_error (bfd_error_bad_value);
2697                     error_ret_free_internal:
2698                       if (elf_section_data (section)->relocs == NULL)
2699                         free (internal_relocs);
2700                       goto error_ret_free_local;
2701                     }
2702
2703                   /* Only look for stubs on CALL and JMPI instructions.  */
2704                   if (r_type != (unsigned int) R_NIOS2_CALL26)
2705                     continue;
2706
2707                   /* Now determine the call target, its name, value,
2708                      section.  */
2709                   sym_sec = NULL;
2710                   sym_value = 0;
2711                   destination = 0;
2712                   hh = NULL;
2713                   if (r_indx < symtab_hdr->sh_info)
2714                     {
2715                       /* It's a local symbol.  */
2716                       Elf_Internal_Sym *sym;
2717                       Elf_Internal_Shdr *hdr;
2718                       unsigned int shndx;
2719
2720                       sym = local_syms + r_indx;
2721                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2722                         sym_value = sym->st_value;
2723                       shndx = sym->st_shndx;
2724                       if (shndx < elf_numsections (input_bfd))
2725                         {
2726                           hdr = elf_elfsections (input_bfd)[shndx];
2727                           sym_sec = hdr->bfd_section;
2728                           destination = (sym_value + irela->r_addend
2729                                          + sym_sec->output_offset
2730                                          + sym_sec->output_section->vma);
2731                         }
2732                     }
2733                   else
2734                     {
2735                       /* It's an external symbol.  */
2736                       int e_indx;
2737
2738                       e_indx = r_indx - symtab_hdr->sh_info;
2739                       hh = ((struct elf32_nios2_link_hash_entry *)
2740                             elf_sym_hashes (input_bfd)[e_indx]);
2741
2742                       while (hh->root.root.type == bfd_link_hash_indirect
2743                              || hh->root.root.type == bfd_link_hash_warning)
2744                         hh = ((struct elf32_nios2_link_hash_entry *)
2745                               hh->root.root.u.i.link);
2746
2747                       if (hh->root.root.type == bfd_link_hash_defined
2748                           || hh->root.root.type == bfd_link_hash_defweak)
2749                         {
2750                           sym_sec = hh->root.root.u.def.section;
2751                           sym_value = hh->root.root.u.def.value;
2752
2753                           if (sym_sec->output_section != NULL)
2754                             destination = (sym_value + irela->r_addend
2755                                            + sym_sec->output_offset
2756                                            + sym_sec->output_section->vma);
2757                           else
2758                             continue;
2759                         }
2760                       else if (hh->root.root.type == bfd_link_hash_undefweak)
2761                         {
2762                           if (! bfd_link_pic (info))
2763                             continue;
2764                         }
2765                       else if (hh->root.root.type == bfd_link_hash_undefined)
2766                         {
2767                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2768                                  && (ELF_ST_VISIBILITY (hh->root.other)
2769                                      == STV_DEFAULT)))
2770                             continue;
2771                         }
2772                       else
2773                         {
2774                           bfd_set_error (bfd_error_bad_value);
2775                           goto error_ret_free_internal;
2776                         }
2777                     }
2778
2779                   /* Determine what (if any) linker stub is needed.  */
2780                   stub_type = nios2_type_of_stub (section, irela, hh, htab,
2781                                                   destination, info);
2782                   if (stub_type == nios2_stub_none)
2783                     continue;
2784
2785                   /* Support for grouping stub sections.  */
2786                   if (stub_type == nios2_stub_call26_before)
2787                     id_sec = htab->stub_group[section->id].first_sec;
2788                   else
2789                     id_sec = htab->stub_group[section->id].last_sec;
2790
2791                   /* Get the name of this stub.  */
2792                   stub_name = nios2_stub_name (id_sec, sym_sec, hh, irela,
2793                                                stub_type);
2794                   if (!stub_name)
2795                     goto error_ret_free_internal;
2796
2797                   hsh = nios2_stub_hash_lookup (&htab->bstab,
2798                                                 stub_name,
2799                                                 FALSE, FALSE);
2800                   if (hsh != NULL)
2801                     {
2802                       /* The proper stub has already been created.  */
2803                       free (stub_name);
2804                       continue;
2805                     }
2806
2807                   hsh = nios2_add_stub (stub_name, section, htab, stub_type);
2808                   if (hsh == NULL)
2809                     {
2810                       free (stub_name);
2811                       goto error_ret_free_internal;
2812                     }
2813                   hsh->target_value = sym_value;
2814                   hsh->target_section = sym_sec;
2815                   hsh->stub_type = stub_type;
2816                   hsh->hh = hh;
2817                   hsh->addend = irela->r_addend;
2818                   stub_changed = TRUE;
2819                 }
2820
2821               /* We're done with the internal relocs, free them.  */
2822               if (elf_section_data (section)->relocs == NULL)
2823                 free (internal_relocs);
2824             }
2825         }
2826
2827       if (!stub_changed)
2828         break;
2829
2830       /* OK, we've added some stubs.  Find out the new size of the
2831          stub sections.  */
2832       for (stub_sec = htab->stub_bfd->sections;
2833            stub_sec != NULL;
2834            stub_sec = stub_sec->next)
2835         stub_sec->size = 0;
2836
2837       bfd_hash_traverse (&htab->bstab, nios2_size_one_stub, htab);
2838
2839       /* Ask the linker to do its stuff.  */
2840       (*htab->layout_sections_again) ();
2841       stub_changed = FALSE;
2842     }
2843
2844   free (htab->all_local_syms);
2845   return TRUE;
2846
2847  error_ret_free_local:
2848   free (htab->all_local_syms);
2849   return FALSE;
2850 }
2851
2852 /* Build all the stubs associated with the current output file.  The
2853    stubs are kept in a hash table attached to the main linker hash
2854    table.  This function is called via nios2elf_finish in the linker.  */
2855 bfd_boolean
2856 nios2_elf32_build_stubs (struct bfd_link_info *info)
2857 {
2858   asection *stub_sec;
2859   struct bfd_hash_table *table;
2860   struct elf32_nios2_link_hash_table *htab;
2861
2862   htab = elf32_nios2_hash_table (info);
2863
2864   for (stub_sec = htab->stub_bfd->sections;
2865        stub_sec != NULL;
2866        stub_sec = stub_sec->next)
2867     /* The stub_bfd may contain non-stub sections if it is also the
2868        dynobj.  Any such non-stub sections are created with the
2869        SEC_LINKER_CREATED flag set, while stub sections do not
2870        have that flag.  Ignore any non-stub sections here.  */
2871     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
2872       {
2873         bfd_size_type size;
2874
2875         /* Allocate memory to hold the linker stubs.  */
2876         size = stub_sec->size;
2877         stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2878         if (stub_sec->contents == NULL && size != 0)
2879           return FALSE;
2880         stub_sec->size = 0;
2881       }
2882
2883   /* Build the stubs as directed by the stub hash table.  */
2884   table = &htab->bstab;
2885   bfd_hash_traverse (table, nios2_build_one_stub, info);
2886
2887   return TRUE;
2888 }
2889
2890
2891 #define is_nios2_elf(bfd) \
2892   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2893    && elf_object_id (bfd) == NIOS2_ELF_DATA)
2894
2895 /* Merge backend specific data from an object file to the output
2896    object file when linking.  */
2897
2898 static bfd_boolean
2899 nios2_elf32_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2900 {
2901   bfd *obfd = info->output_bfd;
2902   flagword old_flags;
2903   flagword new_flags;
2904
2905   if (!is_nios2_elf (ibfd) || !is_nios2_elf (obfd))
2906     return TRUE;
2907
2908   /* Check if we have the same endianness.  */
2909   if (! _bfd_generic_verify_endian_match (ibfd, info))
2910     return FALSE;
2911
2912   new_flags = elf_elfheader (ibfd)->e_flags;
2913   old_flags = elf_elfheader (obfd)->e_flags;
2914   if (!elf_flags_init (obfd))
2915     {
2916       /* First call, no flags set.  */
2917       elf_flags_init (obfd) = TRUE;
2918       elf_elfheader (obfd)->e_flags = new_flags;
2919
2920       switch (new_flags)
2921         {
2922         default:
2923         case EF_NIOS2_ARCH_R1:
2924           bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r1);
2925           break;
2926         case EF_NIOS2_ARCH_R2:
2927           if (bfd_big_endian (ibfd))
2928             {
2929               _bfd_error_handler
2930                 (_("error: %pB: big-endian R2 is not supported"), ibfd);
2931               bfd_set_error (bfd_error_bad_value);
2932               return FALSE;
2933             }
2934           bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r2);
2935           break;
2936         }
2937     }
2938
2939   /* Incompatible flags.  */
2940   else if (new_flags != old_flags)
2941     {
2942       /* So far, the only incompatible flags denote incompatible
2943          architectures.  */
2944       _bfd_error_handler
2945         /* xgettext:c-format */
2946         (_("error: %pB: conflicting CPU architectures %d/%d"),
2947          ibfd, new_flags, old_flags);
2948       bfd_set_error (bfd_error_bad_value);
2949       return FALSE;
2950     }
2951
2952   /* Merge Tag_compatibility attributes and any common GNU ones.  */
2953   _bfd_elf_merge_object_attributes (ibfd, info);
2954
2955   return TRUE;
2956 }
2957
2958 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2959    Given a BFD reloc type, return a howto structure.  */
2960
2961 static reloc_howto_type *
2962 nios2_elf32_bfd_reloc_type_lookup (bfd *abfd,
2963                                    bfd_reloc_code_real_type code)
2964 {
2965   int i;
2966
2967   for (i = 0; i < (int) ARRAY_SIZE (nios2_reloc_map); ++i)
2968     if (nios2_reloc_map[i].bfd_val == code)
2969       return lookup_howto (nios2_reloc_map[i].elf_val, abfd);
2970   return NULL;
2971 }
2972
2973 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2974    Given a reloc name, return a howto structure.  */
2975
2976 static reloc_howto_type *
2977 nios2_elf32_bfd_reloc_name_lookup (bfd *abfd,
2978                                    const char *r_name)
2979 {
2980   int i;
2981   reloc_howto_type *howto_tbl;
2982   int howto_tbl_size;
2983
2984   if (BFD_IS_R2 (abfd))
2985     {
2986       howto_tbl = elf_nios2_r2_howto_table_rel;
2987       howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
2988     }
2989   else
2990     {
2991       howto_tbl = elf_nios2_r1_howto_table_rel;
2992       howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
2993     }
2994
2995   for (i = 0; i < howto_tbl_size; i++)
2996     if (howto_tbl[i].name && strcasecmp (howto_tbl[i].name, r_name) == 0)
2997       return howto_tbl + i;
2998
2999   return NULL;
3000 }
3001
3002 /* Implement elf_info_to_howto:
3003    Given a ELF32 relocation, fill in a arelent structure.  */
3004
3005 static bfd_boolean
3006 nios2_elf32_info_to_howto (bfd *abfd, arelent *cache_ptr,
3007                            Elf_Internal_Rela *dst)
3008 {
3009   unsigned int r_type;
3010
3011   r_type = ELF32_R_TYPE (dst->r_info);
3012   if ((cache_ptr->howto = lookup_howto (r_type, abfd)) == NULL)
3013     {
3014       /* xgettext:c-format */
3015       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3016                           abfd, r_type);
3017       bfd_set_error (bfd_error_bad_value);
3018       return FALSE;
3019     }
3020   return TRUE;
3021 }
3022
3023 /* Return the base VMA address which should be subtracted from real addresses
3024    when resolving @dtpoff relocation.
3025    This is PT_TLS segment p_vaddr.  */
3026 static bfd_vma
3027 dtpoff_base (struct bfd_link_info *info)
3028 {
3029   /* If tls_sec is NULL, we should have signalled an error already.  */
3030   if (elf_hash_table (info)->tls_sec == NULL)
3031     return 0;
3032   return elf_hash_table (info)->tls_sec->vma;
3033 }
3034
3035 /* Return the relocation value for @tpoff relocation
3036    if STT_TLS virtual address is ADDRESS.  */
3037 static bfd_vma
3038 tpoff (struct bfd_link_info *info, bfd_vma address)
3039 {
3040   struct elf_link_hash_table *htab = elf_hash_table (info);
3041
3042   /* If tls_sec is NULL, we should have signalled an error already.  */
3043   if (htab->tls_sec == NULL)
3044     return 0;
3045   return address - htab->tls_sec->vma;
3046 }
3047
3048 /* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
3049    dangerous relocation.  */
3050 static bfd_boolean
3051 nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
3052 {
3053
3054   bfd_boolean gp_found;
3055   struct bfd_hash_entry *h;
3056   struct bfd_link_hash_entry *lh;
3057
3058   /* If we've already figured out what GP will be, just return it. */
3059   *pgp = _bfd_get_gp_value (output_bfd);
3060   if (*pgp)
3061     return TRUE;
3062
3063   h = bfd_hash_lookup (&info->hash->table, "_gp", FALSE, FALSE);
3064   lh = (struct bfd_link_hash_entry *) h;
3065 lookup:
3066   if (lh)
3067     {
3068       switch (lh->type)
3069         {
3070         case bfd_link_hash_undefined:
3071         case bfd_link_hash_undefweak:
3072         case bfd_link_hash_common:
3073           gp_found = FALSE;
3074           break;
3075         case bfd_link_hash_defined:
3076         case bfd_link_hash_defweak:
3077           gp_found = TRUE;
3078           {
3079             asection *sym_sec = lh->u.def.section;
3080             bfd_vma sym_value = lh->u.def.value;
3081
3082             if (sym_sec->output_section)
3083               sym_value = (sym_value + sym_sec->output_offset
3084                            + sym_sec->output_section->vma);
3085             *pgp = sym_value;
3086           }
3087           break;
3088         case bfd_link_hash_indirect:
3089         case bfd_link_hash_warning:
3090           lh = lh->u.i.link;
3091           /* @@FIXME  ignoring warning for now */
3092           goto lookup;
3093         case bfd_link_hash_new:
3094         default:
3095           abort ();
3096         }
3097     }
3098   else
3099     gp_found = FALSE;
3100
3101   if (!gp_found)
3102     {
3103       /* Only get the error once. */
3104       *pgp = 4;
3105       _bfd_set_gp_value (output_bfd, *pgp);
3106       return FALSE;
3107     }
3108
3109   _bfd_set_gp_value (output_bfd, *pgp);
3110
3111   return TRUE;
3112 }
3113
3114 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3115    if it's not available as we don't have a link_info pointer available here
3116    to look it up in the output symbol table.  We don't need to adjust the
3117    symbol value for an external symbol if we are producing relocatable
3118    output.  */
3119 static bfd_reloc_status_type
3120 nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
3121                     char **error_message, bfd_vma *pgp)
3122 {
3123   if (bfd_is_und_section (symbol->section) && !relocatable)
3124     {
3125       *pgp = 0;
3126       return bfd_reloc_undefined;
3127     }
3128
3129   *pgp = _bfd_get_gp_value (output_bfd);
3130   if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
3131     {
3132       if (relocatable)
3133         {
3134           /* Make up a value.  */
3135           *pgp = symbol->section->output_section->vma + 0x4000;
3136           _bfd_set_gp_value (output_bfd, *pgp);
3137         }
3138       else
3139         {
3140           *error_message
3141             = (char *) _("global pointer relative relocation when _gp not defined");
3142           return bfd_reloc_dangerous;
3143         }
3144     }
3145
3146   return bfd_reloc_ok;
3147 }
3148
3149 /* Do the relocations that require special handling.  */
3150 static bfd_reloc_status_type
3151 nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
3152                               asection *input_section,
3153                               bfd_byte *data, bfd_vma offset,
3154                               bfd_vma symbol_value, bfd_vma addend)
3155 {
3156   symbol_value = symbol_value + addend;
3157   addend = 0;
3158   symbol_value = (symbol_value >> 16) & 0xffff;
3159   return _bfd_final_link_relocate (howto, abfd, input_section,
3160                                    data, offset, symbol_value, addend);
3161 }
3162
3163 static bfd_reloc_status_type
3164 nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3165                               asection *input_section,
3166                               bfd_byte *data, bfd_vma offset,
3167                               bfd_vma symbol_value, bfd_vma addend)
3168 {
3169   symbol_value = symbol_value + addend;
3170   addend = 0;
3171   symbol_value = symbol_value & 0xffff;
3172   return _bfd_final_link_relocate (howto, abfd, input_section,
3173                                    data, offset, symbol_value, addend);
3174 }
3175
3176 static bfd_reloc_status_type
3177 nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3178                                  asection *input_section,
3179                                  bfd_byte *data, bfd_vma offset,
3180                                  bfd_vma symbol_value, bfd_vma addend)
3181 {
3182   symbol_value = symbol_value + addend;
3183   addend = 0;
3184   symbol_value = hiadj(symbol_value);
3185   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3186                                    symbol_value, addend);
3187 }
3188
3189 static bfd_reloc_status_type
3190 nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3191                                     asection *input_section,
3192                                     bfd_byte *data, bfd_vma offset,
3193                                     bfd_vma symbol_value, bfd_vma addend)
3194 {
3195   symbol_value = symbol_value + addend;
3196   addend = 0;
3197   symbol_value = symbol_value & 0xffff;
3198   return _bfd_final_link_relocate (howto, abfd, input_section,
3199                                    data, offset, symbol_value, addend);
3200 }
3201
3202 static bfd_reloc_status_type
3203 nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3204                                        asection *input_section,
3205                                        bfd_byte *data, bfd_vma offset,
3206                                        bfd_vma symbol_value, bfd_vma addend)
3207 {
3208   symbol_value = symbol_value + addend;
3209   symbol_value -= (input_section->output_section->vma
3210                    + input_section->output_offset);
3211   symbol_value -= offset;
3212   addend = 0;
3213   symbol_value = hiadj(symbol_value);
3214   return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3215                                    symbol_value, addend);
3216 }
3217
3218 static bfd_reloc_status_type
3219 nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
3220                                  asection *input_section,
3221                                  bfd_byte *data, bfd_vma offset,
3222                                  bfd_vma symbol_value, bfd_vma addend)
3223 {
3224   /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3225      so we need to subtract 4 before doing a final_link_relocate. */
3226   symbol_value = symbol_value + addend - 4;
3227   addend = 0;
3228   return _bfd_final_link_relocate (howto, abfd, input_section,
3229                                    data, offset, symbol_value, addend);
3230 }
3231
3232 static bfd_reloc_status_type
3233 nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
3234                                 asection *input_section,
3235                                 bfd_byte *data, bfd_vma offset,
3236                                 bfd_vma symbol_value, bfd_vma addend)
3237 {
3238   /* Check that the relocation is in the same page as the current address.  */
3239   if (CALL26_SEGMENT (symbol_value + addend)
3240       != CALL26_SEGMENT (input_section->output_section->vma
3241                          + input_section->output_offset
3242                          + offset))
3243     return bfd_reloc_overflow;
3244
3245   /* Check that the target address is correctly aligned on a 4-byte
3246      boundary.  */
3247   if ((symbol_value + addend) & 0x3)
3248     return bfd_reloc_overflow;
3249
3250   return _bfd_final_link_relocate (howto, abfd, input_section,
3251                                    data, offset, symbol_value, addend);
3252 }
3253
3254 static bfd_reloc_status_type
3255 nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
3256                                asection *input_section,
3257                                bfd_byte *data, bfd_vma offset,
3258                                bfd_vma symbol_value, bfd_vma addend)
3259 {
3260   /* Because we need the output_bfd, the special handling is done
3261      in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate.  */
3262   return _bfd_final_link_relocate (howto, abfd, input_section,
3263                                    data, offset, symbol_value, addend);
3264 }
3265
3266 static bfd_reloc_status_type
3267 nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
3268                               asection *input_section,
3269                               bfd_byte *data, bfd_vma offset,
3270                               bfd_vma symbol_value, bfd_vma addend)
3271 {
3272   bfd_vma symbol_lo16, symbol_hi16;
3273   bfd_reloc_status_type r;
3274   symbol_value = symbol_value + addend;
3275   addend = 0;
3276   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3277   symbol_lo16 = symbol_value & 0xffff;
3278
3279   r = _bfd_final_link_relocate (howto, abfd, input_section,
3280                                 data, offset, symbol_hi16, addend);
3281
3282   if (r == bfd_reloc_ok)
3283     return _bfd_final_link_relocate (howto, abfd, input_section,
3284                                      data, offset + 4, symbol_lo16, addend);
3285
3286   return r;
3287 }
3288
3289 static bfd_reloc_status_type
3290 nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
3291                               asection *input_section,
3292                               bfd_byte *data, bfd_vma offset,
3293                               bfd_vma symbol_value, bfd_vma addend)
3294 {
3295   bfd_vma symbol_lo16, symbol_hi16;
3296   bfd_reloc_status_type r;
3297   symbol_value = symbol_value + addend;
3298   addend = 0;
3299   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3300   symbol_lo16 = symbol_value & 0xffff;
3301
3302   r = _bfd_final_link_relocate (howto, abfd, input_section,
3303                                 data, offset, symbol_hi16, addend);
3304
3305   if (r == bfd_reloc_ok)
3306     return _bfd_final_link_relocate (howto, abfd, input_section,
3307                                      data, offset + 4, symbol_lo16, addend);
3308
3309   return r;
3310 }
3311
3312 static bfd_reloc_status_type
3313 nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
3314                                asection *input_section,
3315                                bfd_byte *data, bfd_vma offset,
3316                                bfd_vma symbol_value, bfd_vma addend)
3317 {
3318   bfd_vma symbol_lo16, symbol_hi16;
3319   bfd_reloc_status_type r;
3320   symbol_value = symbol_value + addend;
3321   addend = 0;
3322   symbol_hi16 = (symbol_value >> 16) & 0xffff;
3323   symbol_lo16 = symbol_value & 0xffff;
3324
3325   r = _bfd_final_link_relocate (howto, abfd, input_section,
3326                                 data, offset, symbol_hi16, addend);
3327
3328   if (r == bfd_reloc_ok)
3329     return _bfd_final_link_relocate (howto, abfd, input_section,
3330                                      data, offset + 4, symbol_lo16, addend);
3331
3332   return r;
3333 }
3334
3335 /* HOWTO handlers for relocations that require special handling.  */
3336
3337 /* This is for relocations used only when relaxing to ensure
3338    changes in size of section don't screw up .align.  */
3339 static bfd_reloc_status_type
3340 nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3341                           asymbol *symbol ATTRIBUTE_UNUSED,
3342                           void *data ATTRIBUTE_UNUSED, asection *input_section,
3343                           bfd *output_bfd,
3344                           char **error_message ATTRIBUTE_UNUSED)
3345 {
3346   if (output_bfd != NULL)
3347     reloc_entry->address += input_section->output_offset;
3348   return bfd_reloc_ok;
3349 }
3350
3351 static bfd_reloc_status_type
3352 nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3353                            void *data, asection *input_section,
3354                            bfd *output_bfd,
3355                            char **error_message ATTRIBUTE_UNUSED)
3356 {
3357   /* This part is from bfd_elf_generic_reloc.  */
3358   if (output_bfd != NULL
3359       && (symbol->flags & BSF_SECTION_SYM) == 0
3360       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3361     {
3362       reloc_entry->address += input_section->output_offset;
3363       return bfd_reloc_ok;
3364     }
3365
3366   if (output_bfd != NULL)
3367     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3368     return bfd_reloc_continue;
3369
3370   return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
3371                                        input_section,
3372                                        data, reloc_entry->address,
3373                                        (symbol->value
3374                                         + symbol->section->output_section->vma
3375                                         + symbol->section->output_offset),
3376                                        reloc_entry->addend);
3377 }
3378
3379 static bfd_reloc_status_type
3380 nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3381                            void *data, asection *input_section,
3382                            bfd *output_bfd,
3383                            char **error_message ATTRIBUTE_UNUSED)
3384 {
3385   /* This part is from bfd_elf_generic_reloc.  */
3386   if (output_bfd != NULL
3387       && (symbol->flags & BSF_SECTION_SYM) == 0
3388       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3389     {
3390       reloc_entry->address += input_section->output_offset;
3391       return bfd_reloc_ok;
3392     }
3393
3394   if (output_bfd != NULL)
3395     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3396     return bfd_reloc_continue;
3397
3398   return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
3399                                        input_section,
3400                                        data, reloc_entry->address,
3401                                        (symbol->value
3402                                         + symbol->section->output_section->vma
3403                                         + symbol->section->output_offset),
3404                                        reloc_entry->addend);
3405 }
3406
3407 static bfd_reloc_status_type
3408 nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3409                               void *data, asection *input_section,
3410                               bfd *output_bfd,
3411                               char **error_message ATTRIBUTE_UNUSED)
3412 {
3413   /* This part is from bfd_elf_generic_reloc.  */
3414   if (output_bfd != NULL
3415       && (symbol->flags & BSF_SECTION_SYM) == 0
3416       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3417     {
3418       reloc_entry->address += input_section->output_offset;
3419       return bfd_reloc_ok;
3420     }
3421
3422   if (output_bfd != NULL)
3423     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3424     return bfd_reloc_continue;
3425
3426   return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
3427                                           input_section,
3428                                           data, reloc_entry->address,
3429                                           (symbol->value
3430                                            + symbol->section->output_section->vma
3431                                            + symbol->section->output_offset),
3432                                           reloc_entry->addend);
3433 }
3434
3435 static bfd_reloc_status_type
3436 nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
3437                                  asymbol *symbol, void *data,
3438                                  asection *input_section, bfd *output_bfd,
3439                                  char **error_message ATTRIBUTE_UNUSED)
3440 {
3441   /* This part is from bfd_elf_generic_reloc.  */
3442   if (output_bfd != NULL
3443       && (symbol->flags & BSF_SECTION_SYM) == 0
3444       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3445     {
3446       reloc_entry->address += input_section->output_offset;
3447       return bfd_reloc_ok;
3448     }
3449
3450   if (output_bfd != NULL)
3451     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3452     return bfd_reloc_continue;
3453
3454   return nios2_elf32_do_pcrel_lo16_relocate (
3455     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3456     (symbol->value + symbol->section->output_section->vma
3457      + symbol->section->output_offset),
3458     reloc_entry->addend);
3459 }
3460
3461 static bfd_reloc_status_type
3462 nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
3463                                     asymbol *symbol, void *data,
3464                                     asection *input_section, bfd *output_bfd,
3465                                     char **error_message ATTRIBUTE_UNUSED)
3466 {
3467   /* This part is from bfd_elf_generic_reloc.  */
3468   if (output_bfd != NULL
3469       && (symbol->flags & BSF_SECTION_SYM) == 0
3470       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3471     {
3472       reloc_entry->address += input_section->output_offset;
3473       return bfd_reloc_ok;
3474     }
3475
3476   if (output_bfd != NULL)
3477     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3478     return bfd_reloc_continue;
3479
3480   return nios2_elf32_do_pcrel_hiadj16_relocate (
3481     abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3482     (symbol->value + symbol->section->output_section->vma
3483      + symbol->section->output_offset),
3484     reloc_entry->addend);
3485 }
3486
3487 static bfd_reloc_status_type
3488 nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3489                               void *data, asection *input_section,
3490                               bfd *output_bfd,
3491                               char **error_message ATTRIBUTE_UNUSED)
3492 {
3493   /* This part is from bfd_elf_generic_reloc.  */
3494   if (output_bfd != NULL
3495       && (symbol->flags & BSF_SECTION_SYM) == 0
3496       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3497     {
3498       reloc_entry->address += input_section->output_offset;
3499       return bfd_reloc_ok;
3500     }
3501
3502   if (output_bfd != NULL)
3503     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3504     return bfd_reloc_continue;
3505
3506   return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
3507                                           input_section,
3508                                           data, reloc_entry->address,
3509                                           (symbol->value
3510                                            + symbol->section->output_section->vma
3511                                            + symbol->section->output_offset),
3512                                           reloc_entry->addend);
3513 }
3514
3515 static bfd_reloc_status_type
3516 nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3517                              void *data, asection *input_section,
3518                              bfd *output_bfd,
3519                              char **error_message ATTRIBUTE_UNUSED)
3520 {
3521   /* This part is from bfd_elf_generic_reloc.  */
3522   if (output_bfd != NULL
3523       && (symbol->flags & BSF_SECTION_SYM) == 0
3524       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3525     {
3526       reloc_entry->address += input_section->output_offset;
3527       return bfd_reloc_ok;
3528     }
3529
3530   if (output_bfd != NULL)
3531     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3532     return bfd_reloc_continue;
3533
3534   return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
3535                                          input_section,
3536                                          data, reloc_entry->address,
3537                                          (symbol->value
3538                                           + symbol->section->output_section->vma
3539                                           + symbol->section->output_offset),
3540                                          reloc_entry->addend);
3541 }
3542
3543 static bfd_reloc_status_type
3544 nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3545                             void *data, asection *input_section,
3546                             bfd *output_bfd, char **msg)
3547 {
3548   bfd_vma relocation;
3549   bfd_vma gp;
3550   bfd_reloc_status_type r;
3551
3552
3553   /* This part is from bfd_elf_generic_reloc.  */
3554   if (output_bfd != NULL
3555       && (symbol->flags & BSF_SECTION_SYM) == 0
3556       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3557     {
3558       reloc_entry->address += input_section->output_offset;
3559       return bfd_reloc_ok;
3560     }
3561
3562   if (output_bfd != NULL)
3563     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3564     return bfd_reloc_continue;
3565
3566   relocation = (symbol->value
3567                 + symbol->section->output_section->vma
3568                 + symbol->section->output_offset);
3569
3570   /* This assumes we've already cached the _gp symbol.  */
3571   r = nios2_elf_final_gp (abfd, symbol, FALSE, msg, &gp);
3572   if (r == bfd_reloc_ok)
3573     {
3574       relocation = relocation + reloc_entry->addend - gp;
3575       reloc_entry->addend = 0;
3576       if ((signed) relocation < -32768 || (signed) relocation > 32767)
3577         {
3578           *msg = _("global pointer relative address out of range");
3579           r = bfd_reloc_outofrange;
3580         }
3581       else
3582         r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
3583                                            input_section,
3584                                            data, reloc_entry->address,
3585                                            relocation, reloc_entry->addend);
3586     }
3587
3588   return r;
3589 }
3590
3591 static bfd_reloc_status_type
3592 nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3593                            void *data, asection *input_section,
3594                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3595 {
3596   /* This part is from bfd_elf_generic_reloc.  */
3597   if (output_bfd != NULL
3598       && (symbol->flags & BSF_SECTION_SYM) == 0
3599       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3600     {
3601       reloc_entry->address += input_section->output_offset;
3602       return bfd_reloc_ok;
3603     }
3604
3605   if (output_bfd != NULL)
3606     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3607     return bfd_reloc_continue;
3608
3609   return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
3610                                        input_section,
3611                                        data, reloc_entry->address,
3612                                        (symbol->value
3613                                         + symbol->section->output_section->vma
3614                                         + symbol->section->output_offset),
3615                                        reloc_entry->addend);
3616 }
3617
3618 static bfd_reloc_status_type
3619 nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3620                            void *data, asection *input_section,
3621                            bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3622 {
3623   /* This part is from bfd_elf_generic_reloc.  */
3624   if (output_bfd != NULL
3625       && (symbol->flags & BSF_SECTION_SYM) == 0
3626       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3627     {
3628       reloc_entry->address += input_section->output_offset;
3629       return bfd_reloc_ok;
3630     }
3631
3632   if (output_bfd != NULL)
3633     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3634     return bfd_reloc_continue;
3635
3636   return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
3637                                        input_section,
3638                                        data, reloc_entry->address,
3639                                        (symbol->value
3640                                         + symbol->section->output_section->vma
3641                                         + symbol->section->output_offset),
3642                                        reloc_entry->addend);
3643 }
3644
3645 static bfd_reloc_status_type
3646 nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3647                             void *data, asection *input_section,
3648                             bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3649 {
3650   /* This part is from bfd_elf_generic_reloc.  */
3651   if (output_bfd != NULL
3652       && (symbol->flags & BSF_SECTION_SYM) == 0
3653       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3654     {
3655       reloc_entry->address += input_section->output_offset;
3656       return bfd_reloc_ok;
3657     }
3658
3659   if (output_bfd != NULL)
3660     /* FIXME: See bfd_perform_relocation.  Is this right?  */
3661     return bfd_reloc_continue;
3662
3663   return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
3664                                         input_section,
3665                                         data, reloc_entry->address,
3666                                         (symbol->value
3667                                          + symbol->section->output_section->vma
3668                                          + symbol->section->output_offset),
3669                                         reloc_entry->addend);
3670 }
3671
3672
3673 /* Implement elf_backend_relocate_section.  */
3674 static bfd_boolean
3675 nios2_elf32_relocate_section (bfd *output_bfd,
3676                               struct bfd_link_info *info,
3677                               bfd *input_bfd,
3678                               asection *input_section,
3679                               bfd_byte *contents,
3680                               Elf_Internal_Rela *relocs,
3681                               Elf_Internal_Sym *local_syms,
3682                               asection **local_sections)
3683 {
3684   Elf_Internal_Shdr *symtab_hdr;
3685   struct elf_link_hash_entry **sym_hashes;
3686   Elf_Internal_Rela *rel;
3687   Elf_Internal_Rela *relend;
3688   struct elf32_nios2_link_hash_table *htab;
3689   asection *sgot;
3690   asection *splt;
3691   asection *sreloc = NULL;
3692   bfd_vma *local_got_offsets;
3693   bfd_vma got_base;
3694
3695   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3696   sym_hashes = elf_sym_hashes (input_bfd);
3697   relend = relocs + input_section->reloc_count;
3698
3699   htab = elf32_nios2_hash_table (info);
3700   sgot = htab->root.sgot;
3701   splt = htab->root.splt;
3702   local_got_offsets = elf_local_got_offsets (input_bfd);
3703
3704   if (htab->h_gp_got == NULL)
3705     got_base = 0;
3706   else
3707     got_base = htab->h_gp_got->root.u.def.value;
3708
3709   for (rel = relocs; rel < relend; rel++)
3710     {
3711       reloc_howto_type *howto;
3712       unsigned long r_symndx;
3713       Elf_Internal_Sym *sym;
3714       asection *sec;
3715       struct elf_link_hash_entry *h;
3716       struct elf32_nios2_link_hash_entry *eh;
3717       bfd_vma relocation;
3718       bfd_vma gp;
3719       bfd_reloc_status_type r = bfd_reloc_ok;
3720       const char *name = NULL;
3721       int r_type;
3722       const char *format;
3723       char *msgbuf = NULL;
3724       char *msg = NULL;
3725       bfd_boolean unresolved_reloc;
3726       bfd_vma off;
3727       int use_plt;
3728
3729       r_type = ELF32_R_TYPE (rel->r_info);
3730       r_symndx = ELF32_R_SYM (rel->r_info);
3731
3732       howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info), output_bfd);
3733       h = NULL;
3734       sym = NULL;
3735       sec = NULL;
3736
3737       if (r_symndx < symtab_hdr->sh_info)
3738         {
3739           sym = local_syms + r_symndx;
3740           sec = local_sections[r_symndx];
3741           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3742         }
3743       else
3744         {
3745           bfd_boolean warned, ignored;
3746
3747           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3748                                    r_symndx, symtab_hdr, sym_hashes,
3749                                    h, sec, relocation,
3750                                    unresolved_reloc, warned, ignored);
3751         }
3752
3753       if (sec && discarded_section (sec))
3754         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3755                                          rel, 1, relend, howto, 0, contents);
3756
3757       /* Nothing more to do unless this is a final link.  */
3758       if (bfd_link_relocatable (info))
3759         continue;
3760
3761       if (howto)
3762         {
3763           bfd_boolean resolved_to_zero;
3764
3765           resolved_to_zero = (h != NULL
3766                               && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
3767           switch (howto->type)
3768             {
3769             case R_NIOS2_HI16:
3770               r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
3771                                                 input_section,
3772                                                 contents, rel->r_offset,
3773                                                 relocation, rel->r_addend);
3774               break;
3775             case R_NIOS2_LO16:
3776               r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
3777                                                 input_section,
3778                                                 contents, rel->r_offset,
3779                                                 relocation, rel->r_addend);
3780               break;
3781             case R_NIOS2_PCREL_LO:
3782               r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
3783                                                       input_section,
3784                                                       contents,
3785                                                       rel->r_offset,
3786                                                       relocation,
3787                                                       rel->r_addend);
3788               break;
3789             case R_NIOS2_HIADJ16:
3790               r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
3791                                                    input_section, contents,
3792                                                    rel->r_offset, relocation,
3793                                                    rel->r_addend);
3794               break;
3795             case R_NIOS2_PCREL_HA:
3796               r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
3797                                                          input_section,
3798                                                          contents,
3799                                                          rel->r_offset,
3800                                                          relocation,
3801                                                          rel->r_addend);
3802               break;
3803             case R_NIOS2_PCREL16:
3804               r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
3805                                                    input_section, contents,
3806                                                    rel->r_offset, relocation,
3807                                                    rel->r_addend);
3808               break;
3809             case R_NIOS2_GPREL:
3810               /* Turns an absolute address into a gp-relative address.  */
3811               if (!nios2_elf_assign_gp (output_bfd, &gp, info))
3812                 {
3813                   bfd_vma reloc_address;
3814
3815                   if (sec && sec->output_section)
3816                     reloc_address = (sec->output_section->vma
3817                                      + sec->output_offset
3818                                      + rel->r_offset);
3819                   else
3820                     reloc_address = 0;
3821
3822                   format = _("global pointer relative relocation at address "
3823                              "%#" PRIx64 " when _gp not defined\n");
3824                   if (asprintf (&msgbuf, format,
3825                                 (uint64_t) reloc_address) == -1)
3826                     msgbuf = NULL;
3827                   msg = msgbuf;
3828                   r = bfd_reloc_dangerous;
3829                 }
3830               else
3831                 {
3832                   bfd_vma symbol_address = rel->r_addend + relocation;
3833                   relocation = symbol_address - gp;
3834                   rel->r_addend = 0;
3835                   if (((signed) relocation < -32768
3836                        || (signed) relocation > 32767)
3837                       && (!h
3838                           || h->root.type == bfd_link_hash_defined
3839                           || h->root.type == bfd_link_hash_defweak))
3840                     {
3841                       if (h)
3842                         name = h->root.root.string;
3843                       else
3844                         {
3845                           name = (bfd_elf_string_from_elf_section
3846                                   (input_bfd, symtab_hdr->sh_link,
3847                                    sym->st_name));
3848                           if (name == NULL || *name == '\0')
3849                             name = bfd_section_name (input_bfd, sec);
3850                         }
3851                       /* xgettext:c-format */
3852                       format = _("unable to reach %s (at %#" PRIx64 ") from "
3853                                  "the global pointer (at %#" PRIx64 ") "
3854                                  "because the offset (%" PRId64 ") is out of "
3855                                  "the allowed range, -32678 to 32767\n" );
3856                       if (asprintf (&msgbuf, format, name,
3857                                     (uint64_t) symbol_address, (uint64_t) gp,
3858                                     (int64_t) relocation) == -1)
3859                         msgbuf = NULL;
3860                       msg = msgbuf;
3861                       r = bfd_reloc_outofrange;
3862                     }
3863                   else
3864                     r = _bfd_final_link_relocate (howto, input_bfd,
3865                                                   input_section, contents,
3866                                                   rel->r_offset, relocation,
3867                                                   rel->r_addend);
3868                 }
3869               break;
3870             case R_NIOS2_UJMP:
3871               r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
3872                                                 input_section,
3873                                                 contents, rel->r_offset,
3874                                                 relocation, rel->r_addend);
3875               break;
3876             case R_NIOS2_CJMP:
3877               r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
3878                                                 input_section,
3879                                                 contents, rel->r_offset,
3880                                                 relocation, rel->r_addend);
3881               break;
3882             case R_NIOS2_CALLR:
3883               r = nios2_elf32_do_callr_relocate (input_bfd, howto,
3884                                                  input_section, contents,
3885                                                  rel->r_offset, relocation,
3886                                                  rel->r_addend);
3887               break;
3888             case R_NIOS2_CALL26:
3889             case R_NIOS2_CALL26_NOAT:
3890               /* If we have a call to an undefined weak symbol, we just want
3891                  to stuff a zero in the bits of the call instruction and
3892                  bypass the normal call26 relocation handling, because it'll
3893                  diagnose an overflow error if address 0 isn't in the same
3894                  256MB segment as the call site.  Presumably the call
3895                  should be guarded by a null check anyway.  */
3896               if (h != NULL && h->root.type == bfd_link_hash_undefweak)
3897                 {
3898                   BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
3899                   r = _bfd_final_link_relocate (howto, input_bfd,
3900                                                 input_section, contents,
3901                                                 rel->r_offset, relocation,
3902                                                 rel->r_addend);
3903                   break;
3904                 }
3905               /* Handle relocations which should use the PLT entry.
3906                  NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3907                  which may point to a PLT entry, but we don't need to handle
3908                  that here.  If we created a PLT entry, all branches in this
3909                  object should go to it.  */
3910               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3911                 {
3912                   /* If we've created a .plt section, and assigned a PLT entry
3913                      to this function, it should not be known to bind locally.
3914                      If it were, we would have cleared the PLT entry.  */
3915                   BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3916
3917                   relocation = (splt->output_section->vma
3918                                 + splt->output_offset
3919                                 + h->plt.offset);
3920
3921                   unresolved_reloc = FALSE;
3922                 }
3923               /* Detect R_NIOS2_CALL26 relocations that would overflow the
3924                  256MB segment.  Replace the target with a reference to a
3925                  trampoline instead.
3926                  Note that htab->stub_group is null if relaxation has been
3927                  disabled by the --no-relax linker command-line option, so
3928                  we can use that to skip this processing entirely.  */
3929               if (howto->type == R_NIOS2_CALL26 && htab->stub_group)
3930                 {
3931                   bfd_vma dest = relocation + rel->r_addend;
3932                   enum elf32_nios2_stub_type stub_type;
3933
3934                   eh = (struct elf32_nios2_link_hash_entry *)h;
3935                   stub_type = nios2_type_of_stub (input_section, rel, eh,
3936                                                   htab, dest, NULL);
3937
3938                   if (stub_type != nios2_stub_none)
3939                     {
3940                       struct elf32_nios2_stub_hash_entry *hsh;
3941
3942                       hsh = nios2_get_stub_entry (input_section, sec,
3943                                                   eh, rel, htab, stub_type);
3944                       if (hsh == NULL)
3945                         {
3946                           r = bfd_reloc_undefined;
3947                           break;
3948                         }
3949
3950                       dest = (hsh->stub_offset
3951                               + hsh->stub_sec->output_offset
3952                               + hsh->stub_sec->output_section->vma);
3953                       r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3954                                                           input_section,
3955                                                           contents,
3956                                                           rel->r_offset,
3957                                                           dest, 0);
3958                       break;
3959                     }
3960                 }
3961
3962               /* Normal case.  */
3963               r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3964                                                   input_section, contents,
3965                                                   rel->r_offset, relocation,
3966                                                   rel->r_addend);
3967               break;
3968             case R_NIOS2_ALIGN:
3969               r = bfd_reloc_ok;
3970               /* For symmetry this would be
3971                  r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3972                                                   input_section, contents,
3973                                                   rel->r_offset, relocation,
3974                                                   rel->r_addend);
3975                 but do_ignore_reloc would do no more than return
3976                 bfd_reloc_ok. */
3977               break;
3978
3979             case R_NIOS2_GOT16:
3980             case R_NIOS2_CALL16:
3981             case R_NIOS2_GOT_LO:
3982             case R_NIOS2_GOT_HA:
3983             case R_NIOS2_CALL_LO:
3984             case R_NIOS2_CALL_HA:
3985               /* Relocation is to the entry for this symbol in the
3986                  global offset table.  */
3987               if (sgot == NULL)
3988                 {
3989                   r = bfd_reloc_notsupported;
3990                   break;
3991                 }
3992
3993               use_plt = 0;
3994
3995               if (h != NULL)
3996                 {
3997                   bfd_boolean dyn;
3998
3999                   eh = (struct elf32_nios2_link_hash_entry *)h;
4000                   use_plt = (eh->got_types_used == CALL_USED
4001                              && h->plt.offset != (bfd_vma) -1);
4002
4003                   off = h->got.offset;
4004                   BFD_ASSERT (off != (bfd_vma) -1);
4005                   dyn = htab->root.dynamic_sections_created;
4006                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4007                                                          bfd_link_pic (info),
4008                                                          h)
4009                       || (bfd_link_pic (info)
4010                           && SYMBOL_REFERENCES_LOCAL (info, h))
4011                       || ((ELF_ST_VISIBILITY (h->other)
4012                            || resolved_to_zero)
4013                           && h->root.type == bfd_link_hash_undefweak))
4014                     {
4015                       /* This is actually a static link, or it is a -Bsymbolic
4016                          link and the symbol is defined locally.  We must
4017                          initialize this entry in the global offset table.
4018                          Since the offset must always be a multiple of 4, we
4019                          use the least significant bit to record whether we
4020                          have initialized it already.
4021
4022                          When doing a dynamic link, we create a .rela.got
4023                          relocation entry to initialize the value.  This is
4024                          done in the finish_dynamic_symbol routine.  */
4025                       if ((off & 1) != 0)
4026                         off &= ~1;
4027                       else
4028                         {
4029                           bfd_put_32 (output_bfd, relocation,
4030                                       sgot->contents + off);
4031                           h->got.offset |= 1;
4032                         }
4033                     }
4034                   else
4035                     unresolved_reloc = FALSE;
4036                 }
4037               else
4038                 {
4039                   BFD_ASSERT (local_got_offsets != NULL
4040                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
4041
4042                   off = local_got_offsets[r_symndx];
4043
4044                   /* The offset must always be a multiple of 4.  We use the
4045                      least significant bit to record whether we have already
4046                      generated the necessary reloc.  */
4047                   if ((off & 1) != 0)
4048                     off &= ~1;
4049                   else
4050                     {
4051                       bfd_put_32 (output_bfd, relocation,
4052                                   sgot->contents + off);
4053
4054                       if (bfd_link_pic (info))
4055                         {
4056                           asection *srelgot;
4057                           Elf_Internal_Rela outrel;
4058                           bfd_byte *loc;
4059
4060                           srelgot = htab->root.srelgot;
4061                           BFD_ASSERT (srelgot != NULL);
4062
4063                           outrel.r_addend = relocation;
4064                           outrel.r_offset = (sgot->output_section->vma
4065                                              + sgot->output_offset
4066                                              + off);
4067                           outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4068                           loc = srelgot->contents;
4069                           loc += (srelgot->reloc_count++ *
4070                                   sizeof (Elf32_External_Rela));
4071                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4072                         }
4073
4074                       local_got_offsets[r_symndx] |= 1;
4075                     }
4076                 }
4077
4078               if (use_plt && bfd_link_pic (info))
4079                 {
4080                   off = ((h->plt.offset - 24) / 12 + 3) * 4;
4081                   relocation = (htab->root.sgotplt->output_offset + off
4082                                 - got_base);
4083                 }
4084               else
4085                 relocation = sgot->output_offset + off - got_base;
4086
4087               /* This relocation does not use the addend.  */
4088               rel->r_addend = 0;
4089
4090               switch (howto->type)
4091                 {
4092                 case R_NIOS2_GOT_LO:
4093                 case R_NIOS2_CALL_LO:
4094                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4095                                                     input_section, contents,
4096                                                     rel->r_offset, relocation,
4097                                                     rel->r_addend);
4098                   break;
4099                 case R_NIOS2_GOT_HA:
4100                 case R_NIOS2_CALL_HA:
4101                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4102                                                        input_section, contents,
4103                                                        rel->r_offset,
4104                                                        relocation,
4105                                                        rel->r_addend);
4106                   break;
4107                 default:
4108                   r = _bfd_final_link_relocate (howto, input_bfd,
4109                                                 input_section, contents,
4110                                                 rel->r_offset, relocation,
4111                                                 rel->r_addend);
4112                   break;
4113                 }
4114               break;
4115
4116             case R_NIOS2_GOTOFF_LO:
4117             case R_NIOS2_GOTOFF_HA:
4118             case R_NIOS2_GOTOFF:
4119               /* Relocation is relative to the global offset table pointer.  */
4120
4121               BFD_ASSERT (sgot != NULL);
4122               if (sgot == NULL)
4123                 {
4124                   r = bfd_reloc_notsupported;
4125                   break;
4126                 }
4127
4128               /* Note that sgot->output_offset is not involved in this
4129                  calculation.  We always want the start of .got.  */
4130               relocation -= sgot->output_section->vma;
4131
4132               /* Now we adjust the relocation to be relative to the GOT pointer
4133                  (the _gp_got symbol), which possibly contains the 0x8000 bias.  */
4134               relocation -= got_base;
4135
4136               switch (howto->type)
4137                 {
4138                 case R_NIOS2_GOTOFF_LO:
4139                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4140                                                     input_section, contents,
4141                                                     rel->r_offset, relocation,
4142                                                     rel->r_addend);
4143                   break;
4144                 case R_NIOS2_GOTOFF_HA:
4145                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4146                                                        input_section, contents,
4147                                                        rel->r_offset,
4148                                                        relocation,
4149                                                        rel->r_addend);
4150                   break;
4151                 default:
4152                   r = _bfd_final_link_relocate (howto, input_bfd,
4153                                                 input_section, contents,
4154                                                 rel->r_offset, relocation,
4155                                                 rel->r_addend);
4156                   break;
4157                 }
4158               break;
4159
4160             case R_NIOS2_TLS_LDO16:
4161               relocation -= dtpoff_base (info) + DTP_OFFSET;
4162
4163               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4164                                             contents, rel->r_offset,
4165                                             relocation, rel->r_addend);
4166               break;
4167             case R_NIOS2_TLS_LDM16:
4168               if (htab->root.sgot == NULL)
4169                 abort ();
4170
4171               off = htab->tls_ldm_got.offset;
4172
4173               if ((off & 1) != 0)
4174                 off &= ~1;
4175               else
4176                 {
4177                   /* If we don't know the module number, create a relocation
4178                      for it.  */
4179                   if (bfd_link_pic (info))
4180                     {
4181                       Elf_Internal_Rela outrel;
4182                       bfd_byte *loc;
4183
4184                       if (htab->root.srelgot == NULL)
4185                         abort ();
4186
4187                       outrel.r_addend = 0;
4188                       outrel.r_offset = (htab->root.sgot->output_section->vma
4189                                          + htab->root.sgot->output_offset
4190                                          + off);
4191                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
4192
4193                       loc = htab->root.srelgot->contents;
4194                       loc += (htab->root.srelgot->reloc_count++
4195                               * sizeof (Elf32_External_Rela));
4196                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4197                     }
4198                   else
4199                     bfd_put_32 (output_bfd, 1,
4200                                 htab->root.sgot->contents + off);
4201
4202                   htab->tls_ldm_got.offset |= 1;
4203                 }
4204
4205               relocation = htab->root.sgot->output_offset + off - got_base;
4206
4207               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4208                                             contents, rel->r_offset,
4209                                             relocation, rel->r_addend);
4210
4211               break;
4212             case R_NIOS2_TLS_GD16:
4213             case R_NIOS2_TLS_IE16:
4214               {
4215                 int indx;
4216                 char tls_type;
4217
4218                 if (htab->root.sgot == NULL)
4219                   abort ();
4220
4221                 indx = 0;
4222                 if (h != NULL)
4223                   {
4224                     bfd_boolean dyn;
4225                     dyn = htab->root.dynamic_sections_created;
4226                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4227                                                          bfd_link_pic (info),
4228                                                          h)
4229                         && (!bfd_link_pic (info)
4230                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
4231                       {
4232                         unresolved_reloc = FALSE;
4233                         indx = h->dynindx;
4234                       }
4235                     off = h->got.offset;
4236                     tls_type = (((struct elf32_nios2_link_hash_entry *) h)
4237                                 ->tls_type);
4238                   }
4239                 else
4240                   {
4241                     if (local_got_offsets == NULL)
4242                       abort ();
4243                     off = local_got_offsets[r_symndx];
4244                     tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
4245                                 [r_symndx]);
4246                   }
4247
4248                 if (tls_type == GOT_UNKNOWN)
4249                   abort ();
4250
4251                 if ((off & 1) != 0)
4252                   off &= ~1;
4253                 else
4254                   {
4255                     bfd_boolean need_relocs = FALSE;
4256                     Elf_Internal_Rela outrel;
4257                     bfd_byte *loc = NULL;
4258                     int cur_off = off;
4259
4260                     /* The GOT entries have not been initialized yet.  Do it
4261                        now, and emit any relocations.  If both an IE GOT and a
4262                        GD GOT are necessary, we emit the GD first.  */
4263
4264                     if ((bfd_link_pic (info) || indx != 0)
4265                         && (h == NULL
4266                             || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4267                                 && !resolved_to_zero)
4268                             || h->root.type != bfd_link_hash_undefweak))
4269                       {
4270                         need_relocs = TRUE;
4271                         if (htab->root.srelgot == NULL)
4272                           abort ();
4273                         loc = htab->root.srelgot->contents;
4274                         loc += (htab->root.srelgot->reloc_count *
4275                                 sizeof (Elf32_External_Rela));
4276                       }
4277
4278                     if (tls_type & GOT_TLS_GD)
4279                       {
4280                         if (need_relocs)
4281                           {
4282                             outrel.r_addend = 0;
4283                             outrel.r_offset = (htab->root.sgot->output_section->vma
4284                                                + htab->root.sgot->output_offset
4285                                                + cur_off);
4286                             outrel.r_info = ELF32_R_INFO (indx,
4287                                                           R_NIOS2_TLS_DTPMOD);
4288
4289                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4290                                                        loc);
4291                             htab->root.srelgot->reloc_count++;
4292                             loc += sizeof (Elf32_External_Rela);
4293
4294                             if (indx == 0)
4295                               bfd_put_32 (output_bfd,
4296                                           (relocation - dtpoff_base (info) -
4297                                            DTP_OFFSET),
4298                                           htab->root.sgot->contents + cur_off + 4);
4299                             else
4300                               {
4301                                 outrel.r_addend = 0;
4302                                 outrel.r_info = ELF32_R_INFO (indx,
4303                                   R_NIOS2_TLS_DTPREL);
4304                                 outrel.r_offset += 4;
4305
4306                                 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4307                                                            loc);
4308                                 htab->root.srelgot->reloc_count++;
4309                                 loc += sizeof (Elf32_External_Rela);
4310                               }
4311                           }
4312                         else
4313                           {
4314                             /* If we are not emitting relocations for a
4315                                general dynamic reference, then we must be in a
4316                                static link or an executable link with the
4317                                symbol binding locally.  Mark it as belonging
4318                                to module 1, the executable.  */
4319                             bfd_put_32 (output_bfd, 1,
4320                                         htab->root.sgot->contents + cur_off);
4321                             bfd_put_32 (output_bfd, (relocation -
4322                                                      dtpoff_base (info) -
4323                                                      DTP_OFFSET),
4324                                         htab->root.sgot->contents + cur_off + 4);
4325                           }
4326
4327                         cur_off += 8;
4328                       }
4329
4330                     if (tls_type & GOT_TLS_IE)
4331                       {
4332                         if (need_relocs)
4333                           {
4334                             if (indx == 0)
4335                               outrel.r_addend = (relocation -
4336                                                  dtpoff_base (info));
4337                             else
4338                               outrel.r_addend = 0;
4339                             outrel.r_offset = (htab->root.sgot->output_section->vma
4340                                                + htab->root.sgot->output_offset
4341                                                + cur_off);
4342                             outrel.r_info = ELF32_R_INFO (indx,
4343                                                           R_NIOS2_TLS_TPREL);
4344
4345                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4346                                                        loc);
4347                             htab->root.srelgot->reloc_count++;
4348                             loc += sizeof (Elf32_External_Rela);
4349                           }
4350                         else
4351                           bfd_put_32 (output_bfd, (tpoff (info, relocation)
4352                                                    - TP_OFFSET),
4353                                       htab->root.sgot->contents + cur_off);
4354                         cur_off += 4;
4355                       }
4356
4357                     if (h != NULL)
4358                       h->got.offset |= 1;
4359                     else
4360                       local_got_offsets[r_symndx] |= 1;
4361                   }
4362
4363                 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
4364                   off += 8;
4365                 relocation = htab->root.sgot->output_offset + off - got_base;
4366
4367                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4368                                               contents, rel->r_offset,
4369                                               relocation, rel->r_addend);
4370               }
4371
4372               break;
4373             case R_NIOS2_TLS_LE16:
4374               if (bfd_link_dll (info))
4375                 {
4376                   _bfd_error_handler
4377                     /* xgettext:c-format */
4378                     (_("%pB(%pA+%#" PRIx64 "): %s relocation not "
4379                        "permitted in shared object"),
4380                      input_bfd, input_section,
4381                      (uint64_t) rel->r_offset, howto->name);
4382                   return FALSE;
4383                 }
4384               else
4385                 relocation = tpoff (info, relocation) - TP_OFFSET;
4386
4387               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4388                                             contents, rel->r_offset,
4389                                             relocation, rel->r_addend);
4390               break;
4391
4392             case R_NIOS2_BFD_RELOC_32:
4393               if (bfd_link_pic (info)
4394                   && (input_section->flags & SEC_ALLOC) != 0
4395                   && (h == NULL
4396                       || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4397                           && !resolved_to_zero)
4398                       || h->root.type != bfd_link_hash_undefweak))
4399                 {
4400                   Elf_Internal_Rela outrel;
4401                   bfd_byte *loc;
4402                   bfd_boolean skip, relocate;
4403
4404                   /* When generating a shared object, these relocations
4405                      are copied into the output file to be resolved at run
4406                      time.  */
4407
4408                   skip = FALSE;
4409                   relocate = FALSE;
4410
4411                   outrel.r_offset
4412                     = _bfd_elf_section_offset (output_bfd, info,
4413                                                input_section, rel->r_offset);
4414                   if (outrel.r_offset == (bfd_vma) -1)
4415                     skip = TRUE;
4416                   else if (outrel.r_offset == (bfd_vma) -2)
4417                     skip = TRUE, relocate = TRUE;
4418                   outrel.r_offset += (input_section->output_section->vma
4419                                       + input_section->output_offset);
4420
4421                   if (skip)
4422                     memset (&outrel, 0, sizeof outrel);
4423                   else if (h != NULL
4424                            && h->dynindx != -1
4425                            && (!bfd_link_pic (info)
4426                                || !SYMBOLIC_BIND (info, h)
4427                                || !h->def_regular))
4428                     {
4429                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4430                       outrel.r_addend = rel->r_addend;
4431                     }
4432                   else
4433                     {
4434                       /* This symbol is local, or marked to become local.  */
4435                       outrel.r_addend = relocation + rel->r_addend;
4436                       relocate = TRUE;
4437                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4438                     }
4439
4440                   sreloc = elf_section_data (input_section)->sreloc;
4441                   if (sreloc == NULL)
4442                     abort ();
4443
4444                   loc = sreloc->contents;
4445                   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4446                   bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4447
4448                   /* This reloc will be computed at runtime, so there's no
4449                      need to do anything now, except for R_NIOS2_BFD_RELOC_32
4450                      relocations that have been turned into
4451                      R_NIOS2_RELATIVE.  */
4452                   if (!relocate)
4453                     break;
4454                 }
4455
4456               r = _bfd_final_link_relocate (howto, input_bfd,
4457                                             input_section, contents,
4458                                             rel->r_offset, relocation,
4459                                             rel->r_addend);
4460               break;
4461
4462             case R_NIOS2_TLS_DTPREL:
4463               relocation -= dtpoff_base (info);
4464               /* Fall through.  */
4465
4466             default:
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         }
4474       else
4475         r = bfd_reloc_notsupported;
4476
4477       if (r != bfd_reloc_ok)
4478         {
4479           if (h != NULL)
4480             name = h->root.root.string;
4481           else
4482             {
4483               name = bfd_elf_string_from_elf_section (input_bfd,
4484                                                       symtab_hdr->sh_link,
4485                                                       sym->st_name);
4486               if (name == NULL || *name == '\0')
4487                 name = bfd_section_name (input_bfd, sec);
4488             }
4489
4490           switch (r)
4491             {
4492             case bfd_reloc_overflow:
4493               (*info->callbacks->reloc_overflow) (info, NULL, name,
4494                                                   howto->name, (bfd_vma) 0,
4495                                                   input_bfd, input_section,
4496                                                   rel->r_offset);
4497               break;
4498
4499             case bfd_reloc_undefined:
4500               (*info->callbacks->undefined_symbol) (info, name, input_bfd,
4501                                                     input_section,
4502                                                     rel->r_offset, TRUE);
4503               break;
4504
4505             case bfd_reloc_outofrange:
4506               if (msg == NULL)
4507                 msg = _("relocation out of range");
4508               break;
4509
4510             case bfd_reloc_notsupported:
4511               if (msg == NULL)
4512                 msg = _("unsupported relocation");
4513               break;
4514
4515             case bfd_reloc_dangerous:
4516               if (msg == NULL)
4517                 msg = _("dangerous relocation");
4518               break;
4519
4520             default:
4521               if (msg == NULL)
4522                 msg = _("unknown error");
4523               break;
4524             }
4525
4526           if (msg)
4527             {
4528               (*info->callbacks->warning) (info, msg, name, input_bfd,
4529                                            input_section, rel->r_offset);
4530               if (msgbuf)
4531                 free (msgbuf);
4532               return FALSE;
4533             }
4534         }
4535     }
4536   return TRUE;
4537 }
4538
4539 /* Implement elf-backend_section_flags:
4540    Convert NIOS2 specific section flags to bfd internal section flags.  */
4541 static bfd_boolean
4542 nios2_elf32_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
4543 {
4544   if (hdr->sh_flags & SHF_NIOS2_GPREL)
4545     *flags |= SEC_SMALL_DATA;
4546
4547   return TRUE;
4548 }
4549
4550 /* Implement elf_backend_fake_sections:
4551    Set the correct type for an NIOS2 ELF section.  We do this by the
4552    section name, which is a hack, but ought to work.  */
4553 static bfd_boolean
4554 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
4555                            Elf_Internal_Shdr *hdr, asection *sec)
4556 {
4557   register const char *name = bfd_get_section_name (abfd, sec);
4558
4559   if ((sec->flags & SEC_SMALL_DATA)
4560       || strcmp (name, ".sdata") == 0
4561       || strcmp (name, ".sbss") == 0
4562       || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
4563     hdr->sh_flags |= SHF_NIOS2_GPREL;
4564
4565   return TRUE;
4566 }
4567
4568 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4569    shortcuts to them in our hash table.  */
4570 static bfd_boolean
4571 create_got_section (bfd *dynobj, struct bfd_link_info *info)
4572 {
4573   struct elf32_nios2_link_hash_table *htab;
4574   struct elf_link_hash_entry *h;
4575
4576   htab = elf32_nios2_hash_table (info);
4577
4578   if (! _bfd_elf_create_got_section (dynobj, info))
4579     return FALSE;
4580
4581   /* In order for the two loads in .PLTresolve to share the same %hiadj,
4582      _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary.  */
4583   if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt, 4))
4584     return FALSE;
4585
4586   /* The Nios II ABI specifies that GOT-relative relocations are relative
4587      to the linker-created symbol _gp_got, rather than using
4588      _GLOBAL_OFFSET_TABLE_ directly.  In particular, the latter always
4589      points to the base of the GOT while _gp_got may include a bias.  */
4590   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.sgotplt,
4591                                    "_gp_got");
4592   htab->h_gp_got = h;
4593   if (h == NULL)
4594     return FALSE;
4595
4596   return TRUE;
4597 }
4598
4599 /* Implement elf_backend_create_dynamic_sections:
4600    Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4601    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4602    hash table.  */
4603 static bfd_boolean
4604 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4605 {
4606   struct elf32_nios2_link_hash_table *htab;
4607
4608   htab = elf32_nios2_hash_table (info);
4609   if (!htab->root.sgot && !create_got_section (dynobj, info))
4610     return FALSE;
4611
4612   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4613     return FALSE;
4614
4615   /* In order for the two loads in a shared object .PLTresolve to share the
4616      same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4617      to a 16-byte boundary.  This is because the addresses for these loads
4618      include the -(.plt+4) PIC correction.  */
4619   return bfd_set_section_alignment (dynobj, htab->root.splt, 4);
4620 }
4621
4622 /* Implement elf_backend_copy_indirect_symbol:
4623    Copy the extra info we tack onto an elf_link_hash_entry.  */
4624 static void
4625 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
4626                                   struct elf_link_hash_entry *dir,
4627                                   struct elf_link_hash_entry *ind)
4628 {
4629   struct elf32_nios2_link_hash_entry *edir, *eind;
4630
4631   edir = (struct elf32_nios2_link_hash_entry *) dir;
4632   eind = (struct elf32_nios2_link_hash_entry *) ind;
4633
4634   if (eind->dyn_relocs != NULL)
4635     {
4636       if (edir->dyn_relocs != NULL)
4637         {
4638           struct elf_dyn_relocs **pp;
4639           struct elf_dyn_relocs *p;
4640
4641           /* Add reloc counts against the indirect sym to the direct sym
4642              list.  Merge any entries against the same section.  */
4643           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4644             {
4645               struct elf_dyn_relocs *q;
4646
4647               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4648                 if (q->sec == p->sec)
4649                   {
4650                     q->pc_count += p->pc_count;
4651                     q->count += p->count;
4652                     *pp = p->next;
4653                     break;
4654                   }
4655               if (q == NULL)
4656                 pp = &p->next;
4657             }
4658           *pp = edir->dyn_relocs;
4659         }
4660
4661       edir->dyn_relocs = eind->dyn_relocs;
4662       eind->dyn_relocs = NULL;
4663     }
4664
4665   if (ind->root.type == bfd_link_hash_indirect
4666       && dir->got.refcount <= 0)
4667     {
4668       edir->tls_type = eind->tls_type;
4669       eind->tls_type = GOT_UNKNOWN;
4670     }
4671
4672   edir->got_types_used |= eind->got_types_used;
4673
4674   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4675 }
4676
4677 /* Set the right machine number for a NIOS2 ELF file.  */
4678
4679 static bfd_boolean
4680 nios2_elf32_object_p (bfd *abfd)
4681 {
4682   unsigned long mach;
4683
4684   mach = elf_elfheader (abfd)->e_flags;
4685
4686   switch (mach)
4687     {
4688     default:
4689     case EF_NIOS2_ARCH_R1:
4690       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r1);
4691       break;
4692     case EF_NIOS2_ARCH_R2:
4693       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r2);
4694       break;
4695     }
4696
4697   return TRUE;
4698 }
4699
4700 /* Implement elf_backend_check_relocs:
4701    Look through the relocs for a section during the first phase.  */
4702 static bfd_boolean
4703 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
4704                           asection *sec, const Elf_Internal_Rela *relocs)
4705 {
4706   Elf_Internal_Shdr *symtab_hdr;
4707   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4708   const Elf_Internal_Rela *rel;
4709   const Elf_Internal_Rela *rel_end;
4710   struct elf32_nios2_link_hash_table *htab;
4711   asection *sreloc = NULL;
4712   bfd_signed_vma *local_got_refcounts;
4713
4714   if (bfd_link_relocatable (info))
4715     return TRUE;
4716
4717   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4718   sym_hashes = elf_sym_hashes (abfd);
4719   sym_hashes_end = (sym_hashes
4720                     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
4721   if (!elf_bad_symtab (abfd))
4722     sym_hashes_end -= symtab_hdr->sh_info;
4723   local_got_refcounts = elf_local_got_refcounts (abfd);
4724
4725   htab = elf32_nios2_hash_table (info);
4726
4727   rel_end = relocs + sec->reloc_count;
4728   for (rel = relocs; rel < rel_end; rel++)
4729     {
4730       unsigned int r_type;
4731       struct elf_link_hash_entry *h;
4732       unsigned long r_symndx;
4733
4734       r_symndx = ELF32_R_SYM (rel->r_info);
4735       if (r_symndx < symtab_hdr->sh_info)
4736         h = NULL;
4737       else
4738         {
4739           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4740           while (h->root.type == bfd_link_hash_indirect
4741                  || h->root.type == bfd_link_hash_warning)
4742             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4743         }
4744
4745       r_type = ELF32_R_TYPE (rel->r_info);
4746
4747       switch (r_type)
4748         {
4749         case R_NIOS2_GOT16:
4750         case R_NIOS2_GOT_LO:
4751         case R_NIOS2_GOT_HA:
4752         case R_NIOS2_CALL16:
4753         case R_NIOS2_CALL_LO:
4754         case R_NIOS2_CALL_HA:
4755         case R_NIOS2_TLS_GD16:
4756         case R_NIOS2_TLS_IE16:
4757           /* This symbol requires a global offset table entry.  */
4758           {
4759             int tls_type, old_tls_type;
4760
4761             switch (r_type)
4762               {
4763               default:
4764               case R_NIOS2_GOT16:
4765               case R_NIOS2_GOT_LO:
4766               case R_NIOS2_GOT_HA:
4767               case R_NIOS2_CALL16:
4768               case R_NIOS2_CALL_LO:
4769               case R_NIOS2_CALL_HA:
4770                 tls_type = GOT_NORMAL;
4771                 break;
4772               case R_NIOS2_TLS_GD16:
4773                 tls_type = GOT_TLS_GD;
4774                 break;
4775               case R_NIOS2_TLS_IE16:
4776                 tls_type = GOT_TLS_IE;
4777                 break;
4778               }
4779
4780             if (h != NULL)
4781               {
4782                 struct elf32_nios2_link_hash_entry *eh
4783                   = (struct elf32_nios2_link_hash_entry *)h;
4784                 h->got.refcount++;
4785                 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
4786                 if (r_type == R_NIOS2_CALL16
4787                     || r_type == R_NIOS2_CALL_LO
4788                     || r_type == R_NIOS2_CALL_HA)
4789                   {
4790                     /* Make sure a plt entry is created for this symbol if
4791                        it turns out to be a function defined by a dynamic
4792                        object.  */
4793                     h->plt.refcount++;
4794                     h->needs_plt = 1;
4795                     h->type = STT_FUNC;
4796                     eh->got_types_used |= CALL_USED;
4797                   }
4798                 else
4799                   eh->got_types_used |= GOT_USED;
4800               }
4801             else
4802               {
4803                 /* This is a global offset table entry for a local symbol.  */
4804                 if (local_got_refcounts == NULL)
4805                   {
4806                     bfd_size_type size;
4807
4808                     size = symtab_hdr->sh_info;
4809                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
4810                     local_got_refcounts
4811                       = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
4812                     if (local_got_refcounts == NULL)
4813                       return FALSE;
4814                     elf_local_got_refcounts (abfd) = local_got_refcounts;
4815                     elf32_nios2_local_got_tls_type (abfd)
4816                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4817                   }
4818                 local_got_refcounts[r_symndx]++;
4819                 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
4820               }
4821
4822             /* We will already have issued an error message if there is a
4823                TLS / non-TLS mismatch, based on the symbol type.  We don't
4824                support any linker relaxations.  So just combine any TLS
4825                types needed.  */
4826             if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4827                 && tls_type != GOT_NORMAL)
4828               tls_type |= old_tls_type;
4829
4830             if (old_tls_type != tls_type)
4831               {
4832                 if (h != NULL)
4833                   elf32_nios2_hash_entry (h)->tls_type = tls_type;
4834                 else
4835                   elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
4836               }
4837           }
4838         make_got:
4839           if (htab->root.sgot == NULL)
4840             {
4841               if (htab->root.dynobj == NULL)
4842                 htab->root.dynobj = abfd;
4843               if (!create_got_section (htab->root.dynobj, info))
4844                 return FALSE;
4845             }
4846           break;
4847
4848         case R_NIOS2_TLS_LDM16:
4849           htab->tls_ldm_got.refcount++;
4850           goto make_got;
4851
4852           /* This relocation describes the C++ object vtable hierarchy.
4853              Reconstruct it for later use during GC.  */
4854         case R_NIOS2_GNU_VTINHERIT:
4855           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4856             return FALSE;
4857           break;
4858
4859           /* This relocation describes which C++ vtable entries are actually
4860              used.  Record for later use during GC.  */
4861         case R_NIOS2_GNU_VTENTRY:
4862           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4863             return FALSE;
4864           break;
4865
4866         case R_NIOS2_BFD_RELOC_32:
4867         case R_NIOS2_CALL26:
4868         case R_NIOS2_CALL26_NOAT:
4869         case R_NIOS2_HIADJ16:
4870         case R_NIOS2_LO16:
4871
4872           if (h != NULL)
4873             {
4874               /* If this reloc is in a read-only section, we might
4875                    need a copy reloc.  We can't check reliably at this
4876                    stage whether the section is read-only, as input
4877                    sections have not yet been mapped to output sections.
4878                    Tentatively set the flag for now, and correct in
4879                    adjust_dynamic_symbol.  */
4880               if (!bfd_link_pic (info))
4881                 h->non_got_ref = 1;
4882
4883               /* Make sure a plt entry is created for this symbol if it
4884                  turns out to be a function defined by a dynamic object.  */
4885               h->plt.refcount++;
4886
4887               if (r_type == R_NIOS2_CALL26 || r_type == R_NIOS2_CALL26_NOAT)
4888                 h->needs_plt = 1;
4889             }
4890
4891           /* If we are creating a shared library, we need to copy the
4892              reloc into the shared library.  */
4893           if (bfd_link_pic (info)
4894               && (sec->flags & SEC_ALLOC) != 0
4895               && (r_type == R_NIOS2_BFD_RELOC_32
4896                   || (h != NULL && ! h->needs_plt
4897                       && (! SYMBOLIC_BIND (info, h) || ! h->def_regular))))
4898             {
4899               struct elf_dyn_relocs *p;
4900               struct elf_dyn_relocs **head;
4901
4902               /* When creating a shared object, we must copy these
4903                  reloc types into the output file.  We create a reloc
4904                  section in dynobj and make room for this reloc.  */
4905               if (sreloc == NULL)
4906                 {
4907                   if (htab->root.dynobj == NULL)
4908                     htab->root.dynobj = abfd;
4909
4910                   sreloc = _bfd_elf_make_dynamic_reloc_section
4911                     (sec, htab->root.dynobj, 2, abfd, TRUE);
4912                   if (sreloc == NULL)
4913                     return FALSE;
4914                 }
4915
4916               /* If this is a global symbol, we count the number of
4917                  relocations we need for this symbol.  */
4918               if (h != NULL)
4919                 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
4920               else
4921                 {
4922                   /* Track dynamic relocs needed for local syms too.
4923                      We really need local syms available to do this
4924                      easily.  Oh well.  */
4925
4926                   asection *s;
4927                   void *vpp;
4928                   Elf_Internal_Sym *isym;
4929
4930                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4931                                                 abfd, r_symndx);
4932                   if (isym == NULL)
4933                     return FALSE;
4934
4935                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4936                   if (s == NULL)
4937                     s = sec;
4938
4939                   vpp = &elf_section_data (s)->local_dynrel;
4940                   head = (struct elf_dyn_relocs **) vpp;
4941                 }
4942
4943               p = *head;
4944               if (p == NULL || p->sec != sec)
4945                 {
4946                   bfd_size_type amt = sizeof *p;
4947                   p = ((struct elf_dyn_relocs *)
4948                        bfd_alloc (htab->root.dynobj, amt));
4949                   if (p == NULL)
4950                     return FALSE;
4951                   p->next = *head;
4952                   *head = p;
4953                   p->sec = sec;
4954                   p->count = 0;
4955                   p->pc_count = 0;
4956                 }
4957
4958               p->count += 1;
4959
4960             }
4961           break;
4962         }
4963     }
4964
4965   return TRUE;
4966 }
4967
4968
4969 /* Implement elf_backend_gc_mark_hook:
4970    Return the section that should be marked against GC for a given
4971    relocation.  */
4972 static asection *
4973 nios2_elf32_gc_mark_hook (asection *sec,
4974                           struct bfd_link_info *info,
4975                           Elf_Internal_Rela *rel,
4976                           struct elf_link_hash_entry *h,
4977                           Elf_Internal_Sym *sym)
4978 {
4979   if (h != NULL)
4980     switch (ELF32_R_TYPE (rel->r_info))
4981       {
4982       case R_NIOS2_GNU_VTINHERIT:
4983       case R_NIOS2_GNU_VTENTRY:
4984         return NULL;
4985       }
4986   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4987 }
4988
4989 /* Implement elf_backend_finish_dynamic_symbols:
4990    Finish up dynamic symbol handling.  We set the contents of various
4991    dynamic sections here.  */
4992 static bfd_boolean
4993 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
4994                                    struct bfd_link_info *info,
4995                                    struct elf_link_hash_entry *h,
4996                                    Elf_Internal_Sym *sym)
4997 {
4998   struct elf32_nios2_link_hash_table *htab;
4999   struct elf32_nios2_link_hash_entry *eh
5000     = (struct elf32_nios2_link_hash_entry *)h;
5001   int use_plt;
5002
5003   htab = elf32_nios2_hash_table (info);
5004
5005   if (h->plt.offset != (bfd_vma) -1)
5006     {
5007       asection *splt;
5008       asection *sgotplt;
5009       asection *srela;
5010       bfd_vma plt_index;
5011       bfd_vma got_offset;
5012       Elf_Internal_Rela rela;
5013       bfd_byte *loc;
5014       bfd_vma got_address;
5015
5016       /* This symbol has an entry in the procedure linkage table.  Set
5017          it up.  */
5018       BFD_ASSERT (h->dynindx != -1);
5019       splt = htab->root.splt;
5020       sgotplt = htab->root.sgotplt;
5021       srela = htab->root.srelplt;
5022       BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
5023
5024       /* Emit the PLT entry.  */
5025       if (bfd_link_pic (info))
5026         {
5027           nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
5028                                     3);
5029           plt_index = (h->plt.offset - 24) / 12;
5030           got_offset = (plt_index + 3) * 4;
5031           nios2_elf32_install_imm16 (splt, h->plt.offset,
5032                                      hiadj(plt_index * 4));
5033           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5034                                      (plt_index * 4) & 0xffff);
5035           nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
5036                                      0xfff4 - h->plt.offset);
5037           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5038                          + got_offset);
5039
5040           /* Fill in the entry in the global offset table.  There are no
5041              res_n slots for a shared object PLT, instead the .got.plt entries
5042              point to the PLT entries.  */
5043           bfd_put_32 (output_bfd,
5044                       splt->output_section->vma + splt->output_offset
5045                       + h->plt.offset, sgotplt->contents + got_offset);
5046         }
5047       else
5048         {
5049           plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
5050           got_offset = (plt_index + 3) * 4;
5051
5052           nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
5053           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5054                          + got_offset);
5055           nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
5056           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5057                                      got_address & 0xffff);
5058
5059           /* Fill in the entry in the global offset table.  */
5060           bfd_put_32 (output_bfd,
5061                       splt->output_section->vma + splt->output_offset
5062                       + plt_index * 4, sgotplt->contents + got_offset);
5063         }
5064
5065       /* Fill in the entry in the .rela.plt section.  */
5066       rela.r_offset = got_address;
5067       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
5068       rela.r_addend = 0;
5069       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
5070       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5071
5072       if (!h->def_regular)
5073         {
5074           /* Mark the symbol as undefined, rather than as defined in
5075              the .plt section.  Leave the value alone.  */
5076           sym->st_shndx = SHN_UNDEF;
5077           /* If the symbol is weak, we do need to clear the value.
5078              Otherwise, the PLT entry would provide a definition for
5079              the symbol even if the symbol wasn't defined anywhere,
5080              and so the symbol would never be NULL.  */
5081           if (!h->ref_regular_nonweak)
5082             sym->st_value = 0;
5083         }
5084     }
5085
5086   use_plt = (eh->got_types_used == CALL_USED
5087              && h->plt.offset != (bfd_vma) -1);
5088
5089   if (!use_plt && h->got.offset != (bfd_vma) -1
5090       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5091       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5092     {
5093       asection *sgot;
5094       asection *srela;
5095       Elf_Internal_Rela rela;
5096       bfd_byte *loc;
5097       bfd_vma offset;
5098
5099       /* This symbol has an entry in the global offset table.  Set it
5100          up.  */
5101       sgot = htab->root.sgot;
5102       srela = htab->root.srelgot;
5103       BFD_ASSERT (sgot != NULL && srela != NULL);
5104
5105       offset = (h->got.offset & ~(bfd_vma) 1);
5106       rela.r_offset = (sgot->output_section->vma
5107                        + sgot->output_offset + offset);
5108
5109       /* If this is a -Bsymbolic link, and the symbol is defined
5110          locally, we just want to emit a RELATIVE reloc.  Likewise if
5111          the symbol was forced to be local because of a version file.
5112          The entry in the global offset table will already have been
5113          initialized in the relocate_section function.  */
5114
5115       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
5116         {
5117           rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
5118           rela.r_addend = bfd_get_signed_32 (output_bfd,
5119                                              (sgot->contents + offset));
5120           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
5121         }
5122       else
5123         {
5124           bfd_put_32 (output_bfd, (bfd_vma) 0,
5125                       sgot->contents + offset);
5126           rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
5127           rela.r_addend = 0;
5128         }
5129
5130       loc = srela->contents;
5131       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5132       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5133     }
5134
5135   if (use_plt && h->got.offset != (bfd_vma) -1)
5136     {
5137       bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
5138       asection *sgot = htab->root.sgot;
5139       asection *splt = htab->root.splt;
5140       bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
5141                                + h->plt.offset),
5142                   sgot->contents + offset);
5143     }
5144
5145   if (h->needs_copy)
5146     {
5147       asection *s;
5148       Elf_Internal_Rela rela;
5149       bfd_byte *loc;
5150
5151       /* This symbol needs a copy reloc.  Set it up.  */
5152       BFD_ASSERT (h->dynindx != -1
5153                   && (h->root.type == bfd_link_hash_defined
5154                       || h->root.type == bfd_link_hash_defweak));
5155
5156       rela.r_offset = (h->root.u.def.value
5157                        + h->root.u.def.section->output_section->vma
5158                        + h->root.u.def.section->output_offset);
5159       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
5160       rela.r_addend = 0;
5161       if (h->root.u.def.section == htab->root.sdynrelro)
5162         s = htab->root.sreldynrelro;
5163       else
5164         s = htab->root.srelbss;
5165       BFD_ASSERT (s != NULL);
5166       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5167       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5168     }
5169
5170   /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute.  */
5171   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5172       || h == htab->root.hgot
5173       || h == htab->h_gp_got)
5174     sym->st_shndx = SHN_ABS;
5175
5176   return TRUE;
5177 }
5178
5179 /* Implement elf_backend_finish_dynamic_sections.  */
5180 static bfd_boolean
5181 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
5182                                      struct bfd_link_info *info)
5183 {
5184   asection *sgotplt;
5185   asection *sdyn;
5186   struct elf32_nios2_link_hash_table *htab;
5187
5188   htab = elf32_nios2_hash_table (info);
5189   sgotplt = htab->root.sgotplt;
5190   sdyn = NULL;
5191
5192   if (htab->root.dynamic_sections_created)
5193     {
5194       asection *splt;
5195       Elf32_External_Dyn *dyncon, *dynconend;
5196
5197       splt = htab->root.splt;
5198       sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
5199       BFD_ASSERT (splt != NULL && sdyn != NULL && sgotplt != NULL);
5200
5201       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5202       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5203       for (; dyncon < dynconend; dyncon++)
5204         {
5205           Elf_Internal_Dyn dyn;
5206           asection *s;
5207
5208           bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
5209
5210           switch (dyn.d_tag)
5211             {
5212             default:
5213               break;
5214
5215             case DT_PLTGOT:
5216               s = htab->root.sgotplt;
5217               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5218               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5219               break;
5220
5221             case DT_JMPREL:
5222               s = htab->root.srelplt;
5223               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5224               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5225               break;
5226
5227             case DT_PLTRELSZ:
5228               s = htab->root.srelplt;
5229               dyn.d_un.d_val = s->size;
5230               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5231               break;
5232
5233             case DT_NIOS2_GP:
5234               s = htab->root.sgotplt;
5235               dyn.d_un.d_ptr
5236                 = s->output_section->vma + s->output_offset + 0x7ff0;
5237               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5238               break;
5239             }
5240         }
5241
5242       /* Fill in the first entry in the procedure linkage table.  */
5243       if (splt->size > 0)
5244         {
5245           bfd_vma got_address = (sgotplt->output_section->vma
5246                                  + sgotplt->output_offset);
5247           if (bfd_link_pic (info))
5248             {
5249               bfd_vma got_pcrel = got_address - (splt->output_section->vma
5250                                                  + splt->output_offset);
5251               /* Both GOT and PLT must be aligned to a 16-byte boundary
5252                  for the two loads to share the %hiadj part.  The 4-byte
5253                  offset for nextpc is accounted for in the %lo offsets
5254                  on the loads.  */
5255               BFD_ASSERT ((got_pcrel & 0xf) == 0);
5256               nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
5257               nios2_elf32_install_imm16 (splt, 4, hiadj (got_pcrel));
5258               nios2_elf32_install_imm16 (splt, 12, got_pcrel & 0xffff);
5259               nios2_elf32_install_imm16 (splt, 16, (got_pcrel + 4) & 0xffff);
5260             }
5261           else
5262             {
5263               /* Divide by 4 here, not 3 because we already corrected for the
5264                  res_N branches.  */
5265               bfd_vma res_size = (splt->size - 28) / 4;
5266               bfd_vma res_start = (splt->output_section->vma
5267                                    + splt->output_offset);
5268               bfd_vma res_offset;
5269
5270               for (res_offset = 0; res_offset < res_size; res_offset += 4)
5271                 bfd_put_32 (output_bfd,
5272                             6 | ((res_size - (res_offset + 4)) << 6),
5273                             splt->contents + res_offset);
5274
5275               /* The GOT must be aligned to a 16-byte boundary for the
5276                  two loads to share the same %hiadj part.  */
5277               BFD_ASSERT ((got_address & 0xf) == 0);
5278
5279               nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
5280               nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
5281               nios2_elf32_install_imm16 (splt, res_size + 4,
5282                                          res_start & 0xffff);
5283               nios2_elf32_install_imm16 (splt, res_size + 12,
5284                                          hiadj (got_address));
5285               nios2_elf32_install_imm16 (splt, res_size + 16,
5286                                          (got_address + 4) & 0xffff);
5287               nios2_elf32_install_imm16 (splt, res_size + 20,
5288                                          (got_address + 8) & 0xffff);
5289             }
5290         }
5291     }
5292
5293   /* Fill in the first three entries in the global offset table.  */
5294   if (sgotplt != NULL && sgotplt->size > 0)
5295     {
5296       if (sdyn == NULL)
5297         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
5298       else
5299         bfd_put_32 (output_bfd,
5300                     sdyn->output_section->vma + sdyn->output_offset,
5301                     sgotplt->contents);
5302       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
5303       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
5304
5305       if (sgotplt->output_section != bfd_abs_section_ptr)
5306         elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
5307     }
5308
5309   return TRUE;
5310 }
5311
5312 /* Implement elf_backend_adjust_dynamic_symbol:
5313    Adjust a symbol defined by a dynamic object and referenced by a
5314    regular object.  The current definition is in some section of the
5315    dynamic object, but we're not including those sections.  We have to
5316    change the definition to something the rest of the link can
5317    understand.  */
5318 static bfd_boolean
5319 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
5320                                    struct elf_link_hash_entry *h)
5321 {
5322   struct elf32_nios2_link_hash_table *htab;
5323   bfd *dynobj;
5324   asection *s, *srel;
5325   unsigned align2;
5326
5327   htab = elf32_nios2_hash_table (info);
5328   dynobj = htab->root.dynobj;
5329
5330   /* Make sure we know what is going on here.  */
5331   BFD_ASSERT (dynobj != NULL
5332               && (h->needs_plt
5333                   || h->is_weakalias
5334                   || (h->def_dynamic
5335                       && h->ref_regular
5336                       && !h->def_regular)));
5337
5338   /* If this is a function, put it in the procedure linkage table.  We
5339      will fill in the contents of the procedure linkage table later,
5340      when we know the address of the .got section.  */
5341   if (h->type == STT_FUNC || h->needs_plt)
5342     {
5343       if (h->plt.refcount <= 0
5344           || SYMBOL_CALLS_LOCAL (info, h)
5345           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5346               && h->root.type == bfd_link_hash_undefweak))
5347         {
5348           /* This case can occur if we saw a PLT reloc in an input
5349              file, but the symbol was never referred to by a dynamic
5350              object, or if all references were garbage collected.  In
5351              such a case, we don't actually need to build a procedure
5352              linkage table, and we can just do a PCREL reloc instead.  */
5353           h->plt.offset = (bfd_vma) -1;
5354           h->needs_plt = 0;
5355         }
5356
5357       return TRUE;
5358     }
5359
5360   /* Reinitialize the plt offset now that it is not used as a reference
5361      count any more.  */
5362   h->plt.offset = (bfd_vma) -1;
5363
5364   /* If this is a weak symbol, and there is a real definition, the
5365      processor independent code will have arranged for us to see the
5366      real definition first, and we can just use the same value.  */
5367   if (h->is_weakalias)
5368     {
5369       struct elf_link_hash_entry *def = weakdef (h);
5370       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
5371       h->root.u.def.section = def->root.u.def.section;
5372       h->root.u.def.value = def->root.u.def.value;
5373       return TRUE;
5374     }
5375
5376   /* If there are no non-GOT references, we do not need a copy
5377      relocation.  */
5378   if (!h->non_got_ref)
5379     return TRUE;
5380
5381   /* This is a reference to a symbol defined by a dynamic object which
5382      is not a function.
5383      If we are creating a shared library, we must presume that the
5384      only references to the symbol are via the global offset table.
5385      For such cases we need not do anything here; the relocations will
5386      be handled correctly by relocate_section.  */
5387   if (bfd_link_pic (info))
5388     return TRUE;
5389
5390   if (h->size == 0)
5391     {
5392       _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5393                           h->root.root.string);
5394       return TRUE;
5395     }
5396
5397   /* We must allocate the symbol in our .dynbss section, which will
5398      become part of the .bss section of the executable.  There will be
5399      an entry for this symbol in the .dynsym section.  The dynamic
5400      object will contain position independent code, so all references
5401      from the dynamic object to this symbol will go through the global
5402      offset table.  The dynamic linker will use the .dynsym entry to
5403      determine the address it must put in the global offset table, so
5404      both the dynamic object and the regular object will refer to the
5405      same memory location for the variable.  */
5406   /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5407      copy the initial value out of the dynamic object and into the
5408      runtime process image.  We need to remember the offset into the
5409      .rela.bss section we are going to use.  */
5410   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5411     {
5412       s = htab->root.sdynrelro;
5413       srel = htab->root.sreldynrelro;
5414     }
5415   else
5416     {
5417       s = htab->root.sdynbss;
5418       srel = htab->root.srelbss;
5419     }
5420   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5421     {
5422       srel->size += sizeof (Elf32_External_Rela);
5423       h->needs_copy = 1;
5424     }
5425
5426   align2 = bfd_log2 (h->size);
5427   if (align2 > h->root.u.def.section->alignment_power)
5428     align2 = h->root.u.def.section->alignment_power;
5429
5430   /* Align dynbss.  */
5431   s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
5432   if (align2 > bfd_get_section_alignment (dynobj, s)
5433       && !bfd_set_section_alignment (dynobj, s, align2))
5434     return FALSE;
5435
5436   /* Define the symbol as being at this point in the section.  */
5437   h->root.u.def.section = s;
5438   h->root.u.def.value = s->size;
5439
5440   /* Increment the section size to make room for the symbol.  */
5441   s->size += h->size;
5442
5443   return TRUE;
5444 }
5445
5446 /* Worker function for nios2_elf32_size_dynamic_sections.  */
5447 static bfd_boolean
5448 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5449 {
5450   struct bfd_link_info *info;
5451   struct elf32_nios2_link_hash_table *htab;
5452
5453   if (h->root.type == bfd_link_hash_indirect)
5454     return TRUE;
5455
5456   if (h->root.type == bfd_link_hash_warning)
5457     /* When warning symbols are created, they **replace** the "real"
5458        entry in the hash table, thus we never get to see the real
5459        symbol in a hash traversal.  So look at it now.  */
5460     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5461
5462   info = (struct bfd_link_info *) inf;
5463   htab = elf32_nios2_hash_table (info);
5464
5465   if (h->plt.offset != (bfd_vma)-1)
5466     h->plt.offset += htab->res_n_size;
5467   if (htab->root.splt == h->root.u.def.section)
5468     h->root.u.def.value += htab->res_n_size;
5469
5470   return TRUE;
5471 }
5472
5473 /* Another worker function for nios2_elf32_size_dynamic_sections.
5474    Allocate space in .plt, .got and associated reloc sections for
5475    dynamic relocs.  */
5476 static bfd_boolean
5477 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5478 {
5479   struct bfd_link_info *info;
5480   struct elf32_nios2_link_hash_table *htab;
5481   struct elf32_nios2_link_hash_entry *eh;
5482   struct elf_dyn_relocs *p;
5483   int use_plt;
5484
5485   if (h->root.type == bfd_link_hash_indirect)
5486     return TRUE;
5487
5488   if (h->root.type == bfd_link_hash_warning)
5489     /* When warning symbols are created, they **replace** the "real"
5490        entry in the hash table, thus we never get to see the real
5491        symbol in a hash traversal.  So look at it now.  */
5492     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5493
5494   info = (struct bfd_link_info *) inf;
5495   htab = elf32_nios2_hash_table (info);
5496
5497   if (htab->root.dynamic_sections_created
5498       && h->plt.refcount > 0)
5499     {
5500       /* Make sure this symbol is output as a dynamic symbol.
5501          Undefined weak syms won't yet be marked as dynamic.  */
5502       if (h->dynindx == -1
5503           && !h->forced_local
5504           && !bfd_elf_link_record_dynamic_symbol (info, h))
5505         return FALSE;
5506
5507       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
5508         {
5509           asection *s = htab->root.splt;
5510
5511           /* Allocate room for the header.  */
5512           if (s->size == 0)
5513             {
5514               if (bfd_link_pic (info))
5515                 s->size = 24;
5516               else
5517                 s->size = 28;
5518             }
5519
5520           h->plt.offset = s->size;
5521
5522           /* If this symbol is not defined in a regular file, and we are
5523              not generating a shared library, then set the symbol to this
5524              location in the .plt.  This is required to make function
5525              pointers compare as equal between the normal executable and
5526              the shared library.  */
5527           if (! bfd_link_pic (info)
5528               && !h->def_regular)
5529             {
5530               h->root.u.def.section = s;
5531               h->root.u.def.value = h->plt.offset;
5532             }
5533
5534           /* Make room for this entry.  */
5535           s->size += 12;
5536
5537           /* We also need to make an entry in the .rela.plt section.  */
5538           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
5539
5540           /* And the .got.plt section.  */
5541           htab->root.sgotplt->size += 4;
5542         }
5543       else
5544         {
5545           h->plt.offset = (bfd_vma) -1;
5546           h->needs_plt = 0;
5547         }
5548     }
5549   else
5550     {
5551       h->plt.offset = (bfd_vma) -1;
5552       h->needs_plt = 0;
5553     }
5554
5555   eh = (struct elf32_nios2_link_hash_entry *) h;
5556   use_plt = (eh->got_types_used == CALL_USED
5557              && h->plt.offset != (bfd_vma) -1);
5558
5559   if (h->got.refcount > 0)
5560     {
5561       asection *s;
5562       bfd_boolean dyn;
5563       int tls_type = eh->tls_type;
5564       int indx;
5565
5566       /* Make sure this symbol is output as a dynamic symbol.
5567          Undefined weak syms won't yet be marked as dynamic.  */
5568       if (h->dynindx == -1
5569           && !h->forced_local
5570           && !bfd_elf_link_record_dynamic_symbol (info, h))
5571         return FALSE;
5572
5573       s = htab->root.sgot;
5574       h->got.offset = s->size;
5575
5576       if (tls_type == GOT_UNKNOWN)
5577         abort ();
5578
5579       if (tls_type == GOT_NORMAL)
5580         /* Non-TLS symbols need one GOT slot.  */
5581         s->size += 4;
5582       else
5583         {
5584           if (tls_type & GOT_TLS_GD)
5585             /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots.  */
5586             s->size += 8;
5587           if (tls_type & GOT_TLS_IE)
5588             /* R_NIOS2_TLS_IE16 needs one GOT slot.  */
5589             s->size += 4;
5590         }
5591
5592       dyn = htab->root.dynamic_sections_created;
5593
5594       indx = 0;
5595       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5596           && (!bfd_link_pic (info)
5597               || !SYMBOL_REFERENCES_LOCAL (info, h)))
5598         indx = h->dynindx;
5599
5600       if (tls_type != GOT_NORMAL
5601           && (bfd_link_pic (info) || indx != 0)
5602           && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5603               || h->root.type != bfd_link_hash_undefweak))
5604         {
5605           if (tls_type & GOT_TLS_IE)
5606             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5607
5608           if (tls_type & GOT_TLS_GD)
5609             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5610
5611           if ((tls_type & GOT_TLS_GD) && indx != 0)
5612             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5613         }
5614       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5615                 || h->root.type != bfd_link_hash_undefweak)
5616                && !use_plt
5617                && (bfd_link_pic (info)
5618                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5619         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5620     }
5621   else
5622     h->got.offset = (bfd_vma) -1;
5623
5624   if (eh->dyn_relocs == NULL)
5625     return TRUE;
5626
5627   /* In the shared -Bsymbolic case, discard space allocated for
5628      dynamic pc-relative relocs against symbols which turn out to be
5629      defined in regular objects.  For the normal shared case, discard
5630      space for pc-relative relocs that have become local due to symbol
5631      visibility changes.  */
5632
5633   if (bfd_link_pic (info))
5634     {
5635       if (h->def_regular
5636           && (h->forced_local || SYMBOLIC_BIND (info, h)))
5637         {
5638           struct elf_dyn_relocs **pp;
5639
5640           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5641             {
5642               p->count -= p->pc_count;
5643               p->pc_count = 0;
5644               if (p->count == 0)
5645                 *pp = p->next;
5646               else
5647                 pp = &p->next;
5648             }
5649         }
5650
5651       /* Also discard relocs on undefined weak syms with non-default
5652          visibility.  */
5653       if (eh->dyn_relocs != NULL
5654           && h->root.type == bfd_link_hash_undefweak)
5655         {
5656           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5657               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5658             eh->dyn_relocs = NULL;
5659
5660           /* Make sure undefined weak symbols are output as a dynamic
5661              symbol in PIEs.  */
5662           else if (h->dynindx == -1
5663                    && !h->forced_local
5664                    && !bfd_elf_link_record_dynamic_symbol (info, h))
5665             return FALSE;
5666         }
5667     }
5668   else
5669     {
5670       /* For the non-shared case, discard space for relocs against
5671          symbols which turn out to need copy relocs or are not
5672          dynamic.  */
5673
5674       if (!h->non_got_ref
5675           && ((h->def_dynamic && !h->def_regular)
5676               || (htab->root.dynamic_sections_created
5677                   && (h->root.type == bfd_link_hash_undefweak
5678                       || h->root.type == bfd_link_hash_undefined))))
5679         {
5680           /* Make sure this symbol is output as a dynamic symbol.
5681              Undefined weak syms won't yet be marked as dynamic.  */
5682           if (h->dynindx == -1
5683               && !h->forced_local
5684               && !bfd_elf_link_record_dynamic_symbol (info, h))
5685             return FALSE;
5686
5687           /* If that succeeded, we know we'll be keeping all the
5688              relocs.  */
5689           if (h->dynindx != -1)
5690             goto keep;
5691         }
5692
5693       eh->dyn_relocs = NULL;
5694
5695     keep: ;
5696     }
5697
5698   /* Finally, allocate space.  */
5699   for (p = eh->dyn_relocs; p != NULL; p = p->next)
5700     {
5701       asection *sreloc = elf_section_data (p->sec)->sreloc;
5702       sreloc->size += p->count * sizeof (Elf32_External_Rela);
5703     }
5704
5705   return TRUE;
5706 }
5707
5708 /* Implement elf_backend_size_dynamic_sections:
5709    Set the sizes of the dynamic sections.  */
5710 static bfd_boolean
5711 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5712                                    struct bfd_link_info *info)
5713 {
5714   bfd *dynobj;
5715   asection *s;
5716   bfd_boolean relocs;
5717   bfd *ibfd;
5718   struct elf32_nios2_link_hash_table *htab;
5719
5720   htab = elf32_nios2_hash_table (info);
5721   dynobj = htab->root.dynobj;
5722   BFD_ASSERT (dynobj != NULL);
5723
5724   htab->res_n_size = 0;
5725   if (htab->root.dynamic_sections_created)
5726     {
5727       /* Set the contents of the .interp section to the interpreter.  */
5728       if (bfd_link_executable (info) && !info->nointerp)
5729         {
5730           s = bfd_get_linker_section (dynobj, ".interp");
5731           BFD_ASSERT (s != NULL);
5732           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5733           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5734         }
5735     }
5736   else
5737     {
5738       /* We may have created entries in the .rela.got section.
5739          However, if we are not creating the dynamic sections, we will
5740          not actually use these entries.  Reset the size of .rela.got,
5741          which will cause it to get stripped from the output file
5742          below.  */
5743       s = htab->root.srelgot;
5744       if (s != NULL)
5745         s->size = 0;
5746     }
5747
5748   /* Set up .got offsets for local syms, and space for local dynamic
5749      relocs.  */
5750   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5751     {
5752       bfd_signed_vma *local_got;
5753       bfd_signed_vma *end_local_got;
5754       char *local_tls_type;
5755       bfd_size_type locsymcount;
5756       Elf_Internal_Shdr *symtab_hdr;
5757       asection *srel;
5758
5759       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5760         continue;
5761
5762       for (s = ibfd->sections; s != NULL; s = s->next)
5763         {
5764           struct elf_dyn_relocs *p;
5765
5766           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
5767             {
5768               if (!bfd_is_abs_section (p->sec)
5769                   && bfd_is_abs_section (p->sec->output_section))
5770                 {
5771                   /* Input section has been discarded, either because
5772                      it is a copy of a linkonce section or due to
5773                      linker script /DISCARD/, so we'll be discarding
5774                      the relocs too.  */
5775                 }
5776               else if (p->count != 0)
5777                 {
5778                   srel = elf_section_data (p->sec)->sreloc;
5779                   srel->size += p->count * sizeof (Elf32_External_Rela);
5780                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
5781                     info->flags |= DF_TEXTREL;
5782                 }
5783             }
5784         }
5785
5786       local_got = elf_local_got_refcounts (ibfd);
5787       if (!local_got)
5788         continue;
5789
5790       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5791       locsymcount = symtab_hdr->sh_info;
5792       end_local_got = local_got + locsymcount;
5793       local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
5794       s = htab->root.sgot;
5795       srel = htab->root.srelgot;
5796       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5797         {
5798           if (*local_got > 0)
5799             {
5800               *local_got = s->size;
5801               if (*local_tls_type & GOT_TLS_GD)
5802                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5803                 s->size += 8;
5804               if (*local_tls_type & GOT_TLS_IE)
5805                 s->size += 4;
5806               if (*local_tls_type == GOT_NORMAL)
5807                 s->size += 4;
5808
5809               if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
5810                 srel->size += sizeof (Elf32_External_Rela);
5811             }
5812           else
5813             *local_got = (bfd_vma) -1;
5814         }
5815     }
5816
5817   if (htab->tls_ldm_got.refcount > 0)
5818     {
5819       /* Allocate two GOT entries and one dynamic relocation (if necessary)
5820          for R_NIOS2_TLS_LDM16 relocations.  */
5821       htab->tls_ldm_got.offset = htab->root.sgot->size;
5822       htab->root.sgot->size += 8;
5823       if (bfd_link_pic (info))
5824         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5825     }
5826   else
5827     htab->tls_ldm_got.offset = -1;
5828
5829   /* Allocate global sym .plt and .got entries, and space for global
5830      sym dynamic relocs.  */
5831   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5832
5833   if (htab->root.dynamic_sections_created)
5834     {
5835       /* If the .got section is more than 0x8000 bytes, we add
5836          0x8000 to the value of _gp_got, so that 16-bit relocations
5837          have a greater chance of working. */
5838       if (htab->root.sgot->size >= 0x8000
5839           && htab->h_gp_got->root.u.def.value == 0)
5840         htab->h_gp_got->root.u.def.value = 0x8000;
5841     }
5842
5843   /* The check_relocs and adjust_dynamic_symbol entry points have
5844      determined the sizes of the various dynamic sections.  Allocate
5845      memory for them.  */
5846   relocs = FALSE;
5847   for (s = dynobj->sections; s != NULL; s = s->next)
5848     {
5849       const char *name;
5850
5851       if ((s->flags & SEC_LINKER_CREATED) == 0)
5852         continue;
5853
5854       /* It's OK to base decisions on the section name, because none
5855          of the dynobj section names depend upon the input files.  */
5856       name = bfd_get_section_name (dynobj, s);
5857
5858       if (CONST_STRNEQ (name, ".rela"))
5859         {
5860           if (s->size != 0)
5861             {
5862               if (s != htab->root.srelplt)
5863                 relocs = TRUE;
5864
5865               /* We use the reloc_count field as a counter if we need
5866                  to copy relocs into the output file.  */
5867               s->reloc_count = 0;
5868             }
5869         }
5870       else if (s == htab->root.splt)
5871         {
5872           /* Correct for the number of res_N branches.  */
5873           if (s->size != 0 && !bfd_link_pic (info))
5874             {
5875               htab->res_n_size = (s->size - 28) / 3;
5876               s->size += htab->res_n_size;
5877             }
5878         }
5879       else if (s != htab->sbss
5880                && s != htab->root.sgot
5881                && s != htab->root.sgotplt
5882                && s != htab->root.sdynbss
5883                && s != htab->root.sdynrelro)
5884         /* It's not one of our sections, so don't allocate space.  */
5885         continue;
5886
5887       if (s->size == 0)
5888         {
5889           s->flags |= SEC_EXCLUDE;
5890           continue;
5891         }
5892
5893       if ((s->flags & SEC_HAS_CONTENTS) == 0)
5894         continue;
5895
5896       /* Allocate memory for the section contents.  */
5897       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5898       if (s->contents == NULL)
5899         return FALSE;
5900     }
5901
5902   /* Adjust dynamic symbols that point to the plt to account for the
5903      now-known number of resN slots.  */
5904   if (htab->res_n_size)
5905     elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
5906
5907   if (htab->root.dynamic_sections_created)
5908     {
5909       /* Add some entries to the .dynamic section.  We fill in the
5910          values later, in elf_nios2_finish_dynamic_sections, but we
5911          must add the entries now so that we get the correct size for
5912          the .dynamic section.  The DT_DEBUG entry is filled in by the
5913          dynamic linker and used by the debugger.  */
5914 #define add_dynamic_entry(TAG, VAL) \
5915   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5916
5917       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_DEBUG, 0))
5918         return FALSE;
5919
5920       if (htab->root.sgotplt->size != 0
5921           && !add_dynamic_entry (DT_PLTGOT, 0))
5922         return FALSE;
5923
5924       if (htab->root.splt->size != 0
5925           && (!add_dynamic_entry (DT_PLTRELSZ, 0)
5926               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5927               || !add_dynamic_entry (DT_JMPREL, 0)))
5928         return FALSE;
5929
5930       if (relocs
5931           && (!add_dynamic_entry (DT_RELA, 0)
5932               || !add_dynamic_entry (DT_RELASZ, 0)
5933               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
5934         return FALSE;
5935
5936       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_NIOS2_GP, 0))
5937         return FALSE;
5938
5939       if ((info->flags & DF_TEXTREL) != 0
5940           && !add_dynamic_entry (DT_TEXTREL, 0))
5941         return FALSE;
5942     }
5943 #undef add_dynamic_entry
5944
5945   return TRUE;
5946 }
5947
5948 /* Free the derived linker hash table.  */
5949 static void
5950 nios2_elf32_link_hash_table_free (bfd *obfd)
5951 {
5952   struct elf32_nios2_link_hash_table *htab
5953     = (struct elf32_nios2_link_hash_table *) obfd->link.hash;
5954
5955   bfd_hash_table_free (&htab->bstab);
5956   _bfd_elf_link_hash_table_free (obfd);
5957 }
5958
5959 /* Implement bfd_elf32_bfd_link_hash_table_create.  */
5960 static struct bfd_link_hash_table *
5961 nios2_elf32_link_hash_table_create (bfd *abfd)
5962 {
5963   struct elf32_nios2_link_hash_table *ret;
5964   bfd_size_type amt = sizeof (struct elf32_nios2_link_hash_table);
5965
5966   ret = bfd_zmalloc (amt);
5967   if (ret == NULL)
5968     return NULL;
5969
5970   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5971                                       link_hash_newfunc,
5972                                       sizeof (struct
5973                                               elf32_nios2_link_hash_entry),
5974                                       NIOS2_ELF_DATA))
5975     {
5976       free (ret);
5977       return NULL;
5978     }
5979
5980   /* Init the stub hash table too.  */
5981   if (!bfd_hash_table_init (&ret->bstab, stub_hash_newfunc,
5982                             sizeof (struct elf32_nios2_stub_hash_entry)))
5983     {
5984       _bfd_elf_link_hash_table_free (abfd);
5985       return NULL;
5986     }
5987   ret->root.root.hash_table_free = nios2_elf32_link_hash_table_free;
5988
5989   return &ret->root.root;
5990 }
5991
5992 /* Implement elf_backend_reloc_type_class.  */
5993 static enum elf_reloc_type_class
5994 nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5995                               const asection *rel_sec ATTRIBUTE_UNUSED,
5996                               const Elf_Internal_Rela *rela)
5997 {
5998   switch ((int) ELF32_R_TYPE (rela->r_info))
5999     {
6000     case R_NIOS2_RELATIVE:
6001       return reloc_class_relative;
6002     case R_NIOS2_JUMP_SLOT:
6003       return reloc_class_plt;
6004     case R_NIOS2_COPY:
6005       return reloc_class_copy;
6006     default:
6007       return reloc_class_normal;
6008     }
6009 }
6010
6011 /* Return 1 if target is one of ours.  */
6012 static bfd_boolean
6013 is_nios2_elf_target (const struct bfd_target *targ)
6014 {
6015   return (targ == &nios2_elf32_le_vec
6016           || targ == &nios2_elf32_be_vec);
6017 }
6018
6019 /* Implement elf_backend_add_symbol_hook.
6020    This hook is called by the linker when adding symbols from an object
6021    file.  We use it to put .comm items in .sbss, and not .bss.  */
6022 static bfd_boolean
6023 nios2_elf_add_symbol_hook (bfd *abfd,
6024                            struct bfd_link_info *info,
6025                            Elf_Internal_Sym *sym,
6026                            const char **namep ATTRIBUTE_UNUSED,
6027                            flagword *flagsp ATTRIBUTE_UNUSED,
6028                            asection **secp,
6029                            bfd_vma *valp)
6030 {
6031   if (sym->st_shndx == SHN_COMMON
6032       && !bfd_link_relocatable (info)
6033       && sym->st_size <= elf_gp_size (abfd)
6034       && is_nios2_elf_target (info->output_bfd->xvec))
6035     {
6036       /* Common symbols less than or equal to -G nn bytes are automatically
6037          put into .sbss.  */
6038       struct elf32_nios2_link_hash_table *htab;
6039
6040       htab = elf32_nios2_hash_table (info);
6041       if (htab->sbss == NULL)
6042         {
6043           flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
6044
6045           if (htab->root.dynobj == NULL)
6046             htab->root.dynobj = abfd;
6047
6048           htab->sbss = bfd_make_section_anyway_with_flags (htab->root.dynobj,
6049                                                            ".sbss", flags);
6050           if (htab->sbss == NULL)
6051             return FALSE;
6052         }
6053
6054       *secp = htab->sbss;
6055       *valp = sym->st_size;
6056     }
6057
6058   return TRUE;
6059 }
6060
6061 /* Implement elf_backend_can_make_relative_eh_frame:
6062    Decide whether to attempt to turn absptr or lsda encodings in
6063    shared libraries into pcrel within the given input section.  */
6064 static bfd_boolean
6065 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6066                                         struct bfd_link_info *info
6067                                         ATTRIBUTE_UNUSED,
6068                                         asection *eh_frame_section
6069                                         ATTRIBUTE_UNUSED)
6070 {
6071   /* We can't use PC-relative encodings in the .eh_frame section.  */
6072   return FALSE;
6073 }
6074
6075 /* Implement elf_backend_special_sections.  */
6076 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
6077 {
6078   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,
6079     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6080   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
6081     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6082   { NULL,                     0,  0, 0,              0 }
6083 };
6084
6085 #define ELF_ARCH                        bfd_arch_nios2
6086 #define ELF_TARGET_ID                   NIOS2_ELF_DATA
6087 #define ELF_MACHINE_CODE                EM_ALTERA_NIOS2
6088
6089 /* The Nios II MMU uses a 4K page size.  */
6090
6091 #define ELF_MAXPAGESIZE                 0x1000
6092
6093 #define bfd_elf32_bfd_link_hash_table_create \
6094                                           nios2_elf32_link_hash_table_create
6095
6096 #define bfd_elf32_bfd_merge_private_bfd_data \
6097                                           nios2_elf32_merge_private_bfd_data
6098
6099 /* Relocation table lookup macros.  */
6100
6101 #define bfd_elf32_bfd_reloc_type_lookup   nios2_elf32_bfd_reloc_type_lookup
6102 #define bfd_elf32_bfd_reloc_name_lookup   nios2_elf32_bfd_reloc_name_lookup
6103
6104 /* JUMP_TABLE_LINK macros.  */
6105
6106 /* elf_info_to_howto (using RELA relocations).  */
6107
6108 #define elf_info_to_howto                 nios2_elf32_info_to_howto
6109
6110 /* elf backend functions.  */
6111
6112 #define elf_backend_can_gc_sections     1
6113 #define elf_backend_can_refcount        1
6114 #define elf_backend_plt_readonly        1
6115 #define elf_backend_want_got_plt        1
6116 #define elf_backend_want_dynrelro       1
6117 #define elf_backend_rela_normal         1
6118 #define elf_backend_dtrel_excludes_plt  1
6119
6120 #define elf_backend_relocate_section      nios2_elf32_relocate_section
6121 #define elf_backend_section_flags         nios2_elf32_section_flags
6122 #define elf_backend_fake_sections         nios2_elf32_fake_sections
6123 #define elf_backend_check_relocs          nios2_elf32_check_relocs
6124
6125 #define elf_backend_gc_mark_hook          nios2_elf32_gc_mark_hook
6126 #define elf_backend_create_dynamic_sections \
6127                                           nios2_elf32_create_dynamic_sections
6128 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6129 #define elf_backend_finish_dynamic_sections \
6130                                           nios2_elf32_finish_dynamic_sections
6131 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6132 #define elf_backend_reloc_type_class      nios2_elf32_reloc_type_class
6133 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6134 #define elf_backend_add_symbol_hook       nios2_elf_add_symbol_hook
6135 #define elf_backend_copy_indirect_symbol  nios2_elf32_copy_indirect_symbol
6136 #define elf_backend_object_p              nios2_elf32_object_p
6137
6138 #define elf_backend_grok_prstatus         nios2_grok_prstatus
6139 #define elf_backend_grok_psinfo           nios2_grok_psinfo
6140
6141 #undef elf_backend_can_make_relative_eh_frame
6142 #define elf_backend_can_make_relative_eh_frame \
6143                                           nios2_elf32_can_make_relative_eh_frame
6144
6145 #define elf_backend_special_sections      elf32_nios2_special_sections
6146
6147 #define TARGET_LITTLE_SYM               nios2_elf32_le_vec
6148 #define TARGET_LITTLE_NAME              "elf32-littlenios2"
6149 #define TARGET_BIG_SYM                  nios2_elf32_be_vec
6150 #define TARGET_BIG_NAME                 "elf32-bignios2"
6151
6152 #define elf_backend_got_header_size     12
6153 #define elf_backend_default_execstack   0
6154
6155 #include "elf32-target.h"