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