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