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[256];
3724       const char* msg = (const char*) 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                              "0x%08x when _gp not defined\n");
3824                   sprintf (msgbuf, format, reloc_address);
3825                   msg = msgbuf;
3826                   r = bfd_reloc_dangerous;
3827                 }
3828               else
3829                 {
3830                   bfd_vma symbol_address = rel->r_addend + relocation;
3831                   relocation = symbol_address - gp;
3832                   rel->r_addend = 0;
3833                   if (((signed) relocation < -32768
3834                        || (signed) relocation > 32767)
3835                       && (!h
3836                           || h->root.type == bfd_link_hash_defined
3837                           || h->root.type == bfd_link_hash_defweak))
3838                     {
3839                       if (h)
3840                         name = h->root.root.string;
3841                       /* xgettext:c-format */
3842                       format = _("unable to reach %s (at 0x%08x) from the "
3843                                  "global pointer (at 0x%08x) because the "
3844                                  "offset (%d) is out of the allowed range, "
3845                                  "-32678 to 32767\n" );
3846                       sprintf (msgbuf, format, name, symbol_address, gp,
3847                                (signed)relocation);
3848                       msg = msgbuf;
3849                       r = bfd_reloc_outofrange;
3850                     }
3851                   else
3852                     r = _bfd_final_link_relocate (howto, input_bfd,
3853                                                   input_section, contents,
3854                                                   rel->r_offset, relocation,
3855                                                   rel->r_addend);
3856                 }
3857               break;
3858             case R_NIOS2_UJMP:
3859               r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
3860                                                 input_section,
3861                                                 contents, rel->r_offset,
3862                                                 relocation, rel->r_addend);
3863               break;
3864             case R_NIOS2_CJMP:
3865               r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
3866                                                 input_section,
3867                                                 contents, rel->r_offset,
3868                                                 relocation, rel->r_addend);
3869               break;
3870             case R_NIOS2_CALLR:
3871               r = nios2_elf32_do_callr_relocate (input_bfd, howto,
3872                                                  input_section, contents,
3873                                                  rel->r_offset, relocation,
3874                                                  rel->r_addend);
3875               break;
3876             case R_NIOS2_CALL26:
3877             case R_NIOS2_CALL26_NOAT:
3878               /* If we have a call to an undefined weak symbol, we just want
3879                  to stuff a zero in the bits of the call instruction and
3880                  bypass the normal call26 relocation handling, because it'll
3881                  diagnose an overflow error if address 0 isn't in the same
3882                  256MB segment as the call site.  Presumably the call
3883                  should be guarded by a null check anyway.  */
3884               if (h != NULL && h->root.type == bfd_link_hash_undefweak)
3885                 {
3886                   BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
3887                   r = _bfd_final_link_relocate (howto, input_bfd,
3888                                                 input_section, contents,
3889                                                 rel->r_offset, relocation,
3890                                                 rel->r_addend);
3891                   break;
3892                 }
3893               /* Handle relocations which should use the PLT entry.
3894                  NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3895                  which may point to a PLT entry, but we don't need to handle
3896                  that here.  If we created a PLT entry, all branches in this
3897                  object should go to it.  */
3898               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3899                 {
3900                   /* If we've created a .plt section, and assigned a PLT entry
3901                      to this function, it should not be known to bind locally.
3902                      If it were, we would have cleared the PLT entry.  */
3903                   BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3904
3905                   relocation = (splt->output_section->vma
3906                                 + splt->output_offset
3907                                 + h->plt.offset);
3908
3909                   unresolved_reloc = FALSE;
3910                 }
3911               /* Detect R_NIOS2_CALL26 relocations that would overflow the
3912                  256MB segment.  Replace the target with a reference to a
3913                  trampoline instead.
3914                  Note that htab->stub_group is null if relaxation has been
3915                  disabled by the --no-relax linker command-line option, so
3916                  we can use that to skip this processing entirely.  */
3917               if (howto->type == R_NIOS2_CALL26 && htab->stub_group)
3918                 {
3919                   bfd_vma dest = relocation + rel->r_addend;
3920                   enum elf32_nios2_stub_type stub_type;
3921
3922                   eh = (struct elf32_nios2_link_hash_entry *)h;
3923                   stub_type = nios2_type_of_stub (input_section, rel, eh,
3924                                                   htab, dest, NULL);
3925
3926                   if (stub_type != nios2_stub_none)
3927                     {
3928                       struct elf32_nios2_stub_hash_entry *hsh;
3929
3930                       hsh = nios2_get_stub_entry (input_section, sec,
3931                                                   eh, rel, htab, stub_type);
3932                       if (hsh == NULL)
3933                         {
3934                           r = bfd_reloc_undefined;
3935                           break;
3936                         }
3937
3938                       dest = (hsh->stub_offset
3939                               + hsh->stub_sec->output_offset
3940                               + hsh->stub_sec->output_section->vma);
3941                       r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3942                                                           input_section,
3943                                                           contents,
3944                                                           rel->r_offset,
3945                                                           dest, 0);
3946                       break;
3947                     }
3948                 }
3949
3950               /* Normal case.  */
3951               r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3952                                                   input_section, contents,
3953                                                   rel->r_offset, relocation,
3954                                                   rel->r_addend);
3955               break;
3956             case R_NIOS2_ALIGN:
3957               r = bfd_reloc_ok;
3958               /* For symmetry this would be
3959                  r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3960                                                   input_section, contents,
3961                                                   rel->r_offset, relocation,
3962                                                   rel->r_addend);
3963                 but do_ignore_reloc would do no more than return
3964                 bfd_reloc_ok. */
3965               break;
3966
3967             case R_NIOS2_GOT16:
3968             case R_NIOS2_CALL16:
3969             case R_NIOS2_GOT_LO:
3970             case R_NIOS2_GOT_HA:
3971             case R_NIOS2_CALL_LO:
3972             case R_NIOS2_CALL_HA:
3973               /* Relocation is to the entry for this symbol in the
3974                  global offset table.  */
3975               if (sgot == NULL)
3976                 {
3977                   r = bfd_reloc_notsupported;
3978                   break;
3979                 }
3980
3981               use_plt = 0;
3982
3983               if (h != NULL)
3984                 {
3985                   bfd_boolean dyn;
3986
3987                   eh = (struct elf32_nios2_link_hash_entry *)h;
3988                   use_plt = (eh->got_types_used == CALL_USED
3989                              && h->plt.offset != (bfd_vma) -1);
3990
3991                   off = h->got.offset;
3992                   BFD_ASSERT (off != (bfd_vma) -1);
3993                   dyn = htab->root.dynamic_sections_created;
3994                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3995                                                          bfd_link_pic (info),
3996                                                          h)
3997                       || (bfd_link_pic (info)
3998                           && SYMBOL_REFERENCES_LOCAL (info, h))
3999                       || ((ELF_ST_VISIBILITY (h->other)
4000                            || resolved_to_zero)
4001                           && h->root.type == bfd_link_hash_undefweak))
4002                     {
4003                       /* This is actually a static link, or it is a -Bsymbolic
4004                          link and the symbol is defined locally.  We must
4005                          initialize this entry in the global offset table.
4006                          Since the offset must always be a multiple of 4, we
4007                          use the least significant bit to record whether we
4008                          have initialized it already.
4009
4010                          When doing a dynamic link, we create a .rela.got
4011                          relocation entry to initialize the value.  This is
4012                          done in the finish_dynamic_symbol routine.  */
4013                       if ((off & 1) != 0)
4014                         off &= ~1;
4015                       else
4016                         {
4017                           bfd_put_32 (output_bfd, relocation,
4018                                       sgot->contents + off);
4019                           h->got.offset |= 1;
4020                         }
4021                     }
4022                   else
4023                     unresolved_reloc = FALSE;
4024                 }
4025               else
4026                 {
4027                   BFD_ASSERT (local_got_offsets != NULL
4028                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
4029
4030                   off = local_got_offsets[r_symndx];
4031
4032                   /* The offset must always be a multiple of 4.  We use the
4033                      least significant bit to record whether we have already
4034                      generated the necessary reloc.  */
4035                   if ((off & 1) != 0)
4036                     off &= ~1;
4037                   else
4038                     {
4039                       bfd_put_32 (output_bfd, relocation,
4040                                   sgot->contents + off);
4041
4042                       if (bfd_link_pic (info))
4043                         {
4044                           asection *srelgot;
4045                           Elf_Internal_Rela outrel;
4046                           bfd_byte *loc;
4047
4048                           srelgot = htab->root.srelgot;
4049                           BFD_ASSERT (srelgot != NULL);
4050
4051                           outrel.r_addend = relocation;
4052                           outrel.r_offset = (sgot->output_section->vma
4053                                              + sgot->output_offset
4054                                              + off);
4055                           outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4056                           loc = srelgot->contents;
4057                           loc += (srelgot->reloc_count++ *
4058                                   sizeof (Elf32_External_Rela));
4059                           bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4060                         }
4061
4062                       local_got_offsets[r_symndx] |= 1;
4063                     }
4064                 }
4065
4066               if (use_plt && bfd_link_pic (info))
4067                 {
4068                   off = ((h->plt.offset - 24) / 12 + 3) * 4;
4069                   relocation = (htab->root.sgotplt->output_offset + off
4070                                 - got_base);
4071                 }
4072               else
4073                 relocation = sgot->output_offset + off - got_base;
4074
4075               /* This relocation does not use the addend.  */
4076               rel->r_addend = 0;
4077
4078               switch (howto->type)
4079                 {
4080                 case R_NIOS2_GOT_LO:
4081                 case R_NIOS2_CALL_LO:
4082                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4083                                                     input_section, contents,
4084                                                     rel->r_offset, relocation,
4085                                                     rel->r_addend);
4086                   break;
4087                 case R_NIOS2_GOT_HA:
4088                 case R_NIOS2_CALL_HA:
4089                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4090                                                        input_section, contents,
4091                                                        rel->r_offset,
4092                                                        relocation,
4093                                                        rel->r_addend);
4094                   break;
4095                 default:
4096                   r = _bfd_final_link_relocate (howto, input_bfd,
4097                                                 input_section, contents,
4098                                                 rel->r_offset, relocation,
4099                                                 rel->r_addend);
4100                   break;
4101                 }
4102               break;
4103
4104             case R_NIOS2_GOTOFF_LO:
4105             case R_NIOS2_GOTOFF_HA:
4106             case R_NIOS2_GOTOFF:
4107               /* Relocation is relative to the global offset table pointer.  */
4108
4109               BFD_ASSERT (sgot != NULL);
4110               if (sgot == NULL)
4111                 {
4112                   r = bfd_reloc_notsupported;
4113                   break;
4114                 }
4115
4116               /* Note that sgot->output_offset is not involved in this
4117                  calculation.  We always want the start of .got.  */
4118               relocation -= sgot->output_section->vma;
4119
4120               /* Now we adjust the relocation to be relative to the GOT pointer
4121                  (the _gp_got symbol), which possibly contains the 0x8000 bias.  */
4122               relocation -= got_base;
4123
4124               switch (howto->type)
4125                 {
4126                 case R_NIOS2_GOTOFF_LO:
4127                   r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4128                                                     input_section, contents,
4129                                                     rel->r_offset, relocation,
4130                                                     rel->r_addend);
4131                   break;
4132                 case R_NIOS2_GOTOFF_HA:
4133                   r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4134                                                        input_section, contents,
4135                                                        rel->r_offset,
4136                                                        relocation,
4137                                                        rel->r_addend);
4138                   break;
4139                 default:
4140                   r = _bfd_final_link_relocate (howto, input_bfd,
4141                                                 input_section, contents,
4142                                                 rel->r_offset, relocation,
4143                                                 rel->r_addend);
4144                   break;
4145                 }
4146               break;
4147
4148             case R_NIOS2_TLS_LDO16:
4149               relocation -= dtpoff_base (info) + DTP_OFFSET;
4150
4151               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4152                                             contents, rel->r_offset,
4153                                             relocation, rel->r_addend);
4154               break;
4155             case R_NIOS2_TLS_LDM16:
4156               if (htab->root.sgot == NULL)
4157                 abort ();
4158
4159               off = htab->tls_ldm_got.offset;
4160
4161               if ((off & 1) != 0)
4162                 off &= ~1;
4163               else
4164                 {
4165                   /* If we don't know the module number, create a relocation
4166                      for it.  */
4167                   if (bfd_link_pic (info))
4168                     {
4169                       Elf_Internal_Rela outrel;
4170                       bfd_byte *loc;
4171
4172                       if (htab->root.srelgot == NULL)
4173                         abort ();
4174
4175                       outrel.r_addend = 0;
4176                       outrel.r_offset = (htab->root.sgot->output_section->vma
4177                                          + htab->root.sgot->output_offset
4178                                          + off);
4179                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
4180
4181                       loc = htab->root.srelgot->contents;
4182                       loc += (htab->root.srelgot->reloc_count++
4183                               * sizeof (Elf32_External_Rela));
4184                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4185                     }
4186                   else
4187                     bfd_put_32 (output_bfd, 1,
4188                                 htab->root.sgot->contents + off);
4189
4190                   htab->tls_ldm_got.offset |= 1;
4191                 }
4192
4193               relocation = htab->root.sgot->output_offset + off - got_base;
4194
4195               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4196                                             contents, rel->r_offset,
4197                                             relocation, rel->r_addend);
4198
4199               break;
4200             case R_NIOS2_TLS_GD16:
4201             case R_NIOS2_TLS_IE16:
4202               {
4203                 int indx;
4204                 char tls_type;
4205
4206                 if (htab->root.sgot == NULL)
4207                   abort ();
4208
4209                 indx = 0;
4210                 if (h != NULL)
4211                   {
4212                     bfd_boolean dyn;
4213                     dyn = htab->root.dynamic_sections_created;
4214                     if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4215                                                          bfd_link_pic (info),
4216                                                          h)
4217                         && (!bfd_link_pic (info)
4218                             || !SYMBOL_REFERENCES_LOCAL (info, h)))
4219                       {
4220                         unresolved_reloc = FALSE;
4221                         indx = h->dynindx;
4222                       }
4223                     off = h->got.offset;
4224                     tls_type = (((struct elf32_nios2_link_hash_entry *) h)
4225                                 ->tls_type);
4226                   }
4227                 else
4228                   {
4229                     if (local_got_offsets == NULL)
4230                       abort ();
4231                     off = local_got_offsets[r_symndx];
4232                     tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
4233                                 [r_symndx]);
4234                   }
4235
4236                 if (tls_type == GOT_UNKNOWN)
4237                   abort ();
4238
4239                 if ((off & 1) != 0)
4240                   off &= ~1;
4241                 else
4242                   {
4243                     bfd_boolean need_relocs = FALSE;
4244                     Elf_Internal_Rela outrel;
4245                     bfd_byte *loc = NULL;
4246                     int cur_off = off;
4247
4248                     /* The GOT entries have not been initialized yet.  Do it
4249                        now, and emit any relocations.  If both an IE GOT and a
4250                        GD GOT are necessary, we emit the GD first.  */
4251
4252                     if ((bfd_link_pic (info) || indx != 0)
4253                         && (h == NULL
4254                             || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4255                                 && !resolved_to_zero)
4256                             || h->root.type != bfd_link_hash_undefweak))
4257                       {
4258                         need_relocs = TRUE;
4259                         if (htab->root.srelgot == NULL)
4260                           abort ();
4261                         loc = htab->root.srelgot->contents;
4262                         loc += (htab->root.srelgot->reloc_count *
4263                                 sizeof (Elf32_External_Rela));
4264                       }
4265
4266                     if (tls_type & GOT_TLS_GD)
4267                       {
4268                         if (need_relocs)
4269                           {
4270                             outrel.r_addend = 0;
4271                             outrel.r_offset = (htab->root.sgot->output_section->vma
4272                                                + htab->root.sgot->output_offset
4273                                                + cur_off);
4274                             outrel.r_info = ELF32_R_INFO (indx,
4275                                                           R_NIOS2_TLS_DTPMOD);
4276
4277                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4278                                                        loc);
4279                             htab->root.srelgot->reloc_count++;
4280                             loc += sizeof (Elf32_External_Rela);
4281
4282                             if (indx == 0)
4283                               bfd_put_32 (output_bfd,
4284                                           (relocation - dtpoff_base (info) -
4285                                            DTP_OFFSET),
4286                                           htab->root.sgot->contents + cur_off + 4);
4287                             else
4288                               {
4289                                 outrel.r_addend = 0;
4290                                 outrel.r_info = ELF32_R_INFO (indx,
4291                                   R_NIOS2_TLS_DTPREL);
4292                                 outrel.r_offset += 4;
4293
4294                                 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4295                                                            loc);
4296                                 htab->root.srelgot->reloc_count++;
4297                                 loc += sizeof (Elf32_External_Rela);
4298                               }
4299                           }
4300                         else
4301                           {
4302                             /* If we are not emitting relocations for a
4303                                general dynamic reference, then we must be in a
4304                                static link or an executable link with the
4305                                symbol binding locally.  Mark it as belonging
4306                                to module 1, the executable.  */
4307                             bfd_put_32 (output_bfd, 1,
4308                                         htab->root.sgot->contents + cur_off);
4309                             bfd_put_32 (output_bfd, (relocation -
4310                                                      dtpoff_base (info) -
4311                                                      DTP_OFFSET),
4312                                         htab->root.sgot->contents + cur_off + 4);
4313                           }
4314
4315                         cur_off += 8;
4316                       }
4317
4318                     if (tls_type & GOT_TLS_IE)
4319                       {
4320                         if (need_relocs)
4321                           {
4322                             if (indx == 0)
4323                               outrel.r_addend = (relocation -
4324                                                  dtpoff_base (info));
4325                             else
4326                               outrel.r_addend = 0;
4327                             outrel.r_offset = (htab->root.sgot->output_section->vma
4328                                                + htab->root.sgot->output_offset
4329                                                + cur_off);
4330                             outrel.r_info = ELF32_R_INFO (indx,
4331                                                           R_NIOS2_TLS_TPREL);
4332
4333                             bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4334                                                        loc);
4335                             htab->root.srelgot->reloc_count++;
4336                             loc += sizeof (Elf32_External_Rela);
4337                           }
4338                         else
4339                           bfd_put_32 (output_bfd, (tpoff (info, relocation)
4340                                                    - TP_OFFSET),
4341                                       htab->root.sgot->contents + cur_off);
4342                         cur_off += 4;
4343                       }
4344
4345                     if (h != NULL)
4346                       h->got.offset |= 1;
4347                     else
4348                       local_got_offsets[r_symndx] |= 1;
4349                   }
4350
4351                 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
4352                   off += 8;
4353                 relocation = htab->root.sgot->output_offset + off - got_base;
4354
4355                 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4356                                               contents, rel->r_offset,
4357                                               relocation, rel->r_addend);
4358               }
4359
4360               break;
4361             case R_NIOS2_TLS_LE16:
4362               if (bfd_link_dll (info))
4363                 {
4364                   _bfd_error_handler
4365                     /* xgettext:c-format */
4366                     (_("%pB(%pA+%#" PRIx64 "): %s relocation not "
4367                        "permitted in shared object"),
4368                      input_bfd, input_section,
4369                      (uint64_t) rel->r_offset, howto->name);
4370                   return FALSE;
4371                 }
4372               else
4373                 relocation = tpoff (info, relocation) - TP_OFFSET;
4374
4375               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4376                                             contents, rel->r_offset,
4377                                             relocation, rel->r_addend);
4378               break;
4379
4380             case R_NIOS2_BFD_RELOC_32:
4381               if (bfd_link_pic (info)
4382                   && (input_section->flags & SEC_ALLOC) != 0
4383                   && (h == NULL
4384                       || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4385                           && !resolved_to_zero)
4386                       || h->root.type != bfd_link_hash_undefweak))
4387                 {
4388                   Elf_Internal_Rela outrel;
4389                   bfd_byte *loc;
4390                   bfd_boolean skip, relocate;
4391
4392                   /* When generating a shared object, these relocations
4393                      are copied into the output file to be resolved at run
4394                      time.  */
4395
4396                   skip = FALSE;
4397                   relocate = FALSE;
4398
4399                   outrel.r_offset
4400                     = _bfd_elf_section_offset (output_bfd, info,
4401                                                input_section, rel->r_offset);
4402                   if (outrel.r_offset == (bfd_vma) -1)
4403                     skip = TRUE;
4404                   else if (outrel.r_offset == (bfd_vma) -2)
4405                     skip = TRUE, relocate = TRUE;
4406                   outrel.r_offset += (input_section->output_section->vma
4407                                       + input_section->output_offset);
4408
4409                   if (skip)
4410                     memset (&outrel, 0, sizeof outrel);
4411                   else if (h != NULL
4412                            && h->dynindx != -1
4413                            && (!bfd_link_pic (info)
4414                                || !SYMBOLIC_BIND (info, h)
4415                                || !h->def_regular))
4416                     {
4417                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4418                       outrel.r_addend = rel->r_addend;
4419                     }
4420                   else
4421                     {
4422                       /* This symbol is local, or marked to become local.  */
4423                       outrel.r_addend = relocation + rel->r_addend;
4424                       relocate = TRUE;
4425                       outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4426                     }
4427
4428                   sreloc = elf_section_data (input_section)->sreloc;
4429                   if (sreloc == NULL)
4430                     abort ();
4431
4432                   loc = sreloc->contents;
4433                   loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4434                   bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4435
4436                   /* This reloc will be computed at runtime, so there's no
4437                      need to do anything now, except for R_NIOS2_BFD_RELOC_32
4438                      relocations that have been turned into
4439                      R_NIOS2_RELATIVE.  */
4440                   if (!relocate)
4441                     break;
4442                 }
4443
4444               r = _bfd_final_link_relocate (howto, input_bfd,
4445                                             input_section, contents,
4446                                             rel->r_offset, relocation,
4447                                             rel->r_addend);
4448               break;
4449
4450             case R_NIOS2_TLS_DTPREL:
4451               relocation -= dtpoff_base (info);
4452               /* Fall through.  */
4453
4454             default:
4455               r = _bfd_final_link_relocate (howto, input_bfd,
4456                                             input_section, contents,
4457                                             rel->r_offset, relocation,
4458                                             rel->r_addend);
4459               break;
4460             }
4461         }
4462       else
4463         r = bfd_reloc_notsupported;
4464
4465       if (r != bfd_reloc_ok)
4466         {
4467           if (h != NULL)
4468             name = h->root.root.string;
4469           else
4470             {
4471               name = bfd_elf_string_from_elf_section (input_bfd,
4472                                                       symtab_hdr->sh_link,
4473                                                       sym->st_name);
4474               if (name == NULL || *name == '\0')
4475                 name = bfd_section_name (input_bfd, sec);
4476             }
4477
4478           switch (r)
4479             {
4480             case bfd_reloc_overflow:
4481               (*info->callbacks->reloc_overflow) (info, NULL, name,
4482                                                   howto->name, (bfd_vma) 0,
4483                                                   input_bfd, input_section,
4484                                                   rel->r_offset);
4485               break;
4486
4487             case bfd_reloc_undefined:
4488               (*info->callbacks->undefined_symbol) (info, name, input_bfd,
4489                                                     input_section,
4490                                                     rel->r_offset, TRUE);
4491               break;
4492
4493             case bfd_reloc_outofrange:
4494               if (msg == NULL)
4495                 msg = _("relocation out of range");
4496               break;
4497
4498             case bfd_reloc_notsupported:
4499               if (msg == NULL)
4500                 msg = _("unsupported relocation");
4501               break;
4502
4503             case bfd_reloc_dangerous:
4504               if (msg == NULL)
4505                 msg = _("dangerous relocation");
4506               break;
4507
4508             default:
4509               if (msg == NULL)
4510                 msg = _("unknown error");
4511               break;
4512             }
4513
4514           if (msg)
4515             {
4516               (*info->callbacks->warning) (info, msg, name, input_bfd,
4517                                            input_section, rel->r_offset);
4518               return FALSE;
4519             }
4520         }
4521     }
4522   return TRUE;
4523 }
4524
4525 /* Implement elf-backend_section_flags:
4526    Convert NIOS2 specific section flags to bfd internal section flags.  */
4527 static bfd_boolean
4528 nios2_elf32_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
4529 {
4530   if (hdr->sh_flags & SHF_NIOS2_GPREL)
4531     *flags |= SEC_SMALL_DATA;
4532
4533   return TRUE;
4534 }
4535
4536 /* Implement elf_backend_fake_sections:
4537    Set the correct type for an NIOS2 ELF section.  We do this by the
4538    section name, which is a hack, but ought to work.  */
4539 static bfd_boolean
4540 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
4541                            Elf_Internal_Shdr *hdr, asection *sec)
4542 {
4543   register const char *name = bfd_get_section_name (abfd, sec);
4544
4545   if ((sec->flags & SEC_SMALL_DATA)
4546       || strcmp (name, ".sdata") == 0
4547       || strcmp (name, ".sbss") == 0
4548       || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
4549     hdr->sh_flags |= SHF_NIOS2_GPREL;
4550
4551   return TRUE;
4552 }
4553
4554 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4555    shortcuts to them in our hash table.  */
4556 static bfd_boolean
4557 create_got_section (bfd *dynobj, struct bfd_link_info *info)
4558 {
4559   struct elf32_nios2_link_hash_table *htab;
4560   struct elf_link_hash_entry *h;
4561
4562   htab = elf32_nios2_hash_table (info);
4563
4564   if (! _bfd_elf_create_got_section (dynobj, info))
4565     return FALSE;
4566
4567   /* In order for the two loads in .PLTresolve to share the same %hiadj,
4568      _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary.  */
4569   if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt, 4))
4570     return FALSE;
4571
4572   /* The Nios II ABI specifies that GOT-relative relocations are relative
4573      to the linker-created symbol _gp_got, rather than using
4574      _GLOBAL_OFFSET_TABLE_ directly.  In particular, the latter always
4575      points to the base of the GOT while _gp_got may include a bias.  */
4576   h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.sgotplt,
4577                                    "_gp_got");
4578   htab->h_gp_got = h;
4579   if (h == NULL)
4580     return FALSE;
4581
4582   return TRUE;
4583 }
4584
4585 /* Implement elf_backend_create_dynamic_sections:
4586    Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4587    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4588    hash table.  */
4589 static bfd_boolean
4590 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4591 {
4592   struct elf32_nios2_link_hash_table *htab;
4593
4594   htab = elf32_nios2_hash_table (info);
4595   if (!htab->root.sgot && !create_got_section (dynobj, info))
4596     return FALSE;
4597
4598   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4599     return FALSE;
4600
4601   /* In order for the two loads in a shared object .PLTresolve to share the
4602      same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4603      to a 16-byte boundary.  This is because the addresses for these loads
4604      include the -(.plt+4) PIC correction.  */
4605   return bfd_set_section_alignment (dynobj, htab->root.splt, 4);
4606 }
4607
4608 /* Implement elf_backend_copy_indirect_symbol:
4609    Copy the extra info we tack onto an elf_link_hash_entry.  */
4610 static void
4611 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
4612                                   struct elf_link_hash_entry *dir,
4613                                   struct elf_link_hash_entry *ind)
4614 {
4615   struct elf32_nios2_link_hash_entry *edir, *eind;
4616
4617   edir = (struct elf32_nios2_link_hash_entry *) dir;
4618   eind = (struct elf32_nios2_link_hash_entry *) ind;
4619
4620   if (eind->dyn_relocs != NULL)
4621     {
4622       if (edir->dyn_relocs != NULL)
4623         {
4624           struct elf_dyn_relocs **pp;
4625           struct elf_dyn_relocs *p;
4626
4627           /* Add reloc counts against the indirect sym to the direct sym
4628              list.  Merge any entries against the same section.  */
4629           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4630             {
4631               struct elf_dyn_relocs *q;
4632
4633               for (q = edir->dyn_relocs; q != NULL; q = q->next)
4634                 if (q->sec == p->sec)
4635                   {
4636                     q->pc_count += p->pc_count;
4637                     q->count += p->count;
4638                     *pp = p->next;
4639                     break;
4640                   }
4641               if (q == NULL)
4642                 pp = &p->next;
4643             }
4644           *pp = edir->dyn_relocs;
4645         }
4646
4647       edir->dyn_relocs = eind->dyn_relocs;
4648       eind->dyn_relocs = NULL;
4649     }
4650
4651   if (ind->root.type == bfd_link_hash_indirect
4652       && dir->got.refcount <= 0)
4653     {
4654       edir->tls_type = eind->tls_type;
4655       eind->tls_type = GOT_UNKNOWN;
4656     }
4657
4658   edir->got_types_used |= eind->got_types_used;
4659
4660   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4661 }
4662
4663 /* Set the right machine number for a NIOS2 ELF file.  */
4664
4665 static bfd_boolean
4666 nios2_elf32_object_p (bfd *abfd)
4667 {
4668   unsigned long mach;
4669
4670   mach = elf_elfheader (abfd)->e_flags;
4671
4672   switch (mach)
4673     {
4674     default:
4675     case EF_NIOS2_ARCH_R1:
4676       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r1);
4677       break;
4678     case EF_NIOS2_ARCH_R2:
4679       bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r2);
4680       break;
4681     }
4682
4683   return TRUE;
4684 }
4685
4686 /* Implement elf_backend_check_relocs:
4687    Look through the relocs for a section during the first phase.  */
4688 static bfd_boolean
4689 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
4690                           asection *sec, const Elf_Internal_Rela *relocs)
4691 {
4692   Elf_Internal_Shdr *symtab_hdr;
4693   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4694   const Elf_Internal_Rela *rel;
4695   const Elf_Internal_Rela *rel_end;
4696   struct elf32_nios2_link_hash_table *htab;
4697   asection *sreloc = NULL;
4698   bfd_signed_vma *local_got_refcounts;
4699
4700   if (bfd_link_relocatable (info))
4701     return TRUE;
4702
4703   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4704   sym_hashes = elf_sym_hashes (abfd);
4705   sym_hashes_end = (sym_hashes
4706                     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
4707   if (!elf_bad_symtab (abfd))
4708     sym_hashes_end -= symtab_hdr->sh_info;
4709   local_got_refcounts = elf_local_got_refcounts (abfd);
4710
4711   htab = elf32_nios2_hash_table (info);
4712
4713   rel_end = relocs + sec->reloc_count;
4714   for (rel = relocs; rel < rel_end; rel++)
4715     {
4716       unsigned int r_type;
4717       struct elf_link_hash_entry *h;
4718       unsigned long r_symndx;
4719
4720       r_symndx = ELF32_R_SYM (rel->r_info);
4721       if (r_symndx < symtab_hdr->sh_info)
4722         h = NULL;
4723       else
4724         {
4725           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4726           while (h->root.type == bfd_link_hash_indirect
4727                  || h->root.type == bfd_link_hash_warning)
4728             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4729         }
4730
4731       r_type = ELF32_R_TYPE (rel->r_info);
4732
4733       switch (r_type)
4734         {
4735         case R_NIOS2_GOT16:
4736         case R_NIOS2_GOT_LO:
4737         case R_NIOS2_GOT_HA:
4738         case R_NIOS2_CALL16:
4739         case R_NIOS2_CALL_LO:
4740         case R_NIOS2_CALL_HA:
4741         case R_NIOS2_TLS_GD16:
4742         case R_NIOS2_TLS_IE16:
4743           /* This symbol requires a global offset table entry.  */
4744           {
4745             int tls_type, old_tls_type;
4746
4747             switch (r_type)
4748               {
4749               default:
4750               case R_NIOS2_GOT16:
4751               case R_NIOS2_GOT_LO:
4752               case R_NIOS2_GOT_HA:
4753               case R_NIOS2_CALL16:
4754               case R_NIOS2_CALL_LO:
4755               case R_NIOS2_CALL_HA:
4756                 tls_type = GOT_NORMAL;
4757                 break;
4758               case R_NIOS2_TLS_GD16:
4759                 tls_type = GOT_TLS_GD;
4760                 break;
4761               case R_NIOS2_TLS_IE16:
4762                 tls_type = GOT_TLS_IE;
4763                 break;
4764               }
4765
4766             if (h != NULL)
4767               {
4768                 struct elf32_nios2_link_hash_entry *eh
4769                   = (struct elf32_nios2_link_hash_entry *)h;
4770                 h->got.refcount++;
4771                 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
4772                 if (r_type == R_NIOS2_CALL16
4773                     || r_type == R_NIOS2_CALL_LO
4774                     || r_type == R_NIOS2_CALL_HA)
4775                   {
4776                     /* Make sure a plt entry is created for this symbol if
4777                        it turns out to be a function defined by a dynamic
4778                        object.  */
4779                     h->plt.refcount++;
4780                     h->needs_plt = 1;
4781                     h->type = STT_FUNC;
4782                     eh->got_types_used |= CALL_USED;
4783                   }
4784                 else
4785                   eh->got_types_used |= GOT_USED;
4786               }
4787             else
4788               {
4789                 /* This is a global offset table entry for a local symbol.  */
4790                 if (local_got_refcounts == NULL)
4791                   {
4792                     bfd_size_type size;
4793
4794                     size = symtab_hdr->sh_info;
4795                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
4796                     local_got_refcounts
4797                       = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
4798                     if (local_got_refcounts == NULL)
4799                       return FALSE;
4800                     elf_local_got_refcounts (abfd) = local_got_refcounts;
4801                     elf32_nios2_local_got_tls_type (abfd)
4802                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4803                   }
4804                 local_got_refcounts[r_symndx]++;
4805                 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
4806               }
4807
4808             /* We will already have issued an error message if there is a
4809                TLS / non-TLS mismatch, based on the symbol type.  We don't
4810                support any linker relaxations.  So just combine any TLS
4811                types needed.  */
4812             if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4813                 && tls_type != GOT_NORMAL)
4814               tls_type |= old_tls_type;
4815
4816             if (old_tls_type != tls_type)
4817               {
4818                 if (h != NULL)
4819                   elf32_nios2_hash_entry (h)->tls_type = tls_type;
4820                 else
4821                   elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
4822               }
4823           }
4824         make_got:
4825           if (htab->root.sgot == NULL)
4826             {
4827               if (htab->root.dynobj == NULL)
4828                 htab->root.dynobj = abfd;
4829               if (!create_got_section (htab->root.dynobj, info))
4830                 return FALSE;
4831             }
4832           break;
4833
4834         case R_NIOS2_TLS_LDM16:
4835           htab->tls_ldm_got.refcount++;
4836           goto make_got;
4837
4838           /* This relocation describes the C++ object vtable hierarchy.
4839              Reconstruct it for later use during GC.  */
4840         case R_NIOS2_GNU_VTINHERIT:
4841           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4842             return FALSE;
4843           break;
4844
4845           /* This relocation describes which C++ vtable entries are actually
4846              used.  Record for later use during GC.  */
4847         case R_NIOS2_GNU_VTENTRY:
4848           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4849             return FALSE;
4850           break;
4851
4852         case R_NIOS2_BFD_RELOC_32:
4853         case R_NIOS2_CALL26:
4854         case R_NIOS2_CALL26_NOAT:
4855         case R_NIOS2_HIADJ16:
4856         case R_NIOS2_LO16:
4857
4858           if (h != NULL)
4859             {
4860               /* If this reloc is in a read-only section, we might
4861                    need a copy reloc.  We can't check reliably at this
4862                    stage whether the section is read-only, as input
4863                    sections have not yet been mapped to output sections.
4864                    Tentatively set the flag for now, and correct in
4865                    adjust_dynamic_symbol.  */
4866               if (!bfd_link_pic (info))
4867                 h->non_got_ref = 1;
4868
4869               /* Make sure a plt entry is created for this symbol if it
4870                  turns out to be a function defined by a dynamic object.  */
4871               h->plt.refcount++;
4872
4873               if (r_type == R_NIOS2_CALL26 || r_type == R_NIOS2_CALL26_NOAT)
4874                 h->needs_plt = 1;
4875             }
4876
4877           /* If we are creating a shared library, we need to copy the
4878              reloc into the shared library.  */
4879           if (bfd_link_pic (info)
4880               && (sec->flags & SEC_ALLOC) != 0
4881               && (r_type == R_NIOS2_BFD_RELOC_32
4882                   || (h != NULL && ! h->needs_plt
4883                       && (! SYMBOLIC_BIND (info, h) || ! h->def_regular))))
4884             {
4885               struct elf_dyn_relocs *p;
4886               struct elf_dyn_relocs **head;
4887
4888               /* When creating a shared object, we must copy these
4889                  reloc types into the output file.  We create a reloc
4890                  section in dynobj and make room for this reloc.  */
4891               if (sreloc == NULL)
4892                 {
4893                   if (htab->root.dynobj == NULL)
4894                     htab->root.dynobj = abfd;
4895
4896                   sreloc = _bfd_elf_make_dynamic_reloc_section
4897                     (sec, htab->root.dynobj, 2, abfd, TRUE);
4898                   if (sreloc == NULL)
4899                     return FALSE;
4900                 }
4901
4902               /* If this is a global symbol, we count the number of
4903                  relocations we need for this symbol.  */
4904               if (h != NULL)
4905                 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
4906               else
4907                 {
4908                   /* Track dynamic relocs needed for local syms too.
4909                      We really need local syms available to do this
4910                      easily.  Oh well.  */
4911
4912                   asection *s;
4913                   void *vpp;
4914                   Elf_Internal_Sym *isym;
4915
4916                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4917                                                 abfd, r_symndx);
4918                   if (isym == NULL)
4919                     return FALSE;
4920
4921                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4922                   if (s == NULL)
4923                     s = sec;
4924
4925                   vpp = &elf_section_data (s)->local_dynrel;
4926                   head = (struct elf_dyn_relocs **) vpp;
4927                 }
4928
4929               p = *head;
4930               if (p == NULL || p->sec != sec)
4931                 {
4932                   bfd_size_type amt = sizeof *p;
4933                   p = ((struct elf_dyn_relocs *)
4934                        bfd_alloc (htab->root.dynobj, amt));
4935                   if (p == NULL)
4936                     return FALSE;
4937                   p->next = *head;
4938                   *head = p;
4939                   p->sec = sec;
4940                   p->count = 0;
4941                   p->pc_count = 0;
4942                 }
4943
4944               p->count += 1;
4945
4946             }
4947           break;
4948         }
4949     }
4950
4951   return TRUE;
4952 }
4953
4954
4955 /* Implement elf_backend_gc_mark_hook:
4956    Return the section that should be marked against GC for a given
4957    relocation.  */
4958 static asection *
4959 nios2_elf32_gc_mark_hook (asection *sec,
4960                           struct bfd_link_info *info,
4961                           Elf_Internal_Rela *rel,
4962                           struct elf_link_hash_entry *h,
4963                           Elf_Internal_Sym *sym)
4964 {
4965   if (h != NULL)
4966     switch (ELF32_R_TYPE (rel->r_info))
4967       {
4968       case R_NIOS2_GNU_VTINHERIT:
4969       case R_NIOS2_GNU_VTENTRY:
4970         return NULL;
4971       }
4972   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4973 }
4974
4975 /* Implement elf_backend_finish_dynamic_symbols:
4976    Finish up dynamic symbol handling.  We set the contents of various
4977    dynamic sections here.  */
4978 static bfd_boolean
4979 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
4980                                    struct bfd_link_info *info,
4981                                    struct elf_link_hash_entry *h,
4982                                    Elf_Internal_Sym *sym)
4983 {
4984   struct elf32_nios2_link_hash_table *htab;
4985   struct elf32_nios2_link_hash_entry *eh
4986     = (struct elf32_nios2_link_hash_entry *)h;
4987   int use_plt;
4988
4989   htab = elf32_nios2_hash_table (info);
4990
4991   if (h->plt.offset != (bfd_vma) -1)
4992     {
4993       asection *splt;
4994       asection *sgotplt;
4995       asection *srela;
4996       bfd_vma plt_index;
4997       bfd_vma got_offset;
4998       Elf_Internal_Rela rela;
4999       bfd_byte *loc;
5000       bfd_vma got_address;
5001
5002       /* This symbol has an entry in the procedure linkage table.  Set
5003          it up.  */
5004       BFD_ASSERT (h->dynindx != -1);
5005       splt = htab->root.splt;
5006       sgotplt = htab->root.sgotplt;
5007       srela = htab->root.srelplt;
5008       BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
5009
5010       /* Emit the PLT entry.  */
5011       if (bfd_link_pic (info))
5012         {
5013           nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
5014                                     3);
5015           plt_index = (h->plt.offset - 24) / 12;
5016           got_offset = (plt_index + 3) * 4;
5017           nios2_elf32_install_imm16 (splt, h->plt.offset,
5018                                      hiadj(plt_index * 4));
5019           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5020                                      (plt_index * 4) & 0xffff);
5021           nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
5022                                      0xfff4 - h->plt.offset);
5023           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5024                          + got_offset);
5025
5026           /* Fill in the entry in the global offset table.  There are no
5027              res_n slots for a shared object PLT, instead the .got.plt entries
5028              point to the PLT entries.  */
5029           bfd_put_32 (output_bfd,
5030                       splt->output_section->vma + splt->output_offset
5031                       + h->plt.offset, sgotplt->contents + got_offset);
5032         }
5033       else
5034         {
5035           plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
5036           got_offset = (plt_index + 3) * 4;
5037
5038           nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
5039           got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5040                          + got_offset);
5041           nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
5042           nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5043                                      got_address & 0xffff);
5044
5045           /* Fill in the entry in the global offset table.  */
5046           bfd_put_32 (output_bfd,
5047                       splt->output_section->vma + splt->output_offset
5048                       + plt_index * 4, sgotplt->contents + got_offset);
5049         }
5050
5051       /* Fill in the entry in the .rela.plt section.  */
5052       rela.r_offset = got_address;
5053       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
5054       rela.r_addend = 0;
5055       loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
5056       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5057
5058       if (!h->def_regular)
5059         {
5060           /* Mark the symbol as undefined, rather than as defined in
5061              the .plt section.  Leave the value alone.  */
5062           sym->st_shndx = SHN_UNDEF;
5063           /* If the symbol is weak, we do need to clear the value.
5064              Otherwise, the PLT entry would provide a definition for
5065              the symbol even if the symbol wasn't defined anywhere,
5066              and so the symbol would never be NULL.  */
5067           if (!h->ref_regular_nonweak)
5068             sym->st_value = 0;
5069         }
5070     }
5071
5072   use_plt = (eh->got_types_used == CALL_USED
5073              && h->plt.offset != (bfd_vma) -1);
5074
5075   if (!use_plt && h->got.offset != (bfd_vma) -1
5076       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5077       && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5078     {
5079       asection *sgot;
5080       asection *srela;
5081       Elf_Internal_Rela rela;
5082       bfd_byte *loc;
5083       bfd_vma offset;
5084
5085       /* This symbol has an entry in the global offset table.  Set it
5086          up.  */
5087       sgot = htab->root.sgot;
5088       srela = htab->root.srelgot;
5089       BFD_ASSERT (sgot != NULL && srela != NULL);
5090
5091       offset = (h->got.offset & ~(bfd_vma) 1);
5092       rela.r_offset = (sgot->output_section->vma
5093                        + sgot->output_offset + offset);
5094
5095       /* If this is a -Bsymbolic link, and the symbol is defined
5096          locally, we just want to emit a RELATIVE reloc.  Likewise if
5097          the symbol was forced to be local because of a version file.
5098          The entry in the global offset table will already have been
5099          initialized in the relocate_section function.  */
5100
5101       if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
5102         {
5103           rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
5104           rela.r_addend = bfd_get_signed_32 (output_bfd,
5105                                              (sgot->contents + offset));
5106           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
5107         }
5108       else
5109         {
5110           bfd_put_32 (output_bfd, (bfd_vma) 0,
5111                       sgot->contents + offset);
5112           rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
5113           rela.r_addend = 0;
5114         }
5115
5116       loc = srela->contents;
5117       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5118       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5119     }
5120
5121   if (use_plt && h->got.offset != (bfd_vma) -1)
5122     {
5123       bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
5124       asection *sgot = htab->root.sgot;
5125       asection *splt = htab->root.splt;
5126       bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
5127                                + h->plt.offset),
5128                   sgot->contents + offset);
5129     }
5130
5131   if (h->needs_copy)
5132     {
5133       asection *s;
5134       Elf_Internal_Rela rela;
5135       bfd_byte *loc;
5136
5137       /* This symbol needs a copy reloc.  Set it up.  */
5138       BFD_ASSERT (h->dynindx != -1
5139                   && (h->root.type == bfd_link_hash_defined
5140                       || h->root.type == bfd_link_hash_defweak));
5141
5142       rela.r_offset = (h->root.u.def.value
5143                        + h->root.u.def.section->output_section->vma
5144                        + h->root.u.def.section->output_offset);
5145       rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
5146       rela.r_addend = 0;
5147       if (h->root.u.def.section == htab->root.sdynrelro)
5148         s = htab->root.sreldynrelro;
5149       else
5150         s = htab->root.srelbss;
5151       BFD_ASSERT (s != NULL);
5152       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5153       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5154     }
5155
5156   /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute.  */
5157   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5158       || h == htab->root.hgot
5159       || h == htab->h_gp_got)
5160     sym->st_shndx = SHN_ABS;
5161
5162   return TRUE;
5163 }
5164
5165 /* Implement elf_backend_finish_dynamic_sections.  */
5166 static bfd_boolean
5167 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
5168                                      struct bfd_link_info *info)
5169 {
5170   asection *sgotplt;
5171   asection *sdyn;
5172   struct elf32_nios2_link_hash_table *htab;
5173
5174   htab = elf32_nios2_hash_table (info);
5175   sgotplt = htab->root.sgotplt;
5176   sdyn = NULL;
5177
5178   if (htab->root.dynamic_sections_created)
5179     {
5180       asection *splt;
5181       Elf32_External_Dyn *dyncon, *dynconend;
5182
5183       splt = htab->root.splt;
5184       sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
5185       BFD_ASSERT (splt != NULL && sdyn != NULL && sgotplt != NULL);
5186
5187       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5188       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5189       for (; dyncon < dynconend; dyncon++)
5190         {
5191           Elf_Internal_Dyn dyn;
5192           asection *s;
5193
5194           bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
5195
5196           switch (dyn.d_tag)
5197             {
5198             default:
5199               break;
5200
5201             case DT_PLTGOT:
5202               s = htab->root.sgotplt;
5203               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5204               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5205               break;
5206
5207             case DT_JMPREL:
5208               s = htab->root.srelplt;
5209               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5210               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5211               break;
5212
5213             case DT_PLTRELSZ:
5214               s = htab->root.srelplt;
5215               dyn.d_un.d_val = s->size;
5216               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5217               break;
5218
5219             case DT_NIOS2_GP:
5220               s = htab->root.sgotplt;
5221               dyn.d_un.d_ptr
5222                 = s->output_section->vma + s->output_offset + 0x7ff0;
5223               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5224               break;
5225             }
5226         }
5227
5228       /* Fill in the first entry in the procedure linkage table.  */
5229       if (splt->size > 0)
5230         {
5231           bfd_vma got_address = (sgotplt->output_section->vma
5232                                  + sgotplt->output_offset);
5233           if (bfd_link_pic (info))
5234             {
5235               bfd_vma got_pcrel = got_address - (splt->output_section->vma
5236                                                  + splt->output_offset);
5237               /* Both GOT and PLT must be aligned to a 16-byte boundary
5238                  for the two loads to share the %hiadj part.  The 4-byte
5239                  offset for nextpc is accounted for in the %lo offsets
5240                  on the loads.  */
5241               BFD_ASSERT ((got_pcrel & 0xf) == 0);
5242               nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
5243               nios2_elf32_install_imm16 (splt, 4, hiadj (got_pcrel));
5244               nios2_elf32_install_imm16 (splt, 12, got_pcrel & 0xffff);
5245               nios2_elf32_install_imm16 (splt, 16, (got_pcrel + 4) & 0xffff);
5246             }
5247           else
5248             {
5249               /* Divide by 4 here, not 3 because we already corrected for the
5250                  res_N branches.  */
5251               bfd_vma res_size = (splt->size - 28) / 4;
5252               bfd_vma res_start = (splt->output_section->vma
5253                                    + splt->output_offset);
5254               bfd_vma res_offset;
5255
5256               for (res_offset = 0; res_offset < res_size; res_offset += 4)
5257                 bfd_put_32 (output_bfd,
5258                             6 | ((res_size - (res_offset + 4)) << 6),
5259                             splt->contents + res_offset);
5260
5261               /* The GOT must be aligned to a 16-byte boundary for the
5262                  two loads to share the same %hiadj part.  */
5263               BFD_ASSERT ((got_address & 0xf) == 0);
5264
5265               nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
5266               nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
5267               nios2_elf32_install_imm16 (splt, res_size + 4,
5268                                          res_start & 0xffff);
5269               nios2_elf32_install_imm16 (splt, res_size + 12,
5270                                          hiadj (got_address));
5271               nios2_elf32_install_imm16 (splt, res_size + 16,
5272                                          (got_address + 4) & 0xffff);
5273               nios2_elf32_install_imm16 (splt, res_size + 20,
5274                                          (got_address + 8) & 0xffff);
5275             }
5276         }
5277     }
5278
5279   /* Fill in the first three entries in the global offset table.  */
5280   if (sgotplt != NULL && sgotplt->size > 0)
5281     {
5282       if (sdyn == NULL)
5283         bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
5284       else
5285         bfd_put_32 (output_bfd,
5286                     sdyn->output_section->vma + sdyn->output_offset,
5287                     sgotplt->contents);
5288       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
5289       bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
5290
5291       if (sgotplt->output_section != bfd_abs_section_ptr)
5292         elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
5293     }
5294
5295   return TRUE;
5296 }
5297
5298 /* Implement elf_backend_adjust_dynamic_symbol:
5299    Adjust a symbol defined by a dynamic object and referenced by a
5300    regular object.  The current definition is in some section of the
5301    dynamic object, but we're not including those sections.  We have to
5302    change the definition to something the rest of the link can
5303    understand.  */
5304 static bfd_boolean
5305 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
5306                                    struct elf_link_hash_entry *h)
5307 {
5308   struct elf32_nios2_link_hash_table *htab;
5309   bfd *dynobj;
5310   asection *s, *srel;
5311   unsigned align2;
5312
5313   htab = elf32_nios2_hash_table (info);
5314   dynobj = htab->root.dynobj;
5315
5316   /* Make sure we know what is going on here.  */
5317   BFD_ASSERT (dynobj != NULL
5318               && (h->needs_plt
5319                   || h->is_weakalias
5320                   || (h->def_dynamic
5321                       && h->ref_regular
5322                       && !h->def_regular)));
5323
5324   /* If this is a function, put it in the procedure linkage table.  We
5325      will fill in the contents of the procedure linkage table later,
5326      when we know the address of the .got section.  */
5327   if (h->type == STT_FUNC || h->needs_plt)
5328     {
5329       if (h->plt.refcount <= 0
5330           || SYMBOL_CALLS_LOCAL (info, h)
5331           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5332               && h->root.type == bfd_link_hash_undefweak))
5333         {
5334           /* This case can occur if we saw a PLT reloc in an input
5335              file, but the symbol was never referred to by a dynamic
5336              object, or if all references were garbage collected.  In
5337              such a case, we don't actually need to build a procedure
5338              linkage table, and we can just do a PCREL reloc instead.  */
5339           h->plt.offset = (bfd_vma) -1;
5340           h->needs_plt = 0;
5341         }
5342
5343       return TRUE;
5344     }
5345
5346   /* Reinitialize the plt offset now that it is not used as a reference
5347      count any more.  */
5348   h->plt.offset = (bfd_vma) -1;
5349
5350   /* If this is a weak symbol, and there is a real definition, the
5351      processor independent code will have arranged for us to see the
5352      real definition first, and we can just use the same value.  */
5353   if (h->is_weakalias)
5354     {
5355       struct elf_link_hash_entry *def = weakdef (h);
5356       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
5357       h->root.u.def.section = def->root.u.def.section;
5358       h->root.u.def.value = def->root.u.def.value;
5359       return TRUE;
5360     }
5361
5362   /* If there are no non-GOT references, we do not need a copy
5363      relocation.  */
5364   if (!h->non_got_ref)
5365     return TRUE;
5366
5367   /* This is a reference to a symbol defined by a dynamic object which
5368      is not a function.
5369      If we are creating a shared library, we must presume that the
5370      only references to the symbol are via the global offset table.
5371      For such cases we need not do anything here; the relocations will
5372      be handled correctly by relocate_section.  */
5373   if (bfd_link_pic (info))
5374     return TRUE;
5375
5376   if (h->size == 0)
5377     {
5378       _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5379                           h->root.root.string);
5380       return TRUE;
5381     }
5382
5383   /* We must allocate the symbol in our .dynbss section, which will
5384      become part of the .bss section of the executable.  There will be
5385      an entry for this symbol in the .dynsym section.  The dynamic
5386      object will contain position independent code, so all references
5387      from the dynamic object to this symbol will go through the global
5388      offset table.  The dynamic linker will use the .dynsym entry to
5389      determine the address it must put in the global offset table, so
5390      both the dynamic object and the regular object will refer to the
5391      same memory location for the variable.  */
5392   /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5393      copy the initial value out of the dynamic object and into the
5394      runtime process image.  We need to remember the offset into the
5395      .rela.bss section we are going to use.  */
5396   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5397     {
5398       s = htab->root.sdynrelro;
5399       srel = htab->root.sreldynrelro;
5400     }
5401   else
5402     {
5403       s = htab->root.sdynbss;
5404       srel = htab->root.srelbss;
5405     }
5406   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5407     {
5408       srel->size += sizeof (Elf32_External_Rela);
5409       h->needs_copy = 1;
5410     }
5411
5412   align2 = bfd_log2 (h->size);
5413   if (align2 > h->root.u.def.section->alignment_power)
5414     align2 = h->root.u.def.section->alignment_power;
5415
5416   /* Align dynbss.  */
5417   s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
5418   if (align2 > bfd_get_section_alignment (dynobj, s)
5419       && !bfd_set_section_alignment (dynobj, s, align2))
5420     return FALSE;
5421
5422   /* Define the symbol as being at this point in the section.  */
5423   h->root.u.def.section = s;
5424   h->root.u.def.value = s->size;
5425
5426   /* Increment the section size to make room for the symbol.  */
5427   s->size += h->size;
5428
5429   return TRUE;
5430 }
5431
5432 /* Worker function for nios2_elf32_size_dynamic_sections.  */
5433 static bfd_boolean
5434 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5435 {
5436   struct bfd_link_info *info;
5437   struct elf32_nios2_link_hash_table *htab;
5438
5439   if (h->root.type == bfd_link_hash_indirect)
5440     return TRUE;
5441
5442   if (h->root.type == bfd_link_hash_warning)
5443     /* When warning symbols are created, they **replace** the "real"
5444        entry in the hash table, thus we never get to see the real
5445        symbol in a hash traversal.  So look at it now.  */
5446     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5447
5448   info = (struct bfd_link_info *) inf;
5449   htab = elf32_nios2_hash_table (info);
5450
5451   if (h->plt.offset != (bfd_vma)-1)
5452     h->plt.offset += htab->res_n_size;
5453   if (htab->root.splt == h->root.u.def.section)
5454     h->root.u.def.value += htab->res_n_size;
5455
5456   return TRUE;
5457 }
5458
5459 /* Another worker function for nios2_elf32_size_dynamic_sections.
5460    Allocate space in .plt, .got and associated reloc sections for
5461    dynamic relocs.  */
5462 static bfd_boolean
5463 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5464 {
5465   struct bfd_link_info *info;
5466   struct elf32_nios2_link_hash_table *htab;
5467   struct elf32_nios2_link_hash_entry *eh;
5468   struct elf_dyn_relocs *p;
5469   int use_plt;
5470
5471   if (h->root.type == bfd_link_hash_indirect)
5472     return TRUE;
5473
5474   if (h->root.type == bfd_link_hash_warning)
5475     /* When warning symbols are created, they **replace** the "real"
5476        entry in the hash table, thus we never get to see the real
5477        symbol in a hash traversal.  So look at it now.  */
5478     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5479
5480   info = (struct bfd_link_info *) inf;
5481   htab = elf32_nios2_hash_table (info);
5482
5483   if (htab->root.dynamic_sections_created
5484       && h->plt.refcount > 0)
5485     {
5486       /* Make sure this symbol is output as a dynamic symbol.
5487          Undefined weak syms won't yet be marked as dynamic.  */
5488       if (h->dynindx == -1
5489           && !h->forced_local
5490           && !bfd_elf_link_record_dynamic_symbol (info, h))
5491         return FALSE;
5492
5493       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
5494         {
5495           asection *s = htab->root.splt;
5496
5497           /* Allocate room for the header.  */
5498           if (s->size == 0)
5499             {
5500               if (bfd_link_pic (info))
5501                 s->size = 24;
5502               else
5503                 s->size = 28;
5504             }
5505
5506           h->plt.offset = s->size;
5507
5508           /* If this symbol is not defined in a regular file, and we are
5509              not generating a shared library, then set the symbol to this
5510              location in the .plt.  This is required to make function
5511              pointers compare as equal between the normal executable and
5512              the shared library.  */
5513           if (! bfd_link_pic (info)
5514               && !h->def_regular)
5515             {
5516               h->root.u.def.section = s;
5517               h->root.u.def.value = h->plt.offset;
5518             }
5519
5520           /* Make room for this entry.  */
5521           s->size += 12;
5522
5523           /* We also need to make an entry in the .rela.plt section.  */
5524           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
5525
5526           /* And the .got.plt section.  */
5527           htab->root.sgotplt->size += 4;
5528         }
5529       else
5530         {
5531           h->plt.offset = (bfd_vma) -1;
5532           h->needs_plt = 0;
5533         }
5534     }
5535   else
5536     {
5537       h->plt.offset = (bfd_vma) -1;
5538       h->needs_plt = 0;
5539     }
5540
5541   eh = (struct elf32_nios2_link_hash_entry *) h;
5542   use_plt = (eh->got_types_used == CALL_USED
5543              && h->plt.offset != (bfd_vma) -1);
5544
5545   if (h->got.refcount > 0)
5546     {
5547       asection *s;
5548       bfd_boolean dyn;
5549       int tls_type = eh->tls_type;
5550       int indx;
5551
5552       /* Make sure this symbol is output as a dynamic symbol.
5553          Undefined weak syms won't yet be marked as dynamic.  */
5554       if (h->dynindx == -1
5555           && !h->forced_local
5556           && !bfd_elf_link_record_dynamic_symbol (info, h))
5557         return FALSE;
5558
5559       s = htab->root.sgot;
5560       h->got.offset = s->size;
5561
5562       if (tls_type == GOT_UNKNOWN)
5563         abort ();
5564
5565       if (tls_type == GOT_NORMAL)
5566         /* Non-TLS symbols need one GOT slot.  */
5567         s->size += 4;
5568       else
5569         {
5570           if (tls_type & GOT_TLS_GD)
5571             /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots.  */
5572             s->size += 8;
5573           if (tls_type & GOT_TLS_IE)
5574             /* R_NIOS2_TLS_IE16 needs one GOT slot.  */
5575             s->size += 4;
5576         }
5577
5578       dyn = htab->root.dynamic_sections_created;
5579
5580       indx = 0;
5581       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5582           && (!bfd_link_pic (info)
5583               || !SYMBOL_REFERENCES_LOCAL (info, h)))
5584         indx = h->dynindx;
5585
5586       if (tls_type != GOT_NORMAL
5587           && (bfd_link_pic (info) || indx != 0)
5588           && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5589               || h->root.type != bfd_link_hash_undefweak))
5590         {
5591           if (tls_type & GOT_TLS_IE)
5592             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5593
5594           if (tls_type & GOT_TLS_GD)
5595             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5596
5597           if ((tls_type & GOT_TLS_GD) && indx != 0)
5598             htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5599         }
5600       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5601                 || h->root.type != bfd_link_hash_undefweak)
5602                && !use_plt
5603                && (bfd_link_pic (info)
5604                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5605         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5606     }
5607   else
5608     h->got.offset = (bfd_vma) -1;
5609
5610   if (eh->dyn_relocs == NULL)
5611     return TRUE;
5612
5613   /* In the shared -Bsymbolic case, discard space allocated for
5614      dynamic pc-relative relocs against symbols which turn out to be
5615      defined in regular objects.  For the normal shared case, discard
5616      space for pc-relative relocs that have become local due to symbol
5617      visibility changes.  */
5618
5619   if (bfd_link_pic (info))
5620     {
5621       if (h->def_regular
5622           && (h->forced_local || SYMBOLIC_BIND (info, h)))
5623         {
5624           struct elf_dyn_relocs **pp;
5625
5626           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5627             {
5628               p->count -= p->pc_count;
5629               p->pc_count = 0;
5630               if (p->count == 0)
5631                 *pp = p->next;
5632               else
5633                 pp = &p->next;
5634             }
5635         }
5636
5637       /* Also discard relocs on undefined weak syms with non-default
5638          visibility.  */
5639       if (eh->dyn_relocs != NULL
5640           && h->root.type == bfd_link_hash_undefweak)
5641         {
5642           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5643               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5644             eh->dyn_relocs = NULL;
5645
5646           /* Make sure undefined weak symbols are output as a dynamic
5647              symbol in PIEs.  */
5648           else if (h->dynindx == -1
5649                    && !h->forced_local
5650                    && !bfd_elf_link_record_dynamic_symbol (info, h))
5651             return FALSE;
5652         }
5653     }
5654   else
5655     {
5656       /* For the non-shared case, discard space for relocs against
5657          symbols which turn out to need copy relocs or are not
5658          dynamic.  */
5659
5660       if (!h->non_got_ref
5661           && ((h->def_dynamic && !h->def_regular)
5662               || (htab->root.dynamic_sections_created
5663                   && (h->root.type == bfd_link_hash_undefweak
5664                       || h->root.type == bfd_link_hash_undefined))))
5665         {
5666           /* Make sure this symbol is output as a dynamic symbol.
5667              Undefined weak syms won't yet be marked as dynamic.  */
5668           if (h->dynindx == -1
5669               && !h->forced_local
5670               && !bfd_elf_link_record_dynamic_symbol (info, h))
5671             return FALSE;
5672
5673           /* If that succeeded, we know we'll be keeping all the
5674              relocs.  */
5675           if (h->dynindx != -1)
5676             goto keep;
5677         }
5678
5679       eh->dyn_relocs = NULL;
5680
5681     keep: ;
5682     }
5683
5684   /* Finally, allocate space.  */
5685   for (p = eh->dyn_relocs; p != NULL; p = p->next)
5686     {
5687       asection *sreloc = elf_section_data (p->sec)->sreloc;
5688       sreloc->size += p->count * sizeof (Elf32_External_Rela);
5689     }
5690
5691   return TRUE;
5692 }
5693
5694 /* Implement elf_backend_size_dynamic_sections:
5695    Set the sizes of the dynamic sections.  */
5696 static bfd_boolean
5697 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5698                                    struct bfd_link_info *info)
5699 {
5700   bfd *dynobj;
5701   asection *s;
5702   bfd_boolean relocs;
5703   bfd *ibfd;
5704   struct elf32_nios2_link_hash_table *htab;
5705
5706   htab = elf32_nios2_hash_table (info);
5707   dynobj = htab->root.dynobj;
5708   BFD_ASSERT (dynobj != NULL);
5709
5710   htab->res_n_size = 0;
5711   if (htab->root.dynamic_sections_created)
5712     {
5713       /* Set the contents of the .interp section to the interpreter.  */
5714       if (bfd_link_executable (info) && !info->nointerp)
5715         {
5716           s = bfd_get_linker_section (dynobj, ".interp");
5717           BFD_ASSERT (s != NULL);
5718           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5719           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5720         }
5721     }
5722   else
5723     {
5724       /* We may have created entries in the .rela.got section.
5725          However, if we are not creating the dynamic sections, we will
5726          not actually use these entries.  Reset the size of .rela.got,
5727          which will cause it to get stripped from the output file
5728          below.  */
5729       s = htab->root.srelgot;
5730       if (s != NULL)
5731         s->size = 0;
5732     }
5733
5734   /* Set up .got offsets for local syms, and space for local dynamic
5735      relocs.  */
5736   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5737     {
5738       bfd_signed_vma *local_got;
5739       bfd_signed_vma *end_local_got;
5740       char *local_tls_type;
5741       bfd_size_type locsymcount;
5742       Elf_Internal_Shdr *symtab_hdr;
5743       asection *srel;
5744
5745       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5746         continue;
5747
5748       for (s = ibfd->sections; s != NULL; s = s->next)
5749         {
5750           struct elf_dyn_relocs *p;
5751
5752           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
5753             {
5754               if (!bfd_is_abs_section (p->sec)
5755                   && bfd_is_abs_section (p->sec->output_section))
5756                 {
5757                   /* Input section has been discarded, either because
5758                      it is a copy of a linkonce section or due to
5759                      linker script /DISCARD/, so we'll be discarding
5760                      the relocs too.  */
5761                 }
5762               else if (p->count != 0)
5763                 {
5764                   srel = elf_section_data (p->sec)->sreloc;
5765                   srel->size += p->count * sizeof (Elf32_External_Rela);
5766                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
5767                     info->flags |= DF_TEXTREL;
5768                 }
5769             }
5770         }
5771
5772       local_got = elf_local_got_refcounts (ibfd);
5773       if (!local_got)
5774         continue;
5775
5776       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5777       locsymcount = symtab_hdr->sh_info;
5778       end_local_got = local_got + locsymcount;
5779       local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
5780       s = htab->root.sgot;
5781       srel = htab->root.srelgot;
5782       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5783         {
5784           if (*local_got > 0)
5785             {
5786               *local_got = s->size;
5787               if (*local_tls_type & GOT_TLS_GD)
5788                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5789                 s->size += 8;
5790               if (*local_tls_type & GOT_TLS_IE)
5791                 s->size += 4;
5792               if (*local_tls_type == GOT_NORMAL)
5793                 s->size += 4;
5794
5795               if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
5796                 srel->size += sizeof (Elf32_External_Rela);
5797             }
5798           else
5799             *local_got = (bfd_vma) -1;
5800         }
5801     }
5802
5803   if (htab->tls_ldm_got.refcount > 0)
5804     {
5805       /* Allocate two GOT entries and one dynamic relocation (if necessary)
5806          for R_NIOS2_TLS_LDM16 relocations.  */
5807       htab->tls_ldm_got.offset = htab->root.sgot->size;
5808       htab->root.sgot->size += 8;
5809       if (bfd_link_pic (info))
5810         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5811     }
5812   else
5813     htab->tls_ldm_got.offset = -1;
5814
5815   /* Allocate global sym .plt and .got entries, and space for global
5816      sym dynamic relocs.  */
5817   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5818
5819   if (htab->root.dynamic_sections_created)
5820     {
5821       /* If the .got section is more than 0x8000 bytes, we add
5822          0x8000 to the value of _gp_got, so that 16-bit relocations
5823          have a greater chance of working. */
5824       if (htab->root.sgot->size >= 0x8000
5825           && htab->h_gp_got->root.u.def.value == 0)
5826         htab->h_gp_got->root.u.def.value = 0x8000;
5827     }
5828
5829   /* The check_relocs and adjust_dynamic_symbol entry points have
5830      determined the sizes of the various dynamic sections.  Allocate
5831      memory for them.  */
5832   relocs = FALSE;
5833   for (s = dynobj->sections; s != NULL; s = s->next)
5834     {
5835       const char *name;
5836
5837       if ((s->flags & SEC_LINKER_CREATED) == 0)
5838         continue;
5839
5840       /* It's OK to base decisions on the section name, because none
5841          of the dynobj section names depend upon the input files.  */
5842       name = bfd_get_section_name (dynobj, s);
5843
5844       if (CONST_STRNEQ (name, ".rela"))
5845         {
5846           if (s->size != 0)
5847             {
5848               if (s != htab->root.srelplt)
5849                 relocs = TRUE;
5850
5851               /* We use the reloc_count field as a counter if we need
5852                  to copy relocs into the output file.  */
5853               s->reloc_count = 0;
5854             }
5855         }
5856       else if (s == htab->root.splt)
5857         {
5858           /* Correct for the number of res_N branches.  */
5859           if (s->size != 0 && !bfd_link_pic (info))
5860             {
5861               htab->res_n_size = (s->size - 28) / 3;
5862               s->size += htab->res_n_size;
5863             }
5864         }
5865       else if (s != htab->sbss
5866                && s != htab->root.sgot
5867                && s != htab->root.sgotplt
5868                && s != htab->root.sdynbss
5869                && s != htab->root.sdynrelro)
5870         /* It's not one of our sections, so don't allocate space.  */
5871         continue;
5872
5873       if (s->size == 0)
5874         {
5875           s->flags |= SEC_EXCLUDE;
5876           continue;
5877         }
5878
5879       if ((s->flags & SEC_HAS_CONTENTS) == 0)
5880         continue;
5881
5882       /* Allocate memory for the section contents.  */
5883       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5884       if (s->contents == NULL)
5885         return FALSE;
5886     }
5887
5888   /* Adjust dynamic symbols that point to the plt to account for the
5889      now-known number of resN slots.  */
5890   if (htab->res_n_size)
5891     elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
5892
5893   if (htab->root.dynamic_sections_created)
5894     {
5895       /* Add some entries to the .dynamic section.  We fill in the
5896          values later, in elf_nios2_finish_dynamic_sections, but we
5897          must add the entries now so that we get the correct size for
5898          the .dynamic section.  The DT_DEBUG entry is filled in by the
5899          dynamic linker and used by the debugger.  */
5900 #define add_dynamic_entry(TAG, VAL) \
5901   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5902
5903       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_DEBUG, 0))
5904         return FALSE;
5905
5906       if (htab->root.sgotplt->size != 0
5907           && !add_dynamic_entry (DT_PLTGOT, 0))
5908         return FALSE;
5909
5910       if (htab->root.splt->size != 0
5911           && (!add_dynamic_entry (DT_PLTRELSZ, 0)
5912               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5913               || !add_dynamic_entry (DT_JMPREL, 0)))
5914         return FALSE;
5915
5916       if (relocs
5917           && (!add_dynamic_entry (DT_RELA, 0)
5918               || !add_dynamic_entry (DT_RELASZ, 0)
5919               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
5920         return FALSE;
5921
5922       if (!bfd_link_pic (info) && !add_dynamic_entry (DT_NIOS2_GP, 0))
5923         return FALSE;
5924
5925       if ((info->flags & DF_TEXTREL) != 0
5926           && !add_dynamic_entry (DT_TEXTREL, 0))
5927         return FALSE;
5928     }
5929 #undef add_dynamic_entry
5930
5931   return TRUE;
5932 }
5933
5934 /* Free the derived linker hash table.  */
5935 static void
5936 nios2_elf32_link_hash_table_free (bfd *obfd)
5937 {
5938   struct elf32_nios2_link_hash_table *htab
5939     = (struct elf32_nios2_link_hash_table *) obfd->link.hash;
5940
5941   bfd_hash_table_free (&htab->bstab);
5942   _bfd_elf_link_hash_table_free (obfd);
5943 }
5944
5945 /* Implement bfd_elf32_bfd_link_hash_table_create.  */
5946 static struct bfd_link_hash_table *
5947 nios2_elf32_link_hash_table_create (bfd *abfd)
5948 {
5949   struct elf32_nios2_link_hash_table *ret;
5950   bfd_size_type amt = sizeof (struct elf32_nios2_link_hash_table);
5951
5952   ret = bfd_zmalloc (amt);
5953   if (ret == NULL)
5954     return NULL;
5955
5956   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5957                                       link_hash_newfunc,
5958                                       sizeof (struct
5959                                               elf32_nios2_link_hash_entry),
5960                                       NIOS2_ELF_DATA))
5961     {
5962       free (ret);
5963       return NULL;
5964     }
5965
5966   /* Init the stub hash table too.  */
5967   if (!bfd_hash_table_init (&ret->bstab, stub_hash_newfunc,
5968                             sizeof (struct elf32_nios2_stub_hash_entry)))
5969     {
5970       _bfd_elf_link_hash_table_free (abfd);
5971       return NULL;
5972     }
5973   ret->root.root.hash_table_free = nios2_elf32_link_hash_table_free;
5974
5975   return &ret->root.root;
5976 }
5977
5978 /* Implement elf_backend_reloc_type_class.  */
5979 static enum elf_reloc_type_class
5980 nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5981                               const asection *rel_sec ATTRIBUTE_UNUSED,
5982                               const Elf_Internal_Rela *rela)
5983 {
5984   switch ((int) ELF32_R_TYPE (rela->r_info))
5985     {
5986     case R_NIOS2_RELATIVE:
5987       return reloc_class_relative;
5988     case R_NIOS2_JUMP_SLOT:
5989       return reloc_class_plt;
5990     case R_NIOS2_COPY:
5991       return reloc_class_copy;
5992     default:
5993       return reloc_class_normal;
5994     }
5995 }
5996
5997 /* Return 1 if target is one of ours.  */
5998 static bfd_boolean
5999 is_nios2_elf_target (const struct bfd_target *targ)
6000 {
6001   return (targ == &nios2_elf32_le_vec
6002           || targ == &nios2_elf32_be_vec);
6003 }
6004
6005 /* Implement elf_backend_add_symbol_hook.
6006    This hook is called by the linker when adding symbols from an object
6007    file.  We use it to put .comm items in .sbss, and not .bss.  */
6008 static bfd_boolean
6009 nios2_elf_add_symbol_hook (bfd *abfd,
6010                            struct bfd_link_info *info,
6011                            Elf_Internal_Sym *sym,
6012                            const char **namep ATTRIBUTE_UNUSED,
6013                            flagword *flagsp ATTRIBUTE_UNUSED,
6014                            asection **secp,
6015                            bfd_vma *valp)
6016 {
6017   if (sym->st_shndx == SHN_COMMON
6018       && !bfd_link_relocatable (info)
6019       && sym->st_size <= elf_gp_size (abfd)
6020       && is_nios2_elf_target (info->output_bfd->xvec))
6021     {
6022       /* Common symbols less than or equal to -G nn bytes are automatically
6023          put into .sbss.  */
6024       struct elf32_nios2_link_hash_table *htab;
6025
6026       htab = elf32_nios2_hash_table (info);
6027       if (htab->sbss == NULL)
6028         {
6029           flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
6030
6031           if (htab->root.dynobj == NULL)
6032             htab->root.dynobj = abfd;
6033
6034           htab->sbss = bfd_make_section_anyway_with_flags (htab->root.dynobj,
6035                                                            ".sbss", flags);
6036           if (htab->sbss == NULL)
6037             return FALSE;
6038         }
6039
6040       *secp = htab->sbss;
6041       *valp = sym->st_size;
6042     }
6043
6044   return TRUE;
6045 }
6046
6047 /* Implement elf_backend_can_make_relative_eh_frame:
6048    Decide whether to attempt to turn absptr or lsda encodings in
6049    shared libraries into pcrel within the given input section.  */
6050 static bfd_boolean
6051 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6052                                         struct bfd_link_info *info
6053                                         ATTRIBUTE_UNUSED,
6054                                         asection *eh_frame_section
6055                                         ATTRIBUTE_UNUSED)
6056 {
6057   /* We can't use PC-relative encodings in the .eh_frame section.  */
6058   return FALSE;
6059 }
6060
6061 /* Implement elf_backend_special_sections.  */
6062 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
6063 {
6064   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,
6065     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6066   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
6067     SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6068   { NULL,                     0,  0, 0,              0 }
6069 };
6070
6071 #define ELF_ARCH                        bfd_arch_nios2
6072 #define ELF_TARGET_ID                   NIOS2_ELF_DATA
6073 #define ELF_MACHINE_CODE                EM_ALTERA_NIOS2
6074
6075 /* The Nios II MMU uses a 4K page size.  */
6076
6077 #define ELF_MAXPAGESIZE                 0x1000
6078
6079 #define bfd_elf32_bfd_link_hash_table_create \
6080                                           nios2_elf32_link_hash_table_create
6081
6082 #define bfd_elf32_bfd_merge_private_bfd_data \
6083                                           nios2_elf32_merge_private_bfd_data
6084
6085 /* Relocation table lookup macros.  */
6086
6087 #define bfd_elf32_bfd_reloc_type_lookup   nios2_elf32_bfd_reloc_type_lookup
6088 #define bfd_elf32_bfd_reloc_name_lookup   nios2_elf32_bfd_reloc_name_lookup
6089
6090 /* JUMP_TABLE_LINK macros.  */
6091
6092 /* elf_info_to_howto (using RELA relocations).  */
6093
6094 #define elf_info_to_howto                 nios2_elf32_info_to_howto
6095
6096 /* elf backend functions.  */
6097
6098 #define elf_backend_can_gc_sections     1
6099 #define elf_backend_can_refcount        1
6100 #define elf_backend_plt_readonly        1
6101 #define elf_backend_want_got_plt        1
6102 #define elf_backend_want_dynrelro       1
6103 #define elf_backend_rela_normal         1
6104 #define elf_backend_dtrel_excludes_plt  1
6105
6106 #define elf_backend_relocate_section      nios2_elf32_relocate_section
6107 #define elf_backend_section_flags         nios2_elf32_section_flags
6108 #define elf_backend_fake_sections         nios2_elf32_fake_sections
6109 #define elf_backend_check_relocs          nios2_elf32_check_relocs
6110
6111 #define elf_backend_gc_mark_hook          nios2_elf32_gc_mark_hook
6112 #define elf_backend_create_dynamic_sections \
6113                                           nios2_elf32_create_dynamic_sections
6114 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6115 #define elf_backend_finish_dynamic_sections \
6116                                           nios2_elf32_finish_dynamic_sections
6117 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6118 #define elf_backend_reloc_type_class      nios2_elf32_reloc_type_class
6119 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6120 #define elf_backend_add_symbol_hook       nios2_elf_add_symbol_hook
6121 #define elf_backend_copy_indirect_symbol  nios2_elf32_copy_indirect_symbol
6122 #define elf_backend_object_p              nios2_elf32_object_p
6123
6124 #define elf_backend_grok_prstatus         nios2_grok_prstatus
6125 #define elf_backend_grok_psinfo           nios2_grok_psinfo
6126
6127 #undef elf_backend_can_make_relative_eh_frame
6128 #define elf_backend_can_make_relative_eh_frame \
6129                                           nios2_elf32_can_make_relative_eh_frame
6130
6131 #define elf_backend_special_sections      elf32_nios2_special_sections
6132
6133 #define TARGET_LITTLE_SYM               nios2_elf32_le_vec
6134 #define TARGET_LITTLE_NAME              "elf32-littlenios2"
6135 #define TARGET_BIG_SYM                  nios2_elf32_be_vec
6136 #define TARGET_BIG_NAME                 "elf32-bignios2"
6137
6138 #define elf_backend_got_header_size     12
6139 #define elf_backend_default_execstack   0
6140
6141 #include "elf32-target.h"