bfd/elf32-nios2.c

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