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