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