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