bfd/elf32-nios2.c

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