elf32-or1k.c revision 1.1.1.7
1 /* Or1k-specific support for 32-bit ELF. 2 Copyright (C) 2001-2022 Free Software Foundation, Inc. 3 Contributed for OR32 by Johan Rydberg, jrydberg (at) opencores.org 4 5 PIC parts added by Stefan Kristiansson, stefan.kristiansson (at) saunalahti.fi, 6 largely based on elf32-m32r.c and elf32-microblaze.c. 7 8 This file is part of BFD, the Binary File Descriptor library. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "sysdep.h" 24 #include "bfd.h" 25 #include "libbfd.h" 26 #include "elf-bfd.h" 27 #include "elf/or1k.h" 28 #include "libiberty.h" 29 30 #define N_ONES(X) (((bfd_vma)2 << (X)) - 1) 31 32 #define PLT_ENTRY_SIZE 16 33 #define PLT_ENTRY_SIZE_LARGE (6*4) 34 #define PLT_MAX_INSN_COUNT 6 35 36 #define OR1K_MOVHI(D) (0x18000000 | (D << 21)) 37 #define OR1K_ADRP(D) (0x08000000 | (D << 21)) 38 #define OR1K_LWZ(D,A) (0x84000000 | (D << 21) | (A << 16)) 39 #define OR1K_ADD(D,A,B) (0xE0000000 | (D << 21) | (A << 16) | (B << 11)) 40 #define OR1K_ORI(D,A) (0xA8000000 | (D << 21) | (A << 16)) 41 #define OR1K_ORI0(D) (0xA8000000 | (D << 21)) 42 #define OR1K_JR(B) (0x44000000 | (B << 11)) 43 #define OR1K_NOP 0x15000000 44 45 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 46 47 static reloc_howto_type or1k_elf_howto_table[] = 48 { 49 /* This reloc does nothing. */ 50 HOWTO (R_OR1K_NONE, /* type */ 51 0, /* rightshift */ 52 0, /* size */ 53 0, /* bitsize */ 54 false, /* pc_relative */ 55 0, /* bitpos */ 56 complain_overflow_dont, /* complain_on_overflow */ 57 bfd_elf_generic_reloc, /* special_function */ 58 "R_OR1K_NONE", /* name */ 59 false, /* partial_inplace */ 60 0, /* src_mask */ 61 0, /* dst_mask */ 62 false), /* pcrel_offset */ 63 64 HOWTO (R_OR1K_32, 65 0, /* rightshift */ 66 4, /* size */ 67 32, /* bitsize */ 68 false, /* pc_relative */ 69 0, /* bitpos */ 70 complain_overflow_unsigned, /* complain_on_overflow */ 71 bfd_elf_generic_reloc, /* special_function */ 72 "R_OR1K_32", /* name */ 73 false, /* partial_inplace */ 74 0, /* src_mask */ 75 0xffffffff, /* dst_mask */ 76 false), /* pcrel_offset */ 77 78 HOWTO (R_OR1K_16, 79 0, /* rightshift */ 80 2, /* size */ 81 16, /* bitsize */ 82 false, /* pc_relative */ 83 0, /* bitpos */ 84 complain_overflow_unsigned, /* complain_on_overflow */ 85 bfd_elf_generic_reloc, /* special_function */ 86 "R_OR1K_16", /* name */ 87 false, /* partial_inplace */ 88 0, /* src_mask */ 89 0xffff, /* dst_mask */ 90 false), /* pcrel_offset */ 91 92 HOWTO (R_OR1K_8, 93 0, /* rightshift */ 94 1, /* size */ 95 8, /* bitsize */ 96 false, /* pc_relative */ 97 0, /* bitpos */ 98 complain_overflow_unsigned, /* complain_on_overflow */ 99 bfd_elf_generic_reloc, /* special_function */ 100 "R_OR1K_8", /* name */ 101 false, /* partial_inplace */ 102 0, /* src_mask */ 103 0xff, /* dst_mask */ 104 false), /* pcrel_offset */ 105 106 HOWTO (R_OR1K_LO_16_IN_INSN, /* type */ 107 0, /* rightshift */ 108 4, /* size */ 109 16, /* bitsize */ 110 false, /* pc_relative */ 111 0, /* bitpos */ 112 complain_overflow_dont, /* complain_on_overflow */ 113 bfd_elf_generic_reloc, /* special_function */ 114 "R_OR1K_LO_16_IN_INSN", /* name */ 115 false, /* partial_inplace */ 116 0, /* src_mask */ 117 0x0000ffff, /* dst_mask */ 118 false), /* pcrel_offset */ 119 120 HOWTO (R_OR1K_HI_16_IN_INSN, /* type */ 121 16, /* rightshift */ 122 4, /* size */ 123 16, /* bitsize */ 124 false, /* pc_relative */ 125 0, /* bitpos */ 126 complain_overflow_dont, /* complain_on_overflow */ 127 bfd_elf_generic_reloc, /* special_function */ 128 "R_OR1K_HI_16_IN_INSN", /* name */ 129 false, /* partial_inplace */ 130 0, /* src_mask */ 131 0x0000ffff, /* dst_mask */ 132 false), /* pcrel_offset */ 133 134 /* A PC relative 26 bit relocation, right shifted by 2. */ 135 HOWTO (R_OR1K_INSN_REL_26, /* type */ 136 2, /* rightshift */ 137 4, /* size */ 138 26, /* bitsize */ 139 true, /* pc_relative */ 140 0, /* bitpos */ 141 complain_overflow_signed, /* complain_on_overflow */ 142 bfd_elf_generic_reloc, /* special_function */ 143 "R_OR1K_INSN_REL_26", /* name */ 144 false, /* partial_inplace */ 145 0, /* src_mask */ 146 0x03ffffff, /* dst_mask */ 147 true), /* pcrel_offset */ 148 149 /* GNU extension to record C++ vtable hierarchy. */ 150 HOWTO (R_OR1K_GNU_VTINHERIT, /* type */ 151 0, /* rightshift */ 152 4, /* size */ 153 0, /* bitsize */ 154 false, /* pc_relative */ 155 0, /* bitpos */ 156 complain_overflow_dont, /* complain_on_overflow */ 157 NULL, /* special_function */ 158 "R_OR1K_GNU_VTINHERIT", /* name */ 159 false, /* partial_inplace */ 160 0, /* src_mask */ 161 0, /* dst_mask */ 162 false), /* pcrel_offset */ 163 164 /* GNU extension to record C++ vtable member usage. */ 165 HOWTO (R_OR1K_GNU_VTENTRY, /* type */ 166 0, /* rightshift */ 167 4, /* size */ 168 0, /* bitsize */ 169 false, /* pc_relative */ 170 0, /* bitpos */ 171 complain_overflow_dont, /* complain_on_overflow */ 172 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 173 "R_OR1K_GNU_VTENTRY", /* name */ 174 false, /* partial_inplace */ 175 0, /* src_mask */ 176 0, /* dst_mask */ 177 false), /* pcrel_offset */ 178 179 HOWTO (R_OR1K_32_PCREL, 180 0, /* rightshift */ 181 4, /* size */ 182 32, /* bitsize */ 183 true, /* pc_relative */ 184 0, /* bitpos */ 185 complain_overflow_signed, /* complain_on_overflow */ 186 bfd_elf_generic_reloc, /* special_function */ 187 "R_OR1K_32_PCREL", /* name */ 188 false, /* partial_inplace */ 189 0, /* src_mask */ 190 0xffffffff, /* dst_mask */ 191 true), /* pcrel_offset */ 192 193 HOWTO (R_OR1K_16_PCREL, 194 0, /* rightshift */ 195 2, /* size */ 196 16, /* bitsize */ 197 true, /* pc_relative */ 198 0, /* bitpos */ 199 complain_overflow_signed, /* complain_on_overflow */ 200 bfd_elf_generic_reloc, /* special_function */ 201 "R_OR1K_16_PCREL", /* name */ 202 false, /* partial_inplace */ 203 0, /* src_mask */ 204 0xffff, /* dst_mask */ 205 true), /* pcrel_offset */ 206 207 HOWTO (R_OR1K_8_PCREL, 208 0, /* rightshift */ 209 1, /* size */ 210 8, /* bitsize */ 211 true, /* pc_relative */ 212 0, /* bitpos */ 213 complain_overflow_signed, /* complain_on_overflow */ 214 bfd_elf_generic_reloc, /* special_function */ 215 "R_OR1K_8_PCREL", /* name */ 216 false, /* partial_inplace */ 217 0, /* src_mask */ 218 0xff, /* dst_mask */ 219 true), /* pcrel_offset */ 220 221 HOWTO (R_OR1K_GOTPC_HI16, /* Type. */ 222 16, /* Rightshift. */ 223 4, /* Size. */ 224 16, /* Bitsize. */ 225 true, /* PC_relative. */ 226 0, /* Bitpos. */ 227 complain_overflow_dont, /* Complain on overflow. */ 228 bfd_elf_generic_reloc, /* Special Function. */ 229 "R_OR1K_GOTPC_HI16", /* Name. */ 230 false, /* Partial Inplace. */ 231 0, /* Source Mask. */ 232 0xffff, /* Dest Mask. */ 233 true), /* PC relative offset? */ 234 235 HOWTO (R_OR1K_GOTPC_LO16, /* Type. */ 236 0, /* Rightshift. */ 237 4, /* Size. */ 238 16, /* Bitsize. */ 239 true, /* PC_relative. */ 240 0, /* Bitpos. */ 241 complain_overflow_dont, /* Complain on overflow. */ 242 bfd_elf_generic_reloc, /* Special Function. */ 243 "R_OR1K_GOTPC_LO16", /* Name. */ 244 false, /* Partial Inplace. */ 245 0, /* Source Mask. */ 246 0xffff, /* Dest Mask. */ 247 true), /* PC relative offset? */ 248 249 HOWTO (R_OR1K_GOT16, /* type */ 250 0, /* rightshift */ 251 4, /* size */ 252 16, /* bitsize */ 253 false, /* pc_relative */ 254 0, /* bitpos */ 255 complain_overflow_signed, /* complain_on_overflow */ 256 bfd_elf_generic_reloc, /* special_function */ 257 "R_OR1K_GOT16", /* name */ 258 false, /* partial_inplace */ 259 0, /* src_mask */ 260 0xffff, /* dst_mask */ 261 false), /* pcrel_offset */ 262 263 /* A 26 bit PLT relocation. Shifted by 2. */ 264 HOWTO (R_OR1K_PLT26, /* Type. */ 265 2, /* Rightshift. */ 266 4, /* Size. */ 267 26, /* Bitsize. */ 268 true, /* pc_relative. */ 269 0, /* Bitpos. */ 270 complain_overflow_signed, /* Complain on overflow. */ 271 bfd_elf_generic_reloc, /* Special Function. */ 272 "R_OR1K_PLT26", /* Name. */ 273 false, /* Partial Inplace. */ 274 0, /* Source Mask. */ 275 0x03ffffff, /* Dest Mask. */ 276 true), /* PC relative offset? */ 277 278 HOWTO (R_OR1K_GOTOFF_HI16, /* type */ 279 16, /* rightshift */ 280 4, /* size */ 281 16, /* bitsize */ 282 false, /* pc_relative */ 283 0, /* bitpos */ 284 complain_overflow_dont, /* complain_on_overflow */ 285 bfd_elf_generic_reloc, /* special_function */ 286 "R_OR1K_GOTOFF_HI16", /* name */ 287 false, /* partial_inplace */ 288 0x0, /* src_mask */ 289 0xffff, /* dst_mask */ 290 false), /* pcrel_offset */ 291 292 HOWTO (R_OR1K_GOTOFF_LO16, /* type */ 293 0, /* rightshift */ 294 4, /* size */ 295 16, /* bitsize */ 296 false, /* pc_relative */ 297 0, /* bitpos */ 298 complain_overflow_dont, /* complain_on_overflow */ 299 bfd_elf_generic_reloc, /* special_function */ 300 "R_OR1K_GOTOFF_LO16", /* name */ 301 false, /* partial_inplace */ 302 0x0, /* src_mask */ 303 0xffff, /* dst_mask */ 304 false), /* pcrel_offset */ 305 306 HOWTO (R_OR1K_COPY, /* type */ 307 0, /* rightshift */ 308 4, /* size */ 309 32, /* bitsize */ 310 false, /* pc_relative */ 311 0, /* bitpos */ 312 complain_overflow_bitfield, /* complain_on_overflow */ 313 bfd_elf_generic_reloc, /* special_function */ 314 "R_OR1K_COPY", /* name */ 315 false, /* partial_inplace */ 316 0xffffffff, /* src_mask */ 317 0xffffffff, /* dst_mask */ 318 false), /* pcrel_offset */ 319 320 HOWTO (R_OR1K_GLOB_DAT, /* type */ 321 0, /* rightshift */ 322 4, /* size */ 323 32, /* bitsize */ 324 false, /* pc_relative */ 325 0, /* bitpos */ 326 complain_overflow_bitfield, /* complain_on_overflow */ 327 bfd_elf_generic_reloc, /* special_function */ 328 "R_OR1K_GLOB_DAT", /* name */ 329 false, /* partial_inplace */ 330 0xffffffff, /* src_mask */ 331 0xffffffff, /* dst_mask */ 332 false), /* pcrel_offset */ 333 334 HOWTO (R_OR1K_JMP_SLOT, /* type */ 335 0, /* rightshift */ 336 4, /* size */ 337 32, /* bitsize */ 338 false, /* pc_relative */ 339 0, /* bitpos */ 340 complain_overflow_bitfield, /* complain_on_overflow */ 341 bfd_elf_generic_reloc, /* special_function */ 342 "R_OR1K_JMP_SLOT", /* name */ 343 false, /* partial_inplace */ 344 0xffffffff, /* src_mask */ 345 0xffffffff, /* dst_mask */ 346 false), /* pcrel_offset */ 347 348 HOWTO (R_OR1K_RELATIVE, /* type */ 349 0, /* rightshift */ 350 4, /* size */ 351 32, /* bitsize */ 352 false, /* pc_relative */ 353 0, /* bitpos */ 354 complain_overflow_bitfield, /* complain_on_overflow */ 355 bfd_elf_generic_reloc, /* special_function */ 356 "R_OR1K_RELATIVE", /* name */ 357 false, /* partial_inplace */ 358 0xffffffff, /* src_mask */ 359 0xffffffff, /* dst_mask */ 360 false), /* pcrel_offset */ 361 362 HOWTO (R_OR1K_TLS_GD_HI16, /* type */ 363 16, /* rightshift */ 364 4, /* size */ 365 16, /* bitsize */ 366 false, /* pc_relative */ 367 0, /* bitpos */ 368 complain_overflow_dont, /* complain_on_overflow */ 369 bfd_elf_generic_reloc, /* special_function */ 370 "R_OR1K_TLS_GD_HI16", /* name */ 371 false, /* partial_inplace */ 372 0x0, /* src_mask */ 373 0xffff, /* dst_mask */ 374 false), /* pcrel_offset */ 375 376 HOWTO (R_OR1K_TLS_GD_LO16, /* type */ 377 0, /* rightshift */ 378 4, /* size */ 379 16, /* bitsize */ 380 false, /* pc_relative */ 381 0, /* bitpos */ 382 complain_overflow_dont, /* complain_on_overflow */ 383 bfd_elf_generic_reloc, /* special_function */ 384 "R_OR1K_TLS_GD_LO16", /* name */ 385 false, /* partial_inplace */ 386 0x0, /* src_mask */ 387 0xffff, /* dst_mask */ 388 false), /* pcrel_offset */ 389 390 HOWTO (R_OR1K_TLS_LDM_HI16, /* type */ 391 16, /* rightshift */ 392 4, /* size */ 393 16, /* bitsize */ 394 false, /* pc_relative */ 395 0, /* bitpos */ 396 complain_overflow_dont, /* complain_on_overflow */ 397 bfd_elf_generic_reloc, /* special_function */ 398 "R_OR1K_TLS_LDM_HI16", /* name */ 399 false, /* partial_inplace */ 400 0x0, /* src_mask */ 401 0xffff, /* dst_mask */ 402 false), /* pcrel_offset */ 403 404 HOWTO (R_OR1K_TLS_LDM_LO16, /* type */ 405 0, /* rightshift */ 406 4, /* size */ 407 16, /* bitsize */ 408 false, /* pc_relative */ 409 0, /* bitpos */ 410 complain_overflow_dont, /* complain_on_overflow */ 411 bfd_elf_generic_reloc, /* special_function */ 412 "R_OR1K_TLS_LDM_LO16", /* name */ 413 false, /* partial_inplace */ 414 0x0, /* src_mask */ 415 0xffff, /* dst_mask */ 416 false), /* pcrel_offset */ 417 418 HOWTO (R_OR1K_TLS_LDO_HI16, /* type */ 419 16, /* rightshift */ 420 4, /* size */ 421 16, /* bitsize */ 422 false, /* pc_relative */ 423 0, /* bitpos */ 424 complain_overflow_dont, /* complain_on_overflow */ 425 bfd_elf_generic_reloc, /* special_function */ 426 "R_OR1K_TLS_LDO_HI16", /* name */ 427 false, /* partial_inplace */ 428 0x0, /* src_mask */ 429 0xffff, /* dst_mask */ 430 false), /* pcrel_offset */ 431 432 HOWTO (R_OR1K_TLS_LDO_LO16, /* type */ 433 0, /* rightshift */ 434 4, /* size */ 435 16, /* bitsize */ 436 false, /* pc_relative */ 437 0, /* bitpos */ 438 complain_overflow_dont, /* complain_on_overflow */ 439 bfd_elf_generic_reloc, /* special_function */ 440 "R_OR1K_TLS_LDO_LO16", /* name */ 441 false, /* partial_inplace */ 442 0x0, /* src_mask */ 443 0xffff, /* dst_mask */ 444 false), /* pcrel_offset */ 445 446 HOWTO (R_OR1K_TLS_IE_HI16, /* type */ 447 16, /* rightshift */ 448 4, /* size */ 449 16, /* bitsize */ 450 false, /* pc_relative */ 451 0, /* bitpos */ 452 complain_overflow_dont, /* complain_on_overflow */ 453 bfd_elf_generic_reloc, /* special_function */ 454 "R_OR1K_TLS_IE_HI16", /* name */ 455 false, /* partial_inplace */ 456 0x0, /* src_mask */ 457 0xffff, /* dst_mask */ 458 false), /* pcrel_offset */ 459 460 HOWTO (R_OR1K_TLS_IE_LO16, /* type */ 461 0, /* rightshift */ 462 4, /* size */ 463 16, /* bitsize */ 464 false, /* pc_relative */ 465 0, /* bitpos */ 466 complain_overflow_dont, /* complain_on_overflow */ 467 bfd_elf_generic_reloc, /* special_function */ 468 "R_OR1K_TLS_IE_LO16", /* name */ 469 false, /* partial_inplace */ 470 0x0, /* src_mask */ 471 0xffff, /* dst_mask */ 472 false), /* pcrel_offset */ 473 474 HOWTO (R_OR1K_TLS_LE_HI16, /* type */ 475 16, /* rightshift */ 476 4, /* size */ 477 16, /* bitsize */ 478 false, /* pc_relative */ 479 0, /* bitpos */ 480 complain_overflow_dont, /* complain_on_overflow */ 481 bfd_elf_generic_reloc, /* special_function */ 482 "R_OR1K_TLS_LE_HI16", /* name */ 483 false, /* partial_inplace */ 484 0x0, /* src_mask */ 485 0xffff, /* dst_mask */ 486 false), /* pcrel_offset */ 487 488 HOWTO (R_OR1K_TLS_LE_LO16, /* type */ 489 0, /* rightshift */ 490 4, /* size */ 491 16, /* bitsize */ 492 false, /* pc_relative */ 493 0, /* bitpos */ 494 complain_overflow_dont, /* complain_on_overflow */ 495 bfd_elf_generic_reloc, /* special_function */ 496 "R_OR1K_TLS_LE_LO16", /* name */ 497 false, /* partial_inplace */ 498 0x0, /* src_mask */ 499 0xffff, /* dst_mask */ 500 false), /* pcrel_offset */ 501 502 HOWTO (R_OR1K_TLS_TPOFF, /* type */ 503 0, /* rightshift */ 504 4, /* size */ 505 32, /* bitsize */ 506 false, /* pc_relative */ 507 0, /* bitpos */ 508 complain_overflow_bitfield, /* complain_on_overflow */ 509 bfd_elf_generic_reloc, /* special_function */ 510 "R_OR1K_TLS_TPOFF", /* name */ 511 false, /* partial_inplace */ 512 0xffffffff, /* src_mask */ 513 0xffffffff, /* dst_mask */ 514 false), /* pcrel_offset */ 515 516 HOWTO (R_OR1K_TLS_DTPOFF, /* type */ 517 0, /* rightshift */ 518 4, /* size */ 519 32, /* bitsize */ 520 false, /* pc_relative */ 521 0, /* bitpos */ 522 complain_overflow_bitfield, /* complain_on_overflow */ 523 bfd_elf_generic_reloc, /* special_function */ 524 "R_OR1K_TLS_DTPOFF", /* name */ 525 false, /* partial_inplace */ 526 0xffffffff, /* src_mask */ 527 0xffffffff, /* dst_mask */ 528 false), /* pcrel_offset */ 529 530 HOWTO (R_OR1K_TLS_DTPMOD, /* type */ 531 0, /* rightshift */ 532 4, /* size */ 533 32, /* bitsize */ 534 false, /* pc_relative */ 535 0, /* bitpos */ 536 complain_overflow_bitfield, /* complain_on_overflow */ 537 bfd_elf_generic_reloc, /* special_function */ 538 "R_OR1K_TLS_DTPMOD", /* name */ 539 false, /* partial_inplace */ 540 0xffffffff, /* src_mask */ 541 0xffffffff, /* dst_mask */ 542 false), /* pcrel_offset */ 543 544 HOWTO (R_OR1K_AHI16, /* type */ 545 16, /* rightshift */ 546 4, /* size */ 547 16, /* bitsize */ 548 false, /* pc_relative */ 549 0, /* bitpos */ 550 complain_overflow_dont, /* complain_on_overflow */ 551 bfd_elf_generic_reloc, /* special_function */ 552 "R_OR1K_AHI16", /* name */ 553 false, /* partial_inplace */ 554 0x0, /* src_mask */ 555 0xffff, /* dst_mask */ 556 false), /* pcrel_offset */ 557 558 HOWTO (R_OR1K_GOTOFF_AHI16, /* type */ 559 16, /* rightshift */ 560 4, /* size */ 561 16, /* bitsize */ 562 false, /* pc_relative */ 563 0, /* bitpos */ 564 complain_overflow_dont, /* complain_on_overflow */ 565 bfd_elf_generic_reloc, /* special_function */ 566 "R_OR1K_GOTOFF_AHI16", /* name */ 567 false, /* partial_inplace */ 568 0x0, /* src_mask */ 569 0xffff, /* dst_mask */ 570 false), /* pcrel_offset */ 571 572 HOWTO (R_OR1K_TLS_IE_AHI16, /* type */ 573 16, /* rightshift */ 574 4, /* size */ 575 16, /* bitsize */ 576 false, /* pc_relative */ 577 0, /* bitpos */ 578 complain_overflow_dont, /* complain_on_overflow */ 579 bfd_elf_generic_reloc, /* special_function */ 580 "R_OR1K_TLS_IE_AHI16", /* name */ 581 false, /* partial_inplace */ 582 0x0, /* src_mask */ 583 0xffff, /* dst_mask */ 584 false), /* pcrel_offset */ 585 586 HOWTO (R_OR1K_TLS_LE_AHI16, /* type */ 587 16, /* rightshift */ 588 4, /* size */ 589 16, /* bitsize */ 590 false, /* pc_relative */ 591 0, /* bitpos */ 592 complain_overflow_dont, /* complain_on_overflow */ 593 bfd_elf_generic_reloc, /* special_function */ 594 "R_OR1K_TLS_LE_AHI16", /* name */ 595 false, /* partial_inplace */ 596 0x0, /* src_mask */ 597 0xffff, /* dst_mask */ 598 false), /* pcrel_offset */ 599 600 HOWTO (R_OR1K_SLO16, /* type */ 601 0, /* rightshift */ 602 4, /* size */ 603 16, /* bitsize */ 604 false, /* pc_relative */ 605 0, /* bitpos */ 606 complain_overflow_dont, /* complain_on_overflow */ 607 bfd_elf_generic_reloc, /* special_function */ 608 "R_OR1K_SLO16", /* name */ 609 false, /* partial_inplace */ 610 0x0, /* src_mask */ 611 0xffff, /* dst_mask */ 612 false), /* pcrel_offset */ 613 614 HOWTO (R_OR1K_GOTOFF_SLO16, /* type */ 615 0, /* rightshift */ 616 4, /* size */ 617 16, /* bitsize */ 618 false, /* pc_relative */ 619 0, /* bitpos */ 620 complain_overflow_dont, /* complain_on_overflow */ 621 bfd_elf_generic_reloc, /* special_function */ 622 "R_OR1K_GOTOFF_SLO16", /* name */ 623 false, /* partial_inplace */ 624 0x0, /* src_mask */ 625 0xffff, /* dst_mask */ 626 false), /* pcrel_offset */ 627 628 HOWTO (R_OR1K_TLS_LE_SLO16, /* type */ 629 0, /* rightshift */ 630 4, /* size */ 631 16, /* bitsize */ 632 false, /* pc_relative */ 633 0, /* bitpos */ 634 complain_overflow_dont, /* complain_on_overflow */ 635 bfd_elf_generic_reloc, /* special_function */ 636 "R_OR1K_TLS_LE_SLO16", /* name */ 637 false, /* partial_inplace */ 638 0x0, /* src_mask */ 639 0xffff, /* dst_mask */ 640 false), /* pcrel_offset */ 641 642 /* A page relative 21 bit relocation, right shifted by 13, aligned. 643 Note that this is *page* relative, not pc relative. The idea is 644 similar, but normally the section alignment is not such that the 645 assembler can infer a final value, which it attempts to do with 646 pc-relative relocations to local symbols. */ 647 HOWTO (R_OR1K_PCREL_PG21, /* type */ 648 13, /* rightshift */ 649 4, /* size */ 650 21, /* bitsize */ 651 false, /* pc_relative */ 652 0, /* bitpos */ 653 complain_overflow_signed, /* complain_on_overflow */ 654 bfd_elf_generic_reloc, /* special_function */ 655 "R_OR1K_PCREL_PG21", /* name */ 656 false, /* partial_inplace */ 657 0, /* src_mask */ 658 0x001fffff, /* dst_mask */ 659 true), /* pcrel_offset */ 660 661 HOWTO (R_OR1K_GOT_PG21, /* type */ 662 13, /* rightshift */ 663 4, /* size */ 664 21, /* bitsize */ 665 false, /* pc_relative */ 666 0, /* bitpos */ 667 complain_overflow_signed, /* complain_on_overflow */ 668 bfd_elf_generic_reloc, /* special_function */ 669 "R_OR1K_GOT_PG21", /* name */ 670 false, /* partial_inplace */ 671 0, /* src_mask */ 672 0x001fffff, /* dst_mask */ 673 true), /* pcrel_offset */ 674 675 HOWTO (R_OR1K_TLS_GD_PG21, /* type */ 676 13, /* rightshift */ 677 4, /* size */ 678 21, /* bitsize */ 679 false, /* pc_relative */ 680 0, /* bitpos */ 681 complain_overflow_signed, /* complain_on_overflow */ 682 bfd_elf_generic_reloc, /* special_function */ 683 "R_OR1K_TLS_GD_PG21", /* name */ 684 false, /* partial_inplace */ 685 0, /* src_mask */ 686 0x001fffff, /* dst_mask */ 687 true), /* pcrel_offset */ 688 689 HOWTO (R_OR1K_TLS_LDM_PG21, /* type */ 690 13, /* rightshift */ 691 4, /* size */ 692 21, /* bitsize */ 693 false, /* pc_relative */ 694 0, /* bitpos */ 695 complain_overflow_signed, /* complain_on_overflow */ 696 bfd_elf_generic_reloc, /* special_function */ 697 "R_OR1K_TLS_LDM_PG21", /* name */ 698 false, /* partial_inplace */ 699 0, /* src_mask */ 700 0x001fffff, /* dst_mask */ 701 true), /* pcrel_offset */ 702 703 HOWTO (R_OR1K_TLS_IE_PG21, /* type */ 704 13, /* rightshift */ 705 4, /* size */ 706 21, /* bitsize */ 707 false, /* pc_relative */ 708 0, /* bitpos */ 709 complain_overflow_signed, /* complain_on_overflow */ 710 bfd_elf_generic_reloc, /* special_function */ 711 "R_OR1K_TLS_IE_PG21", /* name */ 712 false, /* partial_inplace */ 713 0, /* src_mask */ 714 0x001fffff, /* dst_mask */ 715 true), /* pcrel_offset */ 716 717 HOWTO (R_OR1K_LO13, /* type */ 718 0, /* rightshift */ 719 4, /* size */ 720 16, /* bitsize */ 721 false, /* pc_relative */ 722 0, /* bitpos */ 723 complain_overflow_dont, /* complain_on_overflow */ 724 bfd_elf_generic_reloc, /* special_function */ 725 "R_OR1K_LO13", /* name */ 726 false, /* partial_inplace */ 727 0x0, /* src_mask */ 728 0xffff, /* dst_mask */ 729 false), /* pcrel_offset */ 730 731 HOWTO (R_OR1K_GOT_LO13, /* type */ 732 0, /* rightshift */ 733 4, /* size */ 734 16, /* bitsize */ 735 false, /* pc_relative */ 736 0, /* bitpos */ 737 complain_overflow_dont, /* complain_on_overflow */ 738 bfd_elf_generic_reloc, /* special_function */ 739 "R_OR1K_GOT_LO13", /* name */ 740 false, /* partial_inplace */ 741 0x0, /* src_mask */ 742 0xffff, /* dst_mask */ 743 false), /* pcrel_offset */ 744 745 HOWTO (R_OR1K_TLS_GD_LO13, /* type */ 746 0, /* rightshift */ 747 4, /* size */ 748 16, /* bitsize */ 749 false, /* pc_relative */ 750 0, /* bitpos */ 751 complain_overflow_dont, /* complain_on_overflow */ 752 bfd_elf_generic_reloc, /* special_function */ 753 "R_OR1K_TLS_GD_LO13", /* name */ 754 false, /* partial_inplace */ 755 0x0, /* src_mask */ 756 0xffff, /* dst_mask */ 757 false), /* pcrel_offset */ 758 759 HOWTO (R_OR1K_TLS_LDM_LO13, /* type */ 760 0, /* rightshift */ 761 4, /* size */ 762 16, /* bitsize */ 763 false, /* pc_relative */ 764 0, /* bitpos */ 765 complain_overflow_dont, /* complain_on_overflow */ 766 bfd_elf_generic_reloc, /* special_function */ 767 "R_OR1K_TLD_LDM_LO13", /* name */ 768 false, /* partial_inplace */ 769 0x0, /* src_mask */ 770 0xffff, /* dst_mask */ 771 false), /* pcrel_offset */ 772 773 HOWTO (R_OR1K_TLS_IE_LO13, /* type */ 774 0, /* rightshift */ 775 4, /* size */ 776 16, /* bitsize */ 777 false, /* pc_relative */ 778 0, /* bitpos */ 779 complain_overflow_dont, /* complain_on_overflow */ 780 bfd_elf_generic_reloc, /* special_function */ 781 "R_OR1K_TLS_IE_LO13", /* name */ 782 false, /* partial_inplace */ 783 0x0, /* src_mask */ 784 0xffff, /* dst_mask */ 785 false), /* pcrel_offset */ 786 787 HOWTO (R_OR1K_SLO13, /* type */ 788 0, /* rightshift */ 789 4, /* size */ 790 16, /* bitsize */ 791 false, /* pc_relative */ 792 0, /* bitpos */ 793 complain_overflow_dont, /* complain_on_overflow */ 794 bfd_elf_generic_reloc, /* special_function */ 795 "R_OR1K_SLO13", /* name */ 796 false, /* partial_inplace */ 797 0x0, /* src_mask */ 798 0xffff, /* dst_mask */ 799 false), /* pcrel_offset */ 800 801 /* A 26 bit PLT relocation, using ADRP. Shifted by 2. */ 802 HOWTO (R_OR1K_PLTA26, /* Type. */ 803 2, /* Rightshift. */ 804 4, /* Size. */ 805 26, /* Bitsize. */ 806 true, /* pc_relative. */ 807 0, /* Bitpos. */ 808 complain_overflow_signed, /* Complain on overflow. */ 809 bfd_elf_generic_reloc, /* Special Function. */ 810 "R_OR1K_PLTA26", /* Name. */ 811 false, /* Partial Inplace. */ 812 0, /* Source Mask. */ 813 0x03ffffff, /* Dest Mask. */ 814 true), /* PC relative offset? */ 815 816 HOWTO (R_OR1K_GOT_AHI16, /* type */ 817 16, /* rightshift */ 818 4, /* size */ 819 16, /* bitsize */ 820 false, /* pc_relative */ 821 0, /* bitpos */ 822 complain_overflow_signed, /* complain_on_overflow */ 823 bfd_elf_generic_reloc, /* special_function */ 824 "R_OR1K_GOT_AHI16", /* name */ 825 false, /* partial_inplace */ 826 0, /* src_mask */ 827 0xffff, /* dst_mask */ 828 false), /* pcrel_offset */ 829 }; 830 831 /* A copy of the R_OR1K_GOT16 used in the presense of R_OR1K_GOT_AHI16 832 relocations when we know we can ignore overflows. */ 833 static reloc_howto_type or1k_elf_got16_no_overflow_howto = 834 HOWTO (R_OR1K_GOT16, /* type */ 835 0, /* rightshift */ 836 4, /* size */ 837 16, /* bitsize */ 838 false, /* pc_relative */ 839 0, /* bitpos */ 840 complain_overflow_dont, /* complain_on_overflow */ 841 bfd_elf_generic_reloc, /* special_function */ 842 "R_OR1K_GOT16", /* name */ 843 false, /* partial_inplace */ 844 0, /* src_mask */ 845 0xffff, /* dst_mask */ 846 false); /* pcrel_offset */ 847 848 /* Map BFD reloc types to Or1k ELF reloc types. */ 849 850 struct or1k_reloc_map 851 { 852 bfd_reloc_code_real_type bfd_reloc_val; 853 unsigned int or1k_reloc_val; 854 }; 855 856 static const struct or1k_reloc_map or1k_reloc_map[] = 857 { 858 { BFD_RELOC_NONE, R_OR1K_NONE }, 859 { BFD_RELOC_32, R_OR1K_32 }, 860 { BFD_RELOC_16, R_OR1K_16 }, 861 { BFD_RELOC_8, R_OR1K_8 }, 862 { BFD_RELOC_LO16, R_OR1K_LO_16_IN_INSN }, 863 { BFD_RELOC_HI16, R_OR1K_HI_16_IN_INSN }, 864 { BFD_RELOC_HI16_S, R_OR1K_AHI16 }, 865 { BFD_RELOC_OR1K_REL_26, R_OR1K_INSN_REL_26 }, 866 { BFD_RELOC_VTABLE_ENTRY, R_OR1K_GNU_VTENTRY }, 867 { BFD_RELOC_VTABLE_INHERIT, R_OR1K_GNU_VTINHERIT }, 868 { BFD_RELOC_32_PCREL, R_OR1K_32_PCREL }, 869 { BFD_RELOC_16_PCREL, R_OR1K_16_PCREL }, 870 { BFD_RELOC_8_PCREL, R_OR1K_8_PCREL }, 871 { BFD_RELOC_LO16_GOTOFF, R_OR1K_GOTOFF_LO16 }, 872 { BFD_RELOC_HI16_GOTOFF, R_OR1K_GOTOFF_HI16 }, 873 { BFD_RELOC_HI16_S_GOTOFF, R_OR1K_GOTOFF_AHI16 }, 874 { BFD_RELOC_OR1K_GOTPC_HI16, R_OR1K_GOTPC_HI16 }, 875 { BFD_RELOC_OR1K_GOTPC_LO16, R_OR1K_GOTPC_LO16 }, 876 { BFD_RELOC_OR1K_GOT16, R_OR1K_GOT16 }, 877 { BFD_RELOC_OR1K_PLT26, R_OR1K_PLT26 }, 878 { BFD_RELOC_OR1K_GLOB_DAT, R_OR1K_GLOB_DAT }, 879 { BFD_RELOC_OR1K_COPY, R_OR1K_COPY }, 880 { BFD_RELOC_OR1K_JMP_SLOT, R_OR1K_JMP_SLOT }, 881 { BFD_RELOC_OR1K_RELATIVE, R_OR1K_RELATIVE }, 882 { BFD_RELOC_OR1K_TLS_GD_HI16, R_OR1K_TLS_GD_HI16 }, 883 { BFD_RELOC_OR1K_TLS_GD_LO16, R_OR1K_TLS_GD_LO16 }, 884 { BFD_RELOC_OR1K_TLS_LDM_HI16, R_OR1K_TLS_LDM_HI16 }, 885 { BFD_RELOC_OR1K_TLS_LDM_LO16, R_OR1K_TLS_LDM_LO16 }, 886 { BFD_RELOC_OR1K_TLS_LDO_HI16, R_OR1K_TLS_LDO_HI16 }, 887 { BFD_RELOC_OR1K_TLS_LDO_LO16, R_OR1K_TLS_LDO_LO16 }, 888 { BFD_RELOC_OR1K_TLS_IE_HI16, R_OR1K_TLS_IE_HI16 }, 889 { BFD_RELOC_OR1K_TLS_IE_LO16, R_OR1K_TLS_IE_LO16 }, 890 { BFD_RELOC_OR1K_TLS_IE_AHI16, R_OR1K_TLS_IE_AHI16 }, 891 { BFD_RELOC_OR1K_TLS_LE_HI16, R_OR1K_TLS_LE_HI16 }, 892 { BFD_RELOC_OR1K_TLS_LE_LO16, R_OR1K_TLS_LE_LO16 }, 893 { BFD_RELOC_OR1K_TLS_LE_AHI16, R_OR1K_TLS_LE_AHI16 }, 894 { BFD_RELOC_OR1K_SLO16, R_OR1K_SLO16 }, 895 { BFD_RELOC_OR1K_GOTOFF_SLO16, R_OR1K_GOTOFF_SLO16 }, 896 { BFD_RELOC_OR1K_TLS_LE_SLO16, R_OR1K_TLS_LE_SLO16 }, 897 { BFD_RELOC_OR1K_PCREL_PG21, R_OR1K_PCREL_PG21 }, 898 { BFD_RELOC_OR1K_GOT_PG21, R_OR1K_GOT_PG21 }, 899 { BFD_RELOC_OR1K_TLS_GD_PG21, R_OR1K_TLS_GD_PG21 }, 900 { BFD_RELOC_OR1K_TLS_LDM_PG21, R_OR1K_TLS_LDM_PG21 }, 901 { BFD_RELOC_OR1K_TLS_IE_PG21, R_OR1K_TLS_IE_PG21 }, 902 { BFD_RELOC_OR1K_LO13, R_OR1K_LO13 }, 903 { BFD_RELOC_OR1K_GOT_LO13, R_OR1K_GOT_LO13 }, 904 { BFD_RELOC_OR1K_TLS_GD_LO13, R_OR1K_TLS_GD_LO13 }, 905 { BFD_RELOC_OR1K_TLS_LDM_LO13, R_OR1K_TLS_LDM_LO13 }, 906 { BFD_RELOC_OR1K_TLS_IE_LO13, R_OR1K_TLS_IE_LO13 }, 907 { BFD_RELOC_OR1K_SLO13, R_OR1K_SLO13 }, 908 { BFD_RELOC_OR1K_PLTA26, R_OR1K_PLTA26 }, 909 { BFD_RELOC_OR1K_GOT_AHI16, R_OR1K_GOT_AHI16 }, 910 }; 911 912 /* tls_type is a mask used to track how each symbol is accessed, 913 it may be accessed via multiple types of TLS access methods. 914 We track this for sizing (allocating got + relocation section space) and 915 for how to process relocations. */ 916 #define TLS_UNKNOWN 0 917 #define TLS_NONE 1 918 #define TLS_GD 2 919 #define TLS_LD 4 920 #define TLS_IE 8 921 #define TLS_LE 16 922 923 /* The size of the TLS thread control block, used to offset LE access. */ 924 #define TCB_SIZE 16 925 926 /* ELF linker hash entry. */ 927 struct elf_or1k_link_hash_entry 928 { 929 struct elf_link_hash_entry root; 930 931 /* For calculating PLT size. */ 932 bfd_vma plt_index; 933 /* Track type of TLS access. */ 934 unsigned char tls_type; 935 }; 936 937 /* ELF object data. */ 938 struct elf_or1k_obj_tdata 939 { 940 struct elf_obj_tdata root; 941 942 /* tls_type for each local got entry. */ 943 unsigned char *local_tls_type; 944 }; 945 946 #define elf_or1k_tdata(abfd) \ 947 ((struct elf_or1k_obj_tdata *) (abfd)->tdata.any) 948 949 #define elf_or1k_local_tls_type(abfd) \ 950 (elf_or1k_tdata (abfd)->local_tls_type) 951 952 /* ELF linker hash table. */ 953 struct elf_or1k_link_hash_table 954 { 955 struct elf_link_hash_table root; 956 957 bfd_vma plt_count; 958 bool saw_plta; 959 }; 960 961 static size_t 962 elf_or1k_plt_entry_size (bfd_vma plt_index) 963 { 964 bfd_vma plt_reloc; 965 966 plt_reloc = plt_index * sizeof (Elf32_External_Rela); 967 968 return (plt_reloc > 0xffff) ? PLT_ENTRY_SIZE_LARGE : PLT_ENTRY_SIZE; 969 } 970 971 /* Get the ELF linker hash table from a link_info structure. */ 972 #define or1k_elf_hash_table(p) \ 973 ((is_elf_hash_table ((p)->hash) \ 974 && elf_hash_table_id (elf_hash_table (p)) == OR1K_ELF_DATA) \ 975 ? (struct elf_or1k_link_hash_table *) (p)->hash : NULL) 976 977 static bool 978 elf_or1k_mkobject (bfd *abfd) 979 { 980 return bfd_elf_allocate_object (abfd, sizeof (struct elf_or1k_obj_tdata), 981 OR1K_ELF_DATA); 982 } 983 984 /* Create an entry in an or1k ELF linker hash table. */ 985 986 static struct bfd_hash_entry * 987 or1k_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 988 struct bfd_hash_table *table, 989 const char *string) 990 { 991 struct elf_or1k_link_hash_entry *ret = 992 (struct elf_or1k_link_hash_entry *) entry; 993 994 /* Allocate the structure if it has not already been allocated by a 995 subclass. */ 996 if (ret == NULL) 997 ret = bfd_hash_allocate (table, 998 sizeof (struct elf_or1k_link_hash_entry)); 999 if (ret == NULL) 1000 return NULL; 1001 1002 /* Call the allocation method of the superclass. */ 1003 ret = ((struct elf_or1k_link_hash_entry *) 1004 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 1005 table, string)); 1006 if (ret != NULL) 1007 { 1008 struct elf_or1k_link_hash_entry *eh; 1009 1010 eh = (struct elf_or1k_link_hash_entry *) ret; 1011 eh->tls_type = TLS_UNKNOWN; 1012 } 1013 1014 return (struct bfd_hash_entry *) ret; 1015 } 1016 1017 /* Create an or1k ELF linker hash table. */ 1018 1019 static struct bfd_link_hash_table * 1020 or1k_elf_link_hash_table_create (bfd *abfd) 1021 { 1022 struct elf_or1k_link_hash_table *ret; 1023 size_t amt = sizeof (struct elf_or1k_link_hash_table); 1024 1025 ret = bfd_zmalloc (amt); 1026 if (ret == NULL) 1027 return NULL; 1028 1029 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 1030 or1k_elf_link_hash_newfunc, 1031 sizeof (struct elf_or1k_link_hash_entry), 1032 OR1K_ELF_DATA)) 1033 { 1034 free (ret); 1035 return NULL; 1036 } 1037 1038 return &ret->root.root; 1039 } 1040 1041 static reloc_howto_type * 1042 or1k_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 1043 bfd_reloc_code_real_type bcode) 1044 { 1045 unsigned int i; 1046 1047 for (i = 0; i < ARRAY_SIZE (or1k_reloc_map); i++) 1048 if (or1k_reloc_map[i].bfd_reloc_val == bcode) 1049 { 1050 unsigned int ocode = or1k_reloc_map[i].or1k_reloc_val; 1051 if (ocode < (unsigned int) R_OR1K_max) 1052 return &or1k_elf_howto_table[ocode]; 1053 else 1054 break; 1055 } 1056 1057 return NULL; 1058 } 1059 1060 static reloc_howto_type * 1061 or1k_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1062 const char *r_name) 1063 { 1064 unsigned int i; 1065 1066 for (i = 0; i < R_OR1K_max; i++) 1067 if (or1k_elf_howto_table[i].name != NULL 1068 && strcasecmp (or1k_elf_howto_table[i].name, r_name) == 0) 1069 return &or1k_elf_howto_table[i]; 1070 1071 return NULL; 1072 } 1073 1074 /* Set the howto pointer for an Or1k ELF reloc. */ 1075 1076 static bool 1077 or1k_info_to_howto_rela (bfd * abfd, 1078 arelent * cache_ptr, 1079 Elf_Internal_Rela * dst) 1080 { 1081 unsigned int r_type; 1082 1083 r_type = ELF32_R_TYPE (dst->r_info); 1084 if (r_type >= (unsigned int) R_OR1K_max) 1085 { 1086 /* xgettext:c-format */ 1087 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 1088 abfd, r_type); 1089 bfd_set_error (bfd_error_bad_value); 1090 return false; 1091 } 1092 cache_ptr->howto = & or1k_elf_howto_table[r_type]; 1093 return true; 1094 } 1095 1096 /* Return the relocation value for @tpoff relocations.. */ 1097 static bfd_vma 1098 tpoff (struct bfd_link_info *info, bfd_vma address, bool dynamic) 1099 { 1100 struct elf_link_hash_table *htab = elf_hash_table (info); 1101 bfd_vma base; 1102 1103 /* If tls_sec is NULL, we should have signalled an error already. */ 1104 if (htab->tls_sec == NULL) 1105 return 0; 1106 1107 if (dynamic) 1108 return address - htab->tls_sec->vma; 1109 else 1110 { 1111 /* On or1k, the tp points to just after the tcb, if we have an alignment 1112 greater than the tcb size we need to offset by the alignment difference. */ 1113 base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power) 1114 - TCB_SIZE; 1115 1116 /* The thread pointer on or1k stores the address after the TCB where 1117 the data is, just compute the difference. No need to compensate 1118 for the size of TCB. */ 1119 return address - htab->tls_sec->vma + base; 1120 } 1121 } 1122 1123 /* If we have both IE and GD accesses to a symbol the IE relocations should be 1124 offset by 8 bytes because the got contains both GD and IE entries. */ 1125 static bfd_vma 1126 or1k_initial_exec_offset (reloc_howto_type *howto, unsigned char tls_type_mask) 1127 { 1128 switch (howto->type) 1129 { 1130 case R_OR1K_TLS_IE_HI16: 1131 case R_OR1K_TLS_IE_LO16: 1132 case R_OR1K_TLS_IE_PG21: 1133 case R_OR1K_TLS_IE_LO13: 1134 case R_OR1K_TLS_IE_AHI16: 1135 return (tls_type_mask & TLS_GD) != 0 ? 8 : 0; 1136 default: 1137 return 0; 1138 } 1139 } 1140 1141 /* Like _bfd_final_link_relocate, but handles non-contiguous fields. */ 1142 1143 static bfd_reloc_status_type 1144 or1k_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd, 1145 asection *input_section, bfd_byte *contents, 1146 bfd_vma offset, bfd_vma value) 1147 { 1148 bfd_reloc_status_type status = bfd_reloc_ok; 1149 int size = bfd_get_reloc_size (howto); 1150 bfd_vma x, place; 1151 1152 /* Sanity check the address. */ 1153 if (offset + size > bfd_get_section_limit_octets (input_bfd, input_section)) 1154 return bfd_reloc_outofrange; 1155 1156 place = (input_section->output_section->vma 1157 + input_section->output_offset 1158 + (howto->pcrel_offset ? offset : 0)); 1159 1160 switch (howto->type) 1161 { 1162 case R_OR1K_AHI16: 1163 case R_OR1K_GOT_AHI16: 1164 case R_OR1K_GOTOFF_AHI16: 1165 case R_OR1K_TLS_IE_AHI16: 1166 case R_OR1K_TLS_LE_AHI16: 1167 /* Adjust the operand to match with a signed LO16. */ 1168 value += 0x8000; 1169 break; 1170 1171 case R_OR1K_INSN_REL_26: 1172 value -= place; 1173 /* Diagnose mis-aligned branch targets. */ 1174 if (value & 3) 1175 status = bfd_reloc_dangerous; 1176 break; 1177 1178 case R_OR1K_PCREL_PG21: 1179 case R_OR1K_GOT_PG21: 1180 case R_OR1K_TLS_GD_PG21: 1181 case R_OR1K_TLS_LDM_PG21: 1182 case R_OR1K_TLS_IE_PG21: 1183 value = (value & -8192) - (place & -8192); 1184 break; 1185 1186 case R_OR1K_LO13: 1187 case R_OR1K_GOT_LO13: 1188 case R_OR1K_TLS_GD_LO13: 1189 case R_OR1K_TLS_LDM_LO13: 1190 case R_OR1K_TLS_IE_LO13: 1191 case R_OR1K_SLO13: 1192 value &= 8191; 1193 break; 1194 1195 default: 1196 if (howto->pc_relative) 1197 value -= place; 1198 break; 1199 } 1200 1201 status = bfd_check_overflow (howto->complain_on_overflow, 1202 howto->bitsize, 1203 howto->rightshift, 1204 bfd_arch_bits_per_address (input_bfd), 1205 value); 1206 value >>= howto->rightshift; 1207 1208 /* If we're overwriting the entire destination, 1209 then no need to read the current contents. */ 1210 if (size == 0 || howto->dst_mask == N_ONES (size)) 1211 x = 0; 1212 else 1213 { 1214 BFD_ASSERT (size == 4); 1215 x = bfd_get_32 (input_bfd, contents + offset); 1216 } 1217 1218 switch (howto->type) 1219 { 1220 case R_OR1K_SLO16: 1221 case R_OR1K_GOTOFF_SLO16: 1222 case R_OR1K_TLS_LE_SLO16: 1223 case R_OR1K_SLO13: 1224 /* The split imm16 field used for stores. */ 1225 x = (x & ~0x3e007ff) | ((value & 0xf800) << 10) | (value & 0x7ff); 1226 break; 1227 1228 default: 1229 { 1230 bfd_vma fieldmask = howto->dst_mask; 1231 value <<= howto->bitpos; 1232 x = (x & ~fieldmask) | (value & fieldmask); 1233 } 1234 break; 1235 } 1236 1237 /* Put the relocated value back in the object file. */ 1238 switch (size) 1239 { 1240 case 0: 1241 break; 1242 case 1: 1243 bfd_put_8 (input_bfd, x, contents + offset); 1244 break; 1245 case 2: 1246 bfd_put_16 (input_bfd, x, contents + offset); 1247 break; 1248 case 4: 1249 bfd_put_32 (input_bfd, x, contents + offset); 1250 break; 1251 #ifdef BFD64 1252 case 8: 1253 bfd_put_64 (input_bfd, x, contents + offset); 1254 break; 1255 #endif 1256 default: 1257 _bfd_error_handler 1258 (_("%pB: Cannot handle relocation value size of %d"), 1259 input_bfd, size); 1260 abort (); 1261 } 1262 return status; 1263 } 1264 1265 /* Relocate an Or1k ELF section. 1266 1267 The RELOCATE_SECTION function is called by the new ELF backend linker 1268 to handle the relocations for a section. 1269 1270 The relocs are always passed as Rela structures; if the section 1271 actually uses Rel structures, the r_addend field will always be 1272 zero. 1273 1274 This function is responsible for adjusting the section contents as 1275 necessary, and (if using Rela relocs and generating a relocatable 1276 output file) adjusting the reloc addend as necessary. 1277 1278 This function does not have to worry about setting the reloc 1279 address or the reloc symbol index. 1280 1281 LOCAL_SYMS is a pointer to the swapped in local symbols. 1282 1283 LOCAL_SECTIONS is an array giving the section in the input file 1284 corresponding to the st_shndx field of each local symbol. 1285 1286 The global hash table entry for the global symbols can be found 1287 via elf_sym_hashes (input_bfd). 1288 1289 When generating relocatable output, this function must handle 1290 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 1291 going to be the section symbol corresponding to the output 1292 section, which means that the addend must be adjusted 1293 accordingly. */ 1294 1295 static int 1296 or1k_elf_relocate_section (bfd *output_bfd, 1297 struct bfd_link_info *info, 1298 bfd *input_bfd, 1299 asection *input_section, 1300 bfd_byte *contents, 1301 Elf_Internal_Rela *relocs, 1302 Elf_Internal_Sym *local_syms, 1303 asection **local_sections) 1304 { 1305 Elf_Internal_Shdr *symtab_hdr; 1306 struct elf_link_hash_entry **sym_hashes; 1307 Elf_Internal_Rela *rel; 1308 Elf_Internal_Rela *relend; 1309 struct elf_or1k_link_hash_table *htab = or1k_elf_hash_table (info); 1310 asection *sreloc; 1311 bfd_vma *local_got_offsets; 1312 asection *sgot, *splt; 1313 bfd_vma plt_base, got_base, got_sym_value; 1314 bool ret_val = true; 1315 bool saw_gotha = false; 1316 1317 if (htab == NULL) 1318 return false; 1319 1320 local_got_offsets = elf_local_got_offsets (input_bfd); 1321 1322 sreloc = elf_section_data (input_section)->sreloc; 1323 1324 splt = htab->root.splt; 1325 plt_base = 0; 1326 if (splt != NULL) 1327 plt_base = splt->output_section->vma + splt->output_offset; 1328 1329 sgot = htab->root.sgot; 1330 got_sym_value = got_base = 0; 1331 if (sgot != NULL) 1332 { 1333 struct elf_link_hash_entry *hgot = htab->root.hgot; 1334 got_sym_value = (hgot->root.u.def.value 1335 + hgot->root.u.def.section->output_section->vma 1336 + hgot->root.u.def.section->output_offset); 1337 got_base = sgot->output_section->vma + sgot->output_offset; 1338 } 1339 1340 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1341 sym_hashes = elf_sym_hashes (input_bfd); 1342 relend = relocs + input_section->reloc_count; 1343 1344 for (rel = relocs; rel < relend; rel++) 1345 { 1346 reloc_howto_type *howto; 1347 unsigned long r_symndx; 1348 Elf_Internal_Sym *sym; 1349 asection *sec; 1350 struct elf_link_hash_entry *h; 1351 bfd_vma relocation; 1352 bfd_reloc_status_type r; 1353 const char *name = NULL; 1354 int r_type; 1355 1356 r_type = ELF32_R_TYPE (rel->r_info); 1357 r_symndx = ELF32_R_SYM (rel->r_info); 1358 1359 if (r_type == R_OR1K_GNU_VTINHERIT 1360 || r_type == R_OR1K_GNU_VTENTRY) 1361 continue; 1362 1363 if (r_type < 0 || r_type >= (int) R_OR1K_max) 1364 { 1365 _bfd_error_handler 1366 (_("%pB: unknown relocation type %d"), 1367 input_bfd, (int) r_type); 1368 bfd_set_error (bfd_error_bad_value); 1369 ret_val = false; 1370 continue; 1371 } 1372 1373 howto = or1k_elf_howto_table + ELF32_R_TYPE (rel->r_info); 1374 h = NULL; 1375 sym = NULL; 1376 sec = NULL; 1377 1378 if (r_symndx < symtab_hdr->sh_info) 1379 { 1380 sym = local_syms + r_symndx; 1381 sec = local_sections[r_symndx]; 1382 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1383 1384 name = bfd_elf_string_from_elf_section 1385 (input_bfd, symtab_hdr->sh_link, sym->st_name); 1386 name = name == NULL ? bfd_section_name (sec) : name; 1387 } 1388 else 1389 { 1390 bool unresolved_reloc, warned, ignored; 1391 1392 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1393 r_symndx, symtab_hdr, sym_hashes, 1394 h, sec, relocation, 1395 unresolved_reloc, warned, ignored); 1396 name = h->root.root.string; 1397 } 1398 1399 if (sec != NULL && discarded_section (sec)) 1400 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 1401 rel, 1, relend, howto, 0, contents); 1402 1403 if (bfd_link_relocatable (info)) 1404 continue; 1405 1406 switch (howto->type) 1407 { 1408 case R_OR1K_PLT26: 1409 case R_OR1K_PLTA26: 1410 /* If the call is not local, redirect the branch to the PLT. 1411 Otherwise do nothing to send the branch to the symbol direct. */ 1412 if (!SYMBOL_CALLS_LOCAL (info, h) 1413 && h->plt.offset != (bfd_vma) -1) 1414 relocation = plt_base + h->plt.offset; 1415 1416 /* Addend should be zero. */ 1417 if (rel->r_addend != 0) 1418 { 1419 _bfd_error_handler 1420 (_("%pB: addend should be zero for plt relocations"), 1421 input_bfd); 1422 bfd_set_error (bfd_error_bad_value); 1423 ret_val = false; 1424 } 1425 break; 1426 1427 case R_OR1K_GOT_AHI16: 1428 case R_OR1K_GOT16: 1429 case R_OR1K_GOT_PG21: 1430 case R_OR1K_GOT_LO13: 1431 { 1432 bfd_vma off; 1433 1434 /* Relocation is to the entry for this symbol 1435 in the global offset table. */ 1436 BFD_ASSERT (sgot != NULL); 1437 if (h != NULL) 1438 { 1439 bool dyn; 1440 1441 off = h->got.offset; 1442 BFD_ASSERT (off != (bfd_vma) -1); 1443 1444 dyn = htab->root.dynamic_sections_created; 1445 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 1446 bfd_link_pic (info), 1447 h) 1448 || (bfd_link_pic (info) 1449 && SYMBOL_REFERENCES_LOCAL (info, h))) 1450 { 1451 /* This is actually a static link, or it is a -Bsymbolic 1452 link and the symbol is defined locally, or the symbol 1453 was forced to be local because of a version file. 1454 We must initialize this entry in the GOT. Since the 1455 offset must always be a multiple of 4, we use the least 1456 significant bit to record whether we have initialized 1457 it already. 1458 1459 When doing a dynamic link, we create a .rela.got 1460 relocation entry to initialize the value. This 1461 is done in the finish_dynamic_symbol routine. */ 1462 if ((off & 1) != 0) 1463 off &= ~1; 1464 else 1465 { 1466 /* Write entry in GOT. */ 1467 bfd_put_32 (output_bfd, relocation, 1468 sgot->contents + off); 1469 /* Mark GOT entry as having been written. */ 1470 h->got.offset |= 1; 1471 } 1472 } 1473 } 1474 else 1475 { 1476 bfd_byte *loc; 1477 1478 BFD_ASSERT (local_got_offsets != NULL 1479 && local_got_offsets[r_symndx] != (bfd_vma) -1); 1480 1481 /* Get offset into GOT table. */ 1482 off = local_got_offsets[r_symndx]; 1483 1484 /* The offset must always be a multiple of 4. We use 1485 the least significant bit to record whether we have 1486 already processed this entry. */ 1487 if ((off & 1) != 0) 1488 off &= ~1; 1489 else 1490 { 1491 /* Write entry in GOT. */ 1492 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 1493 if (bfd_link_pic (info)) 1494 { 1495 asection *srelgot; 1496 Elf_Internal_Rela outrel; 1497 1498 /* We need to generate a R_OR1K_RELATIVE reloc 1499 for the dynamic linker. */ 1500 srelgot = htab->root.srelgot; 1501 BFD_ASSERT (srelgot != NULL); 1502 1503 outrel.r_offset = got_base + off; 1504 outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE); 1505 outrel.r_addend = relocation; 1506 loc = srelgot->contents; 1507 loc += (srelgot->reloc_count 1508 * sizeof (Elf32_External_Rela)); 1509 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1510 ++srelgot->reloc_count; 1511 } 1512 local_got_offsets[r_symndx] |= 1; 1513 } 1514 } 1515 1516 /* The GOT_PG21 and GOT_LO13 relocs are pc-relative, 1517 while the GOT16 reloc is GOT relative. */ 1518 relocation = got_base + off; 1519 if (r_type == R_OR1K_GOT16 1520 || r_type == R_OR1K_GOT_AHI16) 1521 relocation -= got_sym_value; 1522 1523 if (r_type == R_OR1K_GOT_AHI16) 1524 saw_gotha = true; 1525 1526 /* If we have a R_OR1K_GOT16 following a R_OR1K_GOT_AHI16 1527 relocation we assume the code is doing the right thing to avoid 1528 overflows. */ 1529 if (r_type == R_OR1K_GOT16 && saw_gotha) 1530 howto = &or1k_elf_got16_no_overflow_howto; 1531 1532 /* Addend should be zero. */ 1533 if (rel->r_addend != 0) 1534 { 1535 _bfd_error_handler 1536 (_("%pB: addend should be zero for got relocations"), 1537 input_bfd); 1538 bfd_set_error (bfd_error_bad_value); 1539 ret_val = false; 1540 } 1541 } 1542 break; 1543 1544 case R_OR1K_GOTOFF_LO16: 1545 case R_OR1K_GOTOFF_HI16: 1546 case R_OR1K_GOTOFF_AHI16: 1547 case R_OR1K_GOTOFF_SLO16: 1548 /* Relocation is offset from GOT. */ 1549 BFD_ASSERT (sgot != NULL); 1550 if (!SYMBOL_REFERENCES_LOCAL (info, h)) 1551 { 1552 _bfd_error_handler 1553 (_("%pB: gotoff relocation against dynamic symbol %s"), 1554 input_bfd, h->root.root.string); 1555 ret_val = false; 1556 bfd_set_error (bfd_error_bad_value); 1557 } 1558 relocation -= got_sym_value; 1559 break; 1560 1561 case R_OR1K_INSN_REL_26: 1562 /* For a non-shared link, these will reference plt or call the 1563 version of actual object. */ 1564 if (bfd_link_pic (info) && !SYMBOL_CALLS_LOCAL (info, h)) 1565 { 1566 _bfd_error_handler 1567 (_("%pB: pc-relative relocation against dynamic symbol %s"), 1568 input_bfd, name); 1569 ret_val = false; 1570 bfd_set_error (bfd_error_bad_value); 1571 } 1572 break; 1573 1574 case R_OR1K_PCREL_PG21: 1575 case R_OR1K_LO13: 1576 case R_OR1K_SLO13: 1577 /* For a non-shared link, these will reference either the plt 1578 or a .dynbss copy of the symbol. */ 1579 if (bfd_link_pic (info) && !SYMBOL_REFERENCES_LOCAL (info, h)) 1580 { 1581 _bfd_error_handler 1582 (_("%pB: pc-relative relocation against dynamic symbol %s"), 1583 input_bfd, name); 1584 ret_val = false; 1585 bfd_set_error (bfd_error_bad_value); 1586 } 1587 break; 1588 1589 case R_OR1K_HI_16_IN_INSN: 1590 case R_OR1K_LO_16_IN_INSN: 1591 case R_OR1K_AHI16: 1592 case R_OR1K_SLO16: 1593 if (bfd_link_pic (info)) 1594 { 1595 _bfd_error_handler 1596 (_("%pB: non-pic relocation against symbol %s"), 1597 input_bfd, name); 1598 ret_val = false; 1599 bfd_set_error (bfd_error_bad_value); 1600 } 1601 break; 1602 1603 case R_OR1K_32: 1604 /* R_OR1K_16? */ 1605 { 1606 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols 1607 from removed linkonce sections, or sections discarded by 1608 a linker script. */ 1609 if (r_symndx == STN_UNDEF 1610 || (input_section->flags & SEC_ALLOC) == 0) 1611 break; 1612 1613 /* Emit a direct relocation if the symbol is dynamic, 1614 or a RELATIVE reloc for shared objects. We can omit 1615 RELATIVE relocs to local undefweak symbols. */ 1616 if (bfd_link_pic (info) 1617 ? (h == NULL 1618 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1619 || h->root.type != bfd_link_hash_undefweak) 1620 : (h != NULL 1621 && h->dynindx != -1 1622 && !h->non_got_ref 1623 && ((h->def_dynamic && !h->def_regular) 1624 || h->root.type == bfd_link_hash_undefweak 1625 || h->root.type == bfd_link_hash_undefined))) 1626 { 1627 Elf_Internal_Rela outrel; 1628 bfd_byte *loc; 1629 bool skip; 1630 1631 /* When generating a shared object, these relocations 1632 are copied into the output file to be resolved at run 1633 time. */ 1634 1635 BFD_ASSERT (sreloc != NULL); 1636 1637 skip = false; 1638 1639 outrel.r_offset = 1640 _bfd_elf_section_offset (output_bfd, info, input_section, 1641 rel->r_offset); 1642 if (outrel.r_offset == (bfd_vma) -1) 1643 skip = true; 1644 else if (outrel.r_offset == (bfd_vma) -2) 1645 skip = true; 1646 outrel.r_offset += (input_section->output_section->vma 1647 + input_section->output_offset); 1648 1649 if (skip) 1650 memset (&outrel, 0, sizeof outrel); 1651 else if (SYMBOL_REFERENCES_LOCAL (info, h)) 1652 { 1653 outrel.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE); 1654 outrel.r_addend = relocation + rel->r_addend; 1655 } 1656 else 1657 { 1658 BFD_ASSERT (h->dynindx != -1); 1659 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1660 outrel.r_addend = rel->r_addend; 1661 } 1662 1663 loc = sreloc->contents; 1664 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 1665 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1666 break; 1667 } 1668 break; 1669 } 1670 1671 case R_OR1K_TLS_LDM_HI16: 1672 case R_OR1K_TLS_LDM_LO16: 1673 case R_OR1K_TLS_LDM_PG21: 1674 case R_OR1K_TLS_LDM_LO13: 1675 case R_OR1K_TLS_LDO_HI16: 1676 case R_OR1K_TLS_LDO_LO16: 1677 /* TODO: implement support for local dynamic. */ 1678 BFD_FAIL (); 1679 _bfd_error_handler 1680 (_("%pB: support for local dynamic not implemented"), 1681 input_bfd); 1682 bfd_set_error (bfd_error_bad_value); 1683 return false; 1684 1685 case R_OR1K_TLS_GD_HI16: 1686 case R_OR1K_TLS_GD_LO16: 1687 case R_OR1K_TLS_GD_PG21: 1688 case R_OR1K_TLS_GD_LO13: 1689 case R_OR1K_TLS_IE_HI16: 1690 case R_OR1K_TLS_IE_LO16: 1691 case R_OR1K_TLS_IE_PG21: 1692 case R_OR1K_TLS_IE_LO13: 1693 case R_OR1K_TLS_IE_AHI16: 1694 { 1695 bfd_vma gotoff; 1696 Elf_Internal_Rela rela; 1697 asection *srelgot; 1698 bfd_byte *loc; 1699 bool dynamic; 1700 int indx = 0; 1701 unsigned char tls_type; 1702 1703 srelgot = htab->root.srelgot; 1704 1705 /* Mark as TLS related GOT entry by setting 1706 bit 2 to indcate TLS and bit 1 to indicate GOT. */ 1707 if (h != NULL) 1708 { 1709 gotoff = h->got.offset; 1710 tls_type = ((struct elf_or1k_link_hash_entry *) h)->tls_type; 1711 h->got.offset |= 3; 1712 } 1713 else 1714 { 1715 unsigned char *local_tls_type; 1716 1717 gotoff = local_got_offsets[r_symndx]; 1718 local_tls_type = (unsigned char *) elf_or1k_local_tls_type (input_bfd); 1719 tls_type = local_tls_type == NULL ? TLS_NONE 1720 : local_tls_type[r_symndx]; 1721 local_got_offsets[r_symndx] |= 3; 1722 } 1723 1724 /* Only process the relocation once. */ 1725 if ((gotoff & 1) != 0) 1726 { 1727 gotoff += or1k_initial_exec_offset (howto, tls_type); 1728 1729 /* The PG21 and LO13 relocs are pc-relative, while the 1730 rest are GOT relative. */ 1731 relocation = got_base + (gotoff & ~3); 1732 if (!(r_type == R_OR1K_TLS_GD_PG21 1733 || r_type == R_OR1K_TLS_GD_LO13 1734 || r_type == R_OR1K_TLS_IE_PG21 1735 || r_type == R_OR1K_TLS_IE_LO13)) 1736 relocation -= got_sym_value; 1737 break; 1738 } 1739 1740 BFD_ASSERT (elf_hash_table (info)->hgot == NULL 1741 || elf_hash_table (info)->hgot->root.u.def.value == 0); 1742 1743 if (h != NULL) 1744 { 1745 bool dyn = htab->root.dynamic_sections_created; 1746 bool pic = bfd_link_pic (info); 1747 1748 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h) 1749 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h))) 1750 indx = h->dynindx; 1751 } 1752 1753 /* Dynamic entries will require relocations. If we do not need 1754 them we will just use the default R_OR1K_NONE and 1755 not set anything. */ 1756 dynamic = (bfd_link_pic (info) || indx != 0) 1757 && (h == NULL 1758 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1759 || h->root.type != bfd_link_hash_undefweak); 1760 1761 /* Shared GD. */ 1762 if (dynamic && ((tls_type & TLS_GD) != 0)) 1763 { 1764 int i; 1765 1766 /* Add DTPMOD and DTPOFF GOT and rela entries. */ 1767 for (i = 0; i < 2; ++i) 1768 { 1769 BFD_ASSERT (srelgot->contents != NULL); 1770 1771 rela.r_offset = got_base + gotoff + i*4; 1772 if (h != NULL && h->dynindx != -1) 1773 { 1774 rela.r_info = ELF32_R_INFO (h->dynindx, 1775 (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF)); 1776 rela.r_addend = 0; 1777 } 1778 else 1779 { 1780 rela.r_info = ELF32_R_INFO (0, 1781 (i == 0 ? R_OR1K_TLS_DTPMOD : R_OR1K_TLS_DTPOFF)); 1782 rela.r_addend = 1783 (i == 0 ? 0 : tpoff (info, relocation, dynamic)); 1784 } 1785 1786 loc = srelgot->contents; 1787 loc += (srelgot->reloc_count++ 1788 * sizeof (Elf32_External_Rela)); 1789 1790 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 1791 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff + i*4); 1792 } 1793 } 1794 /* Static GD. */ 1795 else if ((tls_type & TLS_GD) != 0) 1796 { 1797 bfd_put_32 (output_bfd, 1, sgot->contents + gotoff); 1798 bfd_put_32 (output_bfd, tpoff (info, relocation, dynamic), 1799 sgot->contents + gotoff + 4); 1800 } 1801 1802 gotoff += or1k_initial_exec_offset (howto, tls_type); 1803 1804 /* Shared IE. */ 1805 if (dynamic && ((tls_type & TLS_IE) != 0)) 1806 { 1807 BFD_ASSERT (srelgot->contents != NULL); 1808 1809 /* Add TPOFF GOT and rela entries. */ 1810 rela.r_offset = got_base + gotoff; 1811 if (h != NULL && h->dynindx != -1) 1812 { 1813 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_TLS_TPOFF); 1814 rela.r_addend = 0; 1815 } 1816 else 1817 { 1818 rela.r_info = ELF32_R_INFO (0, R_OR1K_TLS_TPOFF); 1819 rela.r_addend = tpoff (info, relocation, dynamic); 1820 } 1821 1822 loc = srelgot->contents; 1823 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 1824 1825 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 1826 bfd_put_32 (output_bfd, 0, sgot->contents + gotoff); 1827 } 1828 /* Static IE. */ 1829 else if ((tls_type & TLS_IE) != 0) 1830 bfd_put_32 (output_bfd, tpoff (info, relocation, dynamic), 1831 sgot->contents + gotoff); 1832 1833 /* The PG21 and LO13 relocs are pc-relative, while the 1834 rest are GOT relative. */ 1835 relocation = got_base + gotoff; 1836 if (!(r_type == R_OR1K_TLS_GD_PG21 1837 || r_type == R_OR1K_TLS_GD_LO13 1838 || r_type == R_OR1K_TLS_IE_PG21 1839 || r_type == R_OR1K_TLS_IE_LO13)) 1840 relocation -= got_sym_value; 1841 } 1842 break; 1843 1844 case R_OR1K_TLS_LE_HI16: 1845 case R_OR1K_TLS_LE_LO16: 1846 case R_OR1K_TLS_LE_AHI16: 1847 case R_OR1K_TLS_LE_SLO16: 1848 /* Relocation is offset from TP. */ 1849 relocation = tpoff (info, relocation, 0); 1850 break; 1851 1852 case R_OR1K_TLS_DTPMOD: 1853 case R_OR1K_TLS_DTPOFF: 1854 case R_OR1K_TLS_TPOFF: 1855 /* These are resolved dynamically on load and shouldn't 1856 be used as linker input. */ 1857 BFD_FAIL (); 1858 _bfd_error_handler 1859 (_("%pB: will not resolve runtime TLS relocation"), 1860 input_bfd); 1861 bfd_set_error (bfd_error_bad_value); 1862 return false; 1863 1864 default: 1865 break; 1866 } 1867 1868 r = or1k_final_link_relocate (howto, input_bfd, input_section, contents, 1869 rel->r_offset, relocation + rel->r_addend); 1870 1871 if (r != bfd_reloc_ok) 1872 { 1873 const char *msg = NULL; 1874 1875 switch (r) 1876 { 1877 case bfd_reloc_overflow: 1878 (*info->callbacks->reloc_overflow) 1879 (info, (h ? &h->root : NULL), name, howto->name, 1880 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 1881 break; 1882 1883 case bfd_reloc_undefined: 1884 (*info->callbacks->undefined_symbol) 1885 (info, name, input_bfd, input_section, rel->r_offset, true); 1886 break; 1887 1888 case bfd_reloc_outofrange: 1889 msg = _("internal error: out of range error"); 1890 break; 1891 1892 case bfd_reloc_notsupported: 1893 msg = _("internal error: unsupported relocation error"); 1894 break; 1895 1896 case bfd_reloc_dangerous: 1897 msg = _("internal error: dangerous relocation"); 1898 break; 1899 1900 default: 1901 msg = _("internal error: unknown error"); 1902 break; 1903 } 1904 1905 if (msg) 1906 (*info->callbacks->warning) (info, msg, name, input_bfd, 1907 input_section, rel->r_offset); 1908 } 1909 } 1910 1911 return ret_val; 1912 } 1913 1914 /* Return the section that should be marked against GC for a given 1915 relocation. */ 1916 1917 static asection * 1918 or1k_elf_gc_mark_hook (asection *sec, 1919 struct bfd_link_info *info, 1920 Elf_Internal_Rela *rel, 1921 struct elf_link_hash_entry *h, 1922 Elf_Internal_Sym *sym) 1923 { 1924 if (h != NULL) 1925 switch (ELF32_R_TYPE (rel->r_info)) 1926 { 1927 case R_OR1K_GNU_VTINHERIT: 1928 case R_OR1K_GNU_VTENTRY: 1929 return NULL; 1930 } 1931 1932 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 1933 } 1934 1935 /* Look through the relocs for a section during the first phase. */ 1936 1937 static bool 1938 or1k_elf_check_relocs (bfd *abfd, 1939 struct bfd_link_info *info, 1940 asection *sec, 1941 const Elf_Internal_Rela *relocs) 1942 { 1943 Elf_Internal_Shdr *symtab_hdr; 1944 struct elf_link_hash_entry **sym_hashes; 1945 const Elf_Internal_Rela *rel; 1946 1947 const Elf_Internal_Rela *rel_end; 1948 struct elf_or1k_link_hash_table *htab; 1949 bfd *dynobj; 1950 asection *sreloc = NULL; 1951 1952 if (bfd_link_relocatable (info)) 1953 return true; 1954 1955 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1956 sym_hashes = elf_sym_hashes (abfd); 1957 1958 htab = or1k_elf_hash_table (info); 1959 if (htab == NULL) 1960 return false; 1961 1962 dynobj = htab->root.dynobj; 1963 1964 rel_end = relocs + sec->reloc_count; 1965 for (rel = relocs; rel < rel_end; rel++) 1966 { 1967 struct elf_link_hash_entry *h; 1968 unsigned long r_symndx; 1969 unsigned char tls_type; 1970 int r_type; 1971 1972 r_symndx = ELF32_R_SYM (rel->r_info); 1973 if (r_symndx < symtab_hdr->sh_info) 1974 h = NULL; 1975 else 1976 { 1977 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1978 while (h->root.type == bfd_link_hash_indirect 1979 || h->root.type == bfd_link_hash_warning) 1980 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1981 } 1982 1983 r_type = ELF32_R_TYPE (rel->r_info); 1984 switch (r_type) 1985 { 1986 case R_OR1K_TLS_GD_HI16: 1987 case R_OR1K_TLS_GD_LO16: 1988 case R_OR1K_TLS_GD_PG21: 1989 case R_OR1K_TLS_GD_LO13: 1990 tls_type = TLS_GD; 1991 break; 1992 case R_OR1K_TLS_LDM_HI16: 1993 case R_OR1K_TLS_LDM_LO16: 1994 case R_OR1K_TLS_LDM_PG21: 1995 case R_OR1K_TLS_LDM_LO13: 1996 case R_OR1K_TLS_LDO_HI16: 1997 case R_OR1K_TLS_LDO_LO16: 1998 tls_type = TLS_LD; 1999 break; 2000 case R_OR1K_TLS_IE_HI16: 2001 case R_OR1K_TLS_IE_LO16: 2002 case R_OR1K_TLS_IE_PG21: 2003 case R_OR1K_TLS_IE_LO13: 2004 case R_OR1K_TLS_IE_AHI16: 2005 tls_type = TLS_IE; 2006 break; 2007 case R_OR1K_TLS_LE_HI16: 2008 case R_OR1K_TLS_LE_LO16: 2009 case R_OR1K_TLS_LE_AHI16: 2010 case R_OR1K_TLS_LE_SLO16: 2011 tls_type = TLS_LE; 2012 break; 2013 default: 2014 tls_type = TLS_NONE; 2015 } 2016 2017 /* Record TLS type. */ 2018 if (h != NULL) 2019 ((struct elf_or1k_link_hash_entry *) h)->tls_type |= tls_type; 2020 else 2021 { 2022 unsigned char *local_tls_type; 2023 2024 /* This is a TLS type record for a local symbol. */ 2025 local_tls_type = (unsigned char *) elf_or1k_local_tls_type (abfd); 2026 if (local_tls_type == NULL) 2027 { 2028 bfd_size_type size; 2029 2030 size = symtab_hdr->sh_info; 2031 local_tls_type = bfd_zalloc (abfd, size); 2032 if (local_tls_type == NULL) 2033 return false; 2034 elf_or1k_local_tls_type (abfd) = local_tls_type; 2035 } 2036 local_tls_type[r_symndx] |= tls_type; 2037 } 2038 2039 switch (r_type) 2040 { 2041 /* This relocation describes the C++ object vtable hierarchy. 2042 Reconstruct it for later use during GC. */ 2043 case R_OR1K_GNU_VTINHERIT: 2044 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2045 return false; 2046 break; 2047 2048 /* This relocation describes which C++ vtable entries are actually 2049 used. Record for later use during GC. */ 2050 case R_OR1K_GNU_VTENTRY: 2051 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 2052 return false; 2053 break; 2054 2055 /* This relocation requires .plt entry. */ 2056 case R_OR1K_PLTA26: 2057 htab->saw_plta = true; 2058 /* FALLTHRU */ 2059 case R_OR1K_PLT26: 2060 if (h != NULL) 2061 { 2062 h->needs_plt = 1; 2063 h->plt.refcount += 1; 2064 } 2065 break; 2066 2067 case R_OR1K_GOT_AHI16: 2068 case R_OR1K_GOT16: 2069 case R_OR1K_GOT_PG21: 2070 case R_OR1K_GOT_LO13: 2071 case R_OR1K_TLS_GD_HI16: 2072 case R_OR1K_TLS_GD_LO16: 2073 case R_OR1K_TLS_GD_PG21: 2074 case R_OR1K_TLS_GD_LO13: 2075 case R_OR1K_TLS_IE_HI16: 2076 case R_OR1K_TLS_IE_LO16: 2077 case R_OR1K_TLS_IE_PG21: 2078 case R_OR1K_TLS_IE_LO13: 2079 case R_OR1K_TLS_IE_AHI16: 2080 if (h != NULL) 2081 h->got.refcount += 1; 2082 else 2083 { 2084 bfd_signed_vma *local_got_refcounts; 2085 2086 /* This is a global offset table entry for a local symbol. */ 2087 local_got_refcounts = elf_local_got_refcounts (abfd); 2088 if (local_got_refcounts == NULL) 2089 { 2090 bfd_size_type size; 2091 2092 size = symtab_hdr->sh_info; 2093 size *= sizeof (bfd_signed_vma); 2094 local_got_refcounts = bfd_zalloc (abfd, size); 2095 if (local_got_refcounts == NULL) 2096 return false; 2097 elf_local_got_refcounts (abfd) = local_got_refcounts; 2098 } 2099 local_got_refcounts[r_symndx] += 1; 2100 } 2101 /* FALLTHRU */ 2102 2103 case R_OR1K_GOTOFF_HI16: 2104 case R_OR1K_GOTOFF_LO16: 2105 case R_OR1K_GOTOFF_AHI16: 2106 case R_OR1K_GOTOFF_SLO16: 2107 if (htab->root.sgot == NULL) 2108 { 2109 if (dynobj == NULL) 2110 htab->root.dynobj = dynobj = abfd; 2111 if (!_bfd_elf_create_got_section (dynobj, info)) 2112 return false; 2113 } 2114 break; 2115 2116 case R_OR1K_INSN_REL_26: 2117 case R_OR1K_HI_16_IN_INSN: 2118 case R_OR1K_LO_16_IN_INSN: 2119 case R_OR1K_AHI16: 2120 case R_OR1K_SLO16: 2121 case R_OR1K_32: 2122 case R_OR1K_PCREL_PG21: 2123 case R_OR1K_LO13: 2124 case R_OR1K_SLO13: 2125 { 2126 if (h != NULL && !bfd_link_pic (info)) 2127 { 2128 /* We may need a copy reloc. */ 2129 h->non_got_ref = 1; 2130 2131 /* We may also need a .plt entry. */ 2132 h->plt.refcount += 1; 2133 if (r_type != R_OR1K_INSN_REL_26) 2134 h->pointer_equality_needed = 1; 2135 } 2136 2137 /* If we are creating a shared library, and this is a reloc 2138 against a global symbol, or a non PC relative reloc 2139 against a local symbol, then we need to copy the reloc 2140 into the shared library. However, if we are linking with 2141 -Bsymbolic, we do not need to copy a reloc against a 2142 global symbol which is defined in an object we are 2143 including in the link (i.e., DEF_REGULAR is set). At 2144 this point we have not seen all the input files, so it is 2145 possible that DEF_REGULAR is not set now but will be set 2146 later (it is never cleared). In case of a weak definition, 2147 DEF_REGULAR may be cleared later by a strong definition in 2148 a shared library. We account for that possibility below by 2149 storing information in the relocs_copied field of the hash 2150 table entry. A similar situation occurs when creating 2151 shared libraries and symbol visibility changes render the 2152 symbol local. 2153 2154 If on the other hand, we are creating an executable, we 2155 may need to keep relocations for symbols satisfied by a 2156 dynamic library if we manage to avoid copy relocs for the 2157 symbol. */ 2158 2159 if ((bfd_link_pic (info) 2160 && (sec->flags & SEC_ALLOC) != 0 2161 && (r_type != R_OR1K_INSN_REL_26 2162 || (h != NULL 2163 && (!SYMBOLIC_BIND (info, h) 2164 || h->root.type == bfd_link_hash_defweak 2165 || !h->def_regular)))) 2166 || (!bfd_link_pic (info) 2167 && (sec->flags & SEC_ALLOC) != 0 2168 && h != NULL 2169 && (h->root.type == bfd_link_hash_defweak 2170 || !h->def_regular))) 2171 { 2172 struct elf_dyn_relocs *sec_relocs; 2173 struct elf_dyn_relocs **head; 2174 2175 /* When creating a shared object, we must copy these 2176 relocs into the output file. We create a reloc 2177 section in dynobj and make room for the reloc. */ 2178 if (sreloc == NULL) 2179 { 2180 const char *name; 2181 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx; 2182 unsigned int shnam = _bfd_elf_single_rel_hdr (sec)->sh_name; 2183 2184 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam); 2185 if (name == NULL) 2186 return false; 2187 2188 if (!startswith (name, ".rela") 2189 || strcmp (bfd_section_name (sec), name + 5) != 0) 2190 { 2191 _bfd_error_handler 2192 /* xgettext:c-format */ 2193 (_("%pB: bad relocation section name `%s\'"), 2194 abfd, name); 2195 } 2196 2197 if (htab->root.dynobj == NULL) 2198 htab->root.dynobj = abfd; 2199 dynobj = htab->root.dynobj; 2200 2201 sreloc = bfd_get_section_by_name (dynobj, name); 2202 if (sreloc == NULL) 2203 { 2204 sreloc = _bfd_elf_make_dynamic_reloc_section 2205 (sec, dynobj, 2, abfd, /*rela?*/ true); 2206 2207 if (sreloc == NULL) 2208 return false; 2209 } 2210 elf_section_data (sec)->sreloc = sreloc; 2211 } 2212 2213 /* If this is a global symbol, we count the number of 2214 relocations we need for this symbol. */ 2215 if (h != NULL) 2216 head = &h->dyn_relocs; 2217 else 2218 { 2219 /* Track dynamic relocs needed for local syms too. 2220 We really need local syms available to do this 2221 easily. Oh well. */ 2222 2223 asection *s; 2224 Elf_Internal_Sym *isym; 2225 void *vpp; 2226 2227 isym = bfd_sym_from_r_symndx (&htab->root.sym_cache, 2228 abfd, r_symndx); 2229 if (isym == NULL) 2230 return false; 2231 2232 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 2233 if (s == NULL) 2234 return false; 2235 2236 vpp = &elf_section_data (s)->local_dynrel; 2237 head = (struct elf_dyn_relocs **) vpp; 2238 } 2239 2240 sec_relocs = *head; 2241 /* Allocate this sections dynamic reolcations structure if this 2242 is a new section. */ 2243 if (sec_relocs == NULL || sec_relocs->sec != sec) 2244 { 2245 size_t amt = sizeof *sec_relocs; 2246 sec_relocs = ((struct elf_dyn_relocs *) 2247 bfd_alloc (htab->root.dynobj, amt)); 2248 if (sec_relocs == NULL) 2249 return false; 2250 sec_relocs->next = *head; 2251 *head = sec_relocs; 2252 sec_relocs->sec = sec; 2253 sec_relocs->count = 0; 2254 sec_relocs->pc_count = 0; 2255 } 2256 2257 sec_relocs->count += 1; 2258 if (r_type == R_OR1K_INSN_REL_26) 2259 sec_relocs->pc_count += 1; 2260 } 2261 } 2262 break; 2263 } 2264 } 2265 2266 return true; 2267 } 2268 2269 static void 2270 or1k_write_plt_entry (bfd *output_bfd, bfd_byte *contents, unsigned insnj, 2271 unsigned insns[], size_t insn_count) 2272 { 2273 unsigned nodelay = elf_elfheader (output_bfd)->e_flags & EF_OR1K_NODELAY; 2274 unsigned output_insns[PLT_MAX_INSN_COUNT]; 2275 2276 /* Copy instructions into the output buffer. */ 2277 for (size_t i = 0; i < insn_count; i++) 2278 output_insns[i] = insns[i]; 2279 2280 /* Honor the no-delay-slot setting. */ 2281 if (insns[insn_count-1] == OR1K_NOP) 2282 { 2283 unsigned slot1, slot2; 2284 2285 if (nodelay) 2286 slot1 = insns[insn_count-2], slot2 = insnj; 2287 else 2288 slot1 = insnj, slot2 = insns[insn_count-2]; 2289 2290 output_insns[insn_count-2] = slot1; 2291 output_insns[insn_count-1] = slot2; 2292 output_insns[insn_count] = OR1K_NOP; 2293 } 2294 else 2295 { 2296 unsigned slot1, slot2; 2297 2298 if (nodelay) 2299 slot1 = insns[insn_count-1], slot2 = insnj; 2300 else 2301 slot1 = insnj, slot2 = insns[insn_count-1]; 2302 2303 output_insns[insn_count-1] = slot1; 2304 output_insns[insn_count] = slot2; 2305 } 2306 2307 /* Write out the output buffer. */ 2308 for (size_t i = 0; i < (insn_count+1); i++) 2309 bfd_put_32 (output_bfd, output_insns[i], contents + (i*4)); 2310 } 2311 2312 /* Finish up the dynamic sections. */ 2313 2314 static bool 2315 or1k_elf_finish_dynamic_sections (bfd *output_bfd, 2316 struct bfd_link_info *info) 2317 { 2318 bfd *dynobj; 2319 asection *sdyn, *sgot; 2320 struct elf_or1k_link_hash_table *htab; 2321 2322 htab = or1k_elf_hash_table (info); 2323 if (htab == NULL) 2324 return false; 2325 2326 dynobj = htab->root.dynobj; 2327 2328 sgot = htab->root.sgotplt; 2329 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2330 2331 if (htab->root.dynamic_sections_created) 2332 { 2333 asection *splt; 2334 Elf32_External_Dyn *dyncon, *dynconend; 2335 2336 BFD_ASSERT (sgot != NULL && sdyn != NULL); 2337 2338 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2339 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 2340 2341 for (; dyncon < dynconend; dyncon++) 2342 { 2343 Elf_Internal_Dyn dyn; 2344 asection *s; 2345 2346 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2347 2348 switch (dyn.d_tag) 2349 { 2350 default: 2351 continue; 2352 2353 case DT_PLTGOT: 2354 s = htab->root.sgotplt; 2355 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2356 break; 2357 2358 case DT_JMPREL: 2359 s = htab->root.srelplt; 2360 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2361 break; 2362 2363 case DT_PLTRELSZ: 2364 s = htab->root.srelplt; 2365 dyn.d_un.d_val = s->size; 2366 break; 2367 } 2368 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2369 } 2370 2371 2372 /* Fill in the first entry in the procedure linkage table. */ 2373 splt = htab->root.splt; 2374 if (splt && splt->size > 0) 2375 { 2376 unsigned plt[PLT_MAX_INSN_COUNT]; 2377 size_t plt_insn_count = 3; 2378 bfd_vma got_addr = sgot->output_section->vma + sgot->output_offset; 2379 2380 /* Note we force 16 byte alignment on the .got, so that 2381 the movhi/adrp can be shared between the two loads. */ 2382 2383 if (htab->saw_plta) 2384 { 2385 bfd_vma pc = splt->output_section->vma + splt->output_offset; 2386 unsigned pa = ((got_addr >> 13) - (pc >> 13)) & 0x1fffff; 2387 unsigned po = got_addr & 0x1fff; 2388 plt[0] = OR1K_ADRP(12) | pa; 2389 plt[1] = OR1K_LWZ(15,12) | (po + 8); 2390 plt[2] = OR1K_LWZ(12,12) | (po + 4); 2391 } 2392 else if (bfd_link_pic (info)) 2393 { 2394 plt[0] = OR1K_LWZ(15, 16) | 8; /* .got+8 */ 2395 plt[1] = OR1K_LWZ(12, 16) | 4; /* .got+4 */ 2396 plt[2] = OR1K_NOP; 2397 } 2398 else 2399 { 2400 unsigned ha = ((got_addr + 0x8000) >> 16) & 0xffff; 2401 unsigned lo = got_addr & 0xffff; 2402 plt[0] = OR1K_MOVHI(12) | ha; 2403 plt[1] = OR1K_LWZ(15,12) | (lo + 8); 2404 plt[2] = OR1K_LWZ(12,12) | (lo + 4); 2405 } 2406 2407 or1k_write_plt_entry (output_bfd, splt->contents, OR1K_JR(15), 2408 plt, plt_insn_count); 2409 2410 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 2411 } 2412 } 2413 2414 /* Set the first entry in the global offset table to the address of 2415 the dynamic section. */ 2416 if (sgot && sgot->size > 0) 2417 { 2418 if (sdyn == NULL) 2419 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents); 2420 else 2421 bfd_put_32 (output_bfd, 2422 sdyn->output_section->vma + sdyn->output_offset, 2423 sgot->contents); 2424 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 2425 } 2426 2427 if (htab->root.sgot && htab->root.sgot->size > 0) 2428 elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize = 4; 2429 2430 return true; 2431 } 2432 2433 /* Finish up dynamic symbol handling. We set the contents of various 2434 dynamic sections here. */ 2435 2436 static bool 2437 or1k_elf_finish_dynamic_symbol (bfd *output_bfd, 2438 struct bfd_link_info *info, 2439 struct elf_link_hash_entry *h, 2440 Elf_Internal_Sym *sym) 2441 { 2442 struct elf_or1k_link_hash_table *htab; 2443 bfd_byte *loc; 2444 2445 htab = or1k_elf_hash_table (info); 2446 if (htab == NULL) 2447 return false; 2448 2449 if (h->plt.offset != (bfd_vma) -1) 2450 { 2451 unsigned int plt[PLT_MAX_INSN_COUNT]; 2452 size_t plt_insn_count = 3; 2453 asection *splt; 2454 asection *sgot; 2455 asection *srela; 2456 bfd_vma plt_base_addr; 2457 bfd_vma plt_addr; 2458 bfd_vma plt_index; 2459 bfd_vma plt_reloc; 2460 bfd_vma got_base_addr; 2461 bfd_vma got_offset; 2462 bfd_vma got_addr; 2463 Elf_Internal_Rela rela; 2464 bool large_plt_entry; 2465 2466 /* This symbol has an entry in the procedure linkage table. Set 2467 it up. */ 2468 BFD_ASSERT (h->dynindx != -1); 2469 2470 splt = htab->root.splt; 2471 sgot = htab->root.sgotplt; 2472 srela = htab->root.srelplt; 2473 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL); 2474 2475 plt_base_addr = splt->output_section->vma + splt->output_offset; 2476 got_base_addr = sgot->output_section->vma + sgot->output_offset; 2477 2478 /* Get the index in the procedure linkage table which 2479 corresponds to this symbol. This is the index of this symbol 2480 in all the symbols for which we are making plt entries. The 2481 first entry in the procedure linkage table is reserved. */ 2482 plt_index = ((struct elf_or1k_link_hash_entry *) h)->plt_index; 2483 plt_addr = plt_base_addr + h->plt.offset; 2484 plt_reloc = plt_index * sizeof (Elf32_External_Rela); 2485 2486 large_plt_entry = (elf_or1k_plt_entry_size (plt_index) 2487 == PLT_ENTRY_SIZE_LARGE); 2488 2489 /* Get the offset into the .got table of the entry that 2490 corresponds to this function. Each .got entry is 4 bytes. 2491 The first three are reserved. */ 2492 got_offset = (plt_index + 3) * 4; 2493 got_addr = got_base_addr + got_offset; 2494 2495 /* Fill in the entry in the procedure linkage table. */ 2496 if (htab->saw_plta) 2497 { 2498 unsigned pa = ((got_addr >> 13) - (plt_addr >> 13)) & 0x1fffff; 2499 unsigned po = (got_addr & 0x1fff); 2500 plt[0] = OR1K_ADRP(12) | pa; 2501 plt[1] = OR1K_LWZ(12,12) | po; 2502 plt[2] = OR1K_ORI0(11) | plt_reloc; 2503 } 2504 else if (bfd_link_pic (info)) 2505 { 2506 if (large_plt_entry) 2507 { 2508 unsigned gotha = ((got_offset + 0x8000) >> 16) & 0xffff; 2509 unsigned got = got_offset & 0xffff; 2510 unsigned pltrelhi = (plt_reloc >> 16) & 0xffff; 2511 unsigned pltrello = plt_reloc & 0xffff; 2512 2513 plt[0] = OR1K_MOVHI(12) | gotha; 2514 plt[1] = OR1K_ADD(12,12,16); 2515 plt[2] = OR1K_LWZ(12,12) | got; 2516 plt[3] = OR1K_MOVHI(11) | pltrelhi; 2517 plt[4] = OR1K_ORI(11,11) | pltrello; 2518 plt_insn_count = 5; 2519 } 2520 else 2521 { 2522 plt[0] = OR1K_LWZ(12,16) | got_offset; 2523 plt[1] = OR1K_ORI0(11) | plt_reloc; 2524 plt[2] = OR1K_NOP; 2525 } 2526 } 2527 else 2528 { 2529 unsigned ha = ((got_addr + 0x8000) >> 16) & 0xffff; 2530 unsigned lo = got_addr & 0xffff; 2531 plt[0] = OR1K_MOVHI(12) | ha; 2532 plt[1] = OR1K_LWZ(12,12) | lo; 2533 plt[2] = OR1K_ORI0(11) | plt_reloc; 2534 } 2535 2536 /* For large code model we fixup the non-PIC PLT relocation instructions 2537 here. */ 2538 if (large_plt_entry && !bfd_link_pic (info)) 2539 { 2540 unsigned pltrelhi = (plt_reloc >> 16) & 0xffff; 2541 unsigned pltrello = plt_reloc & 0xffff; 2542 2543 plt[2] = OR1K_MOVHI(11) | pltrelhi; 2544 plt[3] = OR1K_ORI(11,11) | pltrello; 2545 plt[4] = OR1K_NOP; 2546 plt_insn_count = 5; 2547 } 2548 2549 or1k_write_plt_entry (output_bfd, splt->contents + h->plt.offset, 2550 OR1K_JR(12), plt, plt_insn_count); 2551 2552 /* Fill in the entry in the global offset table. We initialize it to 2553 point to the top of the plt. This is done to lazy lookup the actual 2554 symbol as the first plt entry will be setup by libc to call the 2555 runtime dynamic linker. */ 2556 bfd_put_32 (output_bfd, plt_base_addr, sgot->contents + got_offset); 2557 2558 /* Fill in the entry in the .rela.plt section. */ 2559 rela.r_offset = got_addr; 2560 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_JMP_SLOT); 2561 rela.r_addend = 0; 2562 loc = srela->contents; 2563 loc += plt_index * sizeof (Elf32_External_Rela); 2564 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2565 2566 if (!h->def_regular) 2567 { 2568 /* Mark the symbol as undefined, rather than as defined in 2569 the .plt section. Leave the value alone. */ 2570 sym->st_shndx = SHN_UNDEF; 2571 } 2572 } 2573 2574 if (h->got.offset != (bfd_vma) -1 2575 && (h->got.offset & 2) == 0) /* Homemade TLS check. */ 2576 { 2577 asection *sgot; 2578 asection *srelgot; 2579 Elf_Internal_Rela rela; 2580 2581 /* This symbol has an entry in the global offset table. Set it 2582 up. */ 2583 sgot = htab->root.sgot; 2584 srelgot = htab->root.srelgot; 2585 BFD_ASSERT (sgot != NULL && srelgot != NULL); 2586 2587 rela.r_offset = (sgot->output_section->vma 2588 + sgot->output_offset 2589 + (h->got.offset &~ 1)); 2590 2591 /* If this is a -Bsymbolic link, and the symbol is defined 2592 locally, we just want to emit a RELATIVE reloc. Likewise if 2593 the symbol was forced to be local because of a version file. 2594 The entry in the global offset table will already have been 2595 initialized in the relocate_section function. */ 2596 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h)) 2597 { 2598 rela.r_info = ELF32_R_INFO (0, R_OR1K_RELATIVE); 2599 rela.r_addend = (h->root.u.def.value 2600 + h->root.u.def.section->output_section->vma 2601 + h->root.u.def.section->output_offset); 2602 } 2603 else 2604 { 2605 BFD_ASSERT ((h->got.offset & 1) == 0); 2606 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 2607 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_GLOB_DAT); 2608 rela.r_addend = 0; 2609 } 2610 2611 loc = srelgot->contents; 2612 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela); 2613 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2614 ++srelgot->reloc_count; 2615 } 2616 2617 if (h->needs_copy) 2618 { 2619 asection *s; 2620 Elf_Internal_Rela rela; 2621 2622 /* This symbols needs a copy reloc. Set it up. */ 2623 BFD_ASSERT (h->dynindx != -1 2624 && (h->root.type == bfd_link_hash_defined 2625 || h->root.type == bfd_link_hash_defweak)); 2626 2627 rela.r_offset = (h->root.u.def.value 2628 + h->root.u.def.section->output_section->vma 2629 + h->root.u.def.section->output_offset); 2630 rela.r_info = ELF32_R_INFO (h->dynindx, R_OR1K_COPY); 2631 rela.r_addend = 0; 2632 if (h->root.u.def.section == htab->root.sdynrelro) 2633 s = htab->root.sreldynrelro; 2634 else 2635 s = htab->root.srelbss; 2636 loc = s->contents + s->reloc_count * sizeof (Elf32_External_Rela); 2637 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 2638 ++s->reloc_count; 2639 } 2640 2641 /* Mark some specially defined symbols as absolute. */ 2642 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2643 || h == htab->root.hgot) 2644 sym->st_shndx = SHN_ABS; 2645 2646 return true; 2647 } 2648 2649 static enum elf_reloc_type_class 2650 or1k_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2651 const asection *rel_sec ATTRIBUTE_UNUSED, 2652 const Elf_Internal_Rela *rela) 2653 { 2654 switch ((int) ELF32_R_TYPE (rela->r_info)) 2655 { 2656 case R_OR1K_RELATIVE: return reloc_class_relative; 2657 case R_OR1K_JMP_SLOT: return reloc_class_plt; 2658 case R_OR1K_COPY: return reloc_class_copy; 2659 default: return reloc_class_normal; 2660 } 2661 } 2662 2663 /* Adjust a symbol defined by a dynamic object and referenced by a 2664 regular object. The current definition is in some section of the 2665 dynamic object, but we're not including those sections. We have to 2666 change the definition to something the rest of the link can 2667 understand. */ 2668 2669 static bool 2670 or1k_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 2671 struct elf_link_hash_entry *h) 2672 { 2673 struct elf_or1k_link_hash_table *htab; 2674 bfd *dynobj; 2675 asection *s, *srel; 2676 2677 dynobj = elf_hash_table (info)->dynobj; 2678 2679 /* Make sure we know what is going on here. */ 2680 BFD_ASSERT (dynobj != NULL 2681 && (h->needs_plt 2682 || h->is_weakalias 2683 || (h->def_dynamic 2684 && h->ref_regular 2685 && !h->def_regular))); 2686 2687 /* If this is a function, put it in the procedure linkage table. We 2688 will fill in the contents of the procedure linkage table later, 2689 when we know the address of the .got section. */ 2690 if (h->type == STT_FUNC 2691 || h->needs_plt) 2692 { 2693 if (h->plt.refcount <= 0 2694 || (SYMBOL_CALLS_LOCAL (info, h) 2695 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2696 && h->root.type == bfd_link_hash_undefweak))) 2697 { 2698 /* This case can occur if we saw a PLT reloc in an input 2699 file, but the symbol was never referred to by a dynamic 2700 object. In such a case, we don't actually need to build 2701 a procedure linkage table, and we can just do a PCREL 2702 reloc instead. */ 2703 h->plt.offset = (bfd_vma) -1; 2704 h->needs_plt = 0; 2705 } 2706 2707 return true; 2708 } 2709 else 2710 h->plt.offset = (bfd_vma) -1; 2711 2712 /* If this is a weak symbol, and there is a real definition, the 2713 processor independent code will have arranged for us to see the 2714 real definition first, and we can just use the same value. */ 2715 if (h->is_weakalias) 2716 { 2717 struct elf_link_hash_entry *def = weakdef (h); 2718 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2719 h->root.u.def.section = def->root.u.def.section; 2720 h->root.u.def.value = def->root.u.def.value; 2721 return true; 2722 } 2723 2724 /* This is a reference to a symbol defined by a dynamic object which 2725 is not a function. */ 2726 2727 /* If we are creating a shared library, we must presume that the 2728 only references to the symbol are via the global offset table. 2729 For such cases we need not do anything here; the relocations will 2730 be handled correctly by relocate_section. */ 2731 if (bfd_link_pic (info)) 2732 return true; 2733 2734 /* If there are no references to this symbol that do not use the 2735 GOT, we don't need to generate a copy reloc. */ 2736 if (!h->non_got_ref) 2737 return true; 2738 2739 /* If -z nocopyreloc was given, we won't generate them either. */ 2740 if (info->nocopyreloc) 2741 { 2742 h->non_got_ref = 0; 2743 return true; 2744 } 2745 2746 /* If we don't find any dynamic relocs in read-only sections, then 2747 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 2748 if (!_bfd_elf_readonly_dynrelocs (h)) 2749 { 2750 h->non_got_ref = 0; 2751 return true; 2752 } 2753 2754 /* We must allocate the symbol in our .dynbss section, which will 2755 become part of the .bss section of the executable. There will be 2756 an entry for this symbol in the .dynsym section. The dynamic 2757 object will contain position independent code, so all references 2758 from the dynamic object to this symbol will go through the global 2759 offset table. The dynamic linker will use the .dynsym entry to 2760 determine the address it must put in the global offset table, so 2761 both the dynamic object and the regular object will refer to the 2762 same memory location for the variable. */ 2763 2764 htab = or1k_elf_hash_table (info); 2765 if (htab == NULL) 2766 return false; 2767 2768 /* We must generate a R_OR1K_COPY reloc to tell the dynamic linker 2769 to copy the initial value out of the dynamic object and into the 2770 runtime process image. We need to remember the offset into the 2771 .rela.bss section we are going to use. */ 2772 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 2773 { 2774 s = htab->root.sdynrelro; 2775 srel = htab->root.sreldynrelro; 2776 } 2777 else 2778 { 2779 s = htab->root.sdynbss; 2780 srel = htab->root.srelbss; 2781 } 2782 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2783 { 2784 srel->size += sizeof (Elf32_External_Rela); 2785 h->needs_copy = 1; 2786 } 2787 2788 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2789 } 2790 2791 /* Caclulate an update the sizes required for a symbol in the GOT and 2792 RELA relocation section based on the TLS_TYPE and whether or not the symbol 2793 is DYNAMIC. 2794 2795 Symbols with TLS_GD access require 8 bytes in the GOT and, if dynamic, 2796 require two relocation entries. Symbols with TLS_IE access require 4 bytes 2797 in the GOT and, if dynamic, require one relocation entry. Symbols may have 2798 both TLS_GD and TLS_IE access to be accounted for. 2799 2800 Other symbols require 4 bytes in the GOT table and, if dynamic, require one 2801 relocation entry. */ 2802 2803 static void 2804 or1k_set_got_and_rela_sizes (const unsigned char tls_type, 2805 const bool dynamic, 2806 bfd_vma *got_size, 2807 bfd_vma *rela_size) 2808 { 2809 bool is_tls_entry = false; 2810 2811 /* TLS GD requires two GOT entries and two relocs. */ 2812 if ((tls_type & TLS_GD) != 0) 2813 { 2814 *got_size += 8; 2815 is_tls_entry = true; 2816 } 2817 2818 if ((tls_type & TLS_IE) != 0) 2819 { 2820 *got_size += 4; 2821 is_tls_entry = true; 2822 } 2823 2824 if (!is_tls_entry) 2825 *got_size += 4; 2826 2827 if (dynamic) 2828 { 2829 if ((tls_type & TLS_GD) != 0) 2830 *rela_size += 2 * sizeof (Elf32_External_Rela); 2831 2832 if ((tls_type & TLS_IE) != 0) 2833 *rela_size += sizeof (Elf32_External_Rela); 2834 2835 if (!is_tls_entry) 2836 *rela_size += sizeof (Elf32_External_Rela); 2837 } 2838 } 2839 2840 2841 /* Allocate space in .plt, .got and associated reloc sections for 2842 dynamic relocs. */ 2843 2844 static bool 2845 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 2846 { 2847 struct bfd_link_info *info; 2848 struct elf_or1k_link_hash_table *htab; 2849 struct elf_dyn_relocs *sec_relocs; 2850 2851 if (h->root.type == bfd_link_hash_indirect) 2852 return true; 2853 2854 info = (struct bfd_link_info *) inf; 2855 htab = or1k_elf_hash_table (info); 2856 if (htab == NULL) 2857 return false; 2858 2859 if (htab->root.dynamic_sections_created 2860 && h->plt.refcount > 0) 2861 { 2862 /* Make sure this symbol is output as a dynamic symbol. 2863 Undefined weak syms won't yet be marked as dynamic. */ 2864 if (h->dynindx == -1 2865 && !h->forced_local) 2866 { 2867 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2868 return false; 2869 } 2870 2871 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 2872 { 2873 asection *splt = htab->root.splt; 2874 bfd_vma plt_index; 2875 2876 /* Track the index of our plt entry for use in calculating size. */ 2877 plt_index = htab->plt_count++; 2878 ((struct elf_or1k_link_hash_entry *) h)->plt_index = plt_index; 2879 2880 /* If this is the first .plt entry, make room for the special 2881 first entry. */ 2882 if (splt->size == 0) 2883 splt->size = elf_or1k_plt_entry_size (plt_index); 2884 2885 h->plt.offset = splt->size; 2886 2887 /* If this symbol is not defined in a regular file, and we are 2888 not generating a shared library, then set the symbol to this 2889 location in the .plt. This is required to make function 2890 pointers compare as equal between the normal executable and 2891 the shared library. */ 2892 if (! bfd_link_pic (info) 2893 && !h->def_regular) 2894 { 2895 h->root.u.def.section = splt; 2896 h->root.u.def.value = h->plt.offset; 2897 } 2898 2899 /* Make room for this entry. */ 2900 splt->size += elf_or1k_plt_entry_size (plt_index); 2901 2902 /* We also need to make an entry in the .got.plt section, which 2903 will be placed in the .got section by the linker script. */ 2904 htab->root.sgotplt->size += 4; 2905 2906 /* We also need to make an entry in the .rel.plt section. */ 2907 htab->root.srelplt->size += sizeof (Elf32_External_Rela); 2908 } 2909 else 2910 { 2911 h->plt.offset = (bfd_vma) -1; 2912 h->needs_plt = 0; 2913 } 2914 } 2915 else 2916 { 2917 h->plt.offset = (bfd_vma) -1; 2918 h->needs_plt = 0; 2919 } 2920 2921 if (h->got.refcount > 0) 2922 { 2923 asection *sgot; 2924 bool dyn; 2925 unsigned char tls_type; 2926 2927 /* Make sure this symbol is output as a dynamic symbol. 2928 Undefined weak syms won't yet be marked as dynamic. */ 2929 if (h->dynindx == -1 2930 && !h->forced_local) 2931 { 2932 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2933 return false; 2934 } 2935 2936 sgot = htab->root.sgot; 2937 2938 h->got.offset = sgot->size; 2939 2940 tls_type = ((struct elf_or1k_link_hash_entry *) h)->tls_type; 2941 2942 dyn = htab->root.dynamic_sections_created; 2943 dyn = WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h); 2944 or1k_set_got_and_rela_sizes (tls_type, dyn, 2945 &sgot->size, &htab->root.srelgot->size); 2946 } 2947 else 2948 h->got.offset = (bfd_vma) -1; 2949 2950 if (h->dyn_relocs == NULL) 2951 return true; 2952 2953 /* In the shared -Bsymbolic case, discard space allocated for 2954 dynamic pc-relative relocs against symbols which turn out to be 2955 defined in regular objects. For the normal shared case, discard 2956 space for pc-relative relocs that have become local due to symbol 2957 visibility changes. */ 2958 2959 if (bfd_link_pic (info)) 2960 { 2961 if (SYMBOL_CALLS_LOCAL (info, h)) 2962 { 2963 struct elf_dyn_relocs **pp; 2964 2965 for (pp = &h->dyn_relocs; (sec_relocs = *pp) != NULL;) 2966 { 2967 sec_relocs->count -= sec_relocs->pc_count; 2968 sec_relocs->pc_count = 0; 2969 if (sec_relocs->count == 0) 2970 *pp = sec_relocs->next; 2971 else 2972 pp = &sec_relocs->next; 2973 } 2974 } 2975 2976 /* Also discard relocs on undefined weak syms with non-default 2977 visibility. */ 2978 if (h->dyn_relocs != NULL 2979 && h->root.type == bfd_link_hash_undefweak) 2980 { 2981 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 2982 h->dyn_relocs = NULL; 2983 2984 /* Make sure undefined weak symbols are output as a dynamic 2985 symbol in PIEs. */ 2986 else if (h->dynindx == -1 2987 && !h->forced_local) 2988 { 2989 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2990 return false; 2991 } 2992 } 2993 } 2994 else 2995 { 2996 /* For the non-shared case, discard space for relocs against 2997 symbols which turn out to need copy relocs or are not 2998 dynamic. */ 2999 3000 if (!h->non_got_ref 3001 && ((h->def_dynamic 3002 && !h->def_regular) 3003 || (htab->root.dynamic_sections_created 3004 && (h->root.type == bfd_link_hash_undefweak 3005 || h->root.type == bfd_link_hash_undefined)))) 3006 { 3007 /* Make sure this symbol is output as a dynamic symbol. 3008 Undefined weak syms won't yet be marked as dynamic. */ 3009 if (h->dynindx == -1 3010 && !h->forced_local) 3011 { 3012 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3013 return false; 3014 } 3015 3016 /* If that succeeded, we know we'll be keeping all the 3017 relocs. */ 3018 if (h->dynindx != -1) 3019 goto keep; 3020 } 3021 3022 h->dyn_relocs = NULL; 3023 3024 keep: ; 3025 } 3026 3027 /* Finally, allocate space. */ 3028 for (sec_relocs = h->dyn_relocs; 3029 sec_relocs != NULL; 3030 sec_relocs = sec_relocs->next) 3031 { 3032 asection *sreloc = elf_section_data (sec_relocs->sec)->sreloc; 3033 sreloc->size += sec_relocs->count * sizeof (Elf32_External_Rela); 3034 } 3035 3036 return true; 3037 } 3038 3039 /* Set the sizes of the dynamic sections. */ 3040 3041 static bool 3042 or1k_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 3043 struct bfd_link_info *info) 3044 { 3045 struct elf_or1k_link_hash_table *htab; 3046 bfd *dynobj; 3047 asection *s; 3048 bool relocs; 3049 bfd *ibfd; 3050 3051 htab = or1k_elf_hash_table (info); 3052 if (htab == NULL) 3053 return false; 3054 3055 dynobj = htab->root.dynobj; 3056 BFD_ASSERT (dynobj != NULL); 3057 3058 if (htab->root.dynamic_sections_created) 3059 { 3060 /* Set the contents of the .interp section to the interpreter. */ 3061 if (bfd_link_executable (info) && !info->nointerp) 3062 { 3063 s = bfd_get_section_by_name (dynobj, ".interp"); 3064 BFD_ASSERT (s != NULL); 3065 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 3066 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3067 } 3068 } 3069 3070 /* Set up .got offsets for local syms, and space for local dynamic 3071 relocs. */ 3072 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 3073 { 3074 bfd_signed_vma *local_got; 3075 bfd_signed_vma *end_local_got; 3076 bfd_size_type locsymcount; 3077 Elf_Internal_Shdr *symtab_hdr; 3078 unsigned char *local_tls_type; 3079 asection *srel; 3080 3081 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 3082 continue; 3083 3084 for (s = ibfd->sections; s != NULL; s = s->next) 3085 { 3086 struct elf_dyn_relocs *sec_relocs; 3087 3088 for (sec_relocs = ((struct elf_dyn_relocs *) 3089 elf_section_data (s)->local_dynrel); 3090 sec_relocs != NULL; 3091 sec_relocs = sec_relocs->next) 3092 { 3093 if (! bfd_is_abs_section (sec_relocs->sec) 3094 && bfd_is_abs_section (sec_relocs->sec->output_section)) 3095 { 3096 /* Input section has been discarded, either because 3097 it is a copy of a linkonce section or due to 3098 linker script /DISCARD/, so we'll be discarding 3099 the relocs too. */ 3100 } 3101 else if (sec_relocs->count != 0) 3102 { 3103 srel = elf_section_data (sec_relocs->sec)->sreloc; 3104 srel->size += sec_relocs->count 3105 * sizeof (Elf32_External_Rela); 3106 if ((sec_relocs->sec->output_section->flags & SEC_READONLY) 3107 != 0) 3108 info->flags |= DF_TEXTREL; 3109 } 3110 } 3111 } 3112 3113 local_got = elf_local_got_refcounts (ibfd); 3114 if (!local_got) 3115 continue; 3116 3117 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 3118 locsymcount = symtab_hdr->sh_info; 3119 end_local_got = local_got + locsymcount; 3120 s = htab->root.sgot; 3121 srel = htab->root.srelgot; 3122 local_tls_type = (unsigned char *) elf_or1k_local_tls_type (ibfd); 3123 for (; local_got < end_local_got; ++local_got) 3124 { 3125 if (*local_got > 0) 3126 { 3127 unsigned char tls_type = (local_tls_type == NULL) 3128 ? TLS_UNKNOWN 3129 : *local_tls_type; 3130 3131 *local_got = s->size; 3132 or1k_set_got_and_rela_sizes (tls_type, bfd_link_pic (info), 3133 &s->size, &srel->size); 3134 } 3135 else 3136 3137 *local_got = (bfd_vma) -1; 3138 3139 if (local_tls_type) 3140 ++local_tls_type; 3141 } 3142 } 3143 3144 /* Allocate global sym .plt and .got entries, and space for global 3145 sym dynamic relocs. */ 3146 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 3147 3148 /* We now have determined the sizes of the various dynamic sections. 3149 Allocate memory for them. */ 3150 relocs = false; 3151 for (s = dynobj->sections; s != NULL; s = s->next) 3152 { 3153 if ((s->flags & SEC_LINKER_CREATED) == 0) 3154 continue; 3155 3156 if (s == htab->root.splt 3157 || s == htab->root.sgot 3158 || s == htab->root.sgotplt 3159 || s == htab->root.sdynbss 3160 || s == htab->root.sdynrelro) 3161 { 3162 /* Strip this section if we don't need it; see the 3163 comment below. */ 3164 } 3165 else if (startswith (bfd_section_name (s), ".rela")) 3166 { 3167 if (s->size != 0 && s != htab->root.srelplt) 3168 relocs = true; 3169 3170 /* We use the reloc_count field as a counter if we need 3171 to copy relocs into the output file. */ 3172 s->reloc_count = 0; 3173 } 3174 else 3175 /* It's not one of our sections, so don't allocate space. */ 3176 continue; 3177 3178 if (s->size == 0) 3179 { 3180 /* If we don't need this section, strip it from the 3181 output file. This is mostly to handle .rela.bss and 3182 .rela.plt. We must create both sections in 3183 create_dynamic_sections, because they must be created 3184 before the linker maps input sections to output 3185 sections. The linker does that before 3186 adjust_dynamic_symbol is called, and it is that 3187 function which decides whether anything needs to go 3188 into these sections. */ 3189 s->flags |= SEC_EXCLUDE; 3190 continue; 3191 } 3192 3193 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3194 continue; 3195 3196 /* Allocate memory for the section contents. We use bfd_zalloc 3197 here in case unused entries are not reclaimed before the 3198 section's contents are written out. This should not happen, 3199 but this way if it does, we get a R_OR1K_NONE reloc instead 3200 of garbage. */ 3201 s->contents = bfd_zalloc (dynobj, s->size); 3202 3203 if (s->contents == NULL) 3204 return false; 3205 } 3206 3207 return _bfd_elf_add_dynamic_tags (output_bfd, info, relocs); 3208 } 3209 3210 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 3211 3212 static void 3213 or1k_elf_copy_indirect_symbol (struct bfd_link_info *info, 3214 struct elf_link_hash_entry *dir, 3215 struct elf_link_hash_entry *ind) 3216 { 3217 struct elf_or1k_link_hash_entry * edir; 3218 struct elf_or1k_link_hash_entry * eind; 3219 3220 edir = (struct elf_or1k_link_hash_entry *) dir; 3221 eind = (struct elf_or1k_link_hash_entry *) ind; 3222 3223 if (ind->root.type == bfd_link_hash_indirect) 3224 { 3225 if (dir->got.refcount <= 0) 3226 { 3227 edir->tls_type = eind->tls_type; 3228 eind->tls_type = TLS_UNKNOWN; 3229 } 3230 } 3231 3232 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 3233 } 3234 3235 /* Set the right machine number. */ 3236 3237 static bool 3238 or1k_elf_object_p (bfd *abfd) 3239 { 3240 unsigned long mach = bfd_mach_or1k; 3241 3242 if (elf_elfheader (abfd)->e_flags & EF_OR1K_NODELAY) 3243 mach = bfd_mach_or1knd; 3244 3245 return bfd_default_set_arch_mach (abfd, bfd_arch_or1k, mach); 3246 } 3247 3248 /* Store the machine number in the flags field. */ 3249 3250 static bool 3251 or1k_elf_final_write_processing (bfd *abfd) 3252 { 3253 switch (bfd_get_mach (abfd)) 3254 { 3255 default: 3256 case bfd_mach_or1k: 3257 break; 3258 case bfd_mach_or1knd: 3259 elf_elfheader (abfd)->e_flags |= EF_OR1K_NODELAY; 3260 break; 3261 } 3262 return _bfd_elf_final_write_processing (abfd); 3263 } 3264 3265 static bool 3266 or1k_elf_set_private_flags (bfd *abfd, flagword flags) 3267 { 3268 BFD_ASSERT (!elf_flags_init (abfd) 3269 || elf_elfheader (abfd)->e_flags == flags); 3270 3271 elf_elfheader (abfd)->e_flags = flags; 3272 elf_flags_init (abfd) = true; 3273 return true; 3274 } 3275 3276 /* Make sure all input files are consistent with respect to 3277 EF_OR1K_NODELAY flag setting. */ 3278 3279 static bool 3280 elf32_or1k_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 3281 { 3282 bfd *obfd = info->output_bfd; 3283 flagword out_flags; 3284 flagword in_flags; 3285 3286 in_flags = elf_elfheader (ibfd)->e_flags; 3287 out_flags = elf_elfheader (obfd)->e_flags; 3288 3289 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 3290 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 3291 return true; 3292 3293 if (!elf_flags_init (obfd)) 3294 { 3295 elf_flags_init (obfd) = true; 3296 elf_elfheader (obfd)->e_flags = in_flags; 3297 3298 return true; 3299 } 3300 3301 if (in_flags == out_flags) 3302 return true; 3303 3304 if ((in_flags & EF_OR1K_NODELAY) != (out_flags & EF_OR1K_NODELAY)) 3305 { 3306 _bfd_error_handler 3307 (_("%pB: %s flag mismatch with previous modules"), 3308 ibfd, "EF_OR1K_NODELAY"); 3309 3310 bfd_set_error (bfd_error_bad_value); 3311 return false; 3312 } 3313 3314 return true; 3315 3316 } 3317 3318 /* Implement elf_backend_grok_prstatus: 3319 Support for core dump NOTE sections. */ 3320 static bool 3321 or1k_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 3322 { 3323 int offset; 3324 size_t size; 3325 3326 switch (note->descsz) 3327 { 3328 default: 3329 return false; 3330 3331 case 212: /* Linux/OpenRISC */ 3332 /* pr_cursig */ 3333 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 3334 3335 /* pr_pid */ 3336 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24); 3337 3338 /* pr_reg */ 3339 offset = 72; 3340 size = 132; 3341 3342 break; 3343 } 3344 3345 /* Make a ".reg/999" section. */ 3346 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 3347 size, note->descpos + offset); 3348 } 3349 3350 /* Implement elf_backend_grok_psinfo. */ 3351 static bool 3352 or1k_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 3353 { 3354 switch (note->descsz) 3355 { 3356 default: 3357 return false; 3358 3359 case 128: /* Linux/OpenRISC elf_prpsinfo */ 3360 elf_tdata (abfd)->core->program 3361 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); 3362 elf_tdata (abfd)->core->command 3363 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); 3364 } 3365 3366 return true; 3367 } 3368 3369 3370 #define ELF_ARCH bfd_arch_or1k 3371 #define ELF_MACHINE_CODE EM_OR1K 3372 #define ELF_TARGET_ID OR1K_ELF_DATA 3373 #define ELF_MAXPAGESIZE 0x2000 3374 3375 #define TARGET_BIG_SYM or1k_elf32_vec 3376 #define TARGET_BIG_NAME "elf32-or1k" 3377 3378 #define elf_info_to_howto_rel NULL 3379 #define elf_info_to_howto or1k_info_to_howto_rela 3380 #define elf_backend_relocate_section or1k_elf_relocate_section 3381 #define elf_backend_gc_mark_hook or1k_elf_gc_mark_hook 3382 #define elf_backend_check_relocs or1k_elf_check_relocs 3383 #define elf_backend_reloc_type_class or1k_elf_reloc_type_class 3384 #define elf_backend_can_gc_sections 1 3385 #define elf_backend_rela_normal 1 3386 3387 #define bfd_elf32_mkobject elf_or1k_mkobject 3388 3389 #define bfd_elf32_bfd_merge_private_bfd_data elf32_or1k_merge_private_bfd_data 3390 #define bfd_elf32_bfd_set_private_flags or1k_elf_set_private_flags 3391 #define bfd_elf32_bfd_reloc_type_lookup or1k_reloc_type_lookup 3392 #define bfd_elf32_bfd_reloc_name_lookup or1k_reloc_name_lookup 3393 3394 #define elf_backend_object_p or1k_elf_object_p 3395 #define elf_backend_final_write_processing or1k_elf_final_write_processing 3396 #define elf_backend_can_refcount 1 3397 3398 #define elf_backend_plt_readonly 1 3399 #define elf_backend_want_got_plt 1 3400 #define elf_backend_want_plt_sym 0 3401 #define elf_backend_got_header_size 12 3402 #define elf_backend_dtrel_excludes_plt 1 3403 #define elf_backend_want_dynrelro 1 3404 3405 #define bfd_elf32_bfd_link_hash_table_create or1k_elf_link_hash_table_create 3406 #define elf_backend_copy_indirect_symbol or1k_elf_copy_indirect_symbol 3407 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections 3408 #define elf_backend_finish_dynamic_sections or1k_elf_finish_dynamic_sections 3409 #define elf_backend_size_dynamic_sections or1k_elf_size_dynamic_sections 3410 #define elf_backend_adjust_dynamic_symbol or1k_elf_adjust_dynamic_symbol 3411 #define elf_backend_finish_dynamic_symbol or1k_elf_finish_dynamic_symbol 3412 3413 #define elf_backend_grok_prstatus or1k_grok_prstatus 3414 #define elf_backend_grok_psinfo or1k_grok_psinfo 3415 3416 #include "elf32-target.h" 3417
Indexes created Tue Apr 07 00:22:49 UTC 2026