1 /* PowerPC-specific support for 32-bit ELF 2 Copyright (C) 1994-2016 Free Software Foundation, Inc. 3 Written by Ian Lance Taylor, Cygnus Support. 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 19 Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, 20 Boston, MA 02110-1301, USA. */ 21 22 23 /* This file is based on a preliminary PowerPC ELF ABI. The 24 information may not match the final PowerPC ELF ABI. It includes 25 suggestions from the in-progress Embedded PowerPC ABI, and that 26 information may also not match. */ 27 28 #include "sysdep.h" 29 #include <stdarg.h> 30 #include "bfd.h" 31 #include "bfdlink.h" 32 #include "libbfd.h" 33 #include "elf-bfd.h" 34 #include "elf/ppc.h" 35 #include "elf32-ppc.h" 36 #include "elf-vxworks.h" 37 #include "dwarf2.h" 38 39 typedef enum split16_format_type 40 { 41 split16a_type = 0, 42 split16d_type 43 } 44 split16_format_type; 45 46 /* RELA relocations are used here. */ 47 48 static bfd_reloc_status_type ppc_elf_addr16_ha_reloc 49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 50 static bfd_reloc_status_type ppc_elf_unhandled_reloc 51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 52 53 /* Branch prediction bit for branch taken relocs. */ 54 #define BRANCH_PREDICT_BIT 0x200000 55 /* Mask to set RA in memory instructions. */ 56 #define RA_REGISTER_MASK 0x001f0000 57 /* Value to shift register by to insert RA. */ 58 #define RA_REGISTER_SHIFT 16 59 60 /* The name of the dynamic interpreter. This is put in the .interp 61 section. */ 62 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 63 64 /* For old-style PLT. */ 65 /* The number of single-slot PLT entries (the rest use two slots). */ 66 #define PLT_NUM_SINGLE_ENTRIES 8192 67 68 /* For new-style .glink and .plt. */ 69 #define GLINK_PLTRESOLVE 16*4 70 #define GLINK_ENTRY_SIZE 4*4 71 #define TLS_GET_ADDR_GLINK_SIZE 12*4 72 73 /* VxWorks uses its own plt layout, filled in by the static linker. */ 74 75 /* The standard VxWorks PLT entry. */ 76 #define VXWORKS_PLT_ENTRY_SIZE 32 77 static const bfd_vma ppc_elf_vxworks_plt_entry 78 [VXWORKS_PLT_ENTRY_SIZE / 4] = 79 { 80 0x3d800000, /* lis r12,0 */ 81 0x818c0000, /* lwz r12,0(r12) */ 82 0x7d8903a6, /* mtctr r12 */ 83 0x4e800420, /* bctr */ 84 0x39600000, /* li r11,0 */ 85 0x48000000, /* b 14 <.PLT0resolve+0x4> */ 86 0x60000000, /* nop */ 87 0x60000000, /* nop */ 88 }; 89 static const bfd_vma ppc_elf_vxworks_pic_plt_entry 90 [VXWORKS_PLT_ENTRY_SIZE / 4] = 91 { 92 0x3d9e0000, /* addis r12,r30,0 */ 93 0x818c0000, /* lwz r12,0(r12) */ 94 0x7d8903a6, /* mtctr r12 */ 95 0x4e800420, /* bctr */ 96 0x39600000, /* li r11,0 */ 97 0x48000000, /* b 14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */ 98 0x60000000, /* nop */ 99 0x60000000, /* nop */ 100 }; 101 102 /* The initial VxWorks PLT entry. */ 103 #define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32 104 static const bfd_vma ppc_elf_vxworks_plt0_entry 105 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = 106 { 107 0x3d800000, /* lis r12,0 */ 108 0x398c0000, /* addi r12,r12,0 */ 109 0x800c0008, /* lwz r0,8(r12) */ 110 0x7c0903a6, /* mtctr r0 */ 111 0x818c0004, /* lwz r12,4(r12) */ 112 0x4e800420, /* bctr */ 113 0x60000000, /* nop */ 114 0x60000000, /* nop */ 115 }; 116 static const bfd_vma ppc_elf_vxworks_pic_plt0_entry 117 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = 118 { 119 0x819e0008, /* lwz r12,8(r30) */ 120 0x7d8903a6, /* mtctr r12 */ 121 0x819e0004, /* lwz r12,4(r30) */ 122 0x4e800420, /* bctr */ 123 0x60000000, /* nop */ 124 0x60000000, /* nop */ 125 0x60000000, /* nop */ 126 0x60000000, /* nop */ 127 }; 128 129 /* For executables, we have some additional relocations in 130 .rela.plt.unloaded, for the kernel loader. */ 131 132 /* The number of non-JMP_SLOT relocations per PLT0 slot. */ 133 #define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3 134 /* The number of relocations in the PLTResolve slot. */ 135 #define VXWORKS_PLTRESOLVE_RELOCS 2 136 /* The number of relocations in the PLTResolve slot when when creating 137 a shared library. */ 138 #define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0 139 140 /* Some instructions. */ 141 #define ADDIS_11_11 0x3d6b0000 142 #define ADDIS_11_30 0x3d7e0000 143 #define ADDIS_12_12 0x3d8c0000 144 #define ADDI_11_11 0x396b0000 145 #define ADD_0_11_11 0x7c0b5a14 146 #define ADD_3_12_2 0x7c6c1214 147 #define ADD_11_0_11 0x7d605a14 148 #define B 0x48000000 149 #define BA 0x48000002 150 #define BCL_20_31 0x429f0005 151 #define BCTR 0x4e800420 152 #define BEQLR 0x4d820020 153 #define CMPWI_11_0 0x2c0b0000 154 #define LIS_11 0x3d600000 155 #define LIS_12 0x3d800000 156 #define LWZU_0_12 0x840c0000 157 #define LWZ_0_12 0x800c0000 158 #define LWZ_11_3 0x81630000 159 #define LWZ_11_11 0x816b0000 160 #define LWZ_11_30 0x817e0000 161 #define LWZ_12_3 0x81830000 162 #define LWZ_12_12 0x818c0000 163 #define MR_0_3 0x7c601b78 164 #define MR_3_0 0x7c030378 165 #define MFLR_0 0x7c0802a6 166 #define MFLR_12 0x7d8802a6 167 #define MTCTR_0 0x7c0903a6 168 #define MTCTR_11 0x7d6903a6 169 #define MTLR_0 0x7c0803a6 170 #define NOP 0x60000000 171 #define SUB_11_11_12 0x7d6c5850 172 173 /* Offset of tp and dtp pointers from start of TLS block. */ 174 #define TP_OFFSET 0x7000 175 #define DTP_OFFSET 0x8000 176 177 /* The value of a defined global symbol. */ 178 #define SYM_VAL(SYM) \ 179 ((SYM)->root.u.def.section->output_section->vma \ 180 + (SYM)->root.u.def.section->output_offset \ 181 + (SYM)->root.u.def.value) 182 183 static reloc_howto_type *ppc_elf_howto_table[R_PPC_max]; 185 186 static reloc_howto_type ppc_elf_howto_raw[] = { 187 /* This reloc does nothing. */ 188 HOWTO (R_PPC_NONE, /* type */ 189 0, /* rightshift */ 190 3, /* size (0 = byte, 1 = short, 2 = long) */ 191 0, /* bitsize */ 192 FALSE, /* pc_relative */ 193 0, /* bitpos */ 194 complain_overflow_dont, /* complain_on_overflow */ 195 bfd_elf_generic_reloc, /* special_function */ 196 "R_PPC_NONE", /* name */ 197 FALSE, /* partial_inplace */ 198 0, /* src_mask */ 199 0, /* dst_mask */ 200 FALSE), /* pcrel_offset */ 201 202 /* A standard 32 bit relocation. */ 203 HOWTO (R_PPC_ADDR32, /* type */ 204 0, /* rightshift */ 205 2, /* size (0 = byte, 1 = short, 2 = long) */ 206 32, /* bitsize */ 207 FALSE, /* pc_relative */ 208 0, /* bitpos */ 209 complain_overflow_dont, /* complain_on_overflow */ 210 bfd_elf_generic_reloc, /* special_function */ 211 "R_PPC_ADDR32", /* name */ 212 FALSE, /* partial_inplace */ 213 0, /* src_mask */ 214 0xffffffff, /* dst_mask */ 215 FALSE), /* pcrel_offset */ 216 217 /* An absolute 26 bit branch; the lower two bits must be zero. 218 FIXME: we don't check that, we just clear them. */ 219 HOWTO (R_PPC_ADDR24, /* type */ 220 0, /* rightshift */ 221 2, /* size (0 = byte, 1 = short, 2 = long) */ 222 26, /* bitsize */ 223 FALSE, /* pc_relative */ 224 0, /* bitpos */ 225 complain_overflow_signed, /* complain_on_overflow */ 226 bfd_elf_generic_reloc, /* special_function */ 227 "R_PPC_ADDR24", /* name */ 228 FALSE, /* partial_inplace */ 229 0, /* src_mask */ 230 0x3fffffc, /* dst_mask */ 231 FALSE), /* pcrel_offset */ 232 233 /* A standard 16 bit relocation. */ 234 HOWTO (R_PPC_ADDR16, /* type */ 235 0, /* rightshift */ 236 1, /* size (0 = byte, 1 = short, 2 = long) */ 237 16, /* bitsize */ 238 FALSE, /* pc_relative */ 239 0, /* bitpos */ 240 complain_overflow_bitfield, /* complain_on_overflow */ 241 bfd_elf_generic_reloc, /* special_function */ 242 "R_PPC_ADDR16", /* name */ 243 FALSE, /* partial_inplace */ 244 0, /* src_mask */ 245 0xffff, /* dst_mask */ 246 FALSE), /* pcrel_offset */ 247 248 /* A 16 bit relocation without overflow. */ 249 HOWTO (R_PPC_ADDR16_LO, /* type */ 250 0, /* rightshift */ 251 1, /* size (0 = byte, 1 = short, 2 = long) */ 252 16, /* bitsize */ 253 FALSE, /* pc_relative */ 254 0, /* bitpos */ 255 complain_overflow_dont,/* complain_on_overflow */ 256 bfd_elf_generic_reloc, /* special_function */ 257 "R_PPC_ADDR16_LO", /* name */ 258 FALSE, /* partial_inplace */ 259 0, /* src_mask */ 260 0xffff, /* dst_mask */ 261 FALSE), /* pcrel_offset */ 262 263 /* The high order 16 bits of an address. */ 264 HOWTO (R_PPC_ADDR16_HI, /* type */ 265 16, /* rightshift */ 266 1, /* size (0 = byte, 1 = short, 2 = long) */ 267 16, /* bitsize */ 268 FALSE, /* pc_relative */ 269 0, /* bitpos */ 270 complain_overflow_dont, /* complain_on_overflow */ 271 bfd_elf_generic_reloc, /* special_function */ 272 "R_PPC_ADDR16_HI", /* name */ 273 FALSE, /* partial_inplace */ 274 0, /* src_mask */ 275 0xffff, /* dst_mask */ 276 FALSE), /* pcrel_offset */ 277 278 /* The high order 16 bits of an address, plus 1 if the contents of 279 the low 16 bits, treated as a signed number, is negative. */ 280 HOWTO (R_PPC_ADDR16_HA, /* type */ 281 16, /* rightshift */ 282 1, /* size (0 = byte, 1 = short, 2 = long) */ 283 16, /* bitsize */ 284 FALSE, /* pc_relative */ 285 0, /* bitpos */ 286 complain_overflow_dont, /* complain_on_overflow */ 287 ppc_elf_addr16_ha_reloc, /* special_function */ 288 "R_PPC_ADDR16_HA", /* name */ 289 FALSE, /* partial_inplace */ 290 0, /* src_mask */ 291 0xffff, /* dst_mask */ 292 FALSE), /* pcrel_offset */ 293 294 /* An absolute 16 bit branch; the lower two bits must be zero. 295 FIXME: we don't check that, we just clear them. */ 296 HOWTO (R_PPC_ADDR14, /* type */ 297 0, /* rightshift */ 298 2, /* size (0 = byte, 1 = short, 2 = long) */ 299 16, /* bitsize */ 300 FALSE, /* pc_relative */ 301 0, /* bitpos */ 302 complain_overflow_signed, /* complain_on_overflow */ 303 bfd_elf_generic_reloc, /* special_function */ 304 "R_PPC_ADDR14", /* name */ 305 FALSE, /* partial_inplace */ 306 0, /* src_mask */ 307 0xfffc, /* dst_mask */ 308 FALSE), /* pcrel_offset */ 309 310 /* An absolute 16 bit branch, for which bit 10 should be set to 311 indicate that the branch is expected to be taken. The lower two 312 bits must be zero. */ 313 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */ 314 0, /* rightshift */ 315 2, /* size (0 = byte, 1 = short, 2 = long) */ 316 16, /* bitsize */ 317 FALSE, /* pc_relative */ 318 0, /* bitpos */ 319 complain_overflow_signed, /* complain_on_overflow */ 320 bfd_elf_generic_reloc, /* special_function */ 321 "R_PPC_ADDR14_BRTAKEN",/* name */ 322 FALSE, /* partial_inplace */ 323 0, /* src_mask */ 324 0xfffc, /* dst_mask */ 325 FALSE), /* pcrel_offset */ 326 327 /* An absolute 16 bit branch, for which bit 10 should be set to 328 indicate that the branch is not expected to be taken. The lower 329 two bits must be zero. */ 330 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */ 331 0, /* rightshift */ 332 2, /* size (0 = byte, 1 = short, 2 = long) */ 333 16, /* bitsize */ 334 FALSE, /* pc_relative */ 335 0, /* bitpos */ 336 complain_overflow_signed, /* complain_on_overflow */ 337 bfd_elf_generic_reloc, /* special_function */ 338 "R_PPC_ADDR14_BRNTAKEN",/* name */ 339 FALSE, /* partial_inplace */ 340 0, /* src_mask */ 341 0xfffc, /* dst_mask */ 342 FALSE), /* pcrel_offset */ 343 344 /* A relative 26 bit branch; the lower two bits must be zero. */ 345 HOWTO (R_PPC_REL24, /* type */ 346 0, /* rightshift */ 347 2, /* size (0 = byte, 1 = short, 2 = long) */ 348 26, /* bitsize */ 349 TRUE, /* pc_relative */ 350 0, /* bitpos */ 351 complain_overflow_signed, /* complain_on_overflow */ 352 bfd_elf_generic_reloc, /* special_function */ 353 "R_PPC_REL24", /* name */ 354 FALSE, /* partial_inplace */ 355 0, /* src_mask */ 356 0x3fffffc, /* dst_mask */ 357 TRUE), /* pcrel_offset */ 358 359 /* A relative 16 bit branch; the lower two bits must be zero. */ 360 HOWTO (R_PPC_REL14, /* type */ 361 0, /* rightshift */ 362 2, /* size (0 = byte, 1 = short, 2 = long) */ 363 16, /* bitsize */ 364 TRUE, /* pc_relative */ 365 0, /* bitpos */ 366 complain_overflow_signed, /* complain_on_overflow */ 367 bfd_elf_generic_reloc, /* special_function */ 368 "R_PPC_REL14", /* name */ 369 FALSE, /* partial_inplace */ 370 0, /* src_mask */ 371 0xfffc, /* dst_mask */ 372 TRUE), /* pcrel_offset */ 373 374 /* A relative 16 bit branch. Bit 10 should be set to indicate that 375 the branch is expected to be taken. The lower two bits must be 376 zero. */ 377 HOWTO (R_PPC_REL14_BRTAKEN, /* type */ 378 0, /* rightshift */ 379 2, /* size (0 = byte, 1 = short, 2 = long) */ 380 16, /* bitsize */ 381 TRUE, /* pc_relative */ 382 0, /* bitpos */ 383 complain_overflow_signed, /* complain_on_overflow */ 384 bfd_elf_generic_reloc, /* special_function */ 385 "R_PPC_REL14_BRTAKEN", /* name */ 386 FALSE, /* partial_inplace */ 387 0, /* src_mask */ 388 0xfffc, /* dst_mask */ 389 TRUE), /* pcrel_offset */ 390 391 /* A relative 16 bit branch. Bit 10 should be set to indicate that 392 the branch is not expected to be taken. The lower two bits must 393 be zero. */ 394 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */ 395 0, /* rightshift */ 396 2, /* size (0 = byte, 1 = short, 2 = long) */ 397 16, /* bitsize */ 398 TRUE, /* pc_relative */ 399 0, /* bitpos */ 400 complain_overflow_signed, /* complain_on_overflow */ 401 bfd_elf_generic_reloc, /* special_function */ 402 "R_PPC_REL14_BRNTAKEN",/* name */ 403 FALSE, /* partial_inplace */ 404 0, /* src_mask */ 405 0xfffc, /* dst_mask */ 406 TRUE), /* pcrel_offset */ 407 408 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the 409 symbol. */ 410 HOWTO (R_PPC_GOT16, /* type */ 411 0, /* rightshift */ 412 1, /* size (0 = byte, 1 = short, 2 = long) */ 413 16, /* bitsize */ 414 FALSE, /* pc_relative */ 415 0, /* bitpos */ 416 complain_overflow_signed, /* complain_on_overflow */ 417 bfd_elf_generic_reloc, /* special_function */ 418 "R_PPC_GOT16", /* name */ 419 FALSE, /* partial_inplace */ 420 0, /* src_mask */ 421 0xffff, /* dst_mask */ 422 FALSE), /* pcrel_offset */ 423 424 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for 425 the symbol. */ 426 HOWTO (R_PPC_GOT16_LO, /* type */ 427 0, /* rightshift */ 428 1, /* size (0 = byte, 1 = short, 2 = long) */ 429 16, /* bitsize */ 430 FALSE, /* pc_relative */ 431 0, /* bitpos */ 432 complain_overflow_dont, /* complain_on_overflow */ 433 bfd_elf_generic_reloc, /* special_function */ 434 "R_PPC_GOT16_LO", /* name */ 435 FALSE, /* partial_inplace */ 436 0, /* src_mask */ 437 0xffff, /* dst_mask */ 438 FALSE), /* pcrel_offset */ 439 440 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for 441 the symbol. */ 442 HOWTO (R_PPC_GOT16_HI, /* type */ 443 16, /* rightshift */ 444 1, /* size (0 = byte, 1 = short, 2 = long) */ 445 16, /* bitsize */ 446 FALSE, /* pc_relative */ 447 0, /* bitpos */ 448 complain_overflow_dont, /* complain_on_overflow */ 449 bfd_elf_generic_reloc, /* special_function */ 450 "R_PPC_GOT16_HI", /* name */ 451 FALSE, /* partial_inplace */ 452 0, /* src_mask */ 453 0xffff, /* dst_mask */ 454 FALSE), /* pcrel_offset */ 455 456 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for 457 the symbol. */ 458 HOWTO (R_PPC_GOT16_HA, /* type */ 459 16, /* rightshift */ 460 1, /* size (0 = byte, 1 = short, 2 = long) */ 461 16, /* bitsize */ 462 FALSE, /* pc_relative */ 463 0, /* bitpos */ 464 complain_overflow_dont, /* complain_on_overflow */ 465 ppc_elf_addr16_ha_reloc, /* special_function */ 466 "R_PPC_GOT16_HA", /* name */ 467 FALSE, /* partial_inplace */ 468 0, /* src_mask */ 469 0xffff, /* dst_mask */ 470 FALSE), /* pcrel_offset */ 471 472 /* Like R_PPC_REL24, but referring to the procedure linkage table 473 entry for the symbol. */ 474 HOWTO (R_PPC_PLTREL24, /* type */ 475 0, /* rightshift */ 476 2, /* size (0 = byte, 1 = short, 2 = long) */ 477 26, /* bitsize */ 478 TRUE, /* pc_relative */ 479 0, /* bitpos */ 480 complain_overflow_signed, /* complain_on_overflow */ 481 bfd_elf_generic_reloc, /* special_function */ 482 "R_PPC_PLTREL24", /* name */ 483 FALSE, /* partial_inplace */ 484 0, /* src_mask */ 485 0x3fffffc, /* dst_mask */ 486 TRUE), /* pcrel_offset */ 487 488 /* This is used only by the dynamic linker. The symbol should exist 489 both in the object being run and in some shared library. The 490 dynamic linker copies the data addressed by the symbol from the 491 shared library into the object, because the object being 492 run has to have the data at some particular address. */ 493 HOWTO (R_PPC_COPY, /* type */ 494 0, /* rightshift */ 495 2, /* size (0 = byte, 1 = short, 2 = long) */ 496 32, /* bitsize */ 497 FALSE, /* pc_relative */ 498 0, /* bitpos */ 499 complain_overflow_dont, /* complain_on_overflow */ 500 bfd_elf_generic_reloc, /* special_function */ 501 "R_PPC_COPY", /* name */ 502 FALSE, /* partial_inplace */ 503 0, /* src_mask */ 504 0, /* dst_mask */ 505 FALSE), /* pcrel_offset */ 506 507 /* Like R_PPC_ADDR32, but used when setting global offset table 508 entries. */ 509 HOWTO (R_PPC_GLOB_DAT, /* type */ 510 0, /* rightshift */ 511 2, /* size (0 = byte, 1 = short, 2 = long) */ 512 32, /* bitsize */ 513 FALSE, /* pc_relative */ 514 0, /* bitpos */ 515 complain_overflow_dont, /* complain_on_overflow */ 516 bfd_elf_generic_reloc, /* special_function */ 517 "R_PPC_GLOB_DAT", /* name */ 518 FALSE, /* partial_inplace */ 519 0, /* src_mask */ 520 0xffffffff, /* dst_mask */ 521 FALSE), /* pcrel_offset */ 522 523 /* Marks a procedure linkage table entry for a symbol. */ 524 HOWTO (R_PPC_JMP_SLOT, /* type */ 525 0, /* rightshift */ 526 2, /* size (0 = byte, 1 = short, 2 = long) */ 527 32, /* bitsize */ 528 FALSE, /* pc_relative */ 529 0, /* bitpos */ 530 complain_overflow_dont, /* complain_on_overflow */ 531 bfd_elf_generic_reloc, /* special_function */ 532 "R_PPC_JMP_SLOT", /* name */ 533 FALSE, /* partial_inplace */ 534 0, /* src_mask */ 535 0, /* dst_mask */ 536 FALSE), /* pcrel_offset */ 537 538 /* Used only by the dynamic linker. When the object is run, this 539 longword is set to the load address of the object, plus the 540 addend. */ 541 HOWTO (R_PPC_RELATIVE, /* type */ 542 0, /* rightshift */ 543 2, /* size (0 = byte, 1 = short, 2 = long) */ 544 32, /* bitsize */ 545 FALSE, /* pc_relative */ 546 0, /* bitpos */ 547 complain_overflow_dont, /* complain_on_overflow */ 548 bfd_elf_generic_reloc, /* special_function */ 549 "R_PPC_RELATIVE", /* name */ 550 FALSE, /* partial_inplace */ 551 0, /* src_mask */ 552 0xffffffff, /* dst_mask */ 553 FALSE), /* pcrel_offset */ 554 555 /* Like R_PPC_REL24, but uses the value of the symbol within the 556 object rather than the final value. Normally used for 557 _GLOBAL_OFFSET_TABLE_. */ 558 HOWTO (R_PPC_LOCAL24PC, /* type */ 559 0, /* rightshift */ 560 2, /* size (0 = byte, 1 = short, 2 = long) */ 561 26, /* bitsize */ 562 TRUE, /* pc_relative */ 563 0, /* bitpos */ 564 complain_overflow_signed, /* complain_on_overflow */ 565 bfd_elf_generic_reloc, /* special_function */ 566 "R_PPC_LOCAL24PC", /* name */ 567 FALSE, /* partial_inplace */ 568 0, /* src_mask */ 569 0x3fffffc, /* dst_mask */ 570 TRUE), /* pcrel_offset */ 571 572 /* Like R_PPC_ADDR32, but may be unaligned. */ 573 HOWTO (R_PPC_UADDR32, /* type */ 574 0, /* rightshift */ 575 2, /* size (0 = byte, 1 = short, 2 = long) */ 576 32, /* bitsize */ 577 FALSE, /* pc_relative */ 578 0, /* bitpos */ 579 complain_overflow_dont, /* complain_on_overflow */ 580 bfd_elf_generic_reloc, /* special_function */ 581 "R_PPC_UADDR32", /* name */ 582 FALSE, /* partial_inplace */ 583 0, /* src_mask */ 584 0xffffffff, /* dst_mask */ 585 FALSE), /* pcrel_offset */ 586 587 /* Like R_PPC_ADDR16, but may be unaligned. */ 588 HOWTO (R_PPC_UADDR16, /* type */ 589 0, /* rightshift */ 590 1, /* size (0 = byte, 1 = short, 2 = long) */ 591 16, /* bitsize */ 592 FALSE, /* pc_relative */ 593 0, /* bitpos */ 594 complain_overflow_bitfield, /* complain_on_overflow */ 595 bfd_elf_generic_reloc, /* special_function */ 596 "R_PPC_UADDR16", /* name */ 597 FALSE, /* partial_inplace */ 598 0, /* src_mask */ 599 0xffff, /* dst_mask */ 600 FALSE), /* pcrel_offset */ 601 602 /* 32-bit PC relative */ 603 HOWTO (R_PPC_REL32, /* type */ 604 0, /* rightshift */ 605 2, /* size (0 = byte, 1 = short, 2 = long) */ 606 32, /* bitsize */ 607 TRUE, /* pc_relative */ 608 0, /* bitpos */ 609 complain_overflow_dont, /* complain_on_overflow */ 610 bfd_elf_generic_reloc, /* special_function */ 611 "R_PPC_REL32", /* name */ 612 FALSE, /* partial_inplace */ 613 0, /* src_mask */ 614 0xffffffff, /* dst_mask */ 615 TRUE), /* pcrel_offset */ 616 617 /* 32-bit relocation to the symbol's procedure linkage table. 618 FIXME: not supported. */ 619 HOWTO (R_PPC_PLT32, /* type */ 620 0, /* rightshift */ 621 2, /* size (0 = byte, 1 = short, 2 = long) */ 622 32, /* bitsize */ 623 FALSE, /* pc_relative */ 624 0, /* bitpos */ 625 complain_overflow_dont, /* complain_on_overflow */ 626 bfd_elf_generic_reloc, /* special_function */ 627 "R_PPC_PLT32", /* name */ 628 FALSE, /* partial_inplace */ 629 0, /* src_mask */ 630 0, /* dst_mask */ 631 FALSE), /* pcrel_offset */ 632 633 /* 32-bit PC relative relocation to the symbol's procedure linkage table. 634 FIXME: not supported. */ 635 HOWTO (R_PPC_PLTREL32, /* type */ 636 0, /* rightshift */ 637 2, /* size (0 = byte, 1 = short, 2 = long) */ 638 32, /* bitsize */ 639 TRUE, /* pc_relative */ 640 0, /* bitpos */ 641 complain_overflow_dont, /* complain_on_overflow */ 642 bfd_elf_generic_reloc, /* special_function */ 643 "R_PPC_PLTREL32", /* name */ 644 FALSE, /* partial_inplace */ 645 0, /* src_mask */ 646 0, /* dst_mask */ 647 TRUE), /* pcrel_offset */ 648 649 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for 650 the symbol. */ 651 HOWTO (R_PPC_PLT16_LO, /* type */ 652 0, /* rightshift */ 653 1, /* size (0 = byte, 1 = short, 2 = long) */ 654 16, /* bitsize */ 655 FALSE, /* pc_relative */ 656 0, /* bitpos */ 657 complain_overflow_dont, /* complain_on_overflow */ 658 bfd_elf_generic_reloc, /* special_function */ 659 "R_PPC_PLT16_LO", /* name */ 660 FALSE, /* partial_inplace */ 661 0, /* src_mask */ 662 0xffff, /* dst_mask */ 663 FALSE), /* pcrel_offset */ 664 665 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for 666 the symbol. */ 667 HOWTO (R_PPC_PLT16_HI, /* type */ 668 16, /* rightshift */ 669 1, /* size (0 = byte, 1 = short, 2 = long) */ 670 16, /* bitsize */ 671 FALSE, /* pc_relative */ 672 0, /* bitpos */ 673 complain_overflow_dont, /* complain_on_overflow */ 674 bfd_elf_generic_reloc, /* special_function */ 675 "R_PPC_PLT16_HI", /* name */ 676 FALSE, /* partial_inplace */ 677 0, /* src_mask */ 678 0xffff, /* dst_mask */ 679 FALSE), /* pcrel_offset */ 680 681 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for 682 the symbol. */ 683 HOWTO (R_PPC_PLT16_HA, /* type */ 684 16, /* rightshift */ 685 1, /* size (0 = byte, 1 = short, 2 = long) */ 686 16, /* bitsize */ 687 FALSE, /* pc_relative */ 688 0, /* bitpos */ 689 complain_overflow_dont, /* complain_on_overflow */ 690 ppc_elf_addr16_ha_reloc, /* special_function */ 691 "R_PPC_PLT16_HA", /* name */ 692 FALSE, /* partial_inplace */ 693 0, /* src_mask */ 694 0xffff, /* dst_mask */ 695 FALSE), /* pcrel_offset */ 696 697 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with 698 small data items. */ 699 HOWTO (R_PPC_SDAREL16, /* type */ 700 0, /* rightshift */ 701 1, /* size (0 = byte, 1 = short, 2 = long) */ 702 16, /* bitsize */ 703 FALSE, /* pc_relative */ 704 0, /* bitpos */ 705 complain_overflow_signed, /* complain_on_overflow */ 706 bfd_elf_generic_reloc, /* special_function */ 707 "R_PPC_SDAREL16", /* name */ 708 FALSE, /* partial_inplace */ 709 0, /* src_mask */ 710 0xffff, /* dst_mask */ 711 FALSE), /* pcrel_offset */ 712 713 /* 16-bit section relative relocation. */ 714 HOWTO (R_PPC_SECTOFF, /* type */ 715 0, /* rightshift */ 716 1, /* size (0 = byte, 1 = short, 2 = long) */ 717 16, /* bitsize */ 718 FALSE, /* pc_relative */ 719 0, /* bitpos */ 720 complain_overflow_signed, /* complain_on_overflow */ 721 bfd_elf_generic_reloc, /* special_function */ 722 "R_PPC_SECTOFF", /* name */ 723 FALSE, /* partial_inplace */ 724 0, /* src_mask */ 725 0xffff, /* dst_mask */ 726 FALSE), /* pcrel_offset */ 727 728 /* 16-bit lower half section relative relocation. */ 729 HOWTO (R_PPC_SECTOFF_LO, /* type */ 730 0, /* rightshift */ 731 1, /* size (0 = byte, 1 = short, 2 = long) */ 732 16, /* bitsize */ 733 FALSE, /* pc_relative */ 734 0, /* bitpos */ 735 complain_overflow_dont, /* complain_on_overflow */ 736 bfd_elf_generic_reloc, /* special_function */ 737 "R_PPC_SECTOFF_LO", /* name */ 738 FALSE, /* partial_inplace */ 739 0, /* src_mask */ 740 0xffff, /* dst_mask */ 741 FALSE), /* pcrel_offset */ 742 743 /* 16-bit upper half section relative relocation. */ 744 HOWTO (R_PPC_SECTOFF_HI, /* type */ 745 16, /* rightshift */ 746 1, /* size (0 = byte, 1 = short, 2 = long) */ 747 16, /* bitsize */ 748 FALSE, /* pc_relative */ 749 0, /* bitpos */ 750 complain_overflow_dont, /* complain_on_overflow */ 751 bfd_elf_generic_reloc, /* special_function */ 752 "R_PPC_SECTOFF_HI", /* name */ 753 FALSE, /* partial_inplace */ 754 0, /* src_mask */ 755 0xffff, /* dst_mask */ 756 FALSE), /* pcrel_offset */ 757 758 /* 16-bit upper half adjusted section relative relocation. */ 759 HOWTO (R_PPC_SECTOFF_HA, /* type */ 760 16, /* rightshift */ 761 1, /* size (0 = byte, 1 = short, 2 = long) */ 762 16, /* bitsize */ 763 FALSE, /* pc_relative */ 764 0, /* bitpos */ 765 complain_overflow_dont, /* complain_on_overflow */ 766 ppc_elf_addr16_ha_reloc, /* special_function */ 767 "R_PPC_SECTOFF_HA", /* name */ 768 FALSE, /* partial_inplace */ 769 0, /* src_mask */ 770 0xffff, /* dst_mask */ 771 FALSE), /* pcrel_offset */ 772 773 /* Marker relocs for TLS. */ 774 HOWTO (R_PPC_TLS, 775 0, /* rightshift */ 776 2, /* size (0 = byte, 1 = short, 2 = long) */ 777 32, /* bitsize */ 778 FALSE, /* pc_relative */ 779 0, /* bitpos */ 780 complain_overflow_dont, /* complain_on_overflow */ 781 bfd_elf_generic_reloc, /* special_function */ 782 "R_PPC_TLS", /* name */ 783 FALSE, /* partial_inplace */ 784 0, /* src_mask */ 785 0, /* dst_mask */ 786 FALSE), /* pcrel_offset */ 787 788 HOWTO (R_PPC_TLSGD, 789 0, /* rightshift */ 790 2, /* size (0 = byte, 1 = short, 2 = long) */ 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_PPC_TLSGD", /* name */ 797 FALSE, /* partial_inplace */ 798 0, /* src_mask */ 799 0, /* dst_mask */ 800 FALSE), /* pcrel_offset */ 801 802 HOWTO (R_PPC_TLSLD, 803 0, /* rightshift */ 804 2, /* size (0 = byte, 1 = short, 2 = long) */ 805 32, /* bitsize */ 806 FALSE, /* pc_relative */ 807 0, /* bitpos */ 808 complain_overflow_dont, /* complain_on_overflow */ 809 bfd_elf_generic_reloc, /* special_function */ 810 "R_PPC_TLSLD", /* name */ 811 FALSE, /* partial_inplace */ 812 0, /* src_mask */ 813 0, /* dst_mask */ 814 FALSE), /* pcrel_offset */ 815 816 /* Computes the load module index of the load module that contains the 817 definition of its TLS sym. */ 818 HOWTO (R_PPC_DTPMOD32, 819 0, /* rightshift */ 820 2, /* size (0 = byte, 1 = short, 2 = long) */ 821 32, /* bitsize */ 822 FALSE, /* pc_relative */ 823 0, /* bitpos */ 824 complain_overflow_dont, /* complain_on_overflow */ 825 ppc_elf_unhandled_reloc, /* special_function */ 826 "R_PPC_DTPMOD32", /* name */ 827 FALSE, /* partial_inplace */ 828 0, /* src_mask */ 829 0xffffffff, /* dst_mask */ 830 FALSE), /* pcrel_offset */ 831 832 /* Computes a dtv-relative displacement, the difference between the value 833 of sym+add and the base address of the thread-local storage block that 834 contains the definition of sym, minus 0x8000. */ 835 HOWTO (R_PPC_DTPREL32, 836 0, /* rightshift */ 837 2, /* size (0 = byte, 1 = short, 2 = long) */ 838 32, /* bitsize */ 839 FALSE, /* pc_relative */ 840 0, /* bitpos */ 841 complain_overflow_dont, /* complain_on_overflow */ 842 ppc_elf_unhandled_reloc, /* special_function */ 843 "R_PPC_DTPREL32", /* name */ 844 FALSE, /* partial_inplace */ 845 0, /* src_mask */ 846 0xffffffff, /* dst_mask */ 847 FALSE), /* pcrel_offset */ 848 849 /* A 16 bit dtprel reloc. */ 850 HOWTO (R_PPC_DTPREL16, 851 0, /* rightshift */ 852 1, /* size (0 = byte, 1 = short, 2 = long) */ 853 16, /* bitsize */ 854 FALSE, /* pc_relative */ 855 0, /* bitpos */ 856 complain_overflow_signed, /* complain_on_overflow */ 857 ppc_elf_unhandled_reloc, /* special_function */ 858 "R_PPC_DTPREL16", /* name */ 859 FALSE, /* partial_inplace */ 860 0, /* src_mask */ 861 0xffff, /* dst_mask */ 862 FALSE), /* pcrel_offset */ 863 864 /* Like DTPREL16, but no overflow. */ 865 HOWTO (R_PPC_DTPREL16_LO, 866 0, /* rightshift */ 867 1, /* size (0 = byte, 1 = short, 2 = long) */ 868 16, /* bitsize */ 869 FALSE, /* pc_relative */ 870 0, /* bitpos */ 871 complain_overflow_dont, /* complain_on_overflow */ 872 ppc_elf_unhandled_reloc, /* special_function */ 873 "R_PPC_DTPREL16_LO", /* name */ 874 FALSE, /* partial_inplace */ 875 0, /* src_mask */ 876 0xffff, /* dst_mask */ 877 FALSE), /* pcrel_offset */ 878 879 /* Like DTPREL16_LO, but next higher group of 16 bits. */ 880 HOWTO (R_PPC_DTPREL16_HI, 881 16, /* rightshift */ 882 1, /* size (0 = byte, 1 = short, 2 = long) */ 883 16, /* bitsize */ 884 FALSE, /* pc_relative */ 885 0, /* bitpos */ 886 complain_overflow_dont, /* complain_on_overflow */ 887 ppc_elf_unhandled_reloc, /* special_function */ 888 "R_PPC_DTPREL16_HI", /* name */ 889 FALSE, /* partial_inplace */ 890 0, /* src_mask */ 891 0xffff, /* dst_mask */ 892 FALSE), /* pcrel_offset */ 893 894 /* Like DTPREL16_HI, but adjust for low 16 bits. */ 895 HOWTO (R_PPC_DTPREL16_HA, 896 16, /* rightshift */ 897 1, /* size (0 = byte, 1 = short, 2 = long) */ 898 16, /* bitsize */ 899 FALSE, /* pc_relative */ 900 0, /* bitpos */ 901 complain_overflow_dont, /* complain_on_overflow */ 902 ppc_elf_unhandled_reloc, /* special_function */ 903 "R_PPC_DTPREL16_HA", /* name */ 904 FALSE, /* partial_inplace */ 905 0, /* src_mask */ 906 0xffff, /* dst_mask */ 907 FALSE), /* pcrel_offset */ 908 909 /* Computes a tp-relative displacement, the difference between the value of 910 sym+add and the value of the thread pointer (r13). */ 911 HOWTO (R_PPC_TPREL32, 912 0, /* rightshift */ 913 2, /* size (0 = byte, 1 = short, 2 = long) */ 914 32, /* bitsize */ 915 FALSE, /* pc_relative */ 916 0, /* bitpos */ 917 complain_overflow_dont, /* complain_on_overflow */ 918 ppc_elf_unhandled_reloc, /* special_function */ 919 "R_PPC_TPREL32", /* name */ 920 FALSE, /* partial_inplace */ 921 0, /* src_mask */ 922 0xffffffff, /* dst_mask */ 923 FALSE), /* pcrel_offset */ 924 925 /* A 16 bit tprel reloc. */ 926 HOWTO (R_PPC_TPREL16, 927 0, /* rightshift */ 928 1, /* size (0 = byte, 1 = short, 2 = long) */ 929 16, /* bitsize */ 930 FALSE, /* pc_relative */ 931 0, /* bitpos */ 932 complain_overflow_signed, /* complain_on_overflow */ 933 ppc_elf_unhandled_reloc, /* special_function */ 934 "R_PPC_TPREL16", /* name */ 935 FALSE, /* partial_inplace */ 936 0, /* src_mask */ 937 0xffff, /* dst_mask */ 938 FALSE), /* pcrel_offset */ 939 940 /* Like TPREL16, but no overflow. */ 941 HOWTO (R_PPC_TPREL16_LO, 942 0, /* rightshift */ 943 1, /* size (0 = byte, 1 = short, 2 = long) */ 944 16, /* bitsize */ 945 FALSE, /* pc_relative */ 946 0, /* bitpos */ 947 complain_overflow_dont, /* complain_on_overflow */ 948 ppc_elf_unhandled_reloc, /* special_function */ 949 "R_PPC_TPREL16_LO", /* name */ 950 FALSE, /* partial_inplace */ 951 0, /* src_mask */ 952 0xffff, /* dst_mask */ 953 FALSE), /* pcrel_offset */ 954 955 /* Like TPREL16_LO, but next higher group of 16 bits. */ 956 HOWTO (R_PPC_TPREL16_HI, 957 16, /* rightshift */ 958 1, /* size (0 = byte, 1 = short, 2 = long) */ 959 16, /* bitsize */ 960 FALSE, /* pc_relative */ 961 0, /* bitpos */ 962 complain_overflow_dont, /* complain_on_overflow */ 963 ppc_elf_unhandled_reloc, /* special_function */ 964 "R_PPC_TPREL16_HI", /* name */ 965 FALSE, /* partial_inplace */ 966 0, /* src_mask */ 967 0xffff, /* dst_mask */ 968 FALSE), /* pcrel_offset */ 969 970 /* Like TPREL16_HI, but adjust for low 16 bits. */ 971 HOWTO (R_PPC_TPREL16_HA, 972 16, /* rightshift */ 973 1, /* size (0 = byte, 1 = short, 2 = long) */ 974 16, /* bitsize */ 975 FALSE, /* pc_relative */ 976 0, /* bitpos */ 977 complain_overflow_dont, /* complain_on_overflow */ 978 ppc_elf_unhandled_reloc, /* special_function */ 979 "R_PPC_TPREL16_HA", /* name */ 980 FALSE, /* partial_inplace */ 981 0, /* src_mask */ 982 0xffff, /* dst_mask */ 983 FALSE), /* pcrel_offset */ 984 985 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 986 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset 987 to the first entry. */ 988 HOWTO (R_PPC_GOT_TLSGD16, 989 0, /* rightshift */ 990 1, /* size (0 = byte, 1 = short, 2 = long) */ 991 16, /* bitsize */ 992 FALSE, /* pc_relative */ 993 0, /* bitpos */ 994 complain_overflow_signed, /* complain_on_overflow */ 995 ppc_elf_unhandled_reloc, /* special_function */ 996 "R_PPC_GOT_TLSGD16", /* name */ 997 FALSE, /* partial_inplace */ 998 0, /* src_mask */ 999 0xffff, /* dst_mask */ 1000 FALSE), /* pcrel_offset */ 1001 1002 /* Like GOT_TLSGD16, but no overflow. */ 1003 HOWTO (R_PPC_GOT_TLSGD16_LO, 1004 0, /* rightshift */ 1005 1, /* size (0 = byte, 1 = short, 2 = long) */ 1006 16, /* bitsize */ 1007 FALSE, /* pc_relative */ 1008 0, /* bitpos */ 1009 complain_overflow_dont, /* complain_on_overflow */ 1010 ppc_elf_unhandled_reloc, /* special_function */ 1011 "R_PPC_GOT_TLSGD16_LO", /* name */ 1012 FALSE, /* partial_inplace */ 1013 0, /* src_mask */ 1014 0xffff, /* dst_mask */ 1015 FALSE), /* pcrel_offset */ 1016 1017 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */ 1018 HOWTO (R_PPC_GOT_TLSGD16_HI, 1019 16, /* rightshift */ 1020 1, /* size (0 = byte, 1 = short, 2 = long) */ 1021 16, /* bitsize */ 1022 FALSE, /* pc_relative */ 1023 0, /* bitpos */ 1024 complain_overflow_dont, /* complain_on_overflow */ 1025 ppc_elf_unhandled_reloc, /* special_function */ 1026 "R_PPC_GOT_TLSGD16_HI", /* name */ 1027 FALSE, /* partial_inplace */ 1028 0, /* src_mask */ 1029 0xffff, /* dst_mask */ 1030 FALSE), /* pcrel_offset */ 1031 1032 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */ 1033 HOWTO (R_PPC_GOT_TLSGD16_HA, 1034 16, /* rightshift */ 1035 1, /* size (0 = byte, 1 = short, 2 = long) */ 1036 16, /* bitsize */ 1037 FALSE, /* pc_relative */ 1038 0, /* bitpos */ 1039 complain_overflow_dont, /* complain_on_overflow */ 1040 ppc_elf_unhandled_reloc, /* special_function */ 1041 "R_PPC_GOT_TLSGD16_HA", /* name */ 1042 FALSE, /* partial_inplace */ 1043 0, /* src_mask */ 1044 0xffff, /* dst_mask */ 1045 FALSE), /* pcrel_offset */ 1046 1047 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 1048 with values (sym+add)@dtpmod and zero, and computes the offset to the 1049 first entry. */ 1050 HOWTO (R_PPC_GOT_TLSLD16, 1051 0, /* rightshift */ 1052 1, /* size (0 = byte, 1 = short, 2 = long) */ 1053 16, /* bitsize */ 1054 FALSE, /* pc_relative */ 1055 0, /* bitpos */ 1056 complain_overflow_signed, /* complain_on_overflow */ 1057 ppc_elf_unhandled_reloc, /* special_function */ 1058 "R_PPC_GOT_TLSLD16", /* name */ 1059 FALSE, /* partial_inplace */ 1060 0, /* src_mask */ 1061 0xffff, /* dst_mask */ 1062 FALSE), /* pcrel_offset */ 1063 1064 /* Like GOT_TLSLD16, but no overflow. */ 1065 HOWTO (R_PPC_GOT_TLSLD16_LO, 1066 0, /* rightshift */ 1067 1, /* size (0 = byte, 1 = short, 2 = long) */ 1068 16, /* bitsize */ 1069 FALSE, /* pc_relative */ 1070 0, /* bitpos */ 1071 complain_overflow_dont, /* complain_on_overflow */ 1072 ppc_elf_unhandled_reloc, /* special_function */ 1073 "R_PPC_GOT_TLSLD16_LO", /* name */ 1074 FALSE, /* partial_inplace */ 1075 0, /* src_mask */ 1076 0xffff, /* dst_mask */ 1077 FALSE), /* pcrel_offset */ 1078 1079 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */ 1080 HOWTO (R_PPC_GOT_TLSLD16_HI, 1081 16, /* rightshift */ 1082 1, /* size (0 = byte, 1 = short, 2 = long) */ 1083 16, /* bitsize */ 1084 FALSE, /* pc_relative */ 1085 0, /* bitpos */ 1086 complain_overflow_dont, /* complain_on_overflow */ 1087 ppc_elf_unhandled_reloc, /* special_function */ 1088 "R_PPC_GOT_TLSLD16_HI", /* name */ 1089 FALSE, /* partial_inplace */ 1090 0, /* src_mask */ 1091 0xffff, /* dst_mask */ 1092 FALSE), /* pcrel_offset */ 1093 1094 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */ 1095 HOWTO (R_PPC_GOT_TLSLD16_HA, 1096 16, /* rightshift */ 1097 1, /* size (0 = byte, 1 = short, 2 = long) */ 1098 16, /* bitsize */ 1099 FALSE, /* pc_relative */ 1100 0, /* bitpos */ 1101 complain_overflow_dont, /* complain_on_overflow */ 1102 ppc_elf_unhandled_reloc, /* special_function */ 1103 "R_PPC_GOT_TLSLD16_HA", /* name */ 1104 FALSE, /* partial_inplace */ 1105 0, /* src_mask */ 1106 0xffff, /* dst_mask */ 1107 FALSE), /* pcrel_offset */ 1108 1109 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes 1110 the offset to the entry. */ 1111 HOWTO (R_PPC_GOT_DTPREL16, 1112 0, /* rightshift */ 1113 1, /* size (0 = byte, 1 = short, 2 = long) */ 1114 16, /* bitsize */ 1115 FALSE, /* pc_relative */ 1116 0, /* bitpos */ 1117 complain_overflow_signed, /* complain_on_overflow */ 1118 ppc_elf_unhandled_reloc, /* special_function */ 1119 "R_PPC_GOT_DTPREL16", /* name */ 1120 FALSE, /* partial_inplace */ 1121 0, /* src_mask */ 1122 0xffff, /* dst_mask */ 1123 FALSE), /* pcrel_offset */ 1124 1125 /* Like GOT_DTPREL16, but no overflow. */ 1126 HOWTO (R_PPC_GOT_DTPREL16_LO, 1127 0, /* rightshift */ 1128 1, /* size (0 = byte, 1 = short, 2 = long) */ 1129 16, /* bitsize */ 1130 FALSE, /* pc_relative */ 1131 0, /* bitpos */ 1132 complain_overflow_dont, /* complain_on_overflow */ 1133 ppc_elf_unhandled_reloc, /* special_function */ 1134 "R_PPC_GOT_DTPREL16_LO", /* name */ 1135 FALSE, /* partial_inplace */ 1136 0, /* src_mask */ 1137 0xffff, /* dst_mask */ 1138 FALSE), /* pcrel_offset */ 1139 1140 /* Like GOT_DTPREL16_LO, but next higher group of 16 bits. */ 1141 HOWTO (R_PPC_GOT_DTPREL16_HI, 1142 16, /* rightshift */ 1143 1, /* size (0 = byte, 1 = short, 2 = long) */ 1144 16, /* bitsize */ 1145 FALSE, /* pc_relative */ 1146 0, /* bitpos */ 1147 complain_overflow_dont, /* complain_on_overflow */ 1148 ppc_elf_unhandled_reloc, /* special_function */ 1149 "R_PPC_GOT_DTPREL16_HI", /* name */ 1150 FALSE, /* partial_inplace */ 1151 0, /* src_mask */ 1152 0xffff, /* dst_mask */ 1153 FALSE), /* pcrel_offset */ 1154 1155 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */ 1156 HOWTO (R_PPC_GOT_DTPREL16_HA, 1157 16, /* rightshift */ 1158 1, /* size (0 = byte, 1 = short, 2 = long) */ 1159 16, /* bitsize */ 1160 FALSE, /* pc_relative */ 1161 0, /* bitpos */ 1162 complain_overflow_dont, /* complain_on_overflow */ 1163 ppc_elf_unhandled_reloc, /* special_function */ 1164 "R_PPC_GOT_DTPREL16_HA", /* name */ 1165 FALSE, /* partial_inplace */ 1166 0, /* src_mask */ 1167 0xffff, /* dst_mask */ 1168 FALSE), /* pcrel_offset */ 1169 1170 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the 1171 offset to the entry. */ 1172 HOWTO (R_PPC_GOT_TPREL16, 1173 0, /* rightshift */ 1174 1, /* size (0 = byte, 1 = short, 2 = long) */ 1175 16, /* bitsize */ 1176 FALSE, /* pc_relative */ 1177 0, /* bitpos */ 1178 complain_overflow_signed, /* complain_on_overflow */ 1179 ppc_elf_unhandled_reloc, /* special_function */ 1180 "R_PPC_GOT_TPREL16", /* name */ 1181 FALSE, /* partial_inplace */ 1182 0, /* src_mask */ 1183 0xffff, /* dst_mask */ 1184 FALSE), /* pcrel_offset */ 1185 1186 /* Like GOT_TPREL16, but no overflow. */ 1187 HOWTO (R_PPC_GOT_TPREL16_LO, 1188 0, /* rightshift */ 1189 1, /* size (0 = byte, 1 = short, 2 = long) */ 1190 16, /* bitsize */ 1191 FALSE, /* pc_relative */ 1192 0, /* bitpos */ 1193 complain_overflow_dont, /* complain_on_overflow */ 1194 ppc_elf_unhandled_reloc, /* special_function */ 1195 "R_PPC_GOT_TPREL16_LO", /* name */ 1196 FALSE, /* partial_inplace */ 1197 0, /* src_mask */ 1198 0xffff, /* dst_mask */ 1199 FALSE), /* pcrel_offset */ 1200 1201 /* Like GOT_TPREL16_LO, but next higher group of 16 bits. */ 1202 HOWTO (R_PPC_GOT_TPREL16_HI, 1203 16, /* rightshift */ 1204 1, /* size (0 = byte, 1 = short, 2 = long) */ 1205 16, /* bitsize */ 1206 FALSE, /* pc_relative */ 1207 0, /* bitpos */ 1208 complain_overflow_dont, /* complain_on_overflow */ 1209 ppc_elf_unhandled_reloc, /* special_function */ 1210 "R_PPC_GOT_TPREL16_HI", /* name */ 1211 FALSE, /* partial_inplace */ 1212 0, /* src_mask */ 1213 0xffff, /* dst_mask */ 1214 FALSE), /* pcrel_offset */ 1215 1216 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */ 1217 HOWTO (R_PPC_GOT_TPREL16_HA, 1218 16, /* rightshift */ 1219 1, /* size (0 = byte, 1 = short, 2 = long) */ 1220 16, /* bitsize */ 1221 FALSE, /* pc_relative */ 1222 0, /* bitpos */ 1223 complain_overflow_dont, /* complain_on_overflow */ 1224 ppc_elf_unhandled_reloc, /* special_function */ 1225 "R_PPC_GOT_TPREL16_HA", /* name */ 1226 FALSE, /* partial_inplace */ 1227 0, /* src_mask */ 1228 0xffff, /* dst_mask */ 1229 FALSE), /* pcrel_offset */ 1230 1231 /* The remaining relocs are from the Embedded ELF ABI, and are not 1232 in the SVR4 ELF ABI. */ 1233 1234 /* 32 bit value resulting from the addend minus the symbol. */ 1235 HOWTO (R_PPC_EMB_NADDR32, /* type */ 1236 0, /* rightshift */ 1237 2, /* size (0 = byte, 1 = short, 2 = long) */ 1238 32, /* bitsize */ 1239 FALSE, /* pc_relative */ 1240 0, /* bitpos */ 1241 complain_overflow_dont, /* complain_on_overflow */ 1242 bfd_elf_generic_reloc, /* special_function */ 1243 "R_PPC_EMB_NADDR32", /* name */ 1244 FALSE, /* partial_inplace */ 1245 0, /* src_mask */ 1246 0xffffffff, /* dst_mask */ 1247 FALSE), /* pcrel_offset */ 1248 1249 /* 16 bit value resulting from the addend minus the symbol. */ 1250 HOWTO (R_PPC_EMB_NADDR16, /* type */ 1251 0, /* rightshift */ 1252 1, /* size (0 = byte, 1 = short, 2 = long) */ 1253 16, /* bitsize */ 1254 FALSE, /* pc_relative */ 1255 0, /* bitpos */ 1256 complain_overflow_signed, /* complain_on_overflow */ 1257 bfd_elf_generic_reloc, /* special_function */ 1258 "R_PPC_EMB_NADDR16", /* name */ 1259 FALSE, /* partial_inplace */ 1260 0, /* src_mask */ 1261 0xffff, /* dst_mask */ 1262 FALSE), /* pcrel_offset */ 1263 1264 /* 16 bit value resulting from the addend minus the symbol. */ 1265 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */ 1266 0, /* rightshift */ 1267 1, /* size (0 = byte, 1 = short, 2 = long) */ 1268 16, /* bitsize */ 1269 FALSE, /* pc_relative */ 1270 0, /* bitpos */ 1271 complain_overflow_dont,/* complain_on_overflow */ 1272 bfd_elf_generic_reloc, /* special_function */ 1273 "R_PPC_EMB_ADDR16_LO", /* name */ 1274 FALSE, /* partial_inplace */ 1275 0, /* src_mask */ 1276 0xffff, /* dst_mask */ 1277 FALSE), /* pcrel_offset */ 1278 1279 /* The high order 16 bits of the addend minus the symbol. */ 1280 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */ 1281 16, /* rightshift */ 1282 1, /* size (0 = byte, 1 = short, 2 = long) */ 1283 16, /* bitsize */ 1284 FALSE, /* pc_relative */ 1285 0, /* bitpos */ 1286 complain_overflow_dont, /* complain_on_overflow */ 1287 bfd_elf_generic_reloc, /* special_function */ 1288 "R_PPC_EMB_NADDR16_HI", /* name */ 1289 FALSE, /* partial_inplace */ 1290 0, /* src_mask */ 1291 0xffff, /* dst_mask */ 1292 FALSE), /* pcrel_offset */ 1293 1294 /* The high order 16 bits of the result of the addend minus the address, 1295 plus 1 if the contents of the low 16 bits, treated as a signed number, 1296 is negative. */ 1297 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */ 1298 16, /* rightshift */ 1299 1, /* size (0 = byte, 1 = short, 2 = long) */ 1300 16, /* bitsize */ 1301 FALSE, /* pc_relative */ 1302 0, /* bitpos */ 1303 complain_overflow_dont, /* complain_on_overflow */ 1304 ppc_elf_addr16_ha_reloc, /* special_function */ 1305 "R_PPC_EMB_NADDR16_HA", /* name */ 1306 FALSE, /* partial_inplace */ 1307 0, /* src_mask */ 1308 0xffff, /* dst_mask */ 1309 FALSE), /* pcrel_offset */ 1310 1311 /* 16 bit value resulting from allocating a 4 byte word to hold an 1312 address in the .sdata section, and returning the offset from 1313 _SDA_BASE_ for that relocation. */ 1314 HOWTO (R_PPC_EMB_SDAI16, /* type */ 1315 0, /* rightshift */ 1316 1, /* size (0 = byte, 1 = short, 2 = long) */ 1317 16, /* bitsize */ 1318 FALSE, /* pc_relative */ 1319 0, /* bitpos */ 1320 complain_overflow_signed, /* complain_on_overflow */ 1321 bfd_elf_generic_reloc, /* special_function */ 1322 "R_PPC_EMB_SDAI16", /* name */ 1323 FALSE, /* partial_inplace */ 1324 0, /* src_mask */ 1325 0xffff, /* dst_mask */ 1326 FALSE), /* pcrel_offset */ 1327 1328 /* 16 bit value resulting from allocating a 4 byte word to hold an 1329 address in the .sdata2 section, and returning the offset from 1330 _SDA2_BASE_ for that relocation. */ 1331 HOWTO (R_PPC_EMB_SDA2I16, /* type */ 1332 0, /* rightshift */ 1333 1, /* size (0 = byte, 1 = short, 2 = long) */ 1334 16, /* bitsize */ 1335 FALSE, /* pc_relative */ 1336 0, /* bitpos */ 1337 complain_overflow_signed, /* complain_on_overflow */ 1338 bfd_elf_generic_reloc, /* special_function */ 1339 "R_PPC_EMB_SDA2I16", /* name */ 1340 FALSE, /* partial_inplace */ 1341 0, /* src_mask */ 1342 0xffff, /* dst_mask */ 1343 FALSE), /* pcrel_offset */ 1344 1345 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with 1346 small data items. */ 1347 HOWTO (R_PPC_EMB_SDA2REL, /* type */ 1348 0, /* rightshift */ 1349 1, /* size (0 = byte, 1 = short, 2 = long) */ 1350 16, /* bitsize */ 1351 FALSE, /* pc_relative */ 1352 0, /* bitpos */ 1353 complain_overflow_signed, /* complain_on_overflow */ 1354 bfd_elf_generic_reloc, /* special_function */ 1355 "R_PPC_EMB_SDA2REL", /* name */ 1356 FALSE, /* partial_inplace */ 1357 0, /* src_mask */ 1358 0xffff, /* dst_mask */ 1359 FALSE), /* pcrel_offset */ 1360 1361 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit 1362 signed offset from the appropriate base, and filling in the register 1363 field with the appropriate register (0, 2, or 13). */ 1364 HOWTO (R_PPC_EMB_SDA21, /* type */ 1365 0, /* rightshift */ 1366 2, /* size (0 = byte, 1 = short, 2 = long) */ 1367 16, /* bitsize */ 1368 FALSE, /* pc_relative */ 1369 0, /* bitpos */ 1370 complain_overflow_signed, /* complain_on_overflow */ 1371 bfd_elf_generic_reloc, /* special_function */ 1372 "R_PPC_EMB_SDA21", /* name */ 1373 FALSE, /* partial_inplace */ 1374 0, /* src_mask */ 1375 0xffff, /* dst_mask */ 1376 FALSE), /* pcrel_offset */ 1377 1378 /* Relocation not handled: R_PPC_EMB_MRKREF */ 1379 /* Relocation not handled: R_PPC_EMB_RELSEC16 */ 1380 /* Relocation not handled: R_PPC_EMB_RELST_LO */ 1381 /* Relocation not handled: R_PPC_EMB_RELST_HI */ 1382 /* Relocation not handled: R_PPC_EMB_RELST_HA */ 1383 /* Relocation not handled: R_PPC_EMB_BIT_FLD */ 1384 1385 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling 1386 in the 16 bit signed offset from the appropriate base, and filling in the 1387 register field with the appropriate register (0, 2, or 13). */ 1388 HOWTO (R_PPC_EMB_RELSDA, /* type */ 1389 0, /* rightshift */ 1390 1, /* size (0 = byte, 1 = short, 2 = long) */ 1391 16, /* bitsize */ 1392 FALSE, /* pc_relative */ 1393 0, /* bitpos */ 1394 complain_overflow_signed, /* complain_on_overflow */ 1395 bfd_elf_generic_reloc, /* special_function */ 1396 "R_PPC_EMB_RELSDA", /* name */ 1397 FALSE, /* partial_inplace */ 1398 0, /* src_mask */ 1399 0xffff, /* dst_mask */ 1400 FALSE), /* pcrel_offset */ 1401 1402 /* A relative 8 bit branch. */ 1403 HOWTO (R_PPC_VLE_REL8, /* type */ 1404 1, /* rightshift */ 1405 1, /* size (0 = byte, 1 = short, 2 = long) */ 1406 8, /* bitsize */ 1407 TRUE, /* pc_relative */ 1408 0, /* bitpos */ 1409 complain_overflow_signed, /* complain_on_overflow */ 1410 bfd_elf_generic_reloc, /* special_function */ 1411 "R_PPC_VLE_REL8", /* name */ 1412 FALSE, /* partial_inplace */ 1413 0, /* src_mask */ 1414 0xff, /* dst_mask */ 1415 TRUE), /* pcrel_offset */ 1416 1417 /* A relative 15 bit branch. */ 1418 HOWTO (R_PPC_VLE_REL15, /* type */ 1419 1, /* rightshift */ 1420 2, /* size (0 = byte, 1 = short, 2 = long) */ 1421 15, /* bitsize */ 1422 TRUE, /* pc_relative */ 1423 1, /* bitpos */ 1424 complain_overflow_signed, /* complain_on_overflow */ 1425 bfd_elf_generic_reloc, /* special_function */ 1426 "R_PPC_VLE_REL15", /* name */ 1427 FALSE, /* partial_inplace */ 1428 0, /* src_mask */ 1429 0xfe, /* dst_mask */ 1430 TRUE), /* pcrel_offset */ 1431 1432 /* A relative 24 bit branch. */ 1433 HOWTO (R_PPC_VLE_REL24, /* type */ 1434 1, /* rightshift */ 1435 2, /* size (0 = byte, 1 = short, 2 = long) */ 1436 24, /* bitsize */ 1437 TRUE, /* pc_relative */ 1438 1, /* bitpos */ 1439 complain_overflow_signed, /* complain_on_overflow */ 1440 bfd_elf_generic_reloc, /* special_function */ 1441 "R_PPC_VLE_REL24", /* name */ 1442 FALSE, /* partial_inplace */ 1443 0, /* src_mask */ 1444 0x1fffffe, /* dst_mask */ 1445 TRUE), /* pcrel_offset */ 1446 1447 /* The 16 LSBS in split16a format. */ 1448 HOWTO (R_PPC_VLE_LO16A, /* type */ 1449 0, /* rightshift */ 1450 2, /* size (0 = byte, 1 = short, 2 = long) */ 1451 16, /* bitsize */ 1452 FALSE, /* pc_relative */ 1453 0, /* bitpos */ 1454 complain_overflow_dont, /* complain_on_overflow */ 1455 bfd_elf_generic_reloc, /* special_function */ 1456 "R_PPC_VLE_LO16A", /* name */ 1457 FALSE, /* partial_inplace */ 1458 0, /* src_mask */ 1459 0x1f007ff, /* dst_mask */ 1460 FALSE), /* pcrel_offset */ 1461 1462 /* The 16 LSBS in split16d format. */ 1463 HOWTO (R_PPC_VLE_LO16D, /* type */ 1464 0, /* rightshift */ 1465 2, /* size (0 = byte, 1 = short, 2 = long) */ 1466 16, /* bitsize */ 1467 FALSE, /* pc_relative */ 1468 0, /* bitpos */ 1469 complain_overflow_dont, /* complain_on_overflow */ 1470 bfd_elf_generic_reloc, /* special_function */ 1471 "R_PPC_VLE_LO16D", /* name */ 1472 FALSE, /* partial_inplace */ 1473 0, /* src_mask */ 1474 0x1f07ff, /* dst_mask */ 1475 FALSE), /* pcrel_offset */ 1476 1477 /* Bits 16-31 split16a format. */ 1478 HOWTO (R_PPC_VLE_HI16A, /* type */ 1479 16, /* rightshift */ 1480 2, /* size (0 = byte, 1 = short, 2 = long) */ 1481 16, /* bitsize */ 1482 FALSE, /* pc_relative */ 1483 0, /* bitpos */ 1484 complain_overflow_dont, /* complain_on_overflow */ 1485 bfd_elf_generic_reloc, /* special_function */ 1486 "R_PPC_VLE_HI16A", /* name */ 1487 FALSE, /* partial_inplace */ 1488 0, /* src_mask */ 1489 0x1f007ff, /* dst_mask */ 1490 FALSE), /* pcrel_offset */ 1491 1492 /* Bits 16-31 split16d format. */ 1493 HOWTO (R_PPC_VLE_HI16D, /* type */ 1494 16, /* rightshift */ 1495 2, /* size (0 = byte, 1 = short, 2 = long) */ 1496 16, /* bitsize */ 1497 FALSE, /* pc_relative */ 1498 0, /* bitpos */ 1499 complain_overflow_dont, /* complain_on_overflow */ 1500 bfd_elf_generic_reloc, /* special_function */ 1501 "R_PPC_VLE_HI16D", /* name */ 1502 FALSE, /* partial_inplace */ 1503 0, /* src_mask */ 1504 0x1f07ff, /* dst_mask */ 1505 FALSE), /* pcrel_offset */ 1506 1507 /* Bits 16-31 (High Adjusted) in split16a format. */ 1508 HOWTO (R_PPC_VLE_HA16A, /* type */ 1509 16, /* rightshift */ 1510 2, /* size (0 = byte, 1 = short, 2 = long) */ 1511 16, /* bitsize */ 1512 FALSE, /* pc_relative */ 1513 0, /* bitpos */ 1514 complain_overflow_dont, /* complain_on_overflow */ 1515 bfd_elf_generic_reloc, /* special_function */ 1516 "R_PPC_VLE_HA16A", /* name */ 1517 FALSE, /* partial_inplace */ 1518 0, /* src_mask */ 1519 0x1f007ff, /* dst_mask */ 1520 FALSE), /* pcrel_offset */ 1521 1522 /* Bits 16-31 (High Adjusted) in split16d format. */ 1523 HOWTO (R_PPC_VLE_HA16D, /* type */ 1524 16, /* rightshift */ 1525 2, /* size (0 = byte, 1 = short, 2 = long) */ 1526 16, /* bitsize */ 1527 FALSE, /* pc_relative */ 1528 0, /* bitpos */ 1529 complain_overflow_dont, /* complain_on_overflow */ 1530 bfd_elf_generic_reloc, /* special_function */ 1531 "R_PPC_VLE_HA16D", /* name */ 1532 FALSE, /* partial_inplace */ 1533 0, /* src_mask */ 1534 0x1f07ff, /* dst_mask */ 1535 FALSE), /* pcrel_offset */ 1536 1537 /* This reloc is like R_PPC_EMB_SDA21 but only applies to e_add16i 1538 instructions. If the register base is 0 then the linker changes 1539 the e_add16i to an e_li instruction. */ 1540 HOWTO (R_PPC_VLE_SDA21, /* type */ 1541 0, /* rightshift */ 1542 2, /* size (0 = byte, 1 = short, 2 = long) */ 1543 16, /* bitsize */ 1544 FALSE, /* pc_relative */ 1545 0, /* bitpos */ 1546 complain_overflow_signed, /* complain_on_overflow */ 1547 bfd_elf_generic_reloc, /* special_function */ 1548 "R_PPC_VLE_SDA21", /* name */ 1549 FALSE, /* partial_inplace */ 1550 0, /* src_mask */ 1551 0xffff, /* dst_mask */ 1552 FALSE), /* pcrel_offset */ 1553 1554 /* Like R_PPC_VLE_SDA21 but ignore overflow. */ 1555 HOWTO (R_PPC_VLE_SDA21_LO, /* type */ 1556 0, /* rightshift */ 1557 2, /* size (0 = byte, 1 = short, 2 = long) */ 1558 16, /* bitsize */ 1559 FALSE, /* pc_relative */ 1560 0, /* bitpos */ 1561 complain_overflow_dont, /* complain_on_overflow */ 1562 bfd_elf_generic_reloc, /* special_function */ 1563 "R_PPC_VLE_SDA21_LO", /* name */ 1564 FALSE, /* partial_inplace */ 1565 0, /* src_mask */ 1566 0xffff, /* dst_mask */ 1567 FALSE), /* pcrel_offset */ 1568 1569 /* The 16 LSBS relative to _SDA_BASE_ in split16a format. */ 1570 HOWTO (R_PPC_VLE_SDAREL_LO16A,/* type */ 1571 0, /* rightshift */ 1572 2, /* size (0 = byte, 1 = short, 2 = long) */ 1573 16, /* bitsize */ 1574 FALSE, /* pc_relative */ 1575 0, /* bitpos */ 1576 complain_overflow_dont, /* complain_on_overflow */ 1577 bfd_elf_generic_reloc, /* special_function */ 1578 "R_PPC_VLE_SDAREL_LO16A", /* name */ 1579 FALSE, /* partial_inplace */ 1580 0, /* src_mask */ 1581 0x1f007ff, /* dst_mask */ 1582 FALSE), /* pcrel_offset */ 1583 1584 /* The 16 LSBS relative to _SDA_BASE_ in split16d format. */ 1585 HOWTO (R_PPC_VLE_SDAREL_LO16D, /* type */ 1586 0, /* rightshift */ 1587 2, /* size (0 = byte, 1 = short, 2 = long) */ 1588 16, /* bitsize */ 1589 FALSE, /* pc_relative */ 1590 0, /* bitpos */ 1591 complain_overflow_dont, /* complain_on_overflow */ 1592 bfd_elf_generic_reloc, /* special_function */ 1593 "R_PPC_VLE_SDAREL_LO16D", /* name */ 1594 FALSE, /* partial_inplace */ 1595 0, /* src_mask */ 1596 0x1f07ff, /* dst_mask */ 1597 FALSE), /* pcrel_offset */ 1598 1599 /* Bits 16-31 relative to _SDA_BASE_ in split16a format. */ 1600 HOWTO (R_PPC_VLE_SDAREL_HI16A, /* type */ 1601 16, /* rightshift */ 1602 2, /* size (0 = byte, 1 = short, 2 = long) */ 1603 16, /* bitsize */ 1604 FALSE, /* pc_relative */ 1605 0, /* bitpos */ 1606 complain_overflow_dont, /* complain_on_overflow */ 1607 bfd_elf_generic_reloc, /* special_function */ 1608 "R_PPC_VLE_SDAREL_HI16A", /* name */ 1609 FALSE, /* partial_inplace */ 1610 0, /* src_mask */ 1611 0x1f007ff, /* dst_mask */ 1612 FALSE), /* pcrel_offset */ 1613 1614 /* Bits 16-31 relative to _SDA_BASE_ in split16d format. */ 1615 HOWTO (R_PPC_VLE_SDAREL_HI16D, /* type */ 1616 16, /* rightshift */ 1617 2, /* size (0 = byte, 1 = short, 2 = long) */ 1618 16, /* bitsize */ 1619 FALSE, /* pc_relative */ 1620 0, /* bitpos */ 1621 complain_overflow_dont, /* complain_on_overflow */ 1622 bfd_elf_generic_reloc, /* special_function */ 1623 "R_PPC_VLE_SDAREL_HI16D", /* name */ 1624 FALSE, /* partial_inplace */ 1625 0, /* src_mask */ 1626 0x1f07ff, /* dst_mask */ 1627 FALSE), /* pcrel_offset */ 1628 1629 /* Bits 16-31 (HA) relative to _SDA_BASE split16a format. */ 1630 HOWTO (R_PPC_VLE_SDAREL_HA16A, /* type */ 1631 16, /* rightshift */ 1632 2, /* size (0 = byte, 1 = short, 2 = long) */ 1633 16, /* bitsize */ 1634 FALSE, /* pc_relative */ 1635 0, /* bitpos */ 1636 complain_overflow_dont, /* complain_on_overflow */ 1637 bfd_elf_generic_reloc, /* special_function */ 1638 "R_PPC_VLE_SDAREL_HA16A", /* name */ 1639 FALSE, /* partial_inplace */ 1640 0, /* src_mask */ 1641 0x1f007ff, /* dst_mask */ 1642 FALSE), /* pcrel_offset */ 1643 1644 /* Bits 16-31 (HA) relative to _SDA_BASE split16d format. */ 1645 HOWTO (R_PPC_VLE_SDAREL_HA16D, /* type */ 1646 16, /* rightshift */ 1647 2, /* size (0 = byte, 1 = short, 2 = long) */ 1648 16, /* bitsize */ 1649 FALSE, /* pc_relative */ 1650 0, /* bitpos */ 1651 complain_overflow_dont, /* complain_on_overflow */ 1652 bfd_elf_generic_reloc, /* special_function */ 1653 "R_PPC_VLE_SDAREL_HA16D", /* name */ 1654 FALSE, /* partial_inplace */ 1655 0, /* src_mask */ 1656 0x1f07ff, /* dst_mask */ 1657 FALSE), /* pcrel_offset */ 1658 1659 HOWTO (R_PPC_IRELATIVE, /* type */ 1660 0, /* rightshift */ 1661 2, /* size (0 = byte, 1 = short, 2 = long) */ 1662 32, /* bitsize */ 1663 FALSE, /* pc_relative */ 1664 0, /* bitpos */ 1665 complain_overflow_dont, /* complain_on_overflow */ 1666 bfd_elf_generic_reloc, /* special_function */ 1667 "R_PPC_IRELATIVE", /* name */ 1668 FALSE, /* partial_inplace */ 1669 0, /* src_mask */ 1670 0xffffffff, /* dst_mask */ 1671 FALSE), /* pcrel_offset */ 1672 1673 /* A 16 bit relative relocation. */ 1674 HOWTO (R_PPC_REL16, /* type */ 1675 0, /* rightshift */ 1676 1, /* size (0 = byte, 1 = short, 2 = long) */ 1677 16, /* bitsize */ 1678 TRUE, /* pc_relative */ 1679 0, /* bitpos */ 1680 complain_overflow_signed, /* complain_on_overflow */ 1681 bfd_elf_generic_reloc, /* special_function */ 1682 "R_PPC_REL16", /* name */ 1683 FALSE, /* partial_inplace */ 1684 0, /* src_mask */ 1685 0xffff, /* dst_mask */ 1686 TRUE), /* pcrel_offset */ 1687 1688 /* A 16 bit relative relocation without overflow. */ 1689 HOWTO (R_PPC_REL16_LO, /* type */ 1690 0, /* rightshift */ 1691 1, /* size (0 = byte, 1 = short, 2 = long) */ 1692 16, /* bitsize */ 1693 TRUE, /* pc_relative */ 1694 0, /* bitpos */ 1695 complain_overflow_dont,/* complain_on_overflow */ 1696 bfd_elf_generic_reloc, /* special_function */ 1697 "R_PPC_REL16_LO", /* name */ 1698 FALSE, /* partial_inplace */ 1699 0, /* src_mask */ 1700 0xffff, /* dst_mask */ 1701 TRUE), /* pcrel_offset */ 1702 1703 /* The high order 16 bits of a relative address. */ 1704 HOWTO (R_PPC_REL16_HI, /* type */ 1705 16, /* rightshift */ 1706 1, /* size (0 = byte, 1 = short, 2 = long) */ 1707 16, /* bitsize */ 1708 TRUE, /* pc_relative */ 1709 0, /* bitpos */ 1710 complain_overflow_dont, /* complain_on_overflow */ 1711 bfd_elf_generic_reloc, /* special_function */ 1712 "R_PPC_REL16_HI", /* name */ 1713 FALSE, /* partial_inplace */ 1714 0, /* src_mask */ 1715 0xffff, /* dst_mask */ 1716 TRUE), /* pcrel_offset */ 1717 1718 /* The high order 16 bits of a relative address, plus 1 if the contents of 1719 the low 16 bits, treated as a signed number, is negative. */ 1720 HOWTO (R_PPC_REL16_HA, /* type */ 1721 16, /* rightshift */ 1722 1, /* size (0 = byte, 1 = short, 2 = long) */ 1723 16, /* bitsize */ 1724 TRUE, /* pc_relative */ 1725 0, /* bitpos */ 1726 complain_overflow_dont, /* complain_on_overflow */ 1727 ppc_elf_addr16_ha_reloc, /* special_function */ 1728 "R_PPC_REL16_HA", /* name */ 1729 FALSE, /* partial_inplace */ 1730 0, /* src_mask */ 1731 0xffff, /* dst_mask */ 1732 TRUE), /* pcrel_offset */ 1733 1734 /* Like R_PPC_REL16_HA but for split field in addpcis. */ 1735 HOWTO (R_PPC_REL16DX_HA, /* type */ 1736 16, /* rightshift */ 1737 2, /* size (0 = byte, 1 = short, 2 = long) */ 1738 16, /* bitsize */ 1739 TRUE, /* pc_relative */ 1740 0, /* bitpos */ 1741 complain_overflow_signed, /* complain_on_overflow */ 1742 ppc_elf_addr16_ha_reloc, /* special_function */ 1743 "R_PPC_REL16DX_HA", /* name */ 1744 FALSE, /* partial_inplace */ 1745 0, /* src_mask */ 1746 0x1fffc1, /* dst_mask */ 1747 TRUE), /* pcrel_offset */ 1748 1749 /* GNU extension to record C++ vtable hierarchy. */ 1750 HOWTO (R_PPC_GNU_VTINHERIT, /* type */ 1751 0, /* rightshift */ 1752 0, /* size (0 = byte, 1 = short, 2 = long) */ 1753 0, /* bitsize */ 1754 FALSE, /* pc_relative */ 1755 0, /* bitpos */ 1756 complain_overflow_dont, /* complain_on_overflow */ 1757 NULL, /* special_function */ 1758 "R_PPC_GNU_VTINHERIT", /* name */ 1759 FALSE, /* partial_inplace */ 1760 0, /* src_mask */ 1761 0, /* dst_mask */ 1762 FALSE), /* pcrel_offset */ 1763 1764 /* GNU extension to record C++ vtable member usage. */ 1765 HOWTO (R_PPC_GNU_VTENTRY, /* type */ 1766 0, /* rightshift */ 1767 0, /* size (0 = byte, 1 = short, 2 = long) */ 1768 0, /* bitsize */ 1769 FALSE, /* pc_relative */ 1770 0, /* bitpos */ 1771 complain_overflow_dont, /* complain_on_overflow */ 1772 NULL, /* special_function */ 1773 "R_PPC_GNU_VTENTRY", /* name */ 1774 FALSE, /* partial_inplace */ 1775 0, /* src_mask */ 1776 0, /* dst_mask */ 1777 FALSE), /* pcrel_offset */ 1778 1779 /* Phony reloc to handle AIX style TOC entries. */ 1780 HOWTO (R_PPC_TOC16, /* type */ 1781 0, /* rightshift */ 1782 1, /* size (0 = byte, 1 = short, 2 = long) */ 1783 16, /* bitsize */ 1784 FALSE, /* pc_relative */ 1785 0, /* bitpos */ 1786 complain_overflow_signed, /* complain_on_overflow */ 1787 bfd_elf_generic_reloc, /* special_function */ 1788 "R_PPC_TOC16", /* name */ 1789 FALSE, /* partial_inplace */ 1790 0, /* src_mask */ 1791 0xffff, /* dst_mask */ 1792 FALSE), /* pcrel_offset */ 1793 }; 1794 1795 /* External 32-bit PPC structure for PRPSINFO. This structure is 1796 ABI-defined, thus we choose to use char arrays here in order to 1797 avoid dealing with different types in different architectures. 1798 1799 The PPC 32-bit structure uses int for `pr_uid' and `pr_gid' while 1800 most non-PPC architectures use `short int'. 1801 1802 This structure will ultimately be written in the corefile's note 1803 section, as the PRPSINFO. */ 1804 1805 struct elf_external_ppc_linux_prpsinfo32 1806 { 1807 char pr_state; /* Numeric process state. */ 1808 char pr_sname; /* Char for pr_state. */ 1809 char pr_zomb; /* Zombie. */ 1810 char pr_nice; /* Nice val. */ 1811 char pr_flag[4]; /* Flags. */ 1812 char pr_uid[4]; 1813 char pr_gid[4]; 1814 char pr_pid[4]; 1815 char pr_ppid[4]; 1816 char pr_pgrp[4]; 1817 char pr_sid[4]; 1818 char pr_fname[16]; /* Filename of executable. */ 1819 char pr_psargs[80]; /* Initial part of arg list. */ 1820 }; 1821 1822 /* Helper function to copy an elf_internal_linux_prpsinfo in host 1823 endian to an elf_external_ppc_linux_prpsinfo32 in target endian. */ 1824 1825 static inline void 1826 swap_ppc_linux_prpsinfo32_out (bfd *obfd, 1827 const struct elf_internal_linux_prpsinfo *from, 1828 struct elf_external_ppc_linux_prpsinfo32 *to) 1829 { 1830 bfd_put_8 (obfd, from->pr_state, &to->pr_state); 1831 bfd_put_8 (obfd, from->pr_sname, &to->pr_sname); 1832 bfd_put_8 (obfd, from->pr_zomb, &to->pr_zomb); 1833 bfd_put_8 (obfd, from->pr_nice, &to->pr_nice); 1834 bfd_put_32 (obfd, from->pr_flag, to->pr_flag); 1835 bfd_put_32 (obfd, from->pr_uid, to->pr_uid); 1836 bfd_put_32 (obfd, from->pr_gid, to->pr_gid); 1837 bfd_put_32 (obfd, from->pr_pid, to->pr_pid); 1838 bfd_put_32 (obfd, from->pr_ppid, to->pr_ppid); 1839 bfd_put_32 (obfd, from->pr_pgrp, to->pr_pgrp); 1840 bfd_put_32 (obfd, from->pr_sid, to->pr_sid); 1841 strncpy (to->pr_fname, from->pr_fname, sizeof (to->pr_fname)); 1842 strncpy (to->pr_psargs, from->pr_psargs, sizeof (to->pr_psargs)); 1843 } 1844 1845 /* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */ 1847 1848 static void 1849 ppc_elf_howto_init (void) 1850 { 1851 unsigned int i, type; 1852 1853 for (i = 0; 1854 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); 1855 i++) 1856 { 1857 type = ppc_elf_howto_raw[i].type; 1858 if (type >= (sizeof (ppc_elf_howto_table) 1859 / sizeof (ppc_elf_howto_table[0]))) 1860 abort (); 1861 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i]; 1862 } 1863 } 1864 1865 static reloc_howto_type * 1866 ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1867 bfd_reloc_code_real_type code) 1868 { 1869 enum elf_ppc_reloc_type r; 1870 1871 /* Initialize howto table if not already done. */ 1872 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 1873 ppc_elf_howto_init (); 1874 1875 switch (code) 1876 { 1877 default: 1878 return NULL; 1879 1880 case BFD_RELOC_NONE: r = R_PPC_NONE; break; 1881 case BFD_RELOC_32: r = R_PPC_ADDR32; break; 1882 case BFD_RELOC_PPC_BA26: r = R_PPC_ADDR24; break; 1883 case BFD_RELOC_PPC64_ADDR16_DS: 1884 case BFD_RELOC_16: r = R_PPC_ADDR16; break; 1885 case BFD_RELOC_PPC64_ADDR16_LO_DS: 1886 case BFD_RELOC_LO16: r = R_PPC_ADDR16_LO; break; 1887 case BFD_RELOC_HI16: r = R_PPC_ADDR16_HI; break; 1888 case BFD_RELOC_HI16_S: r = R_PPC_ADDR16_HA; break; 1889 case BFD_RELOC_PPC_BA16: r = R_PPC_ADDR14; break; 1890 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC_ADDR14_BRTAKEN; break; 1891 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC_ADDR14_BRNTAKEN; break; 1892 case BFD_RELOC_PPC_B26: r = R_PPC_REL24; break; 1893 case BFD_RELOC_PPC_B16: r = R_PPC_REL14; break; 1894 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC_REL14_BRTAKEN; break; 1895 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC_REL14_BRNTAKEN; break; 1896 case BFD_RELOC_PPC64_GOT16_DS: 1897 case BFD_RELOC_16_GOTOFF: r = R_PPC_GOT16; break; 1898 case BFD_RELOC_PPC64_GOT16_LO_DS: 1899 case BFD_RELOC_LO16_GOTOFF: r = R_PPC_GOT16_LO; break; 1900 case BFD_RELOC_HI16_GOTOFF: r = R_PPC_GOT16_HI; break; 1901 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC_GOT16_HA; break; 1902 case BFD_RELOC_24_PLT_PCREL: r = R_PPC_PLTREL24; break; 1903 case BFD_RELOC_PPC_COPY: r = R_PPC_COPY; break; 1904 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC_GLOB_DAT; break; 1905 case BFD_RELOC_PPC_LOCAL24PC: r = R_PPC_LOCAL24PC; break; 1906 case BFD_RELOC_32_PCREL: r = R_PPC_REL32; break; 1907 case BFD_RELOC_32_PLTOFF: r = R_PPC_PLT32; break; 1908 case BFD_RELOC_32_PLT_PCREL: r = R_PPC_PLTREL32; break; 1909 case BFD_RELOC_PPC64_PLT16_LO_DS: 1910 case BFD_RELOC_LO16_PLTOFF: r = R_PPC_PLT16_LO; break; 1911 case BFD_RELOC_HI16_PLTOFF: r = R_PPC_PLT16_HI; break; 1912 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC_PLT16_HA; break; 1913 case BFD_RELOC_GPREL16: r = R_PPC_SDAREL16; break; 1914 case BFD_RELOC_PPC64_SECTOFF_DS: 1915 case BFD_RELOC_16_BASEREL: r = R_PPC_SECTOFF; break; 1916 case BFD_RELOC_PPC64_SECTOFF_LO_DS: 1917 case BFD_RELOC_LO16_BASEREL: r = R_PPC_SECTOFF_LO; break; 1918 case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break; 1919 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break; 1920 case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break; 1921 case BFD_RELOC_PPC64_TOC16_DS: 1922 case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break; 1923 case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break; 1924 case BFD_RELOC_PPC_TLSGD: r = R_PPC_TLSGD; break; 1925 case BFD_RELOC_PPC_TLSLD: r = R_PPC_TLSLD; break; 1926 case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break; 1927 case BFD_RELOC_PPC64_TPREL16_DS: 1928 case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break; 1929 case BFD_RELOC_PPC64_TPREL16_LO_DS: 1930 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break; 1931 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break; 1932 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break; 1933 case BFD_RELOC_PPC_TPREL: r = R_PPC_TPREL32; break; 1934 case BFD_RELOC_PPC64_DTPREL16_DS: 1935 case BFD_RELOC_PPC_DTPREL16: r = R_PPC_DTPREL16; break; 1936 case BFD_RELOC_PPC64_DTPREL16_LO_DS: 1937 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC_DTPREL16_LO; break; 1938 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC_DTPREL16_HI; break; 1939 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC_DTPREL16_HA; break; 1940 case BFD_RELOC_PPC_DTPREL: r = R_PPC_DTPREL32; break; 1941 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC_GOT_TLSGD16; break; 1942 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC_GOT_TLSGD16_LO; break; 1943 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC_GOT_TLSGD16_HI; break; 1944 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC_GOT_TLSGD16_HA; break; 1945 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC_GOT_TLSLD16; break; 1946 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC_GOT_TLSLD16_LO; break; 1947 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC_GOT_TLSLD16_HI; break; 1948 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC_GOT_TLSLD16_HA; break; 1949 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC_GOT_TPREL16; break; 1950 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC_GOT_TPREL16_LO; break; 1951 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC_GOT_TPREL16_HI; break; 1952 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC_GOT_TPREL16_HA; break; 1953 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC_GOT_DTPREL16; break; 1954 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO; break; 1955 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI; break; 1956 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA; break; 1957 case BFD_RELOC_PPC_EMB_NADDR32: r = R_PPC_EMB_NADDR32; break; 1958 case BFD_RELOC_PPC_EMB_NADDR16: r = R_PPC_EMB_NADDR16; break; 1959 case BFD_RELOC_PPC_EMB_NADDR16_LO: r = R_PPC_EMB_NADDR16_LO; break; 1960 case BFD_RELOC_PPC_EMB_NADDR16_HI: r = R_PPC_EMB_NADDR16_HI; break; 1961 case BFD_RELOC_PPC_EMB_NADDR16_HA: r = R_PPC_EMB_NADDR16_HA; break; 1962 case BFD_RELOC_PPC_EMB_SDAI16: r = R_PPC_EMB_SDAI16; break; 1963 case BFD_RELOC_PPC_EMB_SDA2I16: r = R_PPC_EMB_SDA2I16; break; 1964 case BFD_RELOC_PPC_EMB_SDA2REL: r = R_PPC_EMB_SDA2REL; break; 1965 case BFD_RELOC_PPC_EMB_SDA21: r = R_PPC_EMB_SDA21; break; 1966 case BFD_RELOC_PPC_EMB_MRKREF: r = R_PPC_EMB_MRKREF; break; 1967 case BFD_RELOC_PPC_EMB_RELSEC16: r = R_PPC_EMB_RELSEC16; break; 1968 case BFD_RELOC_PPC_EMB_RELST_LO: r = R_PPC_EMB_RELST_LO; break; 1969 case BFD_RELOC_PPC_EMB_RELST_HI: r = R_PPC_EMB_RELST_HI; break; 1970 case BFD_RELOC_PPC_EMB_RELST_HA: r = R_PPC_EMB_RELST_HA; break; 1971 case BFD_RELOC_PPC_EMB_BIT_FLD: r = R_PPC_EMB_BIT_FLD; break; 1972 case BFD_RELOC_PPC_EMB_RELSDA: r = R_PPC_EMB_RELSDA; break; 1973 case BFD_RELOC_PPC_VLE_REL8: r = R_PPC_VLE_REL8; break; 1974 case BFD_RELOC_PPC_VLE_REL15: r = R_PPC_VLE_REL15; break; 1975 case BFD_RELOC_PPC_VLE_REL24: r = R_PPC_VLE_REL24; break; 1976 case BFD_RELOC_PPC_VLE_LO16A: r = R_PPC_VLE_LO16A; break; 1977 case BFD_RELOC_PPC_VLE_LO16D: r = R_PPC_VLE_LO16D; break; 1978 case BFD_RELOC_PPC_VLE_HI16A: r = R_PPC_VLE_HI16A; break; 1979 case BFD_RELOC_PPC_VLE_HI16D: r = R_PPC_VLE_HI16D; break; 1980 case BFD_RELOC_PPC_VLE_HA16A: r = R_PPC_VLE_HA16A; break; 1981 case BFD_RELOC_PPC_VLE_HA16D: r = R_PPC_VLE_HA16D; break; 1982 case BFD_RELOC_PPC_VLE_SDA21: r = R_PPC_VLE_SDA21; break; 1983 case BFD_RELOC_PPC_VLE_SDA21_LO: r = R_PPC_VLE_SDA21_LO; break; 1984 case BFD_RELOC_PPC_VLE_SDAREL_LO16A: 1985 r = R_PPC_VLE_SDAREL_LO16A; 1986 break; 1987 case BFD_RELOC_PPC_VLE_SDAREL_LO16D: 1988 r = R_PPC_VLE_SDAREL_LO16D; 1989 break; 1990 case BFD_RELOC_PPC_VLE_SDAREL_HI16A: 1991 r = R_PPC_VLE_SDAREL_HI16A; 1992 break; 1993 case BFD_RELOC_PPC_VLE_SDAREL_HI16D: 1994 r = R_PPC_VLE_SDAREL_HI16D; 1995 break; 1996 case BFD_RELOC_PPC_VLE_SDAREL_HA16A: 1997 r = R_PPC_VLE_SDAREL_HA16A; 1998 break; 1999 case BFD_RELOC_PPC_VLE_SDAREL_HA16D: 2000 r = R_PPC_VLE_SDAREL_HA16D; 2001 break; 2002 case BFD_RELOC_16_PCREL: r = R_PPC_REL16; break; 2003 case BFD_RELOC_LO16_PCREL: r = R_PPC_REL16_LO; break; 2004 case BFD_RELOC_HI16_PCREL: r = R_PPC_REL16_HI; break; 2005 case BFD_RELOC_HI16_S_PCREL: r = R_PPC_REL16_HA; break; 2006 case BFD_RELOC_PPC_REL16DX_HA: r = R_PPC_REL16DX_HA; break; 2007 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC_GNU_VTINHERIT; break; 2008 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC_GNU_VTENTRY; break; 2009 } 2010 2011 return ppc_elf_howto_table[r]; 2012 }; 2013 2014 static reloc_howto_type * 2015 ppc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 2016 const char *r_name) 2017 { 2018 unsigned int i; 2019 2020 for (i = 0; 2021 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); 2022 i++) 2023 if (ppc_elf_howto_raw[i].name != NULL 2024 && strcasecmp (ppc_elf_howto_raw[i].name, r_name) == 0) 2025 return &ppc_elf_howto_raw[i]; 2026 2027 return NULL; 2028 } 2029 2030 /* Set the howto pointer for a PowerPC ELF reloc. */ 2031 2032 static void 2033 ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 2034 arelent *cache_ptr, 2035 Elf_Internal_Rela *dst) 2036 { 2037 unsigned int r_type; 2038 2039 /* Initialize howto table if not already done. */ 2040 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 2041 ppc_elf_howto_init (); 2042 2043 r_type = ELF32_R_TYPE (dst->r_info); 2044 if (r_type >= R_PPC_max) 2045 { 2046 (*_bfd_error_handler) (_("%B: unrecognised PPC reloc number: %d"), 2047 abfd, r_type); 2048 bfd_set_error (bfd_error_bad_value); 2049 r_type = R_PPC_NONE; 2050 } 2051 cache_ptr->howto = ppc_elf_howto_table[r_type]; 2052 2053 /* Just because the above assert didn't trigger doesn't mean that 2054 ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation. */ 2055 if (!cache_ptr->howto) 2056 { 2057 (*_bfd_error_handler) (_("%B: invalid relocation type %d"), 2058 abfd, r_type); 2059 bfd_set_error (bfd_error_bad_value); 2060 2061 cache_ptr->howto = ppc_elf_howto_table[R_PPC_NONE]; 2062 } 2063 } 2064 2065 /* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs. */ 2066 2067 static bfd_reloc_status_type 2068 ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED, 2069 arelent *reloc_entry, 2070 asymbol *symbol, 2071 void *data ATTRIBUTE_UNUSED, 2072 asection *input_section, 2073 bfd *output_bfd, 2074 char **error_message ATTRIBUTE_UNUSED) 2075 { 2076 enum elf_ppc_reloc_type r_type; 2077 long insn; 2078 bfd_size_type octets; 2079 bfd_vma value; 2080 2081 if (output_bfd != NULL) 2082 { 2083 reloc_entry->address += input_section->output_offset; 2084 return bfd_reloc_ok; 2085 } 2086 2087 reloc_entry->addend += 0x8000; 2088 r_type = reloc_entry->howto->type; 2089 if (r_type != R_PPC_REL16DX_HA) 2090 return bfd_reloc_continue; 2091 2092 value = 0; 2093 if (!bfd_is_com_section (symbol->section)) 2094 value = symbol->value; 2095 value += (reloc_entry->addend 2096 + symbol->section->output_offset 2097 + symbol->section->output_section->vma); 2098 value -= (reloc_entry->address 2099 + input_section->output_offset 2100 + input_section->output_section->vma); 2101 value >>= 16; 2102 2103 octets = reloc_entry->address * bfd_octets_per_byte (abfd); 2104 insn = bfd_get_32 (abfd, (bfd_byte *) data + octets); 2105 insn &= ~0x1fffc1; 2106 insn |= (value & 0xffc1) | ((value & 0x3e) << 15); 2107 bfd_put_32 (abfd, insn, (bfd_byte *) data + octets); 2108 return bfd_reloc_ok; 2109 } 2110 2111 static bfd_reloc_status_type 2112 ppc_elf_unhandled_reloc (bfd *abfd, 2113 arelent *reloc_entry, 2114 asymbol *symbol, 2115 void *data, 2116 asection *input_section, 2117 bfd *output_bfd, 2118 char **error_message) 2119 { 2120 /* If this is a relocatable link (output_bfd test tells us), just 2121 call the generic function. Any adjustment will be done at final 2122 link time. */ 2123 if (output_bfd != NULL) 2124 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 2125 input_section, output_bfd, error_message); 2126 2127 if (error_message != NULL) 2128 { 2129 static char buf[60]; 2130 sprintf (buf, _("generic linker can't handle %s"), 2131 reloc_entry->howto->name); 2132 *error_message = buf; 2133 } 2134 return bfd_reloc_dangerous; 2135 } 2136 2137 /* Sections created by the linker. */ 2139 2140 typedef struct elf_linker_section 2141 { 2142 /* Pointer to the bfd section. */ 2143 asection *section; 2144 /* Section name. */ 2145 const char *name; 2146 /* Associated bss section name. */ 2147 const char *bss_name; 2148 /* Associated symbol name. */ 2149 const char *sym_name; 2150 /* Associated symbol. */ 2151 struct elf_link_hash_entry *sym; 2152 } elf_linker_section_t; 2153 2154 /* Linked list of allocated pointer entries. This hangs off of the 2155 symbol lists, and provides allows us to return different pointers, 2156 based on different addend's. */ 2157 2158 typedef struct elf_linker_section_pointers 2159 { 2160 /* next allocated pointer for this symbol */ 2161 struct elf_linker_section_pointers *next; 2162 /* offset of pointer from beginning of section */ 2163 bfd_vma offset; 2164 /* addend used */ 2165 bfd_vma addend; 2166 /* which linker section this is */ 2167 elf_linker_section_t *lsect; 2168 } elf_linker_section_pointers_t; 2169 2170 struct ppc_elf_obj_tdata 2171 { 2172 struct elf_obj_tdata elf; 2173 2174 /* A mapping from local symbols to offsets into the various linker 2175 sections added. This is index by the symbol index. */ 2176 elf_linker_section_pointers_t **linker_section_pointers; 2177 2178 /* Flags used to auto-detect plt type. */ 2179 unsigned int makes_plt_call : 1; 2180 unsigned int has_rel16 : 1; 2181 }; 2182 2183 #define ppc_elf_tdata(bfd) \ 2184 ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any) 2185 2186 #define elf_local_ptr_offsets(bfd) \ 2187 (ppc_elf_tdata (bfd)->linker_section_pointers) 2188 2189 #define is_ppc_elf(bfd) \ 2190 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 2191 && elf_object_id (bfd) == PPC32_ELF_DATA) 2192 2193 /* Override the generic function because we store some extras. */ 2194 2195 static bfd_boolean 2196 ppc_elf_mkobject (bfd *abfd) 2197 { 2198 return bfd_elf_allocate_object (abfd, sizeof (struct ppc_elf_obj_tdata), 2199 PPC32_ELF_DATA); 2200 } 2201 2202 /* When defaulting arch/mach, decode apuinfo to find a better match. */ 2203 2204 bfd_boolean 2205 _bfd_elf_ppc_set_arch (bfd *abfd) 2206 { 2207 unsigned long mach = 0; 2208 asection *s; 2209 unsigned char *contents; 2210 2211 if (abfd->arch_info->bits_per_word == 32 2212 && bfd_big_endian (abfd)) 2213 { 2214 2215 for (s = abfd->sections; s != NULL; s = s->next) 2216 if ((elf_section_data (s)->this_hdr.sh_flags & SHF_PPC_VLE) != 0) 2217 break; 2218 if (s != NULL) 2219 mach = bfd_mach_ppc_vle; 2220 } 2221 2222 if (mach == 0) 2223 { 2224 s = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2225 if (s != NULL && bfd_malloc_and_get_section (abfd, s, &contents)) 2226 { 2227 unsigned int apuinfo_size = bfd_get_32 (abfd, contents + 4); 2228 unsigned int i; 2229 2230 for (i = 20; i < apuinfo_size + 20 && i + 4 <= s->size; i += 4) 2231 { 2232 unsigned int val = bfd_get_32 (abfd, contents + i); 2233 switch (val >> 16) 2234 { 2235 case PPC_APUINFO_PMR: 2236 case PPC_APUINFO_RFMCI: 2237 if (mach == 0) 2238 mach = bfd_mach_ppc_titan; 2239 break; 2240 2241 case PPC_APUINFO_ISEL: 2242 case PPC_APUINFO_CACHELCK: 2243 if (mach == bfd_mach_ppc_titan) 2244 mach = bfd_mach_ppc_e500mc; 2245 break; 2246 2247 case PPC_APUINFO_SPE: 2248 case PPC_APUINFO_EFS: 2249 case PPC_APUINFO_BRLOCK: 2250 if (mach != bfd_mach_ppc_vle) 2251 mach = bfd_mach_ppc_e500; 2252 break; 2253 2254 case PPC_APUINFO_VLE: 2255 mach = bfd_mach_ppc_vle; 2256 break; 2257 2258 default: 2259 mach = -1ul; 2260 } 2261 } 2262 free (contents); 2263 } 2264 } 2265 2266 if (mach != 0 && mach != -1ul) 2267 { 2268 const bfd_arch_info_type *arch; 2269 2270 for (arch = abfd->arch_info->next; arch; arch = arch->next) 2271 if (arch->mach == mach) 2272 { 2273 abfd->arch_info = arch; 2274 break; 2275 } 2276 } 2277 return TRUE; 2278 } 2279 2280 /* Fix bad default arch selected for a 32 bit input bfd when the 2281 default is 64 bit. Also select arch based on apuinfo. */ 2282 2283 static bfd_boolean 2284 ppc_elf_object_p (bfd *abfd) 2285 { 2286 if (!abfd->arch_info->the_default) 2287 return TRUE; 2288 2289 if (abfd->arch_info->bits_per_word == 64) 2290 { 2291 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd); 2292 2293 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32) 2294 { 2295 /* Relies on arch after 64 bit default being 32 bit default. */ 2296 abfd->arch_info = abfd->arch_info->next; 2297 BFD_ASSERT (abfd->arch_info->bits_per_word == 32); 2298 } 2299 } 2300 return _bfd_elf_ppc_set_arch (abfd); 2301 } 2302 2303 /* Function to set whether a module needs the -mrelocatable bit set. */ 2304 2305 static bfd_boolean 2306 ppc_elf_set_private_flags (bfd *abfd, flagword flags) 2307 { 2308 BFD_ASSERT (!elf_flags_init (abfd) 2309 || elf_elfheader (abfd)->e_flags == flags); 2310 2311 elf_elfheader (abfd)->e_flags = flags; 2312 elf_flags_init (abfd) = TRUE; 2313 return TRUE; 2314 } 2315 2316 /* Support for core dump NOTE sections. */ 2317 2318 static bfd_boolean 2319 ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2320 { 2321 int offset; 2322 unsigned int size; 2323 2324 switch (note->descsz) 2325 { 2326 default: 2327 return FALSE; 2328 2329 case 268: /* Linux/PPC. */ 2330 /* pr_cursig */ 2331 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 2332 2333 /* pr_pid */ 2334 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24); 2335 2336 /* pr_reg */ 2337 offset = 72; 2338 size = 192; 2339 2340 break; 2341 } 2342 2343 /* Make a ".reg/999" section. */ 2344 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 2345 size, note->descpos + offset); 2346 } 2347 2348 static bfd_boolean 2349 ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 2350 { 2351 switch (note->descsz) 2352 { 2353 default: 2354 return FALSE; 2355 2356 case 128: /* Linux/PPC elf_prpsinfo. */ 2357 elf_tdata (abfd)->core->pid 2358 = bfd_get_32 (abfd, note->descdata + 16); 2359 elf_tdata (abfd)->core->program 2360 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); 2361 elf_tdata (abfd)->core->command 2362 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); 2363 } 2364 2365 /* Note that for some reason, a spurious space is tacked 2366 onto the end of the args in some (at least one anyway) 2367 implementations, so strip it off if it exists. */ 2368 2369 { 2370 char *command = elf_tdata (abfd)->core->command; 2371 int n = strlen (command); 2372 2373 if (0 < n && command[n - 1] == ' ') 2374 command[n - 1] = '\0'; 2375 } 2376 2377 return TRUE; 2378 } 2379 2380 char * 2381 elfcore_write_ppc_linux_prpsinfo32 2382 (bfd *abfd, 2383 char *buf, 2384 int *bufsiz, 2385 const struct elf_internal_linux_prpsinfo *prpsinfo) 2386 { 2387 struct elf_external_ppc_linux_prpsinfo32 data; 2388 2389 swap_ppc_linux_prpsinfo32_out (abfd, prpsinfo, &data); 2390 return elfcore_write_note (abfd, buf, bufsiz, 2391 "CORE", NT_PRPSINFO, &data, sizeof (data)); 2392 } 2393 2394 static char * 2395 ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...) 2396 { 2397 switch (note_type) 2398 { 2399 default: 2400 return NULL; 2401 2402 case NT_PRPSINFO: 2403 { 2404 char data[128]; 2405 va_list ap; 2406 2407 va_start (ap, note_type); 2408 memset (data, 0, sizeof (data)); 2409 strncpy (data + 32, va_arg (ap, const char *), 16); 2410 strncpy (data + 48, va_arg (ap, const char *), 80); 2411 va_end (ap); 2412 return elfcore_write_note (abfd, buf, bufsiz, 2413 "CORE", note_type, data, sizeof (data)); 2414 } 2415 2416 case NT_PRSTATUS: 2417 { 2418 char data[268]; 2419 va_list ap; 2420 long pid; 2421 int cursig; 2422 const void *greg; 2423 2424 va_start (ap, note_type); 2425 memset (data, 0, 72); 2426 pid = va_arg (ap, long); 2427 bfd_put_32 (abfd, pid, data + 24); 2428 cursig = va_arg (ap, int); 2429 bfd_put_16 (abfd, cursig, data + 12); 2430 greg = va_arg (ap, const void *); 2431 memcpy (data + 72, greg, 192); 2432 memset (data + 264, 0, 4); 2433 va_end (ap); 2434 return elfcore_write_note (abfd, buf, bufsiz, 2435 "CORE", note_type, data, sizeof (data)); 2436 } 2437 } 2438 } 2439 2440 static flagword 2441 ppc_elf_lookup_section_flags (char *flag_name) 2442 { 2443 2444 if (!strcmp (flag_name, "SHF_PPC_VLE")) 2445 return SHF_PPC_VLE; 2446 2447 return 0; 2448 } 2449 2450 /* Add the VLE flag if required. */ 2451 2452 bfd_boolean 2453 ppc_elf_section_processing (bfd *abfd, Elf_Internal_Shdr *shdr) 2454 { 2455 if (bfd_get_mach (abfd) == bfd_mach_ppc_vle 2456 && (shdr->sh_flags & SHF_EXECINSTR) != 0) 2457 shdr->sh_flags |= SHF_PPC_VLE; 2458 2459 return TRUE; 2460 } 2461 2462 /* Return address for Ith PLT stub in section PLT, for relocation REL 2463 or (bfd_vma) -1 if it should not be included. */ 2464 2465 static bfd_vma 2466 ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED, 2467 const asection *plt ATTRIBUTE_UNUSED, 2468 const arelent *rel) 2469 { 2470 return rel->address; 2471 } 2472 2473 /* Handle a PowerPC specific section when reading an object file. This 2474 is called when bfd_section_from_shdr finds a section with an unknown 2475 type. */ 2476 2477 static bfd_boolean 2478 ppc_elf_section_from_shdr (bfd *abfd, 2479 Elf_Internal_Shdr *hdr, 2480 const char *name, 2481 int shindex) 2482 { 2483 asection *newsect; 2484 flagword flags; 2485 2486 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 2487 return FALSE; 2488 2489 newsect = hdr->bfd_section; 2490 flags = bfd_get_section_flags (abfd, newsect); 2491 if (hdr->sh_flags & SHF_EXCLUDE) 2492 flags |= SEC_EXCLUDE; 2493 2494 if (hdr->sh_type == SHT_ORDERED) 2495 flags |= SEC_SORT_ENTRIES; 2496 2497 bfd_set_section_flags (abfd, newsect, flags); 2498 return TRUE; 2499 } 2500 2501 /* Set up any other section flags and such that may be necessary. */ 2502 2503 static bfd_boolean 2504 ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 2505 Elf_Internal_Shdr *shdr, 2506 asection *asect) 2507 { 2508 if ((asect->flags & SEC_SORT_ENTRIES) != 0) 2509 shdr->sh_type = SHT_ORDERED; 2510 2511 return TRUE; 2512 } 2513 2514 /* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we 2515 need to bump up the number of section headers. */ 2516 2517 static int 2518 ppc_elf_additional_program_headers (bfd *abfd, 2519 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2520 { 2521 asection *s; 2522 int ret = 0; 2523 2524 s = bfd_get_section_by_name (abfd, ".sbss2"); 2525 if (s != NULL && (s->flags & SEC_ALLOC) != 0) 2526 ++ret; 2527 2528 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0"); 2529 if (s != NULL && (s->flags & SEC_ALLOC) != 0) 2530 ++ret; 2531 2532 return ret; 2533 } 2534 2535 /* Modify the segment map for VLE executables. */ 2536 2537 bfd_boolean 2538 ppc_elf_modify_segment_map (bfd *abfd, 2539 struct bfd_link_info *info ATTRIBUTE_UNUSED) 2540 { 2541 struct elf_segment_map *m, *n; 2542 bfd_size_type amt; 2543 unsigned int j, k; 2544 bfd_boolean sect0_vle, sectj_vle; 2545 2546 /* At this point in the link, output sections have already been sorted by 2547 LMA and assigned to segments. All that is left to do is to ensure 2548 there is no mixing of VLE & non-VLE sections in a text segment. 2549 If we find that case, we split the segment. 2550 We maintain the original output section order. */ 2551 2552 for (m = elf_seg_map (abfd); m != NULL; m = m->next) 2553 { 2554 if (m->count == 0) 2555 continue; 2556 2557 sect0_vle = (elf_section_flags (m->sections[0]) & SHF_PPC_VLE) != 0; 2558 for (j = 1; j < m->count; ++j) 2559 { 2560 sectj_vle = (elf_section_flags (m->sections[j]) & SHF_PPC_VLE) != 0; 2561 2562 if (sectj_vle != sect0_vle) 2563 break; 2564 } 2565 if (j >= m->count) 2566 continue; 2567 2568 /* sections 0..j-1 stay in this (current) segment, 2569 the remainder are put in a new segment. 2570 The scan resumes with the new segment. */ 2571 2572 /* Fix the new segment. */ 2573 amt = sizeof (struct elf_segment_map); 2574 amt += (m->count - j - 1) * sizeof (asection *); 2575 n = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 2576 if (n == NULL) 2577 return FALSE; 2578 2579 n->p_type = PT_LOAD; 2580 n->p_flags = PF_X | PF_R; 2581 if (sectj_vle) 2582 n->p_flags |= PF_PPC_VLE; 2583 n->count = m->count - j; 2584 for (k = 0; k < n->count; ++k) 2585 { 2586 n->sections[k] = m->sections[j+k]; 2587 m->sections[j+k] = NULL; 2588 } 2589 n->next = m->next; 2590 m->next = n; 2591 2592 /* Fix the current segment */ 2593 m->count = j; 2594 } 2595 2596 return TRUE; 2597 } 2598 2599 /* Add extra PPC sections -- Note, for now, make .sbss2 and 2600 .PPC.EMB.sbss0 a normal section, and not a bss section so 2601 that the linker doesn't crater when trying to make more than 2602 2 sections. */ 2603 2604 static const struct bfd_elf_special_section ppc_elf_special_sections[] = 2605 { 2606 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, SHF_ALLOC + SHF_EXECINSTR }, 2607 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 2608 { STRING_COMMA_LEN (".sbss2"), -2, SHT_PROGBITS, SHF_ALLOC }, 2609 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 2610 { STRING_COMMA_LEN (".sdata2"), -2, SHT_PROGBITS, SHF_ALLOC }, 2611 { STRING_COMMA_LEN (".tags"), 0, SHT_ORDERED, SHF_ALLOC }, 2612 { STRING_COMMA_LEN (APUINFO_SECTION_NAME), 0, SHT_NOTE, 0 }, 2613 { STRING_COMMA_LEN (".PPC.EMB.sbss0"), 0, SHT_PROGBITS, SHF_ALLOC }, 2614 { STRING_COMMA_LEN (".PPC.EMB.sdata0"), 0, SHT_PROGBITS, SHF_ALLOC }, 2615 { NULL, 0, 0, 0, 0 } 2616 }; 2617 2618 /* This is what we want for new plt/got. */ 2619 static struct bfd_elf_special_section ppc_alt_plt = 2620 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC }; 2621 2622 static const struct bfd_elf_special_section * 2623 ppc_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 2624 { 2625 const struct bfd_elf_special_section *ssect; 2626 2627 /* See if this is one of the special sections. */ 2628 if (sec->name == NULL) 2629 return NULL; 2630 2631 ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections, 2632 sec->use_rela_p); 2633 if (ssect != NULL) 2634 { 2635 if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0) 2636 ssect = &ppc_alt_plt; 2637 return ssect; 2638 } 2639 2640 return _bfd_elf_get_sec_type_attr (abfd, sec); 2641 } 2642 2643 /* Very simple linked list structure for recording apuinfo values. */ 2645 typedef struct apuinfo_list 2646 { 2647 struct apuinfo_list *next; 2648 unsigned long value; 2649 } 2650 apuinfo_list; 2651 2652 static apuinfo_list *head; 2653 static bfd_boolean apuinfo_set; 2654 2655 static void 2656 apuinfo_list_init (void) 2657 { 2658 head = NULL; 2659 apuinfo_set = FALSE; 2660 } 2661 2662 static void 2663 apuinfo_list_add (unsigned long value) 2664 { 2665 apuinfo_list *entry = head; 2666 2667 while (entry != NULL) 2668 { 2669 if (entry->value == value) 2670 return; 2671 entry = entry->next; 2672 } 2673 2674 entry = bfd_malloc (sizeof (* entry)); 2675 if (entry == NULL) 2676 return; 2677 2678 entry->value = value; 2679 entry->next = head; 2680 head = entry; 2681 } 2682 2683 static unsigned 2684 apuinfo_list_length (void) 2685 { 2686 apuinfo_list *entry; 2687 unsigned long count; 2688 2689 for (entry = head, count = 0; 2690 entry; 2691 entry = entry->next) 2692 ++ count; 2693 2694 return count; 2695 } 2696 2697 static inline unsigned long 2698 apuinfo_list_element (unsigned long number) 2699 { 2700 apuinfo_list * entry; 2701 2702 for (entry = head; 2703 entry && number --; 2704 entry = entry->next) 2705 ; 2706 2707 return entry ? entry->value : 0; 2708 } 2709 2710 static void 2711 apuinfo_list_finish (void) 2712 { 2713 apuinfo_list *entry; 2714 2715 for (entry = head; entry;) 2716 { 2717 apuinfo_list *next = entry->next; 2718 free (entry); 2719 entry = next; 2720 } 2721 2722 head = NULL; 2723 } 2724 2725 /* Scan the input BFDs and create a linked list of 2726 the APUinfo values that will need to be emitted. */ 2727 2728 static void 2729 ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info) 2730 { 2731 bfd *ibfd; 2732 asection *asec; 2733 char *buffer = NULL; 2734 bfd_size_type largest_input_size = 0; 2735 unsigned i; 2736 unsigned long length; 2737 const char *error_message = NULL; 2738 2739 if (link_info == NULL) 2740 return; 2741 2742 apuinfo_list_init (); 2743 2744 /* Read in the input sections contents. */ 2745 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link.next) 2746 { 2747 unsigned long datum; 2748 2749 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); 2750 if (asec == NULL) 2751 continue; 2752 2753 error_message = _("corrupt %s section in %B"); 2754 length = asec->size; 2755 if (length < 20) 2756 goto fail; 2757 2758 apuinfo_set = TRUE; 2759 if (largest_input_size < asec->size) 2760 { 2761 if (buffer) 2762 free (buffer); 2763 largest_input_size = asec->size; 2764 buffer = bfd_malloc (largest_input_size); 2765 if (!buffer) 2766 return; 2767 } 2768 2769 if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0 2770 || (bfd_bread (buffer, length, ibfd) != length)) 2771 { 2772 error_message = _("unable to read in %s section from %B"); 2773 goto fail; 2774 } 2775 2776 /* Verify the contents of the header. Note - we have to 2777 extract the values this way in order to allow for a 2778 host whose endian-ness is different from the target. */ 2779 datum = bfd_get_32 (ibfd, buffer); 2780 if (datum != sizeof APUINFO_LABEL) 2781 goto fail; 2782 2783 datum = bfd_get_32 (ibfd, buffer + 8); 2784 if (datum != 0x2) 2785 goto fail; 2786 2787 if (strcmp (buffer + 12, APUINFO_LABEL) != 0) 2788 goto fail; 2789 2790 /* Get the number of bytes used for apuinfo entries. */ 2791 datum = bfd_get_32 (ibfd, buffer + 4); 2792 if (datum + 20 != length) 2793 goto fail; 2794 2795 /* Scan the apuinfo section, building a list of apuinfo numbers. */ 2796 for (i = 0; i < datum; i += 4) 2797 apuinfo_list_add (bfd_get_32 (ibfd, buffer + 20 + i)); 2798 } 2799 2800 error_message = NULL; 2801 2802 if (apuinfo_set) 2803 { 2804 /* Compute the size of the output section. */ 2805 unsigned num_entries = apuinfo_list_length (); 2806 2807 /* Set the output section size, if it exists. */ 2808 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2809 2810 if (asec && ! bfd_set_section_size (abfd, asec, 20 + num_entries * 4)) 2811 { 2812 ibfd = abfd; 2813 error_message = _("warning: unable to set size of %s section in %B"); 2814 } 2815 } 2816 2817 fail: 2818 if (buffer) 2819 free (buffer); 2820 2821 if (error_message) 2822 (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME); 2823 } 2824 2825 /* Prevent the output section from accumulating the input sections' 2826 contents. We have already stored this in our linked list structure. */ 2827 2828 static bfd_boolean 2829 ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED, 2830 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 2831 asection *asec, 2832 bfd_byte *contents ATTRIBUTE_UNUSED) 2833 { 2834 return apuinfo_set && strcmp (asec->name, APUINFO_SECTION_NAME) == 0; 2835 } 2836 2837 /* Finally we can generate the output section. */ 2838 2839 static void 2840 ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 2841 { 2842 bfd_byte *buffer; 2843 asection *asec; 2844 unsigned i; 2845 unsigned num_entries; 2846 bfd_size_type length; 2847 2848 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2849 if (asec == NULL) 2850 return; 2851 2852 if (!apuinfo_set) 2853 return; 2854 2855 length = asec->size; 2856 if (length < 20) 2857 return; 2858 2859 buffer = bfd_malloc (length); 2860 if (buffer == NULL) 2861 { 2862 (*_bfd_error_handler) 2863 (_("failed to allocate space for new APUinfo section.")); 2864 return; 2865 } 2866 2867 /* Create the apuinfo header. */ 2868 num_entries = apuinfo_list_length (); 2869 bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer); 2870 bfd_put_32 (abfd, num_entries * 4, buffer + 4); 2871 bfd_put_32 (abfd, 0x2, buffer + 8); 2872 strcpy ((char *) buffer + 12, APUINFO_LABEL); 2873 2874 length = 20; 2875 for (i = 0; i < num_entries; i++) 2876 { 2877 bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length); 2878 length += 4; 2879 } 2880 2881 if (length != asec->size) 2882 (*_bfd_error_handler) (_("failed to compute new APUinfo section.")); 2883 2884 if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length)) 2885 (*_bfd_error_handler) (_("failed to install new APUinfo section.")); 2886 2887 free (buffer); 2888 2889 apuinfo_list_finish (); 2890 } 2891 2892 static bfd_boolean 2894 is_nonpic_glink_stub (bfd *abfd, asection *glink, bfd_vma off) 2895 { 2896 bfd_byte buf[GLINK_ENTRY_SIZE]; 2897 2898 if (!bfd_get_section_contents (abfd, glink, buf, off, GLINK_ENTRY_SIZE)) 2899 return FALSE; 2900 2901 return ((bfd_get_32 (abfd, buf + 0) & 0xffff0000) == LIS_11 2902 && (bfd_get_32 (abfd, buf + 4) & 0xffff0000) == LWZ_11_11 2903 && bfd_get_32 (abfd, buf + 8) == MTCTR_11 2904 && bfd_get_32 (abfd, buf + 12) == BCTR); 2905 } 2906 2907 static bfd_boolean 2908 section_covers_vma (bfd *abfd ATTRIBUTE_UNUSED, asection *section, void *ptr) 2909 { 2910 bfd_vma vma = *(bfd_vma *) ptr; 2911 return ((section->flags & SEC_ALLOC) != 0 2912 && section->vma <= vma 2913 && vma < section->vma + section->size); 2914 } 2915 2916 static long 2917 ppc_elf_get_synthetic_symtab (bfd *abfd, long symcount, asymbol **syms, 2918 long dynsymcount, asymbol **dynsyms, 2919 asymbol **ret) 2920 { 2921 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean); 2922 asection *plt, *relplt, *dynamic, *glink; 2923 bfd_vma glink_vma = 0; 2924 bfd_vma resolv_vma = 0; 2925 bfd_vma stub_vma; 2926 asymbol *s; 2927 arelent *p; 2928 long count, i; 2929 size_t size; 2930 char *names; 2931 bfd_byte buf[4]; 2932 2933 *ret = NULL; 2934 2935 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0) 2936 return 0; 2937 2938 if (dynsymcount <= 0) 2939 return 0; 2940 2941 relplt = bfd_get_section_by_name (abfd, ".rela.plt"); 2942 if (relplt == NULL) 2943 return 0; 2944 2945 plt = bfd_get_section_by_name (abfd, ".plt"); 2946 if (plt == NULL) 2947 return 0; 2948 2949 /* Call common code to handle old-style executable PLTs. */ 2950 if (elf_section_flags (plt) & SHF_EXECINSTR) 2951 return _bfd_elf_get_synthetic_symtab (abfd, symcount, syms, 2952 dynsymcount, dynsyms, ret); 2953 2954 /* If this object was prelinked, the prelinker stored the address 2955 of .glink at got[1]. If it wasn't prelinked, got[1] will be zero. */ 2956 dynamic = bfd_get_section_by_name (abfd, ".dynamic"); 2957 if (dynamic != NULL) 2958 { 2959 bfd_byte *dynbuf, *extdyn, *extdynend; 2960 size_t extdynsize; 2961 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *); 2962 2963 if (!bfd_malloc_and_get_section (abfd, dynamic, &dynbuf)) 2964 return -1; 2965 2966 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn; 2967 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in; 2968 2969 extdyn = dynbuf; 2970 extdynend = extdyn + dynamic->size; 2971 for (; extdyn < extdynend; extdyn += extdynsize) 2972 { 2973 Elf_Internal_Dyn dyn; 2974 (*swap_dyn_in) (abfd, extdyn, &dyn); 2975 2976 if (dyn.d_tag == DT_NULL) 2977 break; 2978 2979 if (dyn.d_tag == DT_PPC_GOT) 2980 { 2981 unsigned int g_o_t = dyn.d_un.d_val; 2982 asection *got = bfd_get_section_by_name (abfd, ".got"); 2983 if (got != NULL 2984 && bfd_get_section_contents (abfd, got, buf, 2985 g_o_t - got->vma + 4, 4)) 2986 glink_vma = bfd_get_32 (abfd, buf); 2987 break; 2988 } 2989 } 2990 free (dynbuf); 2991 } 2992 2993 /* Otherwise we read the first plt entry. */ 2994 if (glink_vma == 0) 2995 { 2996 if (bfd_get_section_contents (abfd, plt, buf, 0, 4)) 2997 glink_vma = bfd_get_32 (abfd, buf); 2998 } 2999 3000 if (glink_vma == 0) 3001 return 0; 3002 3003 /* The .glink section usually does not survive the final 3004 link; search for the section (usually .text) where the 3005 glink stubs now reside. */ 3006 glink = bfd_sections_find_if (abfd, section_covers_vma, &glink_vma); 3007 if (glink == NULL) 3008 return 0; 3009 3010 /* Determine glink PLT resolver by reading the relative branch 3011 from the first glink stub. */ 3012 if (bfd_get_section_contents (abfd, glink, buf, 3013 glink_vma - glink->vma, 4)) 3014 { 3015 unsigned int insn = bfd_get_32 (abfd, buf); 3016 3017 /* The first glink stub may either branch to the resolver ... */ 3018 insn ^= B; 3019 if ((insn & ~0x3fffffc) == 0) 3020 resolv_vma = glink_vma + (insn ^ 0x2000000) - 0x2000000; 3021 3022 /* ... or fall through a bunch of NOPs. */ 3023 else if ((insn ^ B ^ NOP) == 0) 3024 for (i = 4; 3025 bfd_get_section_contents (abfd, glink, buf, 3026 glink_vma - glink->vma + i, 4); 3027 i += 4) 3028 if (bfd_get_32 (abfd, buf) != NOP) 3029 { 3030 resolv_vma = glink_vma + i; 3031 break; 3032 } 3033 } 3034 3035 count = relplt->size / sizeof (Elf32_External_Rela); 3036 /* If the stubs are those for -shared/-pie then we might have 3037 multiple stubs for each plt entry. If that is the case then 3038 there is no way to associate stubs with their plt entries short 3039 of figuring out the GOT pointer value used in the stub. */ 3040 if (!is_nonpic_glink_stub (abfd, glink, 3041 glink_vma - GLINK_ENTRY_SIZE - glink->vma)) 3042 return 0; 3043 3044 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table; 3045 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE)) 3046 return -1; 3047 3048 size = count * sizeof (asymbol); 3049 p = relplt->relocation; 3050 for (i = 0; i < count; i++, p++) 3051 { 3052 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt"); 3053 if (p->addend != 0) 3054 size += sizeof ("+0x") - 1 + 8; 3055 } 3056 3057 size += sizeof (asymbol) + sizeof ("__glink"); 3058 3059 if (resolv_vma) 3060 size += sizeof (asymbol) + sizeof ("__glink_PLTresolve"); 3061 3062 s = *ret = bfd_malloc (size); 3063 if (s == NULL) 3064 return -1; 3065 3066 stub_vma = glink_vma; 3067 names = (char *) (s + count + 1 + (resolv_vma != 0)); 3068 p = relplt->relocation + count - 1; 3069 for (i = 0; i < count; i++) 3070 { 3071 size_t len; 3072 3073 *s = **p->sym_ptr_ptr; 3074 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since 3075 we are defining a symbol, ensure one of them is set. */ 3076 if ((s->flags & BSF_LOCAL) == 0) 3077 s->flags |= BSF_GLOBAL; 3078 s->flags |= BSF_SYNTHETIC; 3079 s->section = glink; 3080 stub_vma -= 16; 3081 if (strcmp ((*p->sym_ptr_ptr)->name, "__tls_get_addr_opt") == 0) 3082 stub_vma -= 32; 3083 s->value = stub_vma - glink->vma; 3084 s->name = names; 3085 s->udata.p = NULL; 3086 len = strlen ((*p->sym_ptr_ptr)->name); 3087 memcpy (names, (*p->sym_ptr_ptr)->name, len); 3088 names += len; 3089 if (p->addend != 0) 3090 { 3091 memcpy (names, "+0x", sizeof ("+0x") - 1); 3092 names += sizeof ("+0x") - 1; 3093 bfd_sprintf_vma (abfd, names, p->addend); 3094 names += strlen (names); 3095 } 3096 memcpy (names, "@plt", sizeof ("@plt")); 3097 names += sizeof ("@plt"); 3098 ++s; 3099 --p; 3100 } 3101 3102 /* Add a symbol at the start of the glink branch table. */ 3103 memset (s, 0, sizeof *s); 3104 s->the_bfd = abfd; 3105 s->flags = BSF_GLOBAL | BSF_SYNTHETIC; 3106 s->section = glink; 3107 s->value = glink_vma - glink->vma; 3108 s->name = names; 3109 memcpy (names, "__glink", sizeof ("__glink")); 3110 names += sizeof ("__glink"); 3111 s++; 3112 count++; 3113 3114 if (resolv_vma) 3115 { 3116 /* Add a symbol for the glink PLT resolver. */ 3117 memset (s, 0, sizeof *s); 3118 s->the_bfd = abfd; 3119 s->flags = BSF_GLOBAL | BSF_SYNTHETIC; 3120 s->section = glink; 3121 s->value = resolv_vma - glink->vma; 3122 s->name = names; 3123 memcpy (names, "__glink_PLTresolve", sizeof ("__glink_PLTresolve")); 3124 names += sizeof ("__glink_PLTresolve"); 3125 s++; 3126 count++; 3127 } 3128 3129 return count; 3130 } 3131 3132 /* The following functions are specific to the ELF linker, while 3134 functions above are used generally. They appear in this file more 3135 or less in the order in which they are called. eg. 3136 ppc_elf_check_relocs is called early in the link process, 3137 ppc_elf_finish_dynamic_sections is one of the last functions 3138 called. */ 3139 3140 /* Track PLT entries needed for a given symbol. We might need more 3141 than one glink entry per symbol when generating a pic binary. */ 3142 struct plt_entry 3143 { 3144 struct plt_entry *next; 3145 3146 /* -fPIC uses multiple GOT sections, one per file, called ".got2". 3147 This field stores the offset into .got2 used to initialise the 3148 GOT pointer reg. It will always be at least 32768. (Current 3149 gcc always uses an offset of 32768, but ld -r will pack .got2 3150 sections together resulting in larger offsets). */ 3151 bfd_vma addend; 3152 3153 /* The .got2 section. */ 3154 asection *sec; 3155 3156 /* PLT refcount or offset. */ 3157 union 3158 { 3159 bfd_signed_vma refcount; 3160 bfd_vma offset; 3161 } plt; 3162 3163 /* .glink stub offset. */ 3164 bfd_vma glink_offset; 3165 }; 3166 3167 /* Of those relocs that might be copied as dynamic relocs, this function 3168 selects those that must be copied when linking a shared library, 3169 even when the symbol is local. */ 3170 3171 static int 3172 must_be_dyn_reloc (struct bfd_link_info *info, 3173 enum elf_ppc_reloc_type r_type) 3174 { 3175 switch (r_type) 3176 { 3177 default: 3178 return 1; 3179 3180 case R_PPC_REL24: 3181 case R_PPC_REL14: 3182 case R_PPC_REL14_BRTAKEN: 3183 case R_PPC_REL14_BRNTAKEN: 3184 case R_PPC_REL32: 3185 return 0; 3186 3187 case R_PPC_TPREL32: 3188 case R_PPC_TPREL16: 3189 case R_PPC_TPREL16_LO: 3190 case R_PPC_TPREL16_HI: 3191 case R_PPC_TPREL16_HA: 3192 return !bfd_link_executable (info); 3193 } 3194 } 3195 3196 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 3197 copying dynamic variables from a shared lib into an app's dynbss 3198 section, and instead use a dynamic relocation to point into the 3199 shared lib. */ 3200 #define ELIMINATE_COPY_RELOCS 1 3201 3202 /* Used to track dynamic relocations for local symbols. */ 3203 struct ppc_dyn_relocs 3204 { 3205 struct ppc_dyn_relocs *next; 3206 3207 /* The input section of the reloc. */ 3208 asection *sec; 3209 3210 /* Total number of relocs copied for the input section. */ 3211 unsigned int count : 31; 3212 3213 /* Whether this entry is for STT_GNU_IFUNC symbols. */ 3214 unsigned int ifunc : 1; 3215 }; 3216 3217 /* PPC ELF linker hash entry. */ 3218 3219 struct ppc_elf_link_hash_entry 3220 { 3221 struct elf_link_hash_entry elf; 3222 3223 /* If this symbol is used in the linker created sections, the processor 3224 specific backend uses this field to map the field into the offset 3225 from the beginning of the section. */ 3226 elf_linker_section_pointers_t *linker_section_pointer; 3227 3228 /* Track dynamic relocs copied for this symbol. */ 3229 struct elf_dyn_relocs *dyn_relocs; 3230 3231 /* Contexts in which symbol is used in the GOT (or TOC). 3232 TLS_GD .. TLS_TLS bits are or'd into the mask as the 3233 corresponding relocs are encountered during check_relocs. 3234 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to 3235 indicate the corresponding GOT entry type is not needed. */ 3236 #define TLS_GD 1 /* GD reloc. */ 3237 #define TLS_LD 2 /* LD reloc. */ 3238 #define TLS_TPREL 4 /* TPREL reloc, => IE. */ 3239 #define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ 3240 #define TLS_TLS 16 /* Any TLS reloc. */ 3241 #define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */ 3242 #define PLT_IFUNC 64 /* STT_GNU_IFUNC. */ 3243 char tls_mask; 3244 3245 /* Nonzero if we have seen a small data relocation referring to this 3246 symbol. */ 3247 unsigned char has_sda_refs : 1; 3248 3249 /* Flag use of given relocations. */ 3250 unsigned char has_addr16_ha : 1; 3251 unsigned char has_addr16_lo : 1; 3252 }; 3253 3254 #define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent)) 3255 3256 /* PPC ELF linker hash table. */ 3257 3258 struct ppc_elf_link_hash_table 3259 { 3260 struct elf_link_hash_table elf; 3261 3262 /* Various options passed from the linker. */ 3263 struct ppc_elf_params *params; 3264 3265 /* Short-cuts to get to dynamic linker sections. */ 3266 asection *got; 3267 asection *relgot; 3268 asection *glink; 3269 asection *plt; 3270 asection *relplt; 3271 asection *iplt; 3272 asection *reliplt; 3273 asection *dynbss; 3274 asection *relbss; 3275 asection *dynsbss; 3276 asection *relsbss; 3277 elf_linker_section_t sdata[2]; 3278 asection *sbss; 3279 asection *glink_eh_frame; 3280 3281 /* The (unloaded but important) .rela.plt.unloaded on VxWorks. */ 3282 asection *srelplt2; 3283 3284 /* The .got.plt section (VxWorks only)*/ 3285 asection *sgotplt; 3286 3287 /* Shortcut to __tls_get_addr. */ 3288 struct elf_link_hash_entry *tls_get_addr; 3289 3290 /* The bfd that forced an old-style PLT. */ 3291 bfd *old_bfd; 3292 3293 /* TLS local dynamic got entry handling. */ 3294 union { 3295 bfd_signed_vma refcount; 3296 bfd_vma offset; 3297 } tlsld_got; 3298 3299 /* Offset of branch table to PltResolve function in glink. */ 3300 bfd_vma glink_pltresolve; 3301 3302 /* Size of reserved GOT entries. */ 3303 unsigned int got_header_size; 3304 /* Non-zero if allocating the header left a gap. */ 3305 unsigned int got_gap; 3306 3307 /* The type of PLT we have chosen to use. */ 3308 enum ppc_elf_plt_type plt_type; 3309 3310 /* True if the target system is VxWorks. */ 3311 unsigned int is_vxworks:1; 3312 3313 /* The size of PLT entries. */ 3314 int plt_entry_size; 3315 /* The distance between adjacent PLT slots. */ 3316 int plt_slot_size; 3317 /* The size of the first PLT entry. */ 3318 int plt_initial_entry_size; 3319 3320 /* Small local sym cache. */ 3321 struct sym_cache sym_cache; 3322 }; 3323 3324 /* Rename some of the generic section flags to better document how they 3325 are used for ppc32. The flags are only valid for ppc32 elf objects. */ 3326 3327 /* Nonzero if this section has TLS related relocations. */ 3328 #define has_tls_reloc sec_flg0 3329 3330 /* Nonzero if this section has a call to __tls_get_addr. */ 3331 #define has_tls_get_addr_call sec_flg1 3332 3333 /* Get the PPC ELF linker hash table from a link_info structure. */ 3334 3335 #define ppc_elf_hash_table(p) \ 3336 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 3337 == PPC32_ELF_DATA ? ((struct ppc_elf_link_hash_table *) ((p)->hash)) : NULL) 3338 3339 /* Create an entry in a PPC ELF linker hash table. */ 3340 3341 static struct bfd_hash_entry * 3342 ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 3343 struct bfd_hash_table *table, 3344 const char *string) 3345 { 3346 /* Allocate the structure if it has not already been allocated by a 3347 subclass. */ 3348 if (entry == NULL) 3349 { 3350 entry = bfd_hash_allocate (table, 3351 sizeof (struct ppc_elf_link_hash_entry)); 3352 if (entry == NULL) 3353 return entry; 3354 } 3355 3356 /* Call the allocation method of the superclass. */ 3357 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 3358 if (entry != NULL) 3359 { 3360 ppc_elf_hash_entry (entry)->linker_section_pointer = NULL; 3361 ppc_elf_hash_entry (entry)->dyn_relocs = NULL; 3362 ppc_elf_hash_entry (entry)->tls_mask = 0; 3363 ppc_elf_hash_entry (entry)->has_sda_refs = 0; 3364 } 3365 3366 return entry; 3367 } 3368 3369 /* Create a PPC ELF linker hash table. */ 3370 3371 static struct bfd_link_hash_table * 3372 ppc_elf_link_hash_table_create (bfd *abfd) 3373 { 3374 struct ppc_elf_link_hash_table *ret; 3375 static struct ppc_elf_params default_params = { PLT_OLD, 0, 1, 0, 0, 12, 0 }; 3376 3377 ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table)); 3378 if (ret == NULL) 3379 return NULL; 3380 3381 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 3382 ppc_elf_link_hash_newfunc, 3383 sizeof (struct ppc_elf_link_hash_entry), 3384 PPC32_ELF_DATA)) 3385 { 3386 free (ret); 3387 return NULL; 3388 } 3389 3390 ret->elf.init_plt_refcount.refcount = 0; 3391 ret->elf.init_plt_refcount.glist = NULL; 3392 ret->elf.init_plt_offset.offset = 0; 3393 ret->elf.init_plt_offset.glist = NULL; 3394 3395 ret->params = &default_params; 3396 3397 ret->sdata[0].name = ".sdata"; 3398 ret->sdata[0].sym_name = "_SDA_BASE_"; 3399 ret->sdata[0].bss_name = ".sbss"; 3400 3401 ret->sdata[1].name = ".sdata2"; 3402 ret->sdata[1].sym_name = "_SDA2_BASE_"; 3403 ret->sdata[1].bss_name = ".sbss2"; 3404 3405 ret->plt_entry_size = 12; 3406 ret->plt_slot_size = 8; 3407 ret->plt_initial_entry_size = 72; 3408 3409 return &ret->elf.root; 3410 } 3411 3412 /* Hook linker params into hash table. */ 3413 3414 void 3415 ppc_elf_link_params (struct bfd_link_info *info, struct ppc_elf_params *params) 3416 { 3417 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 3418 3419 if (htab) 3420 htab->params = params; 3421 } 3422 3423 /* Create .got and the related sections. */ 3424 3425 static bfd_boolean 3426 ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info) 3427 { 3428 struct ppc_elf_link_hash_table *htab; 3429 asection *s; 3430 flagword flags; 3431 3432 if (!_bfd_elf_create_got_section (abfd, info)) 3433 return FALSE; 3434 3435 htab = ppc_elf_hash_table (info); 3436 htab->got = s = bfd_get_linker_section (abfd, ".got"); 3437 if (s == NULL) 3438 abort (); 3439 3440 if (htab->is_vxworks) 3441 { 3442 htab->sgotplt = bfd_get_linker_section (abfd, ".got.plt"); 3443 if (!htab->sgotplt) 3444 abort (); 3445 } 3446 else 3447 { 3448 /* The powerpc .got has a blrl instruction in it. Mark it 3449 executable. */ 3450 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS 3451 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3452 if (!bfd_set_section_flags (abfd, s, flags)) 3453 return FALSE; 3454 } 3455 3456 htab->relgot = bfd_get_linker_section (abfd, ".rela.got"); 3457 if (!htab->relgot) 3458 abort (); 3459 3460 return TRUE; 3461 } 3462 3463 /* Create a special linker section, used for R_PPC_EMB_SDAI16 and 3464 R_PPC_EMB_SDA2I16 pointers. These sections become part of .sdata 3465 and .sdata2. Create _SDA_BASE_ and _SDA2_BASE too. */ 3466 3467 static bfd_boolean 3468 ppc_elf_create_linker_section (bfd *abfd, 3469 struct bfd_link_info *info, 3470 flagword flags, 3471 elf_linker_section_t *lsect) 3472 { 3473 asection *s; 3474 3475 flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3476 | SEC_LINKER_CREATED); 3477 3478 s = bfd_make_section_anyway_with_flags (abfd, lsect->name, flags); 3479 if (s == NULL) 3480 return FALSE; 3481 lsect->section = s; 3482 3483 /* Define the sym on the first section of this name. */ 3484 s = bfd_get_section_by_name (abfd, lsect->name); 3485 3486 lsect->sym = _bfd_elf_define_linkage_sym (abfd, info, s, lsect->sym_name); 3487 if (lsect->sym == NULL) 3488 return FALSE; 3489 lsect->sym->root.u.def.value = 0x8000; 3490 return TRUE; 3491 } 3492 3493 static bfd_boolean 3494 ppc_elf_create_glink (bfd *abfd, struct bfd_link_info *info) 3495 { 3496 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 3497 asection *s; 3498 flagword flags; 3499 3500 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS 3501 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3502 s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags); 3503 htab->glink = s; 3504 if (s == NULL 3505 || !bfd_set_section_alignment (abfd, s, 3506 htab->params->ppc476_workaround ? 6 : 4)) 3507 return FALSE; 3508 3509 if (!info->no_ld_generated_unwind_info) 3510 { 3511 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS 3512 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3513 s = bfd_make_section_anyway_with_flags (abfd, ".eh_frame", flags); 3514 htab->glink_eh_frame = s; 3515 if (s == NULL 3516 || !bfd_set_section_alignment (abfd, s, 2)) 3517 return FALSE; 3518 } 3519 3520 flags = SEC_ALLOC | SEC_LINKER_CREATED; 3521 s = bfd_make_section_anyway_with_flags (abfd, ".iplt", flags); 3522 htab->iplt = s; 3523 if (s == NULL 3524 || !bfd_set_section_alignment (abfd, s, 4)) 3525 return FALSE; 3526 3527 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS 3528 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3529 s = bfd_make_section_anyway_with_flags (abfd, ".rela.iplt", flags); 3530 htab->reliplt = s; 3531 if (s == NULL 3532 || ! bfd_set_section_alignment (abfd, s, 2)) 3533 return FALSE; 3534 3535 if (!ppc_elf_create_linker_section (abfd, info, 0, 3536 &htab->sdata[0])) 3537 return FALSE; 3538 3539 if (!ppc_elf_create_linker_section (abfd, info, SEC_READONLY, 3540 &htab->sdata[1])) 3541 return FALSE; 3542 3543 return TRUE; 3544 } 3545 3546 /* We have to create .dynsbss and .rela.sbss here so that they get mapped 3547 to output sections (just like _bfd_elf_create_dynamic_sections has 3548 to create .dynbss and .rela.bss). */ 3549 3550 static bfd_boolean 3551 ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 3552 { 3553 struct ppc_elf_link_hash_table *htab; 3554 asection *s; 3555 flagword flags; 3556 3557 htab = ppc_elf_hash_table (info); 3558 3559 if (htab->got == NULL 3560 && !ppc_elf_create_got (abfd, info)) 3561 return FALSE; 3562 3563 if (!_bfd_elf_create_dynamic_sections (abfd, info)) 3564 return FALSE; 3565 3566 if (htab->glink == NULL 3567 && !ppc_elf_create_glink (abfd, info)) 3568 return FALSE; 3569 3570 htab->dynbss = bfd_get_linker_section (abfd, ".dynbss"); 3571 s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss", 3572 SEC_ALLOC | SEC_LINKER_CREATED); 3573 htab->dynsbss = s; 3574 if (s == NULL) 3575 return FALSE; 3576 3577 if (! bfd_link_pic (info)) 3578 { 3579 htab->relbss = bfd_get_linker_section (abfd, ".rela.bss"); 3580 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS 3581 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3582 s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss", flags); 3583 htab->relsbss = s; 3584 if (s == NULL 3585 || ! bfd_set_section_alignment (abfd, s, 2)) 3586 return FALSE; 3587 } 3588 3589 if (htab->is_vxworks 3590 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) 3591 return FALSE; 3592 3593 htab->relplt = bfd_get_linker_section (abfd, ".rela.plt"); 3594 htab->plt = s = bfd_get_linker_section (abfd, ".plt"); 3595 if (s == NULL) 3596 abort (); 3597 3598 flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED; 3599 if (htab->plt_type == PLT_VXWORKS) 3600 /* The VxWorks PLT is a loaded section with contents. */ 3601 flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY; 3602 return bfd_set_section_flags (abfd, s, flags); 3603 } 3604 3605 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 3606 3607 static void 3608 ppc_elf_copy_indirect_symbol (struct bfd_link_info *info, 3609 struct elf_link_hash_entry *dir, 3610 struct elf_link_hash_entry *ind) 3611 { 3612 struct ppc_elf_link_hash_entry *edir, *eind; 3613 3614 edir = (struct ppc_elf_link_hash_entry *) dir; 3615 eind = (struct ppc_elf_link_hash_entry *) ind; 3616 3617 edir->tls_mask |= eind->tls_mask; 3618 edir->has_sda_refs |= eind->has_sda_refs; 3619 3620 /* If called to transfer flags for a weakdef during processing 3621 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 3622 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 3623 if (!(ELIMINATE_COPY_RELOCS 3624 && eind->elf.root.type != bfd_link_hash_indirect 3625 && edir->elf.dynamic_adjusted)) 3626 edir->elf.non_got_ref |= eind->elf.non_got_ref; 3627 3628 edir->elf.ref_dynamic |= eind->elf.ref_dynamic; 3629 edir->elf.ref_regular |= eind->elf.ref_regular; 3630 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak; 3631 edir->elf.needs_plt |= eind->elf.needs_plt; 3632 edir->elf.pointer_equality_needed |= eind->elf.pointer_equality_needed; 3633 3634 if (eind->dyn_relocs != NULL) 3635 { 3636 if (edir->dyn_relocs != NULL) 3637 { 3638 struct elf_dyn_relocs **pp; 3639 struct elf_dyn_relocs *p; 3640 3641 /* Add reloc counts against the indirect sym to the direct sym 3642 list. Merge any entries against the same section. */ 3643 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 3644 { 3645 struct elf_dyn_relocs *q; 3646 3647 for (q = edir->dyn_relocs; q != NULL; q = q->next) 3648 if (q->sec == p->sec) 3649 { 3650 q->pc_count += p->pc_count; 3651 q->count += p->count; 3652 *pp = p->next; 3653 break; 3654 } 3655 if (q == NULL) 3656 pp = &p->next; 3657 } 3658 *pp = edir->dyn_relocs; 3659 } 3660 3661 edir->dyn_relocs = eind->dyn_relocs; 3662 eind->dyn_relocs = NULL; 3663 } 3664 3665 /* If we were called to copy over info for a weak sym, that's all. 3666 You might think dyn_relocs need not be copied over; After all, 3667 both syms will be dynamic or both non-dynamic so we're just 3668 moving reloc accounting around. However, ELIMINATE_COPY_RELOCS 3669 code in ppc_elf_adjust_dynamic_symbol needs to check for 3670 dyn_relocs in read-only sections, and it does so on what is the 3671 DIR sym here. */ 3672 if (eind->elf.root.type != bfd_link_hash_indirect) 3673 return; 3674 3675 /* Copy over the GOT refcount entries that we may have already seen to 3676 the symbol which just became indirect. */ 3677 edir->elf.got.refcount += eind->elf.got.refcount; 3678 eind->elf.got.refcount = 0; 3679 3680 /* And plt entries. */ 3681 if (eind->elf.plt.plist != NULL) 3682 { 3683 if (edir->elf.plt.plist != NULL) 3684 { 3685 struct plt_entry **entp; 3686 struct plt_entry *ent; 3687 3688 for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; ) 3689 { 3690 struct plt_entry *dent; 3691 3692 for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next) 3693 if (dent->sec == ent->sec && dent->addend == ent->addend) 3694 { 3695 dent->plt.refcount += ent->plt.refcount; 3696 *entp = ent->next; 3697 break; 3698 } 3699 if (dent == NULL) 3700 entp = &ent->next; 3701 } 3702 *entp = edir->elf.plt.plist; 3703 } 3704 3705 edir->elf.plt.plist = eind->elf.plt.plist; 3706 eind->elf.plt.plist = NULL; 3707 } 3708 3709 if (eind->elf.dynindx != -1) 3710 { 3711 if (edir->elf.dynindx != -1) 3712 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 3713 edir->elf.dynstr_index); 3714 edir->elf.dynindx = eind->elf.dynindx; 3715 edir->elf.dynstr_index = eind->elf.dynstr_index; 3716 eind->elf.dynindx = -1; 3717 eind->elf.dynstr_index = 0; 3718 } 3719 } 3720 3721 /* Hook called by the linker routine which adds symbols from an object 3722 file. We use it to put .comm items in .sbss, and not .bss. */ 3723 3724 static bfd_boolean 3725 ppc_elf_add_symbol_hook (bfd *abfd, 3726 struct bfd_link_info *info, 3727 Elf_Internal_Sym *sym, 3728 const char **namep ATTRIBUTE_UNUSED, 3729 flagword *flagsp ATTRIBUTE_UNUSED, 3730 asection **secp, 3731 bfd_vma *valp) 3732 { 3733 if (sym->st_shndx == SHN_COMMON 3734 && !bfd_link_relocatable (info) 3735 && is_ppc_elf (info->output_bfd) 3736 && sym->st_size <= elf_gp_size (abfd)) 3737 { 3738 /* Common symbols less than or equal to -G nn bytes are automatically 3739 put into .sbss. */ 3740 struct ppc_elf_link_hash_table *htab; 3741 3742 htab = ppc_elf_hash_table (info); 3743 if (htab->sbss == NULL) 3744 { 3745 flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED; 3746 3747 if (!htab->elf.dynobj) 3748 htab->elf.dynobj = abfd; 3749 3750 htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 3751 ".sbss", 3752 flags); 3753 if (htab->sbss == NULL) 3754 return FALSE; 3755 } 3756 3757 *secp = htab->sbss; 3758 *valp = sym->st_size; 3759 } 3760 3761 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC 3762 && (abfd->flags & DYNAMIC) == 0 3763 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour) 3764 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc; 3765 3766 return TRUE; 3767 } 3768 3769 /* Find a linker generated pointer with a given addend and type. */ 3771 3772 static elf_linker_section_pointers_t * 3773 elf_find_pointer_linker_section 3774 (elf_linker_section_pointers_t *linker_pointers, 3775 bfd_vma addend, 3776 elf_linker_section_t *lsect) 3777 { 3778 for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) 3779 if (lsect == linker_pointers->lsect && addend == linker_pointers->addend) 3780 return linker_pointers; 3781 3782 return NULL; 3783 } 3784 3785 /* Allocate a pointer to live in a linker created section. */ 3786 3787 static bfd_boolean 3788 elf_allocate_pointer_linker_section (bfd *abfd, 3789 elf_linker_section_t *lsect, 3790 struct elf_link_hash_entry *h, 3791 const Elf_Internal_Rela *rel) 3792 { 3793 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL; 3794 elf_linker_section_pointers_t *linker_section_ptr; 3795 unsigned long r_symndx = ELF32_R_SYM (rel->r_info); 3796 bfd_size_type amt; 3797 3798 BFD_ASSERT (lsect != NULL); 3799 3800 /* Is this a global symbol? */ 3801 if (h != NULL) 3802 { 3803 struct ppc_elf_link_hash_entry *eh; 3804 3805 /* Has this symbol already been allocated? If so, our work is done. */ 3806 eh = (struct ppc_elf_link_hash_entry *) h; 3807 if (elf_find_pointer_linker_section (eh->linker_section_pointer, 3808 rel->r_addend, 3809 lsect)) 3810 return TRUE; 3811 3812 ptr_linker_section_ptr = &eh->linker_section_pointer; 3813 } 3814 else 3815 { 3816 BFD_ASSERT (is_ppc_elf (abfd)); 3817 3818 /* Allocation of a pointer to a local symbol. */ 3819 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd); 3820 3821 /* Allocate a table to hold the local symbols if first time. */ 3822 if (!ptr) 3823 { 3824 unsigned int num_symbols = elf_symtab_hdr (abfd).sh_info; 3825 3826 amt = num_symbols; 3827 amt *= sizeof (elf_linker_section_pointers_t *); 3828 ptr = bfd_zalloc (abfd, amt); 3829 3830 if (!ptr) 3831 return FALSE; 3832 3833 elf_local_ptr_offsets (abfd) = ptr; 3834 } 3835 3836 /* Has this symbol already been allocated? If so, our work is done. */ 3837 if (elf_find_pointer_linker_section (ptr[r_symndx], 3838 rel->r_addend, 3839 lsect)) 3840 return TRUE; 3841 3842 ptr_linker_section_ptr = &ptr[r_symndx]; 3843 } 3844 3845 /* Allocate space for a pointer in the linker section, and allocate 3846 a new pointer record from internal memory. */ 3847 BFD_ASSERT (ptr_linker_section_ptr != NULL); 3848 amt = sizeof (elf_linker_section_pointers_t); 3849 linker_section_ptr = bfd_alloc (abfd, amt); 3850 3851 if (!linker_section_ptr) 3852 return FALSE; 3853 3854 linker_section_ptr->next = *ptr_linker_section_ptr; 3855 linker_section_ptr->addend = rel->r_addend; 3856 linker_section_ptr->lsect = lsect; 3857 *ptr_linker_section_ptr = linker_section_ptr; 3858 3859 if (!bfd_set_section_alignment (lsect->section->owner, lsect->section, 2)) 3860 return FALSE; 3861 linker_section_ptr->offset = lsect->section->size; 3862 lsect->section->size += 4; 3863 3864 #ifdef DEBUG 3865 fprintf (stderr, 3866 "Create pointer in linker section %s, offset = %ld, section size = %ld\n", 3867 lsect->name, (long) linker_section_ptr->offset, 3868 (long) lsect->section->size); 3869 #endif 3870 3871 return TRUE; 3872 } 3873 3874 static struct plt_entry ** 3875 update_local_sym_info (bfd *abfd, 3876 Elf_Internal_Shdr *symtab_hdr, 3877 unsigned long r_symndx, 3878 int tls_type) 3879 { 3880 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd); 3881 struct plt_entry **local_plt; 3882 char *local_got_tls_masks; 3883 3884 if (local_got_refcounts == NULL) 3885 { 3886 bfd_size_type size = symtab_hdr->sh_info; 3887 3888 size *= (sizeof (*local_got_refcounts) 3889 + sizeof (*local_plt) 3890 + sizeof (*local_got_tls_masks)); 3891 local_got_refcounts = bfd_zalloc (abfd, size); 3892 if (local_got_refcounts == NULL) 3893 return NULL; 3894 elf_local_got_refcounts (abfd) = local_got_refcounts; 3895 } 3896 3897 local_plt = (struct plt_entry **) (local_got_refcounts + symtab_hdr->sh_info); 3898 local_got_tls_masks = (char *) (local_plt + symtab_hdr->sh_info); 3899 local_got_tls_masks[r_symndx] |= tls_type; 3900 if (tls_type != PLT_IFUNC) 3901 local_got_refcounts[r_symndx] += 1; 3902 return local_plt + r_symndx; 3903 } 3904 3905 static bfd_boolean 3906 update_plt_info (bfd *abfd, struct plt_entry **plist, 3907 asection *sec, bfd_vma addend) 3908 { 3909 struct plt_entry *ent; 3910 3911 if (addend < 32768) 3912 sec = NULL; 3913 for (ent = *plist; ent != NULL; ent = ent->next) 3914 if (ent->sec == sec && ent->addend == addend) 3915 break; 3916 if (ent == NULL) 3917 { 3918 bfd_size_type amt = sizeof (*ent); 3919 ent = bfd_alloc (abfd, amt); 3920 if (ent == NULL) 3921 return FALSE; 3922 ent->next = *plist; 3923 ent->sec = sec; 3924 ent->addend = addend; 3925 ent->plt.refcount = 0; 3926 *plist = ent; 3927 } 3928 ent->plt.refcount += 1; 3929 return TRUE; 3930 } 3931 3932 static struct plt_entry * 3933 find_plt_ent (struct plt_entry **plist, asection *sec, bfd_vma addend) 3934 { 3935 struct plt_entry *ent; 3936 3937 if (addend < 32768) 3938 sec = NULL; 3939 for (ent = *plist; ent != NULL; ent = ent->next) 3940 if (ent->sec == sec && ent->addend == addend) 3941 break; 3942 return ent; 3943 } 3944 3945 static bfd_boolean 3946 is_branch_reloc (enum elf_ppc_reloc_type r_type) 3947 { 3948 return (r_type == R_PPC_PLTREL24 3949 || r_type == R_PPC_LOCAL24PC 3950 || r_type == R_PPC_REL24 3951 || r_type == R_PPC_REL14 3952 || r_type == R_PPC_REL14_BRTAKEN 3953 || r_type == R_PPC_REL14_BRNTAKEN 3954 || r_type == R_PPC_ADDR24 3955 || r_type == R_PPC_ADDR14 3956 || r_type == R_PPC_ADDR14_BRTAKEN 3957 || r_type == R_PPC_ADDR14_BRNTAKEN); 3958 } 3959 3960 static void 3961 bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type) 3962 { 3963 (*_bfd_error_handler) 3964 (_("%B: relocation %s cannot be used when making a shared object"), 3965 abfd, 3966 ppc_elf_howto_table[r_type]->name); 3967 bfd_set_error (bfd_error_bad_value); 3968 } 3969 3970 /* Look through the relocs for a section during the first phase, and 3971 allocate space in the global offset table or procedure linkage 3972 table. */ 3973 3974 static bfd_boolean 3975 ppc_elf_check_relocs (bfd *abfd, 3976 struct bfd_link_info *info, 3977 asection *sec, 3978 const Elf_Internal_Rela *relocs) 3979 { 3980 struct ppc_elf_link_hash_table *htab; 3981 Elf_Internal_Shdr *symtab_hdr; 3982 struct elf_link_hash_entry **sym_hashes; 3983 const Elf_Internal_Rela *rel; 3984 const Elf_Internal_Rela *rel_end; 3985 asection *got2, *sreloc; 3986 struct elf_link_hash_entry *tga; 3987 3988 if (bfd_link_relocatable (info)) 3989 return TRUE; 3990 3991 /* Don't do anything special with non-loaded, non-alloced sections. 3992 In particular, any relocs in such sections should not affect GOT 3993 and PLT reference counting (ie. we don't allow them to create GOT 3994 or PLT entries), there's no possibility or desire to optimize TLS 3995 relocs, and there's not much point in propagating relocs to shared 3996 libs that the dynamic linker won't relocate. */ 3997 if ((sec->flags & SEC_ALLOC) == 0) 3998 return TRUE; 3999 4000 #ifdef DEBUG 4001 _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B", 4002 sec, abfd); 4003 #endif 4004 4005 BFD_ASSERT (is_ppc_elf (abfd)); 4006 4007 /* Initialize howto table if not already done. */ 4008 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 4009 ppc_elf_howto_init (); 4010 4011 htab = ppc_elf_hash_table (info); 4012 if (htab->glink == NULL) 4013 { 4014 if (htab->elf.dynobj == NULL) 4015 htab->elf.dynobj = abfd; 4016 if (!ppc_elf_create_glink (htab->elf.dynobj, info)) 4017 return FALSE; 4018 } 4019 tga = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 4020 FALSE, FALSE, TRUE); 4021 symtab_hdr = &elf_symtab_hdr (abfd); 4022 sym_hashes = elf_sym_hashes (abfd); 4023 got2 = bfd_get_section_by_name (abfd, ".got2"); 4024 sreloc = NULL; 4025 4026 rel_end = relocs + sec->reloc_count; 4027 for (rel = relocs; rel < rel_end; rel++) 4028 { 4029 unsigned long r_symndx; 4030 enum elf_ppc_reloc_type r_type; 4031 struct elf_link_hash_entry *h; 4032 int tls_type; 4033 struct plt_entry **ifunc; 4034 4035 r_symndx = ELF32_R_SYM (rel->r_info); 4036 if (r_symndx < symtab_hdr->sh_info) 4037 h = NULL; 4038 else 4039 { 4040 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 4041 while (h->root.type == bfd_link_hash_indirect 4042 || h->root.type == bfd_link_hash_warning) 4043 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4044 4045 /* PR15323, ref flags aren't set for references in the same 4046 object. */ 4047 h->root.non_ir_ref = 1; 4048 } 4049 4050 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got. 4051 This shows up in particular in an R_PPC_ADDR32 in the eabi 4052 startup code. */ 4053 if (h != NULL 4054 && htab->got == NULL 4055 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 4056 { 4057 if (htab->elf.dynobj == NULL) 4058 htab->elf.dynobj = abfd; 4059 if (!ppc_elf_create_got (htab->elf.dynobj, info)) 4060 return FALSE; 4061 BFD_ASSERT (h == htab->elf.hgot); 4062 } 4063 4064 tls_type = 0; 4065 r_type = ELF32_R_TYPE (rel->r_info); 4066 ifunc = NULL; 4067 if (h == NULL && !htab->is_vxworks) 4068 { 4069 Elf_Internal_Sym *isym = bfd_sym_from_r_symndx (&htab->sym_cache, 4070 abfd, r_symndx); 4071 if (isym == NULL) 4072 return FALSE; 4073 4074 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 4075 { 4076 /* Set PLT_IFUNC flag for this sym, no GOT entry yet. */ 4077 ifunc = update_local_sym_info (abfd, symtab_hdr, r_symndx, 4078 PLT_IFUNC); 4079 if (ifunc == NULL) 4080 return FALSE; 4081 4082 /* STT_GNU_IFUNC symbols must have a PLT entry; 4083 In a non-pie executable even when there are 4084 no plt calls. */ 4085 if (!bfd_link_pic (info) 4086 || is_branch_reloc (r_type)) 4087 { 4088 bfd_vma addend = 0; 4089 if (r_type == R_PPC_PLTREL24) 4090 { 4091 ppc_elf_tdata (abfd)->makes_plt_call = 1; 4092 if (bfd_link_pic (info)) 4093 addend = rel->r_addend; 4094 } 4095 if (!update_plt_info (abfd, ifunc, got2, addend)) 4096 return FALSE; 4097 } 4098 } 4099 } 4100 4101 if (!htab->is_vxworks 4102 && is_branch_reloc (r_type) 4103 && h != NULL 4104 && h == tga) 4105 { 4106 if (rel != relocs 4107 && (ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSGD 4108 || ELF32_R_TYPE (rel[-1].r_info) == R_PPC_TLSLD)) 4109 /* We have a new-style __tls_get_addr call with a marker 4110 reloc. */ 4111 ; 4112 else 4113 /* Mark this section as having an old-style call. */ 4114 sec->has_tls_get_addr_call = 1; 4115 } 4116 4117 switch (r_type) 4118 { 4119 case R_PPC_TLSGD: 4120 case R_PPC_TLSLD: 4121 /* These special tls relocs tie a call to __tls_get_addr with 4122 its parameter symbol. */ 4123 break; 4124 4125 case R_PPC_GOT_TLSLD16: 4126 case R_PPC_GOT_TLSLD16_LO: 4127 case R_PPC_GOT_TLSLD16_HI: 4128 case R_PPC_GOT_TLSLD16_HA: 4129 tls_type = TLS_TLS | TLS_LD; 4130 goto dogottls; 4131 4132 case R_PPC_GOT_TLSGD16: 4133 case R_PPC_GOT_TLSGD16_LO: 4134 case R_PPC_GOT_TLSGD16_HI: 4135 case R_PPC_GOT_TLSGD16_HA: 4136 tls_type = TLS_TLS | TLS_GD; 4137 goto dogottls; 4138 4139 case R_PPC_GOT_TPREL16: 4140 case R_PPC_GOT_TPREL16_LO: 4141 case R_PPC_GOT_TPREL16_HI: 4142 case R_PPC_GOT_TPREL16_HA: 4143 if (bfd_link_pic (info)) 4144 info->flags |= DF_STATIC_TLS; 4145 tls_type = TLS_TLS | TLS_TPREL; 4146 goto dogottls; 4147 4148 case R_PPC_GOT_DTPREL16: 4149 case R_PPC_GOT_DTPREL16_LO: 4150 case R_PPC_GOT_DTPREL16_HI: 4151 case R_PPC_GOT_DTPREL16_HA: 4152 tls_type = TLS_TLS | TLS_DTPREL; 4153 dogottls: 4154 sec->has_tls_reloc = 1; 4155 /* Fall thru */ 4156 4157 /* GOT16 relocations */ 4158 case R_PPC_GOT16: 4159 case R_PPC_GOT16_LO: 4160 case R_PPC_GOT16_HI: 4161 case R_PPC_GOT16_HA: 4162 /* This symbol requires a global offset table entry. */ 4163 if (htab->got == NULL) 4164 { 4165 if (htab->elf.dynobj == NULL) 4166 htab->elf.dynobj = abfd; 4167 if (!ppc_elf_create_got (htab->elf.dynobj, info)) 4168 return FALSE; 4169 } 4170 if (h != NULL) 4171 { 4172 h->got.refcount += 1; 4173 ppc_elf_hash_entry (h)->tls_mask |= tls_type; 4174 } 4175 else 4176 /* This is a global offset table entry for a local symbol. */ 4177 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type)) 4178 return FALSE; 4179 4180 /* We may also need a plt entry if the symbol turns out to be 4181 an ifunc. */ 4182 if (h != NULL && !bfd_link_pic (info)) 4183 { 4184 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0)) 4185 return FALSE; 4186 } 4187 break; 4188 4189 /* Indirect .sdata relocation. */ 4190 case R_PPC_EMB_SDAI16: 4191 if (bfd_link_pic (info)) 4192 { 4193 bad_shared_reloc (abfd, r_type); 4194 return FALSE; 4195 } 4196 htab->sdata[0].sym->ref_regular = 1; 4197 if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[0], 4198 h, rel)) 4199 return FALSE; 4200 if (h != NULL) 4201 { 4202 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 4203 h->non_got_ref = TRUE; 4204 } 4205 break; 4206 4207 /* Indirect .sdata2 relocation. */ 4208 case R_PPC_EMB_SDA2I16: 4209 if (bfd_link_pic (info)) 4210 { 4211 bad_shared_reloc (abfd, r_type); 4212 return FALSE; 4213 } 4214 htab->sdata[1].sym->ref_regular = 1; 4215 if (!elf_allocate_pointer_linker_section (abfd, &htab->sdata[1], 4216 h, rel)) 4217 return FALSE; 4218 if (h != NULL) 4219 { 4220 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 4221 h->non_got_ref = TRUE; 4222 } 4223 break; 4224 4225 case R_PPC_SDAREL16: 4226 htab->sdata[0].sym->ref_regular = 1; 4227 /* Fall thru */ 4228 4229 case R_PPC_VLE_SDAREL_LO16A: 4230 case R_PPC_VLE_SDAREL_LO16D: 4231 case R_PPC_VLE_SDAREL_HI16A: 4232 case R_PPC_VLE_SDAREL_HI16D: 4233 case R_PPC_VLE_SDAREL_HA16A: 4234 case R_PPC_VLE_SDAREL_HA16D: 4235 if (h != NULL) 4236 { 4237 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 4238 h->non_got_ref = TRUE; 4239 } 4240 break; 4241 4242 case R_PPC_VLE_REL8: 4243 case R_PPC_VLE_REL15: 4244 case R_PPC_VLE_REL24: 4245 case R_PPC_VLE_LO16A: 4246 case R_PPC_VLE_LO16D: 4247 case R_PPC_VLE_HI16A: 4248 case R_PPC_VLE_HI16D: 4249 case R_PPC_VLE_HA16A: 4250 case R_PPC_VLE_HA16D: 4251 break; 4252 4253 case R_PPC_EMB_SDA2REL: 4254 if (bfd_link_pic (info)) 4255 { 4256 bad_shared_reloc (abfd, r_type); 4257 return FALSE; 4258 } 4259 htab->sdata[1].sym->ref_regular = 1; 4260 if (h != NULL) 4261 { 4262 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 4263 h->non_got_ref = TRUE; 4264 } 4265 break; 4266 4267 case R_PPC_VLE_SDA21_LO: 4268 case R_PPC_VLE_SDA21: 4269 case R_PPC_EMB_SDA21: 4270 case R_PPC_EMB_RELSDA: 4271 if (bfd_link_pic (info)) 4272 { 4273 bad_shared_reloc (abfd, r_type); 4274 return FALSE; 4275 } 4276 if (h != NULL) 4277 { 4278 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 4279 h->non_got_ref = TRUE; 4280 } 4281 break; 4282 4283 case R_PPC_EMB_NADDR32: 4284 case R_PPC_EMB_NADDR16: 4285 case R_PPC_EMB_NADDR16_LO: 4286 case R_PPC_EMB_NADDR16_HI: 4287 case R_PPC_EMB_NADDR16_HA: 4288 if (bfd_link_pic (info)) 4289 { 4290 bad_shared_reloc (abfd, r_type); 4291 return FALSE; 4292 } 4293 if (h != NULL) 4294 h->non_got_ref = TRUE; 4295 break; 4296 4297 case R_PPC_PLTREL24: 4298 if (h == NULL) 4299 break; 4300 /* Fall through */ 4301 case R_PPC_PLT32: 4302 case R_PPC_PLTREL32: 4303 case R_PPC_PLT16_LO: 4304 case R_PPC_PLT16_HI: 4305 case R_PPC_PLT16_HA: 4306 #ifdef DEBUG 4307 fprintf (stderr, "Reloc requires a PLT entry\n"); 4308 #endif 4309 /* This symbol requires a procedure linkage table entry. */ 4310 if (h == NULL) 4311 { 4312 if (ifunc == NULL) 4313 { 4314 /* It does not make sense to have a procedure linkage 4315 table entry for a non-ifunc local symbol. */ 4316 info->callbacks->einfo 4317 (_("%P: %H: %s reloc against local symbol\n"), 4318 abfd, sec, rel->r_offset, 4319 ppc_elf_howto_table[r_type]->name); 4320 bfd_set_error (bfd_error_bad_value); 4321 return FALSE; 4322 } 4323 } 4324 else 4325 { 4326 bfd_vma addend = 0; 4327 4328 if (r_type == R_PPC_PLTREL24) 4329 { 4330 ppc_elf_tdata (abfd)->makes_plt_call = 1; 4331 if (bfd_link_pic (info)) 4332 addend = rel->r_addend; 4333 } 4334 h->needs_plt = 1; 4335 if (!update_plt_info (abfd, &h->plt.plist, got2, addend)) 4336 return FALSE; 4337 } 4338 break; 4339 4340 /* The following relocations don't need to propagate the 4341 relocation if linking a shared object since they are 4342 section relative. */ 4343 case R_PPC_SECTOFF: 4344 case R_PPC_SECTOFF_LO: 4345 case R_PPC_SECTOFF_HI: 4346 case R_PPC_SECTOFF_HA: 4347 case R_PPC_DTPREL16: 4348 case R_PPC_DTPREL16_LO: 4349 case R_PPC_DTPREL16_HI: 4350 case R_PPC_DTPREL16_HA: 4351 case R_PPC_TOC16: 4352 break; 4353 4354 case R_PPC_REL16: 4355 case R_PPC_REL16_LO: 4356 case R_PPC_REL16_HI: 4357 case R_PPC_REL16_HA: 4358 case R_PPC_REL16DX_HA: 4359 ppc_elf_tdata (abfd)->has_rel16 = 1; 4360 break; 4361 4362 /* These are just markers. */ 4363 case R_PPC_TLS: 4364 case R_PPC_EMB_MRKREF: 4365 case R_PPC_NONE: 4366 case R_PPC_max: 4367 case R_PPC_RELAX: 4368 case R_PPC_RELAX_PLT: 4369 case R_PPC_RELAX_PLTREL24: 4370 break; 4371 4372 /* These should only appear in dynamic objects. */ 4373 case R_PPC_COPY: 4374 case R_PPC_GLOB_DAT: 4375 case R_PPC_JMP_SLOT: 4376 case R_PPC_RELATIVE: 4377 case R_PPC_IRELATIVE: 4378 break; 4379 4380 /* These aren't handled yet. We'll report an error later. */ 4381 case R_PPC_ADDR30: 4382 case R_PPC_EMB_RELSEC16: 4383 case R_PPC_EMB_RELST_LO: 4384 case R_PPC_EMB_RELST_HI: 4385 case R_PPC_EMB_RELST_HA: 4386 case R_PPC_EMB_BIT_FLD: 4387 break; 4388 4389 /* This refers only to functions defined in the shared library. */ 4390 case R_PPC_LOCAL24PC: 4391 if (h != NULL && h == htab->elf.hgot && htab->plt_type == PLT_UNSET) 4392 { 4393 htab->plt_type = PLT_OLD; 4394 htab->old_bfd = abfd; 4395 } 4396 if (h != NULL && h->type == STT_GNU_IFUNC) 4397 { 4398 if (bfd_link_pic (info)) 4399 { 4400 info->callbacks->einfo 4401 (_("%P: %H: @local call to ifunc %s\n"), 4402 abfd, sec, rel->r_offset, 4403 h->root.root.string); 4404 bfd_set_error (bfd_error_bad_value); 4405 return FALSE; 4406 } 4407 h->needs_plt = 1; 4408 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0)) 4409 return FALSE; 4410 } 4411 break; 4412 4413 /* This relocation describes the C++ object vtable hierarchy. 4414 Reconstruct it for later use during GC. */ 4415 case R_PPC_GNU_VTINHERIT: 4416 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 4417 return FALSE; 4418 break; 4419 4420 /* This relocation describes which C++ vtable entries are actually 4421 used. Record for later use during GC. */ 4422 case R_PPC_GNU_VTENTRY: 4423 BFD_ASSERT (h != NULL); 4424 if (h != NULL 4425 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 4426 return FALSE; 4427 break; 4428 4429 /* We shouldn't really be seeing these. */ 4430 case R_PPC_TPREL32: 4431 case R_PPC_TPREL16: 4432 case R_PPC_TPREL16_LO: 4433 case R_PPC_TPREL16_HI: 4434 case R_PPC_TPREL16_HA: 4435 if (bfd_link_pic (info)) 4436 info->flags |= DF_STATIC_TLS; 4437 goto dodyn; 4438 4439 /* Nor these. */ 4440 case R_PPC_DTPMOD32: 4441 case R_PPC_DTPREL32: 4442 goto dodyn; 4443 4444 case R_PPC_REL32: 4445 if (h == NULL 4446 && got2 != NULL 4447 && (sec->flags & SEC_CODE) != 0 4448 && bfd_link_pic (info) 4449 && htab->plt_type == PLT_UNSET) 4450 { 4451 /* Old -fPIC gcc code has .long LCTOC1-LCFx just before 4452 the start of a function, which assembles to a REL32 4453 reference to .got2. If we detect one of these, then 4454 force the old PLT layout because the linker cannot 4455 reliably deduce the GOT pointer value needed for 4456 PLT call stubs. */ 4457 asection *s; 4458 Elf_Internal_Sym *isym; 4459 4460 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 4461 abfd, r_symndx); 4462 if (isym == NULL) 4463 return FALSE; 4464 4465 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 4466 if (s == got2) 4467 { 4468 htab->plt_type = PLT_OLD; 4469 htab->old_bfd = abfd; 4470 } 4471 } 4472 if (h == NULL || h == htab->elf.hgot) 4473 break; 4474 /* fall through */ 4475 4476 case R_PPC_ADDR32: 4477 case R_PPC_ADDR16: 4478 case R_PPC_ADDR16_LO: 4479 case R_PPC_ADDR16_HI: 4480 case R_PPC_ADDR16_HA: 4481 case R_PPC_UADDR32: 4482 case R_PPC_UADDR16: 4483 if (h != NULL && !bfd_link_pic (info)) 4484 { 4485 /* We may need a plt entry if the symbol turns out to be 4486 a function defined in a dynamic object. */ 4487 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0)) 4488 return FALSE; 4489 4490 /* We may need a copy reloc too. */ 4491 h->non_got_ref = 1; 4492 h->pointer_equality_needed = 1; 4493 if (r_type == R_PPC_ADDR16_HA) 4494 ppc_elf_hash_entry (h)->has_addr16_ha = 1; 4495 if (r_type == R_PPC_ADDR16_LO) 4496 ppc_elf_hash_entry (h)->has_addr16_lo = 1; 4497 } 4498 goto dodyn; 4499 4500 case R_PPC_REL24: 4501 case R_PPC_REL14: 4502 case R_PPC_REL14_BRTAKEN: 4503 case R_PPC_REL14_BRNTAKEN: 4504 if (h == NULL) 4505 break; 4506 if (h == htab->elf.hgot) 4507 { 4508 if (htab->plt_type == PLT_UNSET) 4509 { 4510 htab->plt_type = PLT_OLD; 4511 htab->old_bfd = abfd; 4512 } 4513 break; 4514 } 4515 /* fall through */ 4516 4517 case R_PPC_ADDR24: 4518 case R_PPC_ADDR14: 4519 case R_PPC_ADDR14_BRTAKEN: 4520 case R_PPC_ADDR14_BRNTAKEN: 4521 if (h != NULL && !bfd_link_pic (info)) 4522 { 4523 /* We may need a plt entry if the symbol turns out to be 4524 a function defined in a dynamic object. */ 4525 h->needs_plt = 1; 4526 if (!update_plt_info (abfd, &h->plt.plist, NULL, 0)) 4527 return FALSE; 4528 break; 4529 } 4530 4531 dodyn: 4532 /* If we are creating a shared library, and this is a reloc 4533 against a global symbol, or a non PC relative reloc 4534 against a local symbol, then we need to copy the reloc 4535 into the shared library. However, if we are linking with 4536 -Bsymbolic, we do not need to copy a reloc against a 4537 global symbol which is defined in an object we are 4538 including in the link (i.e., DEF_REGULAR is set). At 4539 this point we have not seen all the input files, so it is 4540 possible that DEF_REGULAR is not set now but will be set 4541 later (it is never cleared). In case of a weak definition, 4542 DEF_REGULAR may be cleared later by a strong definition in 4543 a shared library. We account for that possibility below by 4544 storing information in the dyn_relocs field of the hash 4545 table entry. A similar situation occurs when creating 4546 shared libraries and symbol visibility changes render the 4547 symbol local. 4548 4549 If on the other hand, we are creating an executable, we 4550 may need to keep relocations for symbols satisfied by a 4551 dynamic library if we manage to avoid copy relocs for the 4552 symbol. */ 4553 if ((bfd_link_pic (info) 4554 && (must_be_dyn_reloc (info, r_type) 4555 || (h != NULL 4556 && (!SYMBOLIC_BIND (info, h) 4557 || h->root.type == bfd_link_hash_defweak 4558 || !h->def_regular)))) 4559 || (ELIMINATE_COPY_RELOCS 4560 && !bfd_link_pic (info) 4561 && h != NULL 4562 && (h->root.type == bfd_link_hash_defweak 4563 || !h->def_regular))) 4564 { 4565 #ifdef DEBUG 4566 fprintf (stderr, 4567 "ppc_elf_check_relocs needs to " 4568 "create relocation for %s\n", 4569 (h && h->root.root.string 4570 ? h->root.root.string : "<unknown>")); 4571 #endif 4572 if (sreloc == NULL) 4573 { 4574 if (htab->elf.dynobj == NULL) 4575 htab->elf.dynobj = abfd; 4576 4577 sreloc = _bfd_elf_make_dynamic_reloc_section 4578 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE); 4579 4580 if (sreloc == NULL) 4581 return FALSE; 4582 } 4583 4584 /* If this is a global symbol, we count the number of 4585 relocations we need for this symbol. */ 4586 if (h != NULL) 4587 { 4588 struct elf_dyn_relocs *p; 4589 struct elf_dyn_relocs **rel_head; 4590 4591 rel_head = &ppc_elf_hash_entry (h)->dyn_relocs; 4592 p = *rel_head; 4593 if (p == NULL || p->sec != sec) 4594 { 4595 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 4596 if (p == NULL) 4597 return FALSE; 4598 p->next = *rel_head; 4599 *rel_head = p; 4600 p->sec = sec; 4601 p->count = 0; 4602 p->pc_count = 0; 4603 } 4604 p->count += 1; 4605 if (!must_be_dyn_reloc (info, r_type)) 4606 p->pc_count += 1; 4607 } 4608 else 4609 { 4610 /* Track dynamic relocs needed for local syms too. 4611 We really need local syms available to do this 4612 easily. Oh well. */ 4613 struct ppc_dyn_relocs *p; 4614 struct ppc_dyn_relocs **rel_head; 4615 bfd_boolean is_ifunc; 4616 asection *s; 4617 void *vpp; 4618 Elf_Internal_Sym *isym; 4619 4620 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 4621 abfd, r_symndx); 4622 if (isym == NULL) 4623 return FALSE; 4624 4625 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 4626 if (s == NULL) 4627 s = sec; 4628 4629 vpp = &elf_section_data (s)->local_dynrel; 4630 rel_head = (struct ppc_dyn_relocs **) vpp; 4631 is_ifunc = ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC; 4632 p = *rel_head; 4633 if (p != NULL && p->sec == sec && p->ifunc != is_ifunc) 4634 p = p->next; 4635 if (p == NULL || p->sec != sec || p->ifunc != is_ifunc) 4636 { 4637 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 4638 if (p == NULL) 4639 return FALSE; 4640 p->next = *rel_head; 4641 *rel_head = p; 4642 p->sec = sec; 4643 p->ifunc = is_ifunc; 4644 p->count = 0; 4645 } 4646 p->count += 1; 4647 } 4648 } 4649 4650 break; 4651 } 4652 } 4653 4654 return TRUE; 4655 } 4656 4657 /* Warn for conflicting Tag_GNU_Power_ABI_FP attributes between IBFD 4659 and OBFD, and merge non-conflicting ones. */ 4660 void 4661 _bfd_elf_ppc_merge_fp_attributes (bfd *ibfd, bfd *obfd) 4662 { 4663 obj_attribute *in_attr, *in_attrs; 4664 obj_attribute *out_attr, *out_attrs; 4665 4666 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 4667 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 4668 4669 in_attr = &in_attrs[Tag_GNU_Power_ABI_FP]; 4670 out_attr = &out_attrs[Tag_GNU_Power_ABI_FP]; 4671 4672 if (in_attr->i != out_attr->i) 4673 { 4674 int in_fp = in_attr->i & 3; 4675 int out_fp = out_attr->i & 3; 4676 4677 if (in_fp == 0) 4678 ; 4679 else if (out_fp == 0) 4680 { 4681 out_attr->type = 1; 4682 out_attr->i ^= in_fp; 4683 } 4684 else if (out_fp != 2 && in_fp == 2) 4685 _bfd_error_handler 4686 (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd); 4687 else if (out_fp == 2 && in_fp != 2) 4688 _bfd_error_handler 4689 (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd); 4690 else if (out_fp == 1 && in_fp == 3) 4691 _bfd_error_handler 4692 (_("Warning: %B uses double-precision hard float, " 4693 "%B uses single-precision hard float"), obfd, ibfd); 4694 else if (out_fp == 3 && in_fp == 1) 4695 _bfd_error_handler 4696 (_("Warning: %B uses double-precision hard float, " 4697 "%B uses single-precision hard float"), ibfd, obfd); 4698 4699 in_fp = in_attr->i & 0xc; 4700 out_fp = out_attr->i & 0xc; 4701 if (in_fp == 0) 4702 ; 4703 else if (out_fp == 0) 4704 { 4705 out_attr->type = 1; 4706 out_attr->i ^= in_fp; 4707 } 4708 else if (out_fp != 2 * 4 && in_fp == 2 * 4) 4709 _bfd_error_handler 4710 (_("Warning: %B uses 64-bit long double, " 4711 "%B uses 128-bit long double"), ibfd, obfd); 4712 else if (in_fp != 2 * 4 && out_fp == 2 * 4) 4713 _bfd_error_handler 4714 (_("Warning: %B uses 64-bit long double, " 4715 "%B uses 128-bit long double"), obfd, ibfd); 4716 else if (out_fp == 1 * 4 && in_fp == 3 * 4) 4717 _bfd_error_handler 4718 (_("Warning: %B uses IBM long double, " 4719 "%B uses IEEE long double"), ibfd, obfd); 4720 else if (out_fp == 3 * 4 && in_fp == 1 * 4) 4721 _bfd_error_handler 4722 (_("Warning: %B uses IBM long double, " 4723 "%B uses IEEE long double"), obfd, ibfd); 4724 } 4725 } 4726 4727 /* Merge object attributes from IBFD into OBFD. Warn if 4728 there are conflicting attributes. */ 4729 static bfd_boolean 4730 ppc_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd) 4731 { 4732 obj_attribute *in_attr, *in_attrs; 4733 obj_attribute *out_attr, *out_attrs; 4734 4735 _bfd_elf_ppc_merge_fp_attributes (ibfd, obfd); 4736 4737 in_attrs = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 4738 out_attrs = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 4739 4740 /* Check for conflicting Tag_GNU_Power_ABI_Vector attributes and 4741 merge non-conflicting ones. */ 4742 in_attr = &in_attrs[Tag_GNU_Power_ABI_Vector]; 4743 out_attr = &out_attrs[Tag_GNU_Power_ABI_Vector]; 4744 if (in_attr->i != out_attr->i) 4745 { 4746 int in_vec = in_attr->i & 3; 4747 int out_vec = out_attr->i & 3; 4748 4749 if (in_vec == 0) 4750 ; 4751 else if (out_vec == 0) 4752 { 4753 out_attr->type = 1; 4754 out_attr->i = in_vec; 4755 } 4756 /* For now, allow generic to transition to AltiVec or SPE 4757 without a warning. If GCC marked files with their stack 4758 alignment and used don't-care markings for files which are 4759 not affected by the vector ABI, we could warn about this 4760 case too. */ 4761 else if (in_vec == 1) 4762 ; 4763 else if (out_vec == 1) 4764 { 4765 out_attr->type = 1; 4766 out_attr->i = in_vec; 4767 } 4768 else if (out_vec < in_vec) 4769 _bfd_error_handler 4770 (_("Warning: %B uses AltiVec vector ABI, %B uses SPE vector ABI"), 4771 obfd, ibfd); 4772 else if (out_vec > in_vec) 4773 _bfd_error_handler 4774 (_("Warning: %B uses AltiVec vector ABI, %B uses SPE vector ABI"), 4775 ibfd, obfd); 4776 } 4777 4778 /* Check for conflicting Tag_GNU_Power_ABI_Struct_Return attributes 4779 and merge non-conflicting ones. */ 4780 in_attr = &in_attrs[Tag_GNU_Power_ABI_Struct_Return]; 4781 out_attr = &out_attrs[Tag_GNU_Power_ABI_Struct_Return]; 4782 if (in_attr->i != out_attr->i) 4783 { 4784 int in_struct = in_attr->i & 3; 4785 int out_struct = out_attr->i & 3; 4786 4787 if (in_struct == 0 || in_struct == 3) 4788 ; 4789 else if (out_struct == 0) 4790 { 4791 out_attr->type = 1; 4792 out_attr->i = in_struct; 4793 } 4794 else if (out_struct < in_struct) 4795 _bfd_error_handler 4796 (_("Warning: %B uses r3/r4 for small structure returns, " 4797 "%B uses memory"), obfd, ibfd); 4798 else if (out_struct > in_struct) 4799 _bfd_error_handler 4800 (_("Warning: %B uses r3/r4 for small structure returns, " 4801 "%B uses memory"), ibfd, obfd); 4802 } 4803 4804 /* Merge Tag_compatibility attributes and any common GNU ones. */ 4805 _bfd_elf_merge_object_attributes (ibfd, obfd); 4806 4807 return TRUE; 4808 } 4809 4810 /* Merge backend specific data from an object file to the output 4811 object file when linking. */ 4812 4813 static bfd_boolean 4814 ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4815 { 4816 flagword old_flags; 4817 flagword new_flags; 4818 bfd_boolean error; 4819 4820 if (!is_ppc_elf (ibfd) || !is_ppc_elf (obfd)) 4821 return TRUE; 4822 4823 /* Check if we have the same endianness. */ 4824 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 4825 return FALSE; 4826 4827 if (!ppc_elf_merge_obj_attributes (ibfd, obfd)) 4828 return FALSE; 4829 4830 new_flags = elf_elfheader (ibfd)->e_flags; 4831 old_flags = elf_elfheader (obfd)->e_flags; 4832 if (!elf_flags_init (obfd)) 4833 { 4834 /* First call, no flags set. */ 4835 elf_flags_init (obfd) = TRUE; 4836 elf_elfheader (obfd)->e_flags = new_flags; 4837 } 4838 4839 /* Compatible flags are ok. */ 4840 else if (new_flags == old_flags) 4841 ; 4842 4843 /* Incompatible flags. */ 4844 else 4845 { 4846 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib 4847 to be linked with either. */ 4848 error = FALSE; 4849 if ((new_flags & EF_PPC_RELOCATABLE) != 0 4850 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0) 4851 { 4852 error = TRUE; 4853 (*_bfd_error_handler) 4854 (_("%B: compiled with -mrelocatable and linked with " 4855 "modules compiled normally"), ibfd); 4856 } 4857 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0 4858 && (old_flags & EF_PPC_RELOCATABLE) != 0) 4859 { 4860 error = TRUE; 4861 (*_bfd_error_handler) 4862 (_("%B: compiled normally and linked with " 4863 "modules compiled with -mrelocatable"), ibfd); 4864 } 4865 4866 /* The output is -mrelocatable-lib iff both the input files are. */ 4867 if (! (new_flags & EF_PPC_RELOCATABLE_LIB)) 4868 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB; 4869 4870 /* The output is -mrelocatable iff it can't be -mrelocatable-lib, 4871 but each input file is either -mrelocatable or -mrelocatable-lib. */ 4872 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB) 4873 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)) 4874 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))) 4875 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE; 4876 4877 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if 4878 any module uses it. */ 4879 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB); 4880 4881 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 4882 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 4883 4884 /* Warn about any other mismatches. */ 4885 if (new_flags != old_flags) 4886 { 4887 error = TRUE; 4888 (*_bfd_error_handler) 4889 (_("%B: uses different e_flags (0x%lx) fields " 4890 "than previous modules (0x%lx)"), 4891 ibfd, (long) new_flags, (long) old_flags); 4892 } 4893 4894 if (error) 4895 { 4896 bfd_set_error (bfd_error_bad_value); 4897 return FALSE; 4898 } 4899 } 4900 4901 return TRUE; 4902 } 4903 4904 static void 4905 ppc_elf_vle_split16 (bfd *output_bfd, bfd_byte *loc, 4906 bfd_vma value, 4907 split16_format_type split16_format) 4908 4909 { 4910 unsigned int insn, top5; 4911 4912 insn = bfd_get_32 (output_bfd, loc); 4913 top5 = value & 0xf800; 4914 top5 = top5 << (split16_format == split16a_type ? 9 : 5); 4915 insn |= top5; 4916 insn |= value & 0x7ff; 4917 bfd_put_32 (output_bfd, insn, loc); 4918 } 4919 4920 4921 /* Choose which PLT scheme to use, and set .plt flags appropriately. 4923 Returns -1 on error, 0 for old PLT, 1 for new PLT. */ 4924 int 4925 ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED, 4926 struct bfd_link_info *info) 4927 { 4928 struct ppc_elf_link_hash_table *htab; 4929 flagword flags; 4930 4931 htab = ppc_elf_hash_table (info); 4932 4933 if (htab->plt_type == PLT_UNSET) 4934 { 4935 struct elf_link_hash_entry *h; 4936 4937 if (htab->params->plt_style == PLT_OLD) 4938 htab->plt_type = PLT_OLD; 4939 else if (bfd_link_pic (info) 4940 && htab->elf.dynamic_sections_created 4941 && (h = elf_link_hash_lookup (&htab->elf, "_mcount", 4942 FALSE, FALSE, TRUE)) != NULL 4943 && (h->type == STT_FUNC 4944 || h->needs_plt) 4945 && h->ref_regular 4946 && !(SYMBOL_CALLS_LOCAL (info, h) 4947 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 4948 && h->root.type == bfd_link_hash_undefweak))) 4949 { 4950 /* Profiling of shared libs (and pies) is not supported with 4951 secure plt, because ppc32 does profiling before a 4952 function prologue and a secure plt pic call stubs needs 4953 r30 to be set up. */ 4954 htab->plt_type = PLT_OLD; 4955 } 4956 else 4957 { 4958 bfd *ibfd; 4959 enum ppc_elf_plt_type plt_type = htab->params->plt_style; 4960 4961 /* Look through the reloc flags left by ppc_elf_check_relocs. 4962 Use the old style bss plt if a file makes plt calls 4963 without using the new relocs, and if ld isn't given 4964 --secure-plt and we never see REL16 relocs. */ 4965 if (plt_type == PLT_UNSET) 4966 plt_type = PLT_OLD; 4967 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 4968 if (is_ppc_elf (ibfd)) 4969 { 4970 if (ppc_elf_tdata (ibfd)->has_rel16) 4971 plt_type = PLT_NEW; 4972 else if (ppc_elf_tdata (ibfd)->makes_plt_call) 4973 { 4974 plt_type = PLT_OLD; 4975 htab->old_bfd = ibfd; 4976 break; 4977 } 4978 } 4979 htab->plt_type = plt_type; 4980 } 4981 } 4982 if (htab->plt_type == PLT_OLD && htab->params->plt_style == PLT_NEW) 4983 { 4984 if (htab->old_bfd != NULL) 4985 info->callbacks->einfo (_("%P: bss-plt forced due to %B\n"), 4986 htab->old_bfd); 4987 else 4988 info->callbacks->einfo (_("%P: bss-plt forced by profiling\n")); 4989 } 4990 4991 BFD_ASSERT (htab->plt_type != PLT_VXWORKS); 4992 4993 if (htab->plt_type == PLT_NEW) 4994 { 4995 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 4996 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 4997 4998 /* The new PLT is a loaded section. */ 4999 if (htab->plt != NULL 5000 && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags)) 5001 return -1; 5002 5003 /* The new GOT is not executable. */ 5004 if (htab->got != NULL 5005 && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags)) 5006 return -1; 5007 } 5008 else 5009 { 5010 /* Stop an unused .glink section from affecting .text alignment. */ 5011 if (htab->glink != NULL 5012 && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0)) 5013 return -1; 5014 } 5015 return htab->plt_type == PLT_NEW; 5016 } 5017 5018 /* Return the section that should be marked against GC for a given 5020 relocation. */ 5021 5022 static asection * 5023 ppc_elf_gc_mark_hook (asection *sec, 5024 struct bfd_link_info *info, 5025 Elf_Internal_Rela *rel, 5026 struct elf_link_hash_entry *h, 5027 Elf_Internal_Sym *sym) 5028 { 5029 if (h != NULL) 5030 switch (ELF32_R_TYPE (rel->r_info)) 5031 { 5032 case R_PPC_GNU_VTINHERIT: 5033 case R_PPC_GNU_VTENTRY: 5034 return NULL; 5035 } 5036 5037 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 5038 } 5039 5040 /* Update the got, plt and dynamic reloc reference counts for the 5041 section being removed. */ 5042 5043 static bfd_boolean 5044 ppc_elf_gc_sweep_hook (bfd *abfd, 5045 struct bfd_link_info *info, 5046 asection *sec, 5047 const Elf_Internal_Rela *relocs) 5048 { 5049 struct ppc_elf_link_hash_table *htab; 5050 Elf_Internal_Shdr *symtab_hdr; 5051 struct elf_link_hash_entry **sym_hashes; 5052 bfd_signed_vma *local_got_refcounts; 5053 const Elf_Internal_Rela *rel, *relend; 5054 asection *got2; 5055 5056 if (bfd_link_relocatable (info)) 5057 return TRUE; 5058 5059 if ((sec->flags & SEC_ALLOC) == 0) 5060 return TRUE; 5061 5062 elf_section_data (sec)->local_dynrel = NULL; 5063 5064 htab = ppc_elf_hash_table (info); 5065 symtab_hdr = &elf_symtab_hdr (abfd); 5066 sym_hashes = elf_sym_hashes (abfd); 5067 local_got_refcounts = elf_local_got_refcounts (abfd); 5068 got2 = bfd_get_section_by_name (abfd, ".got2"); 5069 5070 relend = relocs + sec->reloc_count; 5071 for (rel = relocs; rel < relend; rel++) 5072 { 5073 unsigned long r_symndx; 5074 enum elf_ppc_reloc_type r_type; 5075 struct elf_link_hash_entry *h = NULL; 5076 5077 r_symndx = ELF32_R_SYM (rel->r_info); 5078 if (r_symndx >= symtab_hdr->sh_info) 5079 { 5080 struct elf_dyn_relocs **pp, *p; 5081 struct ppc_elf_link_hash_entry *eh; 5082 5083 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5084 while (h->root.type == bfd_link_hash_indirect 5085 || h->root.type == bfd_link_hash_warning) 5086 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5087 eh = (struct ppc_elf_link_hash_entry *) h; 5088 5089 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 5090 if (p->sec == sec) 5091 { 5092 /* Everything must go for SEC. */ 5093 *pp = p->next; 5094 break; 5095 } 5096 } 5097 5098 r_type = ELF32_R_TYPE (rel->r_info); 5099 if (!htab->is_vxworks 5100 && h == NULL 5101 && local_got_refcounts != NULL 5102 && (!bfd_link_pic (info) 5103 || is_branch_reloc (r_type))) 5104 { 5105 struct plt_entry **local_plt = (struct plt_entry **) 5106 (local_got_refcounts + symtab_hdr->sh_info); 5107 char *local_got_tls_masks = (char *) 5108 (local_plt + symtab_hdr->sh_info); 5109 if ((local_got_tls_masks[r_symndx] & PLT_IFUNC) != 0) 5110 { 5111 struct plt_entry **ifunc = local_plt + r_symndx; 5112 bfd_vma addend = 0; 5113 struct plt_entry *ent; 5114 5115 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info)) 5116 addend = rel->r_addend; 5117 ent = find_plt_ent (ifunc, got2, addend); 5118 if (ent->plt.refcount > 0) 5119 ent->plt.refcount -= 1; 5120 continue; 5121 } 5122 } 5123 5124 switch (r_type) 5125 { 5126 case R_PPC_GOT_TLSLD16: 5127 case R_PPC_GOT_TLSLD16_LO: 5128 case R_PPC_GOT_TLSLD16_HI: 5129 case R_PPC_GOT_TLSLD16_HA: 5130 case R_PPC_GOT_TLSGD16: 5131 case R_PPC_GOT_TLSGD16_LO: 5132 case R_PPC_GOT_TLSGD16_HI: 5133 case R_PPC_GOT_TLSGD16_HA: 5134 case R_PPC_GOT_TPREL16: 5135 case R_PPC_GOT_TPREL16_LO: 5136 case R_PPC_GOT_TPREL16_HI: 5137 case R_PPC_GOT_TPREL16_HA: 5138 case R_PPC_GOT_DTPREL16: 5139 case R_PPC_GOT_DTPREL16_LO: 5140 case R_PPC_GOT_DTPREL16_HI: 5141 case R_PPC_GOT_DTPREL16_HA: 5142 case R_PPC_GOT16: 5143 case R_PPC_GOT16_LO: 5144 case R_PPC_GOT16_HI: 5145 case R_PPC_GOT16_HA: 5146 if (h != NULL) 5147 { 5148 if (h->got.refcount > 0) 5149 h->got.refcount--; 5150 if (!bfd_link_pic (info)) 5151 { 5152 struct plt_entry *ent; 5153 5154 ent = find_plt_ent (&h->plt.plist, NULL, 0); 5155 if (ent != NULL && ent->plt.refcount > 0) 5156 ent->plt.refcount -= 1; 5157 } 5158 } 5159 else if (local_got_refcounts != NULL) 5160 { 5161 if (local_got_refcounts[r_symndx] > 0) 5162 local_got_refcounts[r_symndx]--; 5163 } 5164 break; 5165 5166 case R_PPC_REL24: 5167 case R_PPC_REL14: 5168 case R_PPC_REL14_BRTAKEN: 5169 case R_PPC_REL14_BRNTAKEN: 5170 case R_PPC_REL32: 5171 if (h == NULL || h == htab->elf.hgot) 5172 break; 5173 /* Fall thru */ 5174 5175 case R_PPC_ADDR32: 5176 case R_PPC_ADDR24: 5177 case R_PPC_ADDR16: 5178 case R_PPC_ADDR16_LO: 5179 case R_PPC_ADDR16_HI: 5180 case R_PPC_ADDR16_HA: 5181 case R_PPC_ADDR14: 5182 case R_PPC_ADDR14_BRTAKEN: 5183 case R_PPC_ADDR14_BRNTAKEN: 5184 case R_PPC_UADDR32: 5185 case R_PPC_UADDR16: 5186 if (bfd_link_pic (info)) 5187 break; 5188 5189 case R_PPC_PLT32: 5190 case R_PPC_PLTREL24: 5191 case R_PPC_PLTREL32: 5192 case R_PPC_PLT16_LO: 5193 case R_PPC_PLT16_HI: 5194 case R_PPC_PLT16_HA: 5195 if (h != NULL) 5196 { 5197 bfd_vma addend = 0; 5198 struct plt_entry *ent; 5199 5200 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info)) 5201 addend = rel->r_addend; 5202 ent = find_plt_ent (&h->plt.plist, got2, addend); 5203 if (ent != NULL && ent->plt.refcount > 0) 5204 ent->plt.refcount -= 1; 5205 } 5206 break; 5207 5208 default: 5209 break; 5210 } 5211 } 5212 return TRUE; 5213 } 5214 5215 /* Set plt output section type, htab->tls_get_addr, and call the 5217 generic ELF tls_setup function. */ 5218 5219 asection * 5220 ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) 5221 { 5222 struct ppc_elf_link_hash_table *htab; 5223 5224 htab = ppc_elf_hash_table (info); 5225 htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 5226 FALSE, FALSE, TRUE); 5227 if (htab->plt_type != PLT_NEW) 5228 htab->params->no_tls_get_addr_opt = TRUE; 5229 5230 if (!htab->params->no_tls_get_addr_opt) 5231 { 5232 struct elf_link_hash_entry *opt, *tga; 5233 opt = elf_link_hash_lookup (&htab->elf, "__tls_get_addr_opt", 5234 FALSE, FALSE, TRUE); 5235 if (opt != NULL 5236 && (opt->root.type == bfd_link_hash_defined 5237 || opt->root.type == bfd_link_hash_defweak)) 5238 { 5239 /* If glibc supports an optimized __tls_get_addr call stub, 5240 signalled by the presence of __tls_get_addr_opt, and we'll 5241 be calling __tls_get_addr via a plt call stub, then 5242 make __tls_get_addr point to __tls_get_addr_opt. */ 5243 tga = htab->tls_get_addr; 5244 if (htab->elf.dynamic_sections_created 5245 && tga != NULL 5246 && (tga->type == STT_FUNC 5247 || tga->needs_plt) 5248 && !(SYMBOL_CALLS_LOCAL (info, tga) 5249 || (ELF_ST_VISIBILITY (tga->other) != STV_DEFAULT 5250 && tga->root.type == bfd_link_hash_undefweak))) 5251 { 5252 struct plt_entry *ent; 5253 for (ent = tga->plt.plist; ent != NULL; ent = ent->next) 5254 if (ent->plt.refcount > 0) 5255 break; 5256 if (ent != NULL) 5257 { 5258 tga->root.type = bfd_link_hash_indirect; 5259 tga->root.u.i.link = &opt->root; 5260 ppc_elf_copy_indirect_symbol (info, opt, tga); 5261 opt->forced_local = 0; 5262 if (opt->dynindx != -1) 5263 { 5264 /* Use __tls_get_addr_opt in dynamic relocations. */ 5265 opt->dynindx = -1; 5266 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 5267 opt->dynstr_index); 5268 if (!bfd_elf_link_record_dynamic_symbol (info, opt)) 5269 return FALSE; 5270 } 5271 htab->tls_get_addr = opt; 5272 } 5273 } 5274 } 5275 else 5276 htab->params->no_tls_get_addr_opt = TRUE; 5277 } 5278 if (htab->plt_type == PLT_NEW 5279 && htab->plt != NULL 5280 && htab->plt->output_section != NULL) 5281 { 5282 elf_section_type (htab->plt->output_section) = SHT_PROGBITS; 5283 elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE; 5284 } 5285 5286 return _bfd_elf_tls_setup (obfd, info); 5287 } 5288 5289 /* Return TRUE iff REL is a branch reloc with a global symbol matching 5290 HASH. */ 5291 5292 static bfd_boolean 5293 branch_reloc_hash_match (const bfd *ibfd, 5294 const Elf_Internal_Rela *rel, 5295 const struct elf_link_hash_entry *hash) 5296 { 5297 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 5298 enum elf_ppc_reloc_type r_type = ELF32_R_TYPE (rel->r_info); 5299 unsigned int r_symndx = ELF32_R_SYM (rel->r_info); 5300 5301 if (r_symndx >= symtab_hdr->sh_info && is_branch_reloc (r_type)) 5302 { 5303 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd); 5304 struct elf_link_hash_entry *h; 5305 5306 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5307 while (h->root.type == bfd_link_hash_indirect 5308 || h->root.type == bfd_link_hash_warning) 5309 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5310 if (h == hash) 5311 return TRUE; 5312 } 5313 return FALSE; 5314 } 5315 5316 /* Run through all the TLS relocs looking for optimization 5317 opportunities. */ 5318 5319 bfd_boolean 5320 ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, 5321 struct bfd_link_info *info) 5322 { 5323 bfd *ibfd; 5324 asection *sec; 5325 struct ppc_elf_link_hash_table *htab; 5326 int pass; 5327 5328 if (!bfd_link_executable (info)) 5329 return TRUE; 5330 5331 htab = ppc_elf_hash_table (info); 5332 if (htab == NULL) 5333 return FALSE; 5334 5335 /* Make two passes through the relocs. First time check that tls 5336 relocs involved in setting up a tls_get_addr call are indeed 5337 followed by such a call. If they are not, don't do any tls 5338 optimization. On the second pass twiddle tls_mask flags to 5339 notify relocate_section that optimization can be done, and 5340 adjust got and plt refcounts. */ 5341 for (pass = 0; pass < 2; ++pass) 5342 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 5343 { 5344 Elf_Internal_Sym *locsyms = NULL; 5345 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (ibfd); 5346 asection *got2 = bfd_get_section_by_name (ibfd, ".got2"); 5347 5348 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 5349 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section)) 5350 { 5351 Elf_Internal_Rela *relstart, *rel, *relend; 5352 int expecting_tls_get_addr = 0; 5353 5354 /* Read the relocations. */ 5355 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 5356 info->keep_memory); 5357 if (relstart == NULL) 5358 return FALSE; 5359 5360 relend = relstart + sec->reloc_count; 5361 for (rel = relstart; rel < relend; rel++) 5362 { 5363 enum elf_ppc_reloc_type r_type; 5364 unsigned long r_symndx; 5365 struct elf_link_hash_entry *h = NULL; 5366 char *tls_mask; 5367 char tls_set, tls_clear; 5368 bfd_boolean is_local; 5369 bfd_signed_vma *got_count; 5370 5371 r_symndx = ELF32_R_SYM (rel->r_info); 5372 if (r_symndx >= symtab_hdr->sh_info) 5373 { 5374 struct elf_link_hash_entry **sym_hashes; 5375 5376 sym_hashes = elf_sym_hashes (ibfd); 5377 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5378 while (h->root.type == bfd_link_hash_indirect 5379 || h->root.type == bfd_link_hash_warning) 5380 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5381 } 5382 5383 is_local = FALSE; 5384 if (h == NULL 5385 || !h->def_dynamic) 5386 is_local = TRUE; 5387 5388 r_type = ELF32_R_TYPE (rel->r_info); 5389 /* If this section has old-style __tls_get_addr calls 5390 without marker relocs, then check that each 5391 __tls_get_addr call reloc is preceded by a reloc 5392 that conceivably belongs to the __tls_get_addr arg 5393 setup insn. If we don't find matching arg setup 5394 relocs, don't do any tls optimization. */ 5395 if (pass == 0 5396 && sec->has_tls_get_addr_call 5397 && h != NULL 5398 && h == htab->tls_get_addr 5399 && !expecting_tls_get_addr 5400 && is_branch_reloc (r_type)) 5401 { 5402 info->callbacks->minfo ("%H __tls_get_addr lost arg, " 5403 "TLS optimization disabled\n", 5404 ibfd, sec, rel->r_offset); 5405 if (elf_section_data (sec)->relocs != relstart) 5406 free (relstart); 5407 return TRUE; 5408 } 5409 5410 expecting_tls_get_addr = 0; 5411 switch (r_type) 5412 { 5413 case R_PPC_GOT_TLSLD16: 5414 case R_PPC_GOT_TLSLD16_LO: 5415 expecting_tls_get_addr = 1; 5416 /* Fall thru */ 5417 5418 case R_PPC_GOT_TLSLD16_HI: 5419 case R_PPC_GOT_TLSLD16_HA: 5420 /* These relocs should never be against a symbol 5421 defined in a shared lib. Leave them alone if 5422 that turns out to be the case. */ 5423 if (!is_local) 5424 continue; 5425 5426 /* LD -> LE */ 5427 tls_set = 0; 5428 tls_clear = TLS_LD; 5429 break; 5430 5431 case R_PPC_GOT_TLSGD16: 5432 case R_PPC_GOT_TLSGD16_LO: 5433 expecting_tls_get_addr = 1; 5434 /* Fall thru */ 5435 5436 case R_PPC_GOT_TLSGD16_HI: 5437 case R_PPC_GOT_TLSGD16_HA: 5438 if (is_local) 5439 /* GD -> LE */ 5440 tls_set = 0; 5441 else 5442 /* GD -> IE */ 5443 tls_set = TLS_TLS | TLS_TPRELGD; 5444 tls_clear = TLS_GD; 5445 break; 5446 5447 case R_PPC_GOT_TPREL16: 5448 case R_PPC_GOT_TPREL16_LO: 5449 case R_PPC_GOT_TPREL16_HI: 5450 case R_PPC_GOT_TPREL16_HA: 5451 if (is_local) 5452 { 5453 /* IE -> LE */ 5454 tls_set = 0; 5455 tls_clear = TLS_TPREL; 5456 break; 5457 } 5458 else 5459 continue; 5460 5461 case R_PPC_TLSGD: 5462 case R_PPC_TLSLD: 5463 expecting_tls_get_addr = 2; 5464 tls_set = 0; 5465 tls_clear = 0; 5466 break; 5467 5468 default: 5469 continue; 5470 } 5471 5472 if (pass == 0) 5473 { 5474 if (!expecting_tls_get_addr 5475 || (expecting_tls_get_addr == 1 5476 && !sec->has_tls_get_addr_call)) 5477 continue; 5478 5479 if (rel + 1 < relend 5480 && branch_reloc_hash_match (ibfd, rel + 1, 5481 htab->tls_get_addr)) 5482 continue; 5483 5484 /* Uh oh, we didn't find the expected call. We 5485 could just mark this symbol to exclude it 5486 from tls optimization but it's safer to skip 5487 the entire optimization. */ 5488 info->callbacks->minfo (_("%H arg lost __tls_get_addr, " 5489 "TLS optimization disabled\n"), 5490 ibfd, sec, rel->r_offset); 5491 if (elf_section_data (sec)->relocs != relstart) 5492 free (relstart); 5493 return TRUE; 5494 } 5495 5496 if (expecting_tls_get_addr) 5497 { 5498 struct plt_entry *ent; 5499 bfd_vma addend = 0; 5500 5501 if (bfd_link_pic (info) 5502 && ELF32_R_TYPE (rel[1].r_info) == R_PPC_PLTREL24) 5503 addend = rel[1].r_addend; 5504 ent = find_plt_ent (&htab->tls_get_addr->plt.plist, 5505 got2, addend); 5506 if (ent != NULL && ent->plt.refcount > 0) 5507 ent->plt.refcount -= 1; 5508 5509 if (expecting_tls_get_addr == 2) 5510 continue; 5511 } 5512 5513 if (h != NULL) 5514 { 5515 tls_mask = &ppc_elf_hash_entry (h)->tls_mask; 5516 got_count = &h->got.refcount; 5517 } 5518 else 5519 { 5520 bfd_signed_vma *lgot_refs; 5521 struct plt_entry **local_plt; 5522 char *lgot_masks; 5523 5524 if (locsyms == NULL) 5525 { 5526 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 5527 if (locsyms == NULL) 5528 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 5529 symtab_hdr->sh_info, 5530 0, NULL, NULL, NULL); 5531 if (locsyms == NULL) 5532 { 5533 if (elf_section_data (sec)->relocs != relstart) 5534 free (relstart); 5535 return FALSE; 5536 } 5537 } 5538 lgot_refs = elf_local_got_refcounts (ibfd); 5539 if (lgot_refs == NULL) 5540 abort (); 5541 local_plt = (struct plt_entry **) 5542 (lgot_refs + symtab_hdr->sh_info); 5543 lgot_masks = (char *) (local_plt + symtab_hdr->sh_info); 5544 tls_mask = &lgot_masks[r_symndx]; 5545 got_count = &lgot_refs[r_symndx]; 5546 } 5547 5548 if (tls_set == 0) 5549 { 5550 /* We managed to get rid of a got entry. */ 5551 if (*got_count > 0) 5552 *got_count -= 1; 5553 } 5554 5555 *tls_mask |= tls_set; 5556 *tls_mask &= ~tls_clear; 5557 } 5558 5559 if (elf_section_data (sec)->relocs != relstart) 5560 free (relstart); 5561 } 5562 5563 if (locsyms != NULL 5564 && (symtab_hdr->contents != (unsigned char *) locsyms)) 5565 { 5566 if (!info->keep_memory) 5567 free (locsyms); 5568 else 5569 symtab_hdr->contents = (unsigned char *) locsyms; 5570 } 5571 } 5572 return TRUE; 5573 } 5574 5575 /* Return true if we have dynamic relocs that apply to read-only sections. */ 5577 5578 static bfd_boolean 5579 readonly_dynrelocs (struct elf_link_hash_entry *h) 5580 { 5581 struct elf_dyn_relocs *p; 5582 5583 for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) 5584 { 5585 asection *s = p->sec->output_section; 5586 5587 if (s != NULL 5588 && ((s->flags & (SEC_READONLY | SEC_ALLOC)) 5589 == (SEC_READONLY | SEC_ALLOC))) 5590 return TRUE; 5591 } 5592 return FALSE; 5593 } 5594 5595 /* Adjust a symbol defined by a dynamic object and referenced by a 5596 regular object. The current definition is in some section of the 5597 dynamic object, but we're not including those sections. We have to 5598 change the definition to something the rest of the link can 5599 understand. */ 5600 5601 static bfd_boolean 5602 ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 5603 struct elf_link_hash_entry *h) 5604 { 5605 struct ppc_elf_link_hash_table *htab; 5606 asection *s; 5607 5608 #ifdef DEBUG 5609 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", 5610 h->root.root.string); 5611 #endif 5612 5613 /* Make sure we know what is going on here. */ 5614 htab = ppc_elf_hash_table (info); 5615 BFD_ASSERT (htab->elf.dynobj != NULL 5616 && (h->needs_plt 5617 || h->type == STT_GNU_IFUNC 5618 || h->u.weakdef != NULL 5619 || (h->def_dynamic 5620 && h->ref_regular 5621 && !h->def_regular))); 5622 5623 /* Deal with function syms. */ 5624 if (h->type == STT_FUNC 5625 || h->type == STT_GNU_IFUNC 5626 || h->needs_plt) 5627 { 5628 /* Clear procedure linkage table information for any symbol that 5629 won't need a .plt entry. */ 5630 struct plt_entry *ent; 5631 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 5632 if (ent->plt.refcount > 0) 5633 break; 5634 if (ent == NULL 5635 || (h->type != STT_GNU_IFUNC 5636 && (SYMBOL_CALLS_LOCAL (info, h) 5637 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 5638 && h->root.type == bfd_link_hash_undefweak)))) 5639 { 5640 /* A PLT entry is not required/allowed when: 5641 5642 1. We are not using ld.so; because then the PLT entry 5643 can't be set up, so we can't use one. In this case, 5644 ppc_elf_adjust_dynamic_symbol won't even be called. 5645 5646 2. GC has rendered the entry unused. 5647 5648 3. We know for certain that a call to this symbol 5649 will go to this object, or will remain undefined. */ 5650 h->plt.plist = NULL; 5651 h->needs_plt = 0; 5652 h->pointer_equality_needed = 0; 5653 } 5654 else 5655 { 5656 /* Taking a function's address in a read/write section 5657 doesn't require us to define the function symbol in the 5658 executable on a plt call stub. A dynamic reloc can 5659 be used instead. */ 5660 if (h->pointer_equality_needed 5661 && h->type != STT_GNU_IFUNC 5662 && !htab->is_vxworks 5663 && !ppc_elf_hash_entry (h)->has_sda_refs 5664 && !readonly_dynrelocs (h)) 5665 { 5666 h->pointer_equality_needed = 0; 5667 h->non_got_ref = 0; 5668 } 5669 5670 /* After adjust_dynamic_symbol, non_got_ref set in the 5671 non-shared case means that we have allocated space in 5672 .dynbss for the symbol and thus dyn_relocs for this 5673 symbol should be discarded. 5674 If we get here we know we are making a PLT entry for this 5675 symbol, and in an executable we'd normally resolve 5676 relocations against this symbol to the PLT entry. Allow 5677 dynamic relocs if the reference is weak, and the dynamic 5678 relocs will not cause text relocation. */ 5679 else if (!h->ref_regular_nonweak 5680 && h->non_got_ref 5681 && h->type != STT_GNU_IFUNC 5682 && !htab->is_vxworks 5683 && !ppc_elf_hash_entry (h)->has_sda_refs 5684 && !readonly_dynrelocs (h)) 5685 h->non_got_ref = 0; 5686 } 5687 h->protected_def = 0; 5688 return TRUE; 5689 } 5690 else 5691 h->plt.plist = NULL; 5692 5693 /* If this is a weak symbol, and there is a real definition, the 5694 processor independent code will have arranged for us to see the 5695 real definition first, and we can just use the same value. */ 5696 if (h->u.weakdef != NULL) 5697 { 5698 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 5699 || h->u.weakdef->root.type == bfd_link_hash_defweak); 5700 h->root.u.def.section = h->u.weakdef->root.u.def.section; 5701 h->root.u.def.value = h->u.weakdef->root.u.def.value; 5702 if (ELIMINATE_COPY_RELOCS) 5703 h->non_got_ref = h->u.weakdef->non_got_ref; 5704 return TRUE; 5705 } 5706 5707 /* This is a reference to a symbol defined by a dynamic object which 5708 is not a function. */ 5709 5710 /* If we are creating a shared library, we must presume that the 5711 only references to the symbol are via the global offset table. 5712 For such cases we need not do anything here; the relocations will 5713 be handled correctly by relocate_section. */ 5714 if (bfd_link_pic (info)) 5715 { 5716 h->protected_def = 0; 5717 return TRUE; 5718 } 5719 5720 /* If there are no references to this symbol that do not use the 5721 GOT, we don't need to generate a copy reloc. */ 5722 if (!h->non_got_ref) 5723 { 5724 h->protected_def = 0; 5725 return TRUE; 5726 } 5727 5728 /* Protected variables do not work with .dynbss. The copy in 5729 .dynbss won't be used by the shared library with the protected 5730 definition for the variable. Editing to PIC, or text relocations 5731 are preferable to an incorrect program. */ 5732 if (h->protected_def) 5733 { 5734 if (ELIMINATE_COPY_RELOCS 5735 && ppc_elf_hash_entry (h)->has_addr16_ha 5736 && ppc_elf_hash_entry (h)->has_addr16_lo 5737 && htab->params->pic_fixup == 0 5738 && info->disable_target_specific_optimizations <= 1) 5739 htab->params->pic_fixup = 1; 5740 h->non_got_ref = 0; 5741 return TRUE; 5742 } 5743 5744 /* If -z nocopyreloc was given, we won't generate them either. */ 5745 if (info->nocopyreloc) 5746 { 5747 h->non_got_ref = 0; 5748 return TRUE; 5749 } 5750 5751 /* If we didn't find any dynamic relocs in read-only sections, then 5752 we'll be keeping the dynamic relocs and avoiding the copy reloc. 5753 We can't do this if there are any small data relocations. This 5754 doesn't work on VxWorks, where we can not have dynamic 5755 relocations (other than copy and jump slot relocations) in an 5756 executable. */ 5757 if (ELIMINATE_COPY_RELOCS 5758 && !ppc_elf_hash_entry (h)->has_sda_refs 5759 && !htab->is_vxworks 5760 && !h->def_regular 5761 && !readonly_dynrelocs (h)) 5762 { 5763 h->non_got_ref = 0; 5764 return TRUE; 5765 } 5766 5767 /* We must allocate the symbol in our .dynbss section, which will 5768 become part of the .bss section of the executable. There will be 5769 an entry for this symbol in the .dynsym section. The dynamic 5770 object will contain position independent code, so all references 5771 from the dynamic object to this symbol will go through the global 5772 offset table. The dynamic linker will use the .dynsym entry to 5773 determine the address it must put in the global offset table, so 5774 both the dynamic object and the regular object will refer to the 5775 same memory location for the variable. 5776 5777 Of course, if the symbol is referenced using SDAREL relocs, we 5778 must instead allocate it in .sbss. */ 5779 5780 if (ppc_elf_hash_entry (h)->has_sda_refs) 5781 s = htab->dynsbss; 5782 else 5783 s = htab->dynbss; 5784 BFD_ASSERT (s != NULL); 5785 5786 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to 5787 copy the initial value out of the dynamic object and into the 5788 runtime process image. We need to remember the offset into the 5789 .rela.bss section we are going to use. */ 5790 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 5791 { 5792 asection *srel; 5793 5794 if (ppc_elf_hash_entry (h)->has_sda_refs) 5795 srel = htab->relsbss; 5796 else 5797 srel = htab->relbss; 5798 BFD_ASSERT (srel != NULL); 5799 srel->size += sizeof (Elf32_External_Rela); 5800 h->needs_copy = 1; 5801 } 5802 5803 return _bfd_elf_adjust_dynamic_copy (info, h, s); 5804 } 5805 5806 /* Generate a symbol to mark plt call stubs. For non-PIC code the sym is 5808 xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0, 5809 specifying the addend on the plt relocation. For -fpic code, the sym 5810 is xxxxxxxx.plt_pic32.<callee>, and for -fPIC 5811 xxxxxxxx.got2.plt_pic32.<callee>. */ 5812 5813 static bfd_boolean 5814 add_stub_sym (struct plt_entry *ent, 5815 struct elf_link_hash_entry *h, 5816 struct bfd_link_info *info) 5817 { 5818 struct elf_link_hash_entry *sh; 5819 size_t len1, len2, len3; 5820 char *name; 5821 const char *stub; 5822 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 5823 5824 if (bfd_link_pic (info)) 5825 stub = ".plt_pic32."; 5826 else 5827 stub = ".plt_call32."; 5828 5829 len1 = strlen (h->root.root.string); 5830 len2 = strlen (stub); 5831 len3 = 0; 5832 if (ent->sec) 5833 len3 = strlen (ent->sec->name); 5834 name = bfd_malloc (len1 + len2 + len3 + 9); 5835 if (name == NULL) 5836 return FALSE; 5837 sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff); 5838 if (ent->sec) 5839 memcpy (name + 8, ent->sec->name, len3); 5840 memcpy (name + 8 + len3, stub, len2); 5841 memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1); 5842 sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); 5843 if (sh == NULL) 5844 return FALSE; 5845 if (sh->root.type == bfd_link_hash_new) 5846 { 5847 sh->root.type = bfd_link_hash_defined; 5848 sh->root.u.def.section = htab->glink; 5849 sh->root.u.def.value = ent->glink_offset; 5850 sh->ref_regular = 1; 5851 sh->def_regular = 1; 5852 sh->ref_regular_nonweak = 1; 5853 sh->forced_local = 1; 5854 sh->non_elf = 0; 5855 sh->root.linker_def = 1; 5856 } 5857 return TRUE; 5858 } 5859 5860 /* Allocate NEED contiguous space in .got, and return the offset. 5861 Handles allocation of the got header when crossing 32k. */ 5862 5863 static bfd_vma 5864 allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need) 5865 { 5866 bfd_vma where; 5867 unsigned int max_before_header; 5868 5869 if (htab->plt_type == PLT_VXWORKS) 5870 { 5871 where = htab->got->size; 5872 htab->got->size += need; 5873 } 5874 else 5875 { 5876 max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764; 5877 if (need <= htab->got_gap) 5878 { 5879 where = max_before_header - htab->got_gap; 5880 htab->got_gap -= need; 5881 } 5882 else 5883 { 5884 if (htab->got->size + need > max_before_header 5885 && htab->got->size <= max_before_header) 5886 { 5887 htab->got_gap = max_before_header - htab->got->size; 5888 htab->got->size = max_before_header + htab->got_header_size; 5889 } 5890 where = htab->got->size; 5891 htab->got->size += need; 5892 } 5893 } 5894 return where; 5895 } 5896 5897 /* Allocate space in associated reloc sections for dynamic relocs. */ 5898 5899 static bfd_boolean 5900 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 5901 { 5902 struct bfd_link_info *info = inf; 5903 struct ppc_elf_link_hash_entry *eh; 5904 struct ppc_elf_link_hash_table *htab; 5905 struct elf_dyn_relocs *p; 5906 5907 if (h->root.type == bfd_link_hash_indirect) 5908 return TRUE; 5909 5910 htab = ppc_elf_hash_table (info); 5911 if (htab->elf.dynamic_sections_created 5912 || h->type == STT_GNU_IFUNC) 5913 { 5914 struct plt_entry *ent; 5915 bfd_boolean doneone = FALSE; 5916 bfd_vma plt_offset = 0, glink_offset = 0; 5917 bfd_boolean dyn; 5918 5919 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 5920 if (ent->plt.refcount > 0) 5921 { 5922 /* Make sure this symbol is output as a dynamic symbol. */ 5923 if (h->dynindx == -1 5924 && !h->forced_local 5925 && !h->def_regular 5926 && htab->elf.dynamic_sections_created) 5927 { 5928 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 5929 return FALSE; 5930 } 5931 5932 dyn = htab->elf.dynamic_sections_created; 5933 if (bfd_link_pic (info) 5934 || h->type == STT_GNU_IFUNC 5935 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)) 5936 { 5937 asection *s = htab->plt; 5938 if (!dyn || h->dynindx == -1) 5939 s = htab->iplt; 5940 5941 if (htab->plt_type == PLT_NEW || !dyn || h->dynindx == -1) 5942 { 5943 if (!doneone) 5944 { 5945 plt_offset = s->size; 5946 s->size += 4; 5947 } 5948 ent->plt.offset = plt_offset; 5949 5950 s = htab->glink; 5951 if (!doneone || bfd_link_pic (info)) 5952 { 5953 glink_offset = s->size; 5954 s->size += GLINK_ENTRY_SIZE; 5955 if (h == htab->tls_get_addr 5956 && !htab->params->no_tls_get_addr_opt) 5957 s->size += TLS_GET_ADDR_GLINK_SIZE - GLINK_ENTRY_SIZE; 5958 } 5959 if (!doneone 5960 && !bfd_link_pic (info) 5961 && h->def_dynamic 5962 && !h->def_regular) 5963 { 5964 h->root.u.def.section = s; 5965 h->root.u.def.value = glink_offset; 5966 } 5967 ent->glink_offset = glink_offset; 5968 5969 if (htab->params->emit_stub_syms 5970 && !add_stub_sym (ent, h, info)) 5971 return FALSE; 5972 } 5973 else 5974 { 5975 if (!doneone) 5976 { 5977 /* If this is the first .plt entry, make room 5978 for the special first entry. */ 5979 if (s->size == 0) 5980 s->size += htab->plt_initial_entry_size; 5981 5982 /* The PowerPC PLT is actually composed of two 5983 parts, the first part is 2 words (for a load 5984 and a jump), and then there is a remaining 5985 word available at the end. */ 5986 plt_offset = (htab->plt_initial_entry_size 5987 + (htab->plt_slot_size 5988 * ((s->size 5989 - htab->plt_initial_entry_size) 5990 / htab->plt_entry_size))); 5991 5992 /* If this symbol is not defined in a regular 5993 file, and we are not generating a shared 5994 library, then set the symbol to this location 5995 in the .plt. This is to avoid text 5996 relocations, and is required to make 5997 function pointers compare as equal between 5998 the normal executable and the shared library. */ 5999 if (! bfd_link_pic (info) 6000 && h->def_dynamic 6001 && !h->def_regular) 6002 { 6003 h->root.u.def.section = s; 6004 h->root.u.def.value = plt_offset; 6005 } 6006 6007 /* Make room for this entry. */ 6008 s->size += htab->plt_entry_size; 6009 /* After the 8192nd entry, room for two entries 6010 is allocated. */ 6011 if (htab->plt_type == PLT_OLD 6012 && (s->size - htab->plt_initial_entry_size) 6013 / htab->plt_entry_size 6014 > PLT_NUM_SINGLE_ENTRIES) 6015 s->size += htab->plt_entry_size; 6016 } 6017 ent->plt.offset = plt_offset; 6018 } 6019 6020 /* We also need to make an entry in the .rela.plt section. */ 6021 if (!doneone) 6022 { 6023 if (!htab->elf.dynamic_sections_created 6024 || h->dynindx == -1) 6025 htab->reliplt->size += sizeof (Elf32_External_Rela); 6026 else 6027 { 6028 htab->relplt->size += sizeof (Elf32_External_Rela); 6029 6030 if (htab->plt_type == PLT_VXWORKS) 6031 { 6032 /* Allocate space for the unloaded relocations. */ 6033 if (!bfd_link_pic (info) 6034 && htab->elf.dynamic_sections_created) 6035 { 6036 if (ent->plt.offset 6037 == (bfd_vma) htab->plt_initial_entry_size) 6038 { 6039 htab->srelplt2->size 6040 += (sizeof (Elf32_External_Rela) 6041 * VXWORKS_PLTRESOLVE_RELOCS); 6042 } 6043 6044 htab->srelplt2->size 6045 += (sizeof (Elf32_External_Rela) 6046 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS); 6047 } 6048 6049 /* Every PLT entry has an associated GOT entry in 6050 .got.plt. */ 6051 htab->sgotplt->size += 4; 6052 } 6053 } 6054 doneone = TRUE; 6055 } 6056 } 6057 else 6058 ent->plt.offset = (bfd_vma) -1; 6059 } 6060 else 6061 ent->plt.offset = (bfd_vma) -1; 6062 6063 if (!doneone) 6064 { 6065 h->plt.plist = NULL; 6066 h->needs_plt = 0; 6067 } 6068 } 6069 else 6070 { 6071 h->plt.plist = NULL; 6072 h->needs_plt = 0; 6073 } 6074 6075 eh = (struct ppc_elf_link_hash_entry *) h; 6076 if (eh->elf.got.refcount > 0 6077 || (ELIMINATE_COPY_RELOCS 6078 && !eh->elf.def_regular 6079 && eh->elf.protected_def 6080 && eh->has_addr16_ha 6081 && eh->has_addr16_lo 6082 && htab->params->pic_fixup > 0)) 6083 { 6084 bfd_boolean dyn; 6085 unsigned int need; 6086 6087 /* Make sure this symbol is output as a dynamic symbol. */ 6088 if (eh->elf.dynindx == -1 6089 && !eh->elf.forced_local 6090 && eh->elf.type != STT_GNU_IFUNC 6091 && htab->elf.dynamic_sections_created) 6092 { 6093 if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf)) 6094 return FALSE; 6095 } 6096 6097 need = 0; 6098 if ((eh->tls_mask & TLS_TLS) != 0) 6099 { 6100 if ((eh->tls_mask & TLS_LD) != 0) 6101 { 6102 if (!eh->elf.def_dynamic) 6103 /* We'll just use htab->tlsld_got.offset. This should 6104 always be the case. It's a little odd if we have 6105 a local dynamic reloc against a non-local symbol. */ 6106 htab->tlsld_got.refcount += 1; 6107 else 6108 need += 8; 6109 } 6110 if ((eh->tls_mask & TLS_GD) != 0) 6111 need += 8; 6112 if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0) 6113 need += 4; 6114 if ((eh->tls_mask & TLS_DTPREL) != 0) 6115 need += 4; 6116 } 6117 else 6118 need += 4; 6119 if (need == 0) 6120 eh->elf.got.offset = (bfd_vma) -1; 6121 else 6122 { 6123 eh->elf.got.offset = allocate_got (htab, need); 6124 dyn = htab->elf.dynamic_sections_created; 6125 if ((bfd_link_pic (info) 6126 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf)) 6127 && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT 6128 || eh->elf.root.type != bfd_link_hash_undefweak)) 6129 { 6130 asection *rsec = htab->relgot; 6131 6132 if (eh->elf.type == STT_GNU_IFUNC) 6133 rsec = htab->reliplt; 6134 /* All the entries we allocated need relocs. 6135 Except LD only needs one. */ 6136 if ((eh->tls_mask & TLS_LD) != 0 6137 && eh->elf.def_dynamic) 6138 need -= 4; 6139 rsec->size += need * (sizeof (Elf32_External_Rela) / 4); 6140 } 6141 } 6142 } 6143 else 6144 eh->elf.got.offset = (bfd_vma) -1; 6145 6146 if (eh->dyn_relocs == NULL 6147 || !htab->elf.dynamic_sections_created) 6148 return TRUE; 6149 6150 /* In the shared -Bsymbolic case, discard space allocated for 6151 dynamic pc-relative relocs against symbols which turn out to be 6152 defined in regular objects. For the normal shared case, discard 6153 space for relocs that have become local due to symbol visibility 6154 changes. */ 6155 6156 if (bfd_link_pic (info)) 6157 { 6158 /* Relocs that use pc_count are those that appear on a call insn, 6159 or certain REL relocs (see must_be_dyn_reloc) that can be 6160 generated via assembly. We want calls to protected symbols to 6161 resolve directly to the function rather than going via the plt. 6162 If people want function pointer comparisons to work as expected 6163 then they should avoid writing weird assembly. */ 6164 if (SYMBOL_CALLS_LOCAL (info, h)) 6165 { 6166 struct elf_dyn_relocs **pp; 6167 6168 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 6169 { 6170 p->count -= p->pc_count; 6171 p->pc_count = 0; 6172 if (p->count == 0) 6173 *pp = p->next; 6174 else 6175 pp = &p->next; 6176 } 6177 } 6178 6179 if (htab->is_vxworks) 6180 { 6181 struct elf_dyn_relocs **pp; 6182 6183 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 6184 { 6185 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) 6186 *pp = p->next; 6187 else 6188 pp = &p->next; 6189 } 6190 } 6191 6192 /* Discard relocs on undefined symbols that must be local. */ 6193 if (eh->dyn_relocs != NULL 6194 && h->root.type == bfd_link_hash_undefined 6195 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 6196 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)) 6197 eh->dyn_relocs = NULL; 6198 6199 /* Also discard relocs on undefined weak syms with non-default 6200 visibility. */ 6201 if (eh->dyn_relocs != NULL 6202 && h->root.type == bfd_link_hash_undefweak) 6203 { 6204 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 6205 eh->dyn_relocs = NULL; 6206 6207 /* Make sure undefined weak symbols are output as a dynamic 6208 symbol in PIEs. */ 6209 else if (h->dynindx == -1 6210 && !h->forced_local 6211 && !h->def_regular) 6212 { 6213 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6214 return FALSE; 6215 } 6216 } 6217 } 6218 else if (ELIMINATE_COPY_RELOCS) 6219 { 6220 /* For the non-shared case, discard space for relocs against 6221 symbols which turn out to need copy relocs or are not 6222 dynamic. */ 6223 6224 if (!h->non_got_ref 6225 && !h->def_regular 6226 && !(h->protected_def 6227 && eh->has_addr16_ha 6228 && eh->has_addr16_lo 6229 && htab->params->pic_fixup > 0)) 6230 { 6231 /* Make sure this symbol is output as a dynamic symbol. 6232 Undefined weak syms won't yet be marked as dynamic. */ 6233 if (h->dynindx == -1 6234 && !h->forced_local) 6235 { 6236 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 6237 return FALSE; 6238 } 6239 6240 /* If that succeeded, we know we'll be keeping all the 6241 relocs. */ 6242 if (h->dynindx != -1) 6243 goto keep; 6244 } 6245 6246 eh->dyn_relocs = NULL; 6247 6248 keep: ; 6249 } 6250 6251 /* Finally, allocate space. */ 6252 for (p = eh->dyn_relocs; p != NULL; p = p->next) 6253 { 6254 asection *sreloc = elf_section_data (p->sec)->sreloc; 6255 if (eh->elf.type == STT_GNU_IFUNC) 6256 sreloc = htab->reliplt; 6257 sreloc->size += p->count * sizeof (Elf32_External_Rela); 6258 } 6259 6260 return TRUE; 6261 } 6262 6263 /* Set DF_TEXTREL if we find any dynamic relocs that apply to 6264 read-only sections. */ 6265 6266 static bfd_boolean 6267 maybe_set_textrel (struct elf_link_hash_entry *h, void *info) 6268 { 6269 if (h->root.type == bfd_link_hash_indirect) 6270 return TRUE; 6271 6272 if (readonly_dynrelocs (h)) 6273 { 6274 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL; 6275 6276 /* Not an error, just cut short the traversal. */ 6277 return FALSE; 6278 } 6279 return TRUE; 6280 } 6281 6282 static const unsigned char glink_eh_frame_cie[] = 6283 { 6284 0, 0, 0, 16, /* length. */ 6285 0, 0, 0, 0, /* id. */ 6286 1, /* CIE version. */ 6287 'z', 'R', 0, /* Augmentation string. */ 6288 4, /* Code alignment. */ 6289 0x7c, /* Data alignment. */ 6290 65, /* RA reg. */ 6291 1, /* Augmentation size. */ 6292 DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding. */ 6293 DW_CFA_def_cfa, 1, 0 /* def_cfa: r1 offset 0. */ 6294 }; 6295 6296 /* Set the sizes of the dynamic sections. */ 6297 6298 static bfd_boolean 6299 ppc_elf_size_dynamic_sections (bfd *output_bfd, 6300 struct bfd_link_info *info) 6301 { 6302 struct ppc_elf_link_hash_table *htab; 6303 asection *s; 6304 bfd_boolean relocs; 6305 bfd *ibfd; 6306 6307 #ifdef DEBUG 6308 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n"); 6309 #endif 6310 6311 htab = ppc_elf_hash_table (info); 6312 BFD_ASSERT (htab->elf.dynobj != NULL); 6313 6314 if (elf_hash_table (info)->dynamic_sections_created) 6315 { 6316 /* Set the contents of the .interp section to the interpreter. */ 6317 if (bfd_link_executable (info) && !info->nointerp) 6318 { 6319 s = bfd_get_linker_section (htab->elf.dynobj, ".interp"); 6320 BFD_ASSERT (s != NULL); 6321 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 6322 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 6323 } 6324 } 6325 6326 if (htab->plt_type == PLT_OLD) 6327 htab->got_header_size = 16; 6328 else if (htab->plt_type == PLT_NEW) 6329 htab->got_header_size = 12; 6330 6331 /* Set up .got offsets for local syms, and space for local dynamic 6332 relocs. */ 6333 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 6334 { 6335 bfd_signed_vma *local_got; 6336 bfd_signed_vma *end_local_got; 6337 struct plt_entry **local_plt; 6338 struct plt_entry **end_local_plt; 6339 char *lgot_masks; 6340 bfd_size_type locsymcount; 6341 Elf_Internal_Shdr *symtab_hdr; 6342 6343 if (!is_ppc_elf (ibfd)) 6344 continue; 6345 6346 for (s = ibfd->sections; s != NULL; s = s->next) 6347 { 6348 struct ppc_dyn_relocs *p; 6349 6350 for (p = ((struct ppc_dyn_relocs *) 6351 elf_section_data (s)->local_dynrel); 6352 p != NULL; 6353 p = p->next) 6354 { 6355 if (!bfd_is_abs_section (p->sec) 6356 && bfd_is_abs_section (p->sec->output_section)) 6357 { 6358 /* Input section has been discarded, either because 6359 it is a copy of a linkonce section or due to 6360 linker script /DISCARD/, so we'll be discarding 6361 the relocs too. */ 6362 } 6363 else if (htab->is_vxworks 6364 && strcmp (p->sec->output_section->name, 6365 ".tls_vars") == 0) 6366 { 6367 /* Relocations in vxworks .tls_vars sections are 6368 handled specially by the loader. */ 6369 } 6370 else if (p->count != 0) 6371 { 6372 asection *sreloc = elf_section_data (p->sec)->sreloc; 6373 if (p->ifunc) 6374 sreloc = htab->reliplt; 6375 sreloc->size += p->count * sizeof (Elf32_External_Rela); 6376 if ((p->sec->output_section->flags 6377 & (SEC_READONLY | SEC_ALLOC)) 6378 == (SEC_READONLY | SEC_ALLOC)) 6379 info->flags |= DF_TEXTREL; 6380 } 6381 } 6382 } 6383 6384 local_got = elf_local_got_refcounts (ibfd); 6385 if (!local_got) 6386 continue; 6387 6388 symtab_hdr = &elf_symtab_hdr (ibfd); 6389 locsymcount = symtab_hdr->sh_info; 6390 end_local_got = local_got + locsymcount; 6391 local_plt = (struct plt_entry **) end_local_got; 6392 end_local_plt = local_plt + locsymcount; 6393 lgot_masks = (char *) end_local_plt; 6394 6395 for (; local_got < end_local_got; ++local_got, ++lgot_masks) 6396 if (*local_got > 0) 6397 { 6398 unsigned int need = 0; 6399 if ((*lgot_masks & TLS_TLS) != 0) 6400 { 6401 if ((*lgot_masks & TLS_GD) != 0) 6402 need += 8; 6403 if ((*lgot_masks & TLS_LD) != 0) 6404 htab->tlsld_got.refcount += 1; 6405 if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0) 6406 need += 4; 6407 if ((*lgot_masks & TLS_DTPREL) != 0) 6408 need += 4; 6409 } 6410 else 6411 need += 4; 6412 if (need == 0) 6413 *local_got = (bfd_vma) -1; 6414 else 6415 { 6416 *local_got = allocate_got (htab, need); 6417 if (bfd_link_pic (info)) 6418 { 6419 asection *srel = htab->relgot; 6420 if ((*lgot_masks & PLT_IFUNC) != 0) 6421 srel = htab->reliplt; 6422 srel->size += need * (sizeof (Elf32_External_Rela) / 4); 6423 } 6424 } 6425 } 6426 else 6427 *local_got = (bfd_vma) -1; 6428 6429 if (htab->is_vxworks) 6430 continue; 6431 6432 /* Allocate space for calls to local STT_GNU_IFUNC syms in .iplt. */ 6433 for (; local_plt < end_local_plt; ++local_plt) 6434 { 6435 struct plt_entry *ent; 6436 bfd_boolean doneone = FALSE; 6437 bfd_vma plt_offset = 0, glink_offset = 0; 6438 6439 for (ent = *local_plt; ent != NULL; ent = ent->next) 6440 if (ent->plt.refcount > 0) 6441 { 6442 s = htab->iplt; 6443 6444 if (!doneone) 6445 { 6446 plt_offset = s->size; 6447 s->size += 4; 6448 } 6449 ent->plt.offset = plt_offset; 6450 6451 s = htab->glink; 6452 if (!doneone || bfd_link_pic (info)) 6453 { 6454 glink_offset = s->size; 6455 s->size += GLINK_ENTRY_SIZE; 6456 } 6457 ent->glink_offset = glink_offset; 6458 6459 if (!doneone) 6460 { 6461 htab->reliplt->size += sizeof (Elf32_External_Rela); 6462 doneone = TRUE; 6463 } 6464 } 6465 else 6466 ent->plt.offset = (bfd_vma) -1; 6467 } 6468 } 6469 6470 /* Allocate space for global sym dynamic relocs. */ 6471 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info); 6472 6473 if (htab->tlsld_got.refcount > 0) 6474 { 6475 htab->tlsld_got.offset = allocate_got (htab, 8); 6476 if (bfd_link_pic (info)) 6477 htab->relgot->size += sizeof (Elf32_External_Rela); 6478 } 6479 else 6480 htab->tlsld_got.offset = (bfd_vma) -1; 6481 6482 if (htab->got != NULL && htab->plt_type != PLT_VXWORKS) 6483 { 6484 unsigned int g_o_t = 32768; 6485 6486 /* If we haven't allocated the header, do so now. When we get here, 6487 for old plt/got the got size will be 0 to 32764 (not allocated), 6488 or 32780 to 65536 (header allocated). For new plt/got, the 6489 corresponding ranges are 0 to 32768 and 32780 to 65536. */ 6490 if (htab->got->size <= 32768) 6491 { 6492 g_o_t = htab->got->size; 6493 if (htab->plt_type == PLT_OLD) 6494 g_o_t += 4; 6495 htab->got->size += htab->got_header_size; 6496 } 6497 6498 htab->elf.hgot->root.u.def.value = g_o_t; 6499 } 6500 if (bfd_link_pic (info)) 6501 { 6502 struct elf_link_hash_entry *sda = htab->sdata[0].sym; 6503 6504 sda->root.u.def.section = htab->elf.hgot->root.u.def.section; 6505 sda->root.u.def.value = htab->elf.hgot->root.u.def.value; 6506 } 6507 if (info->emitrelocations) 6508 { 6509 struct elf_link_hash_entry *sda = htab->sdata[0].sym; 6510 6511 if (sda != NULL && sda->ref_regular) 6512 sda->root.u.def.section->flags |= SEC_KEEP; 6513 sda = htab->sdata[1].sym; 6514 if (sda != NULL && sda->ref_regular) 6515 sda->root.u.def.section->flags |= SEC_KEEP; 6516 } 6517 6518 if (htab->glink != NULL 6519 && htab->glink->size != 0 6520 && htab->elf.dynamic_sections_created) 6521 { 6522 htab->glink_pltresolve = htab->glink->size; 6523 /* Space for the branch table. */ 6524 htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4; 6525 /* Pad out to align the start of PLTresolve. */ 6526 htab->glink->size += -htab->glink->size & (htab->params->ppc476_workaround 6527 ? 63 : 15); 6528 htab->glink->size += GLINK_PLTRESOLVE; 6529 6530 if (htab->params->emit_stub_syms) 6531 { 6532 struct elf_link_hash_entry *sh; 6533 sh = elf_link_hash_lookup (&htab->elf, "__glink", 6534 TRUE, FALSE, FALSE); 6535 if (sh == NULL) 6536 return FALSE; 6537 if (sh->root.type == bfd_link_hash_new) 6538 { 6539 sh->root.type = bfd_link_hash_defined; 6540 sh->root.u.def.section = htab->glink; 6541 sh->root.u.def.value = htab->glink_pltresolve; 6542 sh->ref_regular = 1; 6543 sh->def_regular = 1; 6544 sh->ref_regular_nonweak = 1; 6545 sh->forced_local = 1; 6546 sh->non_elf = 0; 6547 sh->root.linker_def = 1; 6548 } 6549 sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve", 6550 TRUE, FALSE, FALSE); 6551 if (sh == NULL) 6552 return FALSE; 6553 if (sh->root.type == bfd_link_hash_new) 6554 { 6555 sh->root.type = bfd_link_hash_defined; 6556 sh->root.u.def.section = htab->glink; 6557 sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE; 6558 sh->ref_regular = 1; 6559 sh->def_regular = 1; 6560 sh->ref_regular_nonweak = 1; 6561 sh->forced_local = 1; 6562 sh->non_elf = 0; 6563 sh->root.linker_def = 1; 6564 } 6565 } 6566 } 6567 6568 if (htab->glink != NULL 6569 && htab->glink->size != 0 6570 && htab->glink_eh_frame != NULL 6571 && !bfd_is_abs_section (htab->glink_eh_frame->output_section) 6572 && _bfd_elf_eh_frame_present (info)) 6573 { 6574 s = htab->glink_eh_frame; 6575 s->size = sizeof (glink_eh_frame_cie) + 20; 6576 if (bfd_link_pic (info)) 6577 { 6578 s->size += 4; 6579 if (htab->glink->size - GLINK_PLTRESOLVE + 8 >= 256) 6580 s->size += 4; 6581 } 6582 } 6583 6584 /* We've now determined the sizes of the various dynamic sections. 6585 Allocate memory for them. */ 6586 relocs = FALSE; 6587 for (s = htab->elf.dynobj->sections; s != NULL; s = s->next) 6588 { 6589 bfd_boolean strip_section = TRUE; 6590 6591 if ((s->flags & SEC_LINKER_CREATED) == 0) 6592 continue; 6593 6594 if (s == htab->plt 6595 || s == htab->got) 6596 { 6597 /* We'd like to strip these sections if they aren't needed, but if 6598 we've exported dynamic symbols from them we must leave them. 6599 It's too late to tell BFD to get rid of the symbols. */ 6600 if (htab->elf.hplt != NULL) 6601 strip_section = FALSE; 6602 /* Strip this section if we don't need it; see the 6603 comment below. */ 6604 } 6605 else if (s == htab->iplt 6606 || s == htab->glink 6607 || s == htab->glink_eh_frame 6608 || s == htab->sgotplt 6609 || s == htab->sbss 6610 || s == htab->dynbss 6611 || s == htab->dynsbss) 6612 { 6613 /* Strip these too. */ 6614 } 6615 else if (s == htab->sdata[0].section 6616 || s == htab->sdata[1].section) 6617 { 6618 strip_section = (s->flags & SEC_KEEP) == 0; 6619 } 6620 else if (CONST_STRNEQ (bfd_get_section_name (htab->elf.dynobj, s), 6621 ".rela")) 6622 { 6623 if (s->size != 0) 6624 { 6625 /* Remember whether there are any relocation sections. */ 6626 relocs = TRUE; 6627 6628 /* We use the reloc_count field as a counter if we need 6629 to copy relocs into the output file. */ 6630 s->reloc_count = 0; 6631 } 6632 } 6633 else 6634 { 6635 /* It's not one of our sections, so don't allocate space. */ 6636 continue; 6637 } 6638 6639 if (s->size == 0 && strip_section) 6640 { 6641 /* If we don't need this section, strip it from the 6642 output file. This is mostly to handle .rela.bss and 6643 .rela.plt. We must create both sections in 6644 create_dynamic_sections, because they must be created 6645 before the linker maps input sections to output 6646 sections. The linker does that before 6647 adjust_dynamic_symbol is called, and it is that 6648 function which decides whether anything needs to go 6649 into these sections. */ 6650 s->flags |= SEC_EXCLUDE; 6651 continue; 6652 } 6653 6654 if ((s->flags & SEC_HAS_CONTENTS) == 0) 6655 continue; 6656 6657 /* Allocate memory for the section contents. */ 6658 s->contents = bfd_zalloc (htab->elf.dynobj, s->size); 6659 if (s->contents == NULL) 6660 return FALSE; 6661 } 6662 6663 if (htab->elf.dynamic_sections_created) 6664 { 6665 /* Add some entries to the .dynamic section. We fill in the 6666 values later, in ppc_elf_finish_dynamic_sections, but we 6667 must add the entries now so that we get the correct size for 6668 the .dynamic section. The DT_DEBUG entry is filled in by the 6669 dynamic linker and used by the debugger. */ 6670 #define add_dynamic_entry(TAG, VAL) \ 6671 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 6672 6673 if (bfd_link_executable (info)) 6674 { 6675 if (!add_dynamic_entry (DT_DEBUG, 0)) 6676 return FALSE; 6677 } 6678 6679 if (htab->plt != NULL && htab->plt->size != 0) 6680 { 6681 if (!add_dynamic_entry (DT_PLTGOT, 0) 6682 || !add_dynamic_entry (DT_PLTRELSZ, 0) 6683 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 6684 || !add_dynamic_entry (DT_JMPREL, 0)) 6685 return FALSE; 6686 } 6687 6688 if (htab->plt_type == PLT_NEW 6689 && htab->glink != NULL 6690 && htab->glink->size != 0) 6691 { 6692 if (!add_dynamic_entry (DT_PPC_GOT, 0)) 6693 return FALSE; 6694 if (!htab->params->no_tls_get_addr_opt 6695 && htab->tls_get_addr != NULL 6696 && htab->tls_get_addr->plt.plist != NULL 6697 && !add_dynamic_entry (DT_PPC_OPT, PPC_OPT_TLS)) 6698 return FALSE; 6699 } 6700 6701 if (relocs) 6702 { 6703 if (!add_dynamic_entry (DT_RELA, 0) 6704 || !add_dynamic_entry (DT_RELASZ, 0) 6705 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 6706 return FALSE; 6707 } 6708 6709 /* If any dynamic relocs apply to a read-only section, then we 6710 need a DT_TEXTREL entry. */ 6711 if ((info->flags & DF_TEXTREL) == 0) 6712 elf_link_hash_traverse (elf_hash_table (info), maybe_set_textrel, 6713 info); 6714 6715 if ((info->flags & DF_TEXTREL) != 0) 6716 { 6717 if (!add_dynamic_entry (DT_TEXTREL, 0)) 6718 return FALSE; 6719 } 6720 if (htab->is_vxworks 6721 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 6722 return FALSE; 6723 } 6724 #undef add_dynamic_entry 6725 6726 if (htab->glink_eh_frame != NULL 6727 && htab->glink_eh_frame->contents != NULL) 6728 { 6729 unsigned char *p = htab->glink_eh_frame->contents; 6730 bfd_vma val; 6731 6732 memcpy (p, glink_eh_frame_cie, sizeof (glink_eh_frame_cie)); 6733 /* CIE length (rewrite in case little-endian). */ 6734 bfd_put_32 (htab->elf.dynobj, sizeof (glink_eh_frame_cie) - 4, p); 6735 p += sizeof (glink_eh_frame_cie); 6736 /* FDE length. */ 6737 val = htab->glink_eh_frame->size - 4 - sizeof (glink_eh_frame_cie); 6738 bfd_put_32 (htab->elf.dynobj, val, p); 6739 p += 4; 6740 /* CIE pointer. */ 6741 val = p - htab->glink_eh_frame->contents; 6742 bfd_put_32 (htab->elf.dynobj, val, p); 6743 p += 4; 6744 /* Offset to .glink. Set later. */ 6745 p += 4; 6746 /* .glink size. */ 6747 bfd_put_32 (htab->elf.dynobj, htab->glink->size, p); 6748 p += 4; 6749 /* Augmentation. */ 6750 p += 1; 6751 6752 if (bfd_link_pic (info) 6753 && htab->elf.dynamic_sections_created) 6754 { 6755 bfd_vma adv = (htab->glink->size - GLINK_PLTRESOLVE + 8) >> 2; 6756 if (adv < 64) 6757 *p++ = DW_CFA_advance_loc + adv; 6758 else if (adv < 256) 6759 { 6760 *p++ = DW_CFA_advance_loc1; 6761 *p++ = adv; 6762 } 6763 else if (adv < 65536) 6764 { 6765 *p++ = DW_CFA_advance_loc2; 6766 bfd_put_16 (htab->elf.dynobj, adv, p); 6767 p += 2; 6768 } 6769 else 6770 { 6771 *p++ = DW_CFA_advance_loc4; 6772 bfd_put_32 (htab->elf.dynobj, adv, p); 6773 p += 4; 6774 } 6775 *p++ = DW_CFA_register; 6776 *p++ = 65; 6777 p++; 6778 *p++ = DW_CFA_advance_loc + 4; 6779 *p++ = DW_CFA_restore_extended; 6780 *p++ = 65; 6781 } 6782 BFD_ASSERT ((bfd_vma) ((p + 3 - htab->glink_eh_frame->contents) & -4) 6783 == htab->glink_eh_frame->size); 6784 } 6785 6786 return TRUE; 6787 } 6788 6789 /* Arrange to have _SDA_BASE_ or _SDA2_BASE_ stripped from the output 6790 if it looks like nothing is using them. */ 6791 6792 static void 6793 maybe_strip_sdasym (bfd *output_bfd, elf_linker_section_t *lsect) 6794 { 6795 struct elf_link_hash_entry *sda = lsect->sym; 6796 6797 if (sda != NULL && !sda->ref_regular && sda->dynindx == -1) 6798 { 6799 asection *s; 6800 6801 s = bfd_get_section_by_name (output_bfd, lsect->name); 6802 if (s == NULL || bfd_section_removed_from_list (output_bfd, s)) 6803 { 6804 s = bfd_get_section_by_name (output_bfd, lsect->bss_name); 6805 if (s == NULL || bfd_section_removed_from_list (output_bfd, s)) 6806 { 6807 sda->def_regular = 0; 6808 /* This is somewhat magic. See elf_link_output_extsym. */ 6809 sda->ref_dynamic = 1; 6810 sda->forced_local = 0; 6811 } 6812 } 6813 } 6814 } 6815 6816 void 6817 ppc_elf_maybe_strip_sdata_syms (struct bfd_link_info *info) 6818 { 6819 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 6820 6821 if (htab != NULL) 6822 { 6823 maybe_strip_sdasym (info->output_bfd, &htab->sdata[0]); 6824 maybe_strip_sdasym (info->output_bfd, &htab->sdata[1]); 6825 } 6826 } 6827 6828 6829 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section. */ 6830 6831 static bfd_boolean 6832 ppc_elf_hash_symbol (struct elf_link_hash_entry *h) 6833 { 6834 if (h->plt.plist != NULL 6835 && !h->def_regular 6836 && (!h->pointer_equality_needed 6837 || !h->ref_regular_nonweak)) 6838 return FALSE; 6839 6840 return _bfd_elf_hash_symbol (h); 6841 } 6842 6843 #define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) 6845 6846 /* Relaxation trampolines. r12 is available for clobbering (r11, is 6847 used for some functions that are allowed to break the ABI). */ 6848 static const int shared_stub_entry[] = 6849 { 6850 0x7c0802a6, /* mflr 0 */ 6851 0x429f0005, /* bcl 20, 31, .Lxxx */ 6852 0x7d8802a6, /* mflr 12 */ 6853 0x3d8c0000, /* addis 12, 12, (xxx-.Lxxx)@ha */ 6854 0x398c0000, /* addi 12, 12, (xxx-.Lxxx)@l */ 6855 0x7c0803a6, /* mtlr 0 */ 6856 0x7d8903a6, /* mtctr 12 */ 6857 0x4e800420, /* bctr */ 6858 }; 6859 6860 static const int stub_entry[] = 6861 { 6862 0x3d800000, /* lis 12,xxx@ha */ 6863 0x398c0000, /* addi 12,12,xxx@l */ 6864 0x7d8903a6, /* mtctr 12 */ 6865 0x4e800420, /* bctr */ 6866 }; 6867 6868 struct ppc_elf_relax_info 6869 { 6870 unsigned int workaround_size; 6871 unsigned int picfixup_size; 6872 }; 6873 6874 /* This function implements long branch trampolines, and the ppc476 6875 icache bug workaround. Any section needing trampolines or patch 6876 space for the workaround has its size extended so that we can 6877 add trampolines at the end of the section. */ 6878 6879 static bfd_boolean 6880 ppc_elf_relax_section (bfd *abfd, 6881 asection *isec, 6882 struct bfd_link_info *link_info, 6883 bfd_boolean *again) 6884 { 6885 struct one_branch_fixup 6886 { 6887 struct one_branch_fixup *next; 6888 asection *tsec; 6889 /* Final link, can use the symbol offset. For a 6890 relocatable link we use the symbol's index. */ 6891 bfd_vma toff; 6892 bfd_vma trampoff; 6893 }; 6894 6895 Elf_Internal_Shdr *symtab_hdr; 6896 bfd_byte *contents = NULL; 6897 Elf_Internal_Sym *isymbuf = NULL; 6898 Elf_Internal_Rela *internal_relocs = NULL; 6899 Elf_Internal_Rela *irel, *irelend = NULL; 6900 struct one_branch_fixup *branch_fixups = NULL; 6901 struct ppc_elf_relax_info *relax_info = NULL; 6902 unsigned changes = 0; 6903 bfd_boolean workaround_change; 6904 struct ppc_elf_link_hash_table *htab; 6905 bfd_size_type trampbase, trampoff, newsize, picfixup_size; 6906 asection *got2; 6907 bfd_boolean maybe_pasted; 6908 6909 *again = FALSE; 6910 6911 /* No need to do anything with non-alloc or non-code sections. */ 6912 if ((isec->flags & SEC_ALLOC) == 0 6913 || (isec->flags & SEC_CODE) == 0 6914 || (isec->flags & SEC_LINKER_CREATED) != 0 6915 || isec->size < 4) 6916 return TRUE; 6917 6918 /* We cannot represent the required PIC relocs in the output, so don't 6919 do anything. The linker doesn't support mixing -shared and -r 6920 anyway. */ 6921 if (bfd_link_relocatable (link_info) && bfd_link_pic (link_info)) 6922 return TRUE; 6923 6924 htab = ppc_elf_hash_table (link_info); 6925 if (htab == NULL) 6926 return TRUE; 6927 6928 isec->size = (isec->size + 3) & -4; 6929 if (isec->rawsize == 0) 6930 isec->rawsize = isec->size; 6931 trampbase = isec->size; 6932 6933 BFD_ASSERT (isec->sec_info_type == SEC_INFO_TYPE_NONE 6934 || isec->sec_info_type == SEC_INFO_TYPE_TARGET); 6935 isec->sec_info_type = SEC_INFO_TYPE_TARGET; 6936 6937 if (htab->params->ppc476_workaround 6938 || htab->params->pic_fixup > 0) 6939 { 6940 if (elf_section_data (isec)->sec_info == NULL) 6941 { 6942 elf_section_data (isec)->sec_info 6943 = bfd_zalloc (abfd, sizeof (struct ppc_elf_relax_info)); 6944 if (elf_section_data (isec)->sec_info == NULL) 6945 return FALSE; 6946 } 6947 relax_info = elf_section_data (isec)->sec_info; 6948 trampbase -= relax_info->workaround_size; 6949 } 6950 6951 maybe_pasted = (strcmp (isec->output_section->name, ".init") == 0 6952 || strcmp (isec->output_section->name, ".fini") == 0); 6953 /* Space for a branch around any trampolines. */ 6954 trampoff = trampbase; 6955 if (maybe_pasted && trampbase == isec->rawsize) 6956 trampoff += 4; 6957 6958 symtab_hdr = &elf_symtab_hdr (abfd); 6959 picfixup_size = 0; 6960 if (htab->params->branch_trampolines 6961 || htab->params->pic_fixup > 0) 6962 { 6963 /* Get a copy of the native relocations. */ 6964 if (isec->reloc_count != 0) 6965 { 6966 internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, 6967 link_info->keep_memory); 6968 if (internal_relocs == NULL) 6969 goto error_return; 6970 } 6971 6972 got2 = bfd_get_section_by_name (abfd, ".got2"); 6973 6974 irelend = internal_relocs + isec->reloc_count; 6975 for (irel = internal_relocs; irel < irelend; irel++) 6976 { 6977 unsigned long r_type = ELF32_R_TYPE (irel->r_info); 6978 bfd_vma toff, roff; 6979 asection *tsec; 6980 struct one_branch_fixup *f; 6981 size_t insn_offset = 0; 6982 bfd_vma max_branch_offset = 0, val; 6983 bfd_byte *hit_addr; 6984 unsigned long t0; 6985 struct elf_link_hash_entry *h; 6986 struct plt_entry **plist; 6987 unsigned char sym_type; 6988 6989 switch (r_type) 6990 { 6991 case R_PPC_REL24: 6992 case R_PPC_LOCAL24PC: 6993 case R_PPC_PLTREL24: 6994 max_branch_offset = 1 << 25; 6995 break; 6996 6997 case R_PPC_REL14: 6998 case R_PPC_REL14_BRTAKEN: 6999 case R_PPC_REL14_BRNTAKEN: 7000 max_branch_offset = 1 << 15; 7001 break; 7002 7003 case R_PPC_ADDR16_HA: 7004 if (htab->params->pic_fixup > 0) 7005 break; 7006 continue; 7007 7008 default: 7009 continue; 7010 } 7011 7012 /* Get the value of the symbol referred to by the reloc. */ 7013 h = NULL; 7014 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 7015 { 7016 /* A local symbol. */ 7017 Elf_Internal_Sym *isym; 7018 7019 /* Read this BFD's local symbols. */ 7020 if (isymbuf == NULL) 7021 { 7022 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 7023 if (isymbuf == NULL) 7024 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 7025 symtab_hdr->sh_info, 0, 7026 NULL, NULL, NULL); 7027 if (isymbuf == 0) 7028 goto error_return; 7029 } 7030 isym = isymbuf + ELF32_R_SYM (irel->r_info); 7031 if (isym->st_shndx == SHN_UNDEF) 7032 tsec = bfd_und_section_ptr; 7033 else if (isym->st_shndx == SHN_ABS) 7034 tsec = bfd_abs_section_ptr; 7035 else if (isym->st_shndx == SHN_COMMON) 7036 tsec = bfd_com_section_ptr; 7037 else 7038 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 7039 7040 toff = isym->st_value; 7041 sym_type = ELF_ST_TYPE (isym->st_info); 7042 } 7043 else 7044 { 7045 /* Global symbol handling. */ 7046 unsigned long indx; 7047 7048 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 7049 h = elf_sym_hashes (abfd)[indx]; 7050 7051 while (h->root.type == bfd_link_hash_indirect 7052 || h->root.type == bfd_link_hash_warning) 7053 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7054 7055 if (h->root.type == bfd_link_hash_defined 7056 || h->root.type == bfd_link_hash_defweak) 7057 { 7058 tsec = h->root.u.def.section; 7059 toff = h->root.u.def.value; 7060 } 7061 else if (h->root.type == bfd_link_hash_undefined 7062 || h->root.type == bfd_link_hash_undefweak) 7063 { 7064 tsec = bfd_und_section_ptr; 7065 toff = bfd_link_relocatable (link_info) ? indx : 0; 7066 } 7067 else 7068 continue; 7069 7070 /* If this branch is to __tls_get_addr then we may later 7071 optimise away the call. We won't be needing a long- 7072 branch stub in that case. */ 7073 if (bfd_link_executable (link_info) 7074 && h == htab->tls_get_addr 7075 && irel != internal_relocs) 7076 { 7077 unsigned long t_symndx = ELF32_R_SYM (irel[-1].r_info); 7078 unsigned long t_rtype = ELF32_R_TYPE (irel[-1].r_info); 7079 unsigned int tls_mask = 0; 7080 7081 /* The previous reloc should be one of R_PPC_TLSGD or 7082 R_PPC_TLSLD, or for older object files, a reloc 7083 on the __tls_get_addr arg setup insn. Get tls 7084 mask bits from the symbol on that reloc. */ 7085 if (t_symndx < symtab_hdr->sh_info) 7086 { 7087 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd); 7088 7089 if (local_got_offsets != NULL) 7090 { 7091 struct plt_entry **local_plt = (struct plt_entry **) 7092 (local_got_offsets + symtab_hdr->sh_info); 7093 char *lgot_masks = (char *) 7094 (local_plt + symtab_hdr->sh_info); 7095 tls_mask = lgot_masks[t_symndx]; 7096 } 7097 } 7098 else 7099 { 7100 struct elf_link_hash_entry *th 7101 = elf_sym_hashes (abfd)[t_symndx - symtab_hdr->sh_info]; 7102 7103 while (th->root.type == bfd_link_hash_indirect 7104 || th->root.type == bfd_link_hash_warning) 7105 th = (struct elf_link_hash_entry *) th->root.u.i.link; 7106 7107 tls_mask 7108 = ((struct ppc_elf_link_hash_entry *) th)->tls_mask; 7109 } 7110 7111 /* The mask bits tell us if the call will be 7112 optimised away. */ 7113 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0 7114 && (t_rtype == R_PPC_TLSGD 7115 || t_rtype == R_PPC_GOT_TLSGD16 7116 || t_rtype == R_PPC_GOT_TLSGD16_LO)) 7117 continue; 7118 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0 7119 && (t_rtype == R_PPC_TLSLD 7120 || t_rtype == R_PPC_GOT_TLSLD16 7121 || t_rtype == R_PPC_GOT_TLSLD16_LO)) 7122 continue; 7123 } 7124 7125 sym_type = h->type; 7126 } 7127 7128 if (r_type == R_PPC_ADDR16_HA) 7129 { 7130 if (h != NULL 7131 && !h->def_regular 7132 && h->protected_def 7133 && ppc_elf_hash_entry (h)->has_addr16_ha 7134 && ppc_elf_hash_entry (h)->has_addr16_lo) 7135 picfixup_size += 12; 7136 continue; 7137 } 7138 7139 /* The condition here under which we call find_plt_ent must 7140 match that in relocate_section. If we call find_plt_ent here 7141 but not in relocate_section, or vice versa, then the branch 7142 destination used here may be incorrect. */ 7143 plist = NULL; 7144 if (h != NULL) 7145 { 7146 /* We know is_branch_reloc (r_type) is true. */ 7147 if (h->type == STT_GNU_IFUNC 7148 || r_type == R_PPC_PLTREL24) 7149 plist = &h->plt.plist; 7150 } 7151 else if (sym_type == STT_GNU_IFUNC 7152 && elf_local_got_offsets (abfd) != NULL) 7153 { 7154 bfd_vma *local_got_offsets = elf_local_got_offsets (abfd); 7155 struct plt_entry **local_plt = (struct plt_entry **) 7156 (local_got_offsets + symtab_hdr->sh_info); 7157 plist = local_plt + ELF32_R_SYM (irel->r_info); 7158 } 7159 if (plist != NULL) 7160 { 7161 bfd_vma addend = 0; 7162 struct plt_entry *ent; 7163 7164 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (link_info)) 7165 addend = irel->r_addend; 7166 ent = find_plt_ent (plist, got2, addend); 7167 if (ent != NULL) 7168 { 7169 if (htab->plt_type == PLT_NEW 7170 || h == NULL 7171 || !htab->elf.dynamic_sections_created 7172 || h->dynindx == -1) 7173 { 7174 tsec = htab->glink; 7175 toff = ent->glink_offset; 7176 } 7177 else 7178 { 7179 tsec = htab->plt; 7180 toff = ent->plt.offset; 7181 } 7182 } 7183 } 7184 7185 /* If the branch and target are in the same section, you have 7186 no hope of adding stubs. We'll error out later should the 7187 branch overflow. */ 7188 if (tsec == isec) 7189 continue; 7190 7191 /* There probably isn't any reason to handle symbols in 7192 SEC_MERGE sections; SEC_MERGE doesn't seem a likely 7193 attribute for a code section, and we are only looking at 7194 branches. However, implement it correctly here as a 7195 reference for other target relax_section functions. */ 7196 if (0 && tsec->sec_info_type == SEC_INFO_TYPE_MERGE) 7197 { 7198 /* At this stage in linking, no SEC_MERGE symbol has been 7199 adjusted, so all references to such symbols need to be 7200 passed through _bfd_merged_section_offset. (Later, in 7201 relocate_section, all SEC_MERGE symbols *except* for 7202 section symbols have been adjusted.) 7203 7204 gas may reduce relocations against symbols in SEC_MERGE 7205 sections to a relocation against the section symbol when 7206 the original addend was zero. When the reloc is against 7207 a section symbol we should include the addend in the 7208 offset passed to _bfd_merged_section_offset, since the 7209 location of interest is the original symbol. On the 7210 other hand, an access to "sym+addend" where "sym" is not 7211 a section symbol should not include the addend; Such an 7212 access is presumed to be an offset from "sym"; The 7213 location of interest is just "sym". */ 7214 if (sym_type == STT_SECTION) 7215 toff += irel->r_addend; 7216 7217 toff 7218 = _bfd_merged_section_offset (abfd, &tsec, 7219 elf_section_data (tsec)->sec_info, 7220 toff); 7221 7222 if (sym_type != STT_SECTION) 7223 toff += irel->r_addend; 7224 } 7225 /* PLTREL24 addends are special. */ 7226 else if (r_type != R_PPC_PLTREL24) 7227 toff += irel->r_addend; 7228 7229 /* Attempted -shared link of non-pic code loses. */ 7230 if ((!bfd_link_relocatable (link_info) 7231 && tsec == bfd_und_section_ptr) 7232 || tsec->output_section == NULL 7233 || (tsec->owner != NULL 7234 && (tsec->owner->flags & BFD_PLUGIN) != 0)) 7235 continue; 7236 7237 roff = irel->r_offset; 7238 7239 /* If the branch is in range, no need to do anything. */ 7240 if (tsec != bfd_und_section_ptr 7241 && (!bfd_link_relocatable (link_info) 7242 /* A relocatable link may have sections moved during 7243 final link, so do not presume they remain in range. */ 7244 || tsec->output_section == isec->output_section)) 7245 { 7246 bfd_vma symaddr, reladdr; 7247 7248 symaddr = tsec->output_section->vma + tsec->output_offset + toff; 7249 reladdr = isec->output_section->vma + isec->output_offset + roff; 7250 if (symaddr - reladdr + max_branch_offset 7251 < 2 * max_branch_offset) 7252 continue; 7253 } 7254 7255 /* Look for an existing fixup to this address. */ 7256 for (f = branch_fixups; f ; f = f->next) 7257 if (f->tsec == tsec && f->toff == toff) 7258 break; 7259 7260 if (f == NULL) 7261 { 7262 size_t size; 7263 unsigned long stub_rtype; 7264 7265 val = trampoff - roff; 7266 if (val >= max_branch_offset) 7267 /* Oh dear, we can't reach a trampoline. Don't try to add 7268 one. We'll report an error later. */ 7269 continue; 7270 7271 if (bfd_link_pic (link_info)) 7272 { 7273 size = 4 * ARRAY_SIZE (shared_stub_entry); 7274 insn_offset = 12; 7275 } 7276 else 7277 { 7278 size = 4 * ARRAY_SIZE (stub_entry); 7279 insn_offset = 0; 7280 } 7281 stub_rtype = R_PPC_RELAX; 7282 if (tsec == htab->plt 7283 || tsec == htab->glink) 7284 { 7285 stub_rtype = R_PPC_RELAX_PLT; 7286 if (r_type == R_PPC_PLTREL24) 7287 stub_rtype = R_PPC_RELAX_PLTREL24; 7288 } 7289 7290 /* Hijack the old relocation. Since we need two 7291 relocations for this use a "composite" reloc. */ 7292 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 7293 stub_rtype); 7294 irel->r_offset = trampoff + insn_offset; 7295 if (r_type == R_PPC_PLTREL24 7296 && stub_rtype != R_PPC_RELAX_PLTREL24) 7297 irel->r_addend = 0; 7298 7299 /* Record the fixup so we don't do it again this section. */ 7300 f = bfd_malloc (sizeof (*f)); 7301 f->next = branch_fixups; 7302 f->tsec = tsec; 7303 f->toff = toff; 7304 f->trampoff = trampoff; 7305 branch_fixups = f; 7306 7307 trampoff += size; 7308 changes++; 7309 } 7310 else 7311 { 7312 val = f->trampoff - roff; 7313 if (val >= max_branch_offset) 7314 continue; 7315 7316 /* Nop out the reloc, since we're finalizing things here. */ 7317 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE); 7318 } 7319 7320 /* Get the section contents. */ 7321 if (contents == NULL) 7322 { 7323 /* Get cached copy if it exists. */ 7324 if (elf_section_data (isec)->this_hdr.contents != NULL) 7325 contents = elf_section_data (isec)->this_hdr.contents; 7326 /* Go get them off disk. */ 7327 else if (!bfd_malloc_and_get_section (abfd, isec, &contents)) 7328 goto error_return; 7329 } 7330 7331 /* Fix up the existing branch to hit the trampoline. */ 7332 hit_addr = contents + roff; 7333 switch (r_type) 7334 { 7335 case R_PPC_REL24: 7336 case R_PPC_LOCAL24PC: 7337 case R_PPC_PLTREL24: 7338 t0 = bfd_get_32 (abfd, hit_addr); 7339 t0 &= ~0x3fffffc; 7340 t0 |= val & 0x3fffffc; 7341 bfd_put_32 (abfd, t0, hit_addr); 7342 break; 7343 7344 case R_PPC_REL14: 7345 case R_PPC_REL14_BRTAKEN: 7346 case R_PPC_REL14_BRNTAKEN: 7347 t0 = bfd_get_32 (abfd, hit_addr); 7348 t0 &= ~0xfffc; 7349 t0 |= val & 0xfffc; 7350 bfd_put_32 (abfd, t0, hit_addr); 7351 break; 7352 } 7353 } 7354 7355 while (branch_fixups != NULL) 7356 { 7357 struct one_branch_fixup *f = branch_fixups; 7358 branch_fixups = branch_fixups->next; 7359 free (f); 7360 } 7361 } 7362 7363 workaround_change = FALSE; 7364 newsize = trampoff; 7365 if (htab->params->ppc476_workaround 7366 && (!bfd_link_relocatable (link_info) 7367 || isec->output_section->alignment_power >= htab->params->pagesize_p2)) 7368 { 7369 bfd_vma addr, end_addr; 7370 unsigned int crossings; 7371 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2; 7372 7373 addr = isec->output_section->vma + isec->output_offset; 7374 end_addr = addr + trampoff; 7375 addr &= -pagesize; 7376 crossings = ((end_addr & -pagesize) - addr) >> htab->params->pagesize_p2; 7377 if (crossings != 0) 7378 { 7379 /* Keep space aligned, to ensure the patch code itself does 7380 not cross a page. Don't decrease size calculated on a 7381 previous pass as otherwise we might never settle on a layout. */ 7382 newsize = 15 - ((end_addr - 1) & 15); 7383 newsize += crossings * 16; 7384 if (relax_info->workaround_size < newsize) 7385 { 7386 relax_info->workaround_size = newsize; 7387 workaround_change = TRUE; 7388 } 7389 /* Ensure relocate_section is called. */ 7390 isec->flags |= SEC_RELOC; 7391 } 7392 newsize = trampoff + relax_info->workaround_size; 7393 } 7394 7395 if (htab->params->pic_fixup > 0) 7396 { 7397 picfixup_size -= relax_info->picfixup_size; 7398 if (picfixup_size != 0) 7399 relax_info->picfixup_size += picfixup_size; 7400 newsize += relax_info->picfixup_size; 7401 } 7402 7403 if (changes != 0 || picfixup_size != 0 || workaround_change) 7404 isec->size = newsize; 7405 7406 if (isymbuf != NULL 7407 && symtab_hdr->contents != (unsigned char *) isymbuf) 7408 { 7409 if (! link_info->keep_memory) 7410 free (isymbuf); 7411 else 7412 { 7413 /* Cache the symbols for elf_link_input_bfd. */ 7414 symtab_hdr->contents = (unsigned char *) isymbuf; 7415 } 7416 } 7417 7418 if (contents != NULL 7419 && elf_section_data (isec)->this_hdr.contents != contents) 7420 { 7421 if (!changes && !link_info->keep_memory) 7422 free (contents); 7423 else 7424 { 7425 /* Cache the section contents for elf_link_input_bfd. */ 7426 elf_section_data (isec)->this_hdr.contents = contents; 7427 } 7428 } 7429 7430 changes += picfixup_size; 7431 if (changes != 0) 7432 { 7433 /* Append sufficient NOP relocs so we can write out relocation 7434 information for the trampolines. */ 7435 Elf_Internal_Shdr *rel_hdr; 7436 Elf_Internal_Rela *new_relocs = bfd_malloc ((changes + isec->reloc_count) 7437 * sizeof (*new_relocs)); 7438 unsigned ix; 7439 7440 if (!new_relocs) 7441 goto error_return; 7442 memcpy (new_relocs, internal_relocs, 7443 isec->reloc_count * sizeof (*new_relocs)); 7444 for (ix = changes; ix--;) 7445 { 7446 irel = new_relocs + ix + isec->reloc_count; 7447 7448 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE); 7449 } 7450 if (internal_relocs != elf_section_data (isec)->relocs) 7451 free (internal_relocs); 7452 elf_section_data (isec)->relocs = new_relocs; 7453 isec->reloc_count += changes; 7454 rel_hdr = _bfd_elf_single_rel_hdr (isec); 7455 rel_hdr->sh_size += changes * rel_hdr->sh_entsize; 7456 } 7457 else if (internal_relocs != NULL 7458 && elf_section_data (isec)->relocs != internal_relocs) 7459 free (internal_relocs); 7460 7461 *again = changes != 0 || workaround_change; 7462 return TRUE; 7463 7464 error_return: 7465 while (branch_fixups != NULL) 7466 { 7467 struct one_branch_fixup *f = branch_fixups; 7468 branch_fixups = branch_fixups->next; 7469 free (f); 7470 } 7471 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents) 7472 free (isymbuf); 7473 if (contents != NULL 7474 && elf_section_data (isec)->this_hdr.contents != contents) 7475 free (contents); 7476 if (internal_relocs != NULL 7477 && elf_section_data (isec)->relocs != internal_relocs) 7478 free (internal_relocs); 7479 return FALSE; 7480 } 7481 7482 /* What to do when ld finds relocations against symbols defined in 7484 discarded sections. */ 7485 7486 static unsigned int 7487 ppc_elf_action_discarded (asection *sec) 7488 { 7489 if (strcmp (".fixup", sec->name) == 0) 7490 return 0; 7491 7492 if (strcmp (".got2", sec->name) == 0) 7493 return 0; 7494 7495 return _bfd_elf_default_action_discarded (sec); 7496 } 7497 7498 /* Fill in the address for a pointer generated in a linker section. */ 7500 7501 static bfd_vma 7502 elf_finish_pointer_linker_section (bfd *input_bfd, 7503 elf_linker_section_t *lsect, 7504 struct elf_link_hash_entry *h, 7505 bfd_vma relocation, 7506 const Elf_Internal_Rela *rel) 7507 { 7508 elf_linker_section_pointers_t *linker_section_ptr; 7509 7510 BFD_ASSERT (lsect != NULL); 7511 7512 if (h != NULL) 7513 { 7514 /* Handle global symbol. */ 7515 struct ppc_elf_link_hash_entry *eh; 7516 7517 eh = (struct ppc_elf_link_hash_entry *) h; 7518 BFD_ASSERT (eh->elf.def_regular); 7519 linker_section_ptr = eh->linker_section_pointer; 7520 } 7521 else 7522 { 7523 /* Handle local symbol. */ 7524 unsigned long r_symndx = ELF32_R_SYM (rel->r_info); 7525 7526 BFD_ASSERT (is_ppc_elf (input_bfd)); 7527 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL); 7528 linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx]; 7529 } 7530 7531 linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr, 7532 rel->r_addend, 7533 lsect); 7534 BFD_ASSERT (linker_section_ptr != NULL); 7535 7536 /* Offset will always be a multiple of four, so use the bottom bit 7537 as a "written" flag. */ 7538 if ((linker_section_ptr->offset & 1) == 0) 7539 { 7540 bfd_put_32 (lsect->section->owner, 7541 relocation + linker_section_ptr->addend, 7542 lsect->section->contents + linker_section_ptr->offset); 7543 linker_section_ptr->offset += 1; 7544 } 7545 7546 relocation = (lsect->section->output_section->vma 7547 + lsect->section->output_offset 7548 + linker_section_ptr->offset - 1 7549 - SYM_VAL (lsect->sym)); 7550 7551 #ifdef DEBUG 7552 fprintf (stderr, 7553 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n", 7554 lsect->name, (long) relocation, (long) relocation); 7555 #endif 7556 7557 return relocation; 7558 } 7559 7560 #define PPC_LO(v) ((v) & 0xffff) 7561 #define PPC_HI(v) (((v) >> 16) & 0xffff) 7562 #define PPC_HA(v) PPC_HI ((v) + 0x8000) 7563 7564 static void 7565 write_glink_stub (struct plt_entry *ent, asection *plt_sec, unsigned char *p, 7566 struct bfd_link_info *info) 7567 { 7568 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 7569 bfd *output_bfd = info->output_bfd; 7570 bfd_vma plt; 7571 7572 plt = ((ent->plt.offset & ~1) 7573 + plt_sec->output_section->vma 7574 + plt_sec->output_offset); 7575 7576 if (bfd_link_pic (info)) 7577 { 7578 bfd_vma got = 0; 7579 7580 if (ent->addend >= 32768) 7581 got = (ent->addend 7582 + ent->sec->output_section->vma 7583 + ent->sec->output_offset); 7584 else if (htab->elf.hgot != NULL) 7585 got = SYM_VAL (htab->elf.hgot); 7586 7587 plt -= got; 7588 7589 if (plt + 0x8000 < 0x10000) 7590 { 7591 bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p); 7592 p += 4; 7593 bfd_put_32 (output_bfd, MTCTR_11, p); 7594 p += 4; 7595 bfd_put_32 (output_bfd, BCTR, p); 7596 p += 4; 7597 bfd_put_32 (output_bfd, htab->params->ppc476_workaround ? BA : NOP, p); 7598 p += 4; 7599 } 7600 else 7601 { 7602 bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p); 7603 p += 4; 7604 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); 7605 p += 4; 7606 bfd_put_32 (output_bfd, MTCTR_11, p); 7607 p += 4; 7608 bfd_put_32 (output_bfd, BCTR, p); 7609 p += 4; 7610 } 7611 } 7612 else 7613 { 7614 bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p); 7615 p += 4; 7616 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); 7617 p += 4; 7618 bfd_put_32 (output_bfd, MTCTR_11, p); 7619 p += 4; 7620 bfd_put_32 (output_bfd, BCTR, p); 7621 p += 4; 7622 } 7623 } 7624 7625 /* Return true if symbol is defined statically. */ 7626 7627 static bfd_boolean 7628 is_static_defined (struct elf_link_hash_entry *h) 7629 { 7630 return ((h->root.type == bfd_link_hash_defined 7631 || h->root.type == bfd_link_hash_defweak) 7632 && h->root.u.def.section != NULL 7633 && h->root.u.def.section->output_section != NULL); 7634 } 7635 7636 /* If INSN is an opcode that may be used with an @tls operand, return 7637 the transformed insn for TLS optimisation, otherwise return 0. If 7638 REG is non-zero only match an insn with RB or RA equal to REG. */ 7639 7640 unsigned int 7641 _bfd_elf_ppc_at_tls_transform (unsigned int insn, unsigned int reg) 7642 { 7643 unsigned int rtra; 7644 7645 if ((insn & (0x3f << 26)) != 31 << 26) 7646 return 0; 7647 7648 if (reg == 0 || ((insn >> 11) & 0x1f) == reg) 7649 rtra = insn & ((1 << 26) - (1 << 16)); 7650 else if (((insn >> 16) & 0x1f) == reg) 7651 rtra = (insn & (0x1f << 21)) | ((insn & (0x1f << 11)) << 5); 7652 else 7653 return 0; 7654 7655 if ((insn & (0x3ff << 1)) == 266 << 1) 7656 /* add -> addi. */ 7657 insn = 14 << 26; 7658 else if ((insn & (0x1f << 1)) == 23 << 1 7659 && ((insn & (0x1f << 6)) < 14 << 6 7660 || ((insn & (0x1f << 6)) >= 16 << 6 7661 && (insn & (0x1f << 6)) < 24 << 6))) 7662 /* load and store indexed -> dform. */ 7663 insn = (32 | ((insn >> 6) & 0x1f)) << 26; 7664 else if ((insn & (((0x1a << 5) | 0x1f) << 1)) == 21 << 1) 7665 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */ 7666 insn = ((58 | ((insn >> 6) & 4)) << 26) | ((insn >> 6) & 1); 7667 else if ((insn & (((0x1f << 5) | 0x1f) << 1)) == 341 << 1) 7668 /* lwax -> lwa. */ 7669 insn = (58 << 26) | 2; 7670 else 7671 return 0; 7672 insn |= rtra; 7673 return insn; 7674 } 7675 7676 /* If INSN is an opcode that may be used with an @tprel operand, return 7677 the transformed insn for an undefined weak symbol, ie. with the 7678 thread pointer REG operand removed. Otherwise return 0. */ 7679 7680 unsigned int 7681 _bfd_elf_ppc_at_tprel_transform (unsigned int insn, unsigned int reg) 7682 { 7683 if ((insn & (0x1f << 16)) == reg << 16 7684 && ((insn & (0x3f << 26)) == 14u << 26 /* addi */ 7685 || (insn & (0x3f << 26)) == 15u << 26 /* addis */ 7686 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */ 7687 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */ 7688 || (insn & (0x3f << 26)) == 36u << 26 /* stw */ 7689 || (insn & (0x3f << 26)) == 38u << 26 /* stb */ 7690 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */ 7691 || (insn & (0x3f << 26)) == 42u << 26 /* lha */ 7692 || (insn & (0x3f << 26)) == 44u << 26 /* sth */ 7693 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */ 7694 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */ 7695 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */ 7696 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */ 7697 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */ 7698 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */ 7699 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */ 7700 && (insn & 3) != 1) 7701 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */ 7702 && ((insn & 3) == 0 || (insn & 3) == 3)))) 7703 { 7704 insn &= ~(0x1f << 16); 7705 } 7706 else if ((insn & (0x1f << 21)) == reg << 21 7707 && ((insn & (0x3e << 26)) == 24u << 26 /* ori, oris */ 7708 || (insn & (0x3e << 26)) == 26u << 26 /* xori,xoris */ 7709 || (insn & (0x3e << 26)) == 28u << 26 /* andi,andis */)) 7710 { 7711 insn &= ~(0x1f << 21); 7712 insn |= (insn & (0x1f << 16)) << 5; 7713 if ((insn & (0x3e << 26)) == 26 << 26 /* xori,xoris */) 7714 insn -= 2 >> 26; /* convert to ori,oris */ 7715 } 7716 else 7717 insn = 0; 7718 return insn; 7719 } 7720 7721 static bfd_boolean 7722 is_insn_ds_form (unsigned int insn) 7723 { 7724 return ((insn & (0x3f << 26)) == 58u << 26 /* ld,ldu,lwa */ 7725 || (insn & (0x3f << 26)) == 62u << 26 /* std,stdu,stq */ 7726 || (insn & (0x3f << 26)) == 57u << 26 /* lfdp */ 7727 || (insn & (0x3f << 26)) == 61u << 26 /* stfdp */); 7728 } 7729 7730 static bfd_boolean 7731 is_insn_dq_form (unsigned int insn) 7732 { 7733 return ((insn & (0x3f << 26)) == 56u << 26 /* lq */ 7734 || ((insn & (0x3f << 26)) == (61u << 26) /* lxv, stxv */ 7735 && (insn & 3) == 1)); 7736 } 7737 7738 /* The RELOCATE_SECTION function is called by the ELF backend linker 7739 to handle the relocations for a section. 7740 7741 The relocs are always passed as Rela structures; if the section 7742 actually uses Rel structures, the r_addend field will always be 7743 zero. 7744 7745 This function is responsible for adjust the section contents as 7746 necessary, and (if using Rela relocs and generating a 7747 relocatable output file) adjusting the reloc addend as 7748 necessary. 7749 7750 This function does not have to worry about setting the reloc 7751 address or the reloc symbol index. 7752 7753 LOCAL_SYMS is a pointer to the swapped in local symbols. 7754 7755 LOCAL_SECTIONS is an array giving the section in the input file 7756 corresponding to the st_shndx field of each local symbol. 7757 7758 The global hash table entry for the global symbols can be found 7759 via elf_sym_hashes (input_bfd). 7760 7761 When generating relocatable output, this function must handle 7762 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 7763 going to be the section symbol corresponding to the output 7764 section, which means that the addend must be adjusted 7765 accordingly. */ 7766 7767 static bfd_boolean 7768 ppc_elf_relocate_section (bfd *output_bfd, 7769 struct bfd_link_info *info, 7770 bfd *input_bfd, 7771 asection *input_section, 7772 bfd_byte *contents, 7773 Elf_Internal_Rela *relocs, 7774 Elf_Internal_Sym *local_syms, 7775 asection **local_sections) 7776 { 7777 Elf_Internal_Shdr *symtab_hdr; 7778 struct elf_link_hash_entry **sym_hashes; 7779 struct ppc_elf_link_hash_table *htab; 7780 Elf_Internal_Rela *rel; 7781 Elf_Internal_Rela *wrel; 7782 Elf_Internal_Rela *relend; 7783 Elf_Internal_Rela outrel; 7784 asection *got2; 7785 bfd_vma *local_got_offsets; 7786 bfd_boolean ret = TRUE; 7787 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0); 7788 bfd_boolean is_vxworks_tls; 7789 unsigned int picfixup_size = 0; 7790 struct ppc_elf_relax_info *relax_info = NULL; 7791 7792 #ifdef DEBUG 7793 _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, " 7794 "%ld relocations%s", 7795 input_bfd, input_section, 7796 (long) input_section->reloc_count, 7797 (bfd_link_relocatable (info)) ? " (relocatable)" : ""); 7798 #endif 7799 7800 got2 = bfd_get_section_by_name (input_bfd, ".got2"); 7801 7802 /* Initialize howto table if not already done. */ 7803 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 7804 ppc_elf_howto_init (); 7805 7806 htab = ppc_elf_hash_table (info); 7807 local_got_offsets = elf_local_got_offsets (input_bfd); 7808 symtab_hdr = &elf_symtab_hdr (input_bfd); 7809 sym_hashes = elf_sym_hashes (input_bfd); 7810 /* We have to handle relocations in vxworks .tls_vars sections 7811 specially, because the dynamic loader is 'weird'. */ 7812 is_vxworks_tls = (htab->is_vxworks && bfd_link_pic (info) 7813 && !strcmp (input_section->output_section->name, 7814 ".tls_vars")); 7815 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET) 7816 relax_info = elf_section_data (input_section)->sec_info; 7817 rel = wrel = relocs; 7818 relend = relocs + input_section->reloc_count; 7819 for (; rel < relend; wrel++, rel++) 7820 { 7821 enum elf_ppc_reloc_type r_type; 7822 bfd_vma addend; 7823 bfd_reloc_status_type r; 7824 Elf_Internal_Sym *sym; 7825 asection *sec; 7826 struct elf_link_hash_entry *h; 7827 const char *sym_name; 7828 reloc_howto_type *howto; 7829 unsigned long r_symndx; 7830 bfd_vma relocation; 7831 bfd_vma branch_bit, from; 7832 bfd_boolean unresolved_reloc; 7833 bfd_boolean warned; 7834 unsigned int tls_type, tls_mask, tls_gd; 7835 struct plt_entry **ifunc; 7836 struct reloc_howto_struct alt_howto; 7837 7838 again: 7839 r_type = ELF32_R_TYPE (rel->r_info); 7840 sym = NULL; 7841 sec = NULL; 7842 h = NULL; 7843 unresolved_reloc = FALSE; 7844 warned = FALSE; 7845 r_symndx = ELF32_R_SYM (rel->r_info); 7846 7847 if (r_symndx < symtab_hdr->sh_info) 7848 { 7849 sym = local_syms + r_symndx; 7850 sec = local_sections[r_symndx]; 7851 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); 7852 7853 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 7854 } 7855 else 7856 { 7857 bfd_boolean ignored; 7858 7859 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 7860 r_symndx, symtab_hdr, sym_hashes, 7861 h, sec, relocation, 7862 unresolved_reloc, warned, ignored); 7863 7864 sym_name = h->root.root.string; 7865 } 7866 7867 if (sec != NULL && discarded_section (sec)) 7868 { 7869 /* For relocs against symbols from removed linkonce sections, 7870 or sections discarded by a linker script, we just want the 7871 section contents zeroed. Avoid any special processing. */ 7872 howto = NULL; 7873 if (r_type < R_PPC_max) 7874 howto = ppc_elf_howto_table[r_type]; 7875 7876 _bfd_clear_contents (howto, input_bfd, input_section, 7877 contents + rel->r_offset); 7878 wrel->r_offset = rel->r_offset; 7879 wrel->r_info = 0; 7880 wrel->r_addend = 0; 7881 7882 /* For ld -r, remove relocations in debug sections against 7883 sections defined in discarded sections. Not done for 7884 non-debug to preserve relocs in .eh_frame which the 7885 eh_frame editing code expects to be present. */ 7886 if (bfd_link_relocatable (info) 7887 && (input_section->flags & SEC_DEBUGGING)) 7888 wrel--; 7889 7890 continue; 7891 } 7892 7893 if (bfd_link_relocatable (info)) 7894 { 7895 if (got2 != NULL 7896 && r_type == R_PPC_PLTREL24 7897 && rel->r_addend != 0) 7898 { 7899 /* R_PPC_PLTREL24 is rather special. If non-zero, the 7900 addend specifies the GOT pointer offset within .got2. */ 7901 rel->r_addend += got2->output_offset; 7902 } 7903 if (r_type != R_PPC_RELAX_PLT 7904 && r_type != R_PPC_RELAX_PLTREL24 7905 && r_type != R_PPC_RELAX) 7906 goto copy_reloc; 7907 } 7908 7909 /* TLS optimizations. Replace instruction sequences and relocs 7910 based on information we collected in tls_optimize. We edit 7911 RELOCS so that --emit-relocs will output something sensible 7912 for the final instruction stream. */ 7913 tls_mask = 0; 7914 tls_gd = 0; 7915 if (h != NULL) 7916 tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask; 7917 else if (local_got_offsets != NULL) 7918 { 7919 struct plt_entry **local_plt; 7920 char *lgot_masks; 7921 local_plt 7922 = (struct plt_entry **) (local_got_offsets + symtab_hdr->sh_info); 7923 lgot_masks = (char *) (local_plt + symtab_hdr->sh_info); 7924 tls_mask = lgot_masks[r_symndx]; 7925 } 7926 7927 /* Ensure reloc mapping code below stays sane. */ 7928 if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3) 7929 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3) 7930 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3) 7931 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3) 7932 || (R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TPREL16 & 3) 7933 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3) 7934 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3) 7935 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3)) 7936 abort (); 7937 switch (r_type) 7938 { 7939 default: 7940 break; 7941 7942 case R_PPC_GOT_TPREL16: 7943 case R_PPC_GOT_TPREL16_LO: 7944 if ((tls_mask & TLS_TLS) != 0 7945 && (tls_mask & TLS_TPREL) == 0) 7946 { 7947 bfd_vma insn; 7948 7949 insn = bfd_get_32 (output_bfd, 7950 contents + rel->r_offset - d_offset); 7951 insn &= 31 << 21; 7952 insn |= 0x3c020000; /* addis 0,2,0 */ 7953 bfd_put_32 (output_bfd, insn, 7954 contents + rel->r_offset - d_offset); 7955 r_type = R_PPC_TPREL16_HA; 7956 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 7957 } 7958 break; 7959 7960 case R_PPC_TLS: 7961 if ((tls_mask & TLS_TLS) != 0 7962 && (tls_mask & TLS_TPREL) == 0) 7963 { 7964 bfd_vma insn; 7965 7966 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 7967 insn = _bfd_elf_ppc_at_tls_transform (insn, 2); 7968 if (insn == 0) 7969 abort (); 7970 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 7971 r_type = R_PPC_TPREL16_LO; 7972 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 7973 7974 /* Was PPC_TLS which sits on insn boundary, now 7975 PPC_TPREL16_LO which is at low-order half-word. */ 7976 rel->r_offset += d_offset; 7977 } 7978 break; 7979 7980 case R_PPC_GOT_TLSGD16_HI: 7981 case R_PPC_GOT_TLSGD16_HA: 7982 tls_gd = TLS_TPRELGD; 7983 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0) 7984 goto tls_gdld_hi; 7985 break; 7986 7987 case R_PPC_GOT_TLSLD16_HI: 7988 case R_PPC_GOT_TLSLD16_HA: 7989 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0) 7990 { 7991 tls_gdld_hi: 7992 if ((tls_mask & tls_gd) != 0) 7993 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3) 7994 + R_PPC_GOT_TPREL16); 7995 else 7996 { 7997 rel->r_offset -= d_offset; 7998 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset); 7999 r_type = R_PPC_NONE; 8000 } 8001 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 8002 } 8003 break; 8004 8005 case R_PPC_GOT_TLSGD16: 8006 case R_PPC_GOT_TLSGD16_LO: 8007 tls_gd = TLS_TPRELGD; 8008 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0) 8009 goto tls_ldgd_opt; 8010 break; 8011 8012 case R_PPC_GOT_TLSLD16: 8013 case R_PPC_GOT_TLSLD16_LO: 8014 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0) 8015 { 8016 unsigned int insn1, insn2; 8017 bfd_vma offset; 8018 8019 tls_ldgd_opt: 8020 offset = (bfd_vma) -1; 8021 /* If not using the newer R_PPC_TLSGD/LD to mark 8022 __tls_get_addr calls, we must trust that the call 8023 stays with its arg setup insns, ie. that the next 8024 reloc is the __tls_get_addr call associated with 8025 the current reloc. Edit both insns. */ 8026 if (input_section->has_tls_get_addr_call 8027 && rel + 1 < relend 8028 && branch_reloc_hash_match (input_bfd, rel + 1, 8029 htab->tls_get_addr)) 8030 offset = rel[1].r_offset; 8031 /* We read the low GOT_TLS insn because we need to keep 8032 the destination reg. It may be something other than 8033 the usual r3, and moved to r3 before the call by 8034 intervening code. */ 8035 insn1 = bfd_get_32 (output_bfd, 8036 contents + rel->r_offset - d_offset); 8037 if ((tls_mask & tls_gd) != 0) 8038 { 8039 /* IE */ 8040 insn1 &= (0x1f << 21) | (0x1f << 16); 8041 insn1 |= 32 << 26; /* lwz */ 8042 if (offset != (bfd_vma) -1) 8043 { 8044 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE); 8045 insn2 = 0x7c631214; /* add 3,3,2 */ 8046 bfd_put_32 (output_bfd, insn2, contents + offset); 8047 } 8048 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3) 8049 + R_PPC_GOT_TPREL16); 8050 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 8051 } 8052 else 8053 { 8054 /* LE */ 8055 insn1 &= 0x1f << 21; 8056 insn1 |= 0x3c020000; /* addis r,2,0 */ 8057 if (tls_gd == 0) 8058 { 8059 /* Was an LD reloc. */ 8060 for (r_symndx = 0; 8061 r_symndx < symtab_hdr->sh_info; 8062 r_symndx++) 8063 if (local_sections[r_symndx] == sec) 8064 break; 8065 if (r_symndx >= symtab_hdr->sh_info) 8066 r_symndx = STN_UNDEF; 8067 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 8068 if (r_symndx != STN_UNDEF) 8069 rel->r_addend -= (local_syms[r_symndx].st_value 8070 + sec->output_offset 8071 + sec->output_section->vma); 8072 } 8073 r_type = R_PPC_TPREL16_HA; 8074 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 8075 if (offset != (bfd_vma) -1) 8076 { 8077 rel[1].r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO); 8078 rel[1].r_offset = offset + d_offset; 8079 rel[1].r_addend = rel->r_addend; 8080 insn2 = 0x38630000; /* addi 3,3,0 */ 8081 bfd_put_32 (output_bfd, insn2, contents + offset); 8082 } 8083 } 8084 bfd_put_32 (output_bfd, insn1, 8085 contents + rel->r_offset - d_offset); 8086 if (tls_gd == 0) 8087 { 8088 /* We changed the symbol on an LD reloc. Start over 8089 in order to get h, sym, sec etc. right. */ 8090 goto again; 8091 } 8092 } 8093 break; 8094 8095 case R_PPC_TLSGD: 8096 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_GD) == 0) 8097 { 8098 unsigned int insn2; 8099 bfd_vma offset = rel->r_offset; 8100 8101 if ((tls_mask & TLS_TPRELGD) != 0) 8102 { 8103 /* IE */ 8104 r_type = R_PPC_NONE; 8105 insn2 = 0x7c631214; /* add 3,3,2 */ 8106 } 8107 else 8108 { 8109 /* LE */ 8110 r_type = R_PPC_TPREL16_LO; 8111 rel->r_offset += d_offset; 8112 insn2 = 0x38630000; /* addi 3,3,0 */ 8113 } 8114 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 8115 bfd_put_32 (output_bfd, insn2, contents + offset); 8116 /* Zap the reloc on the _tls_get_addr call too. */ 8117 BFD_ASSERT (offset == rel[1].r_offset); 8118 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE); 8119 } 8120 break; 8121 8122 case R_PPC_TLSLD: 8123 if ((tls_mask & TLS_TLS) != 0 && (tls_mask & TLS_LD) == 0) 8124 { 8125 unsigned int insn2; 8126 8127 for (r_symndx = 0; 8128 r_symndx < symtab_hdr->sh_info; 8129 r_symndx++) 8130 if (local_sections[r_symndx] == sec) 8131 break; 8132 if (r_symndx >= symtab_hdr->sh_info) 8133 r_symndx = STN_UNDEF; 8134 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 8135 if (r_symndx != STN_UNDEF) 8136 rel->r_addend -= (local_syms[r_symndx].st_value 8137 + sec->output_offset 8138 + sec->output_section->vma); 8139 8140 rel->r_info = ELF32_R_INFO (r_symndx, R_PPC_TPREL16_LO); 8141 rel->r_offset += d_offset; 8142 insn2 = 0x38630000; /* addi 3,3,0 */ 8143 bfd_put_32 (output_bfd, insn2, 8144 contents + rel->r_offset - d_offset); 8145 /* Zap the reloc on the _tls_get_addr call too. */ 8146 BFD_ASSERT (rel->r_offset - d_offset == rel[1].r_offset); 8147 rel[1].r_info = ELF32_R_INFO (STN_UNDEF, R_PPC_NONE); 8148 goto again; 8149 } 8150 break; 8151 } 8152 8153 /* Handle other relocations that tweak non-addend part of insn. */ 8154 branch_bit = 0; 8155 switch (r_type) 8156 { 8157 default: 8158 break; 8159 8160 /* Branch taken prediction relocations. */ 8161 case R_PPC_ADDR14_BRTAKEN: 8162 case R_PPC_REL14_BRTAKEN: 8163 branch_bit = BRANCH_PREDICT_BIT; 8164 /* Fall thru */ 8165 8166 /* Branch not taken prediction relocations. */ 8167 case R_PPC_ADDR14_BRNTAKEN: 8168 case R_PPC_REL14_BRNTAKEN: 8169 { 8170 bfd_vma insn; 8171 8172 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 8173 insn &= ~BRANCH_PREDICT_BIT; 8174 insn |= branch_bit; 8175 8176 from = (rel->r_offset 8177 + input_section->output_offset 8178 + input_section->output_section->vma); 8179 8180 /* Invert 'y' bit if not the default. */ 8181 if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0) 8182 insn ^= BRANCH_PREDICT_BIT; 8183 8184 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 8185 break; 8186 } 8187 } 8188 8189 if (ELIMINATE_COPY_RELOCS 8190 && h != NULL 8191 && !h->def_regular 8192 && h->protected_def 8193 && ppc_elf_hash_entry (h)->has_addr16_ha 8194 && ppc_elf_hash_entry (h)->has_addr16_lo 8195 && htab->params->pic_fixup > 0) 8196 { 8197 /* Convert lis;addi or lis;load/store accessing a protected 8198 variable defined in a shared library to PIC. */ 8199 unsigned int insn; 8200 8201 if (r_type == R_PPC_ADDR16_HA) 8202 { 8203 insn = bfd_get_32 (output_bfd, 8204 contents + rel->r_offset - d_offset); 8205 if ((insn & (0x3f << 26)) == (15u << 26) 8206 && (insn & (0x1f << 16)) == 0 /* lis */) 8207 { 8208 bfd_byte *p; 8209 bfd_vma off; 8210 bfd_vma got_addr; 8211 8212 p = (contents + input_section->size 8213 - relax_info->workaround_size 8214 - relax_info->picfixup_size 8215 + picfixup_size); 8216 off = (p - contents) - (rel->r_offset - d_offset); 8217 if (off > 0x1fffffc || (off & 3) != 0) 8218 info->callbacks->einfo 8219 (_("%P: %H: fixup branch overflow\n"), 8220 input_bfd, input_section, rel->r_offset); 8221 8222 bfd_put_32 (output_bfd, B | off, 8223 contents + rel->r_offset - d_offset); 8224 got_addr = (htab->got->output_section->vma 8225 + htab->got->output_offset 8226 + (h->got.offset & ~1)); 8227 wrel->r_offset = (p - contents) + d_offset; 8228 wrel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_HA); 8229 wrel->r_addend = got_addr; 8230 insn &= ~0xffff; 8231 insn |= ((unsigned int )(got_addr + 0x8000) >> 16) & 0xffff; 8232 bfd_put_32 (output_bfd, insn, p); 8233 8234 /* Convert lis to lwz, loading address from GOT. */ 8235 insn &= ~0xffff; 8236 insn ^= (32u ^ 15u) << 26; 8237 insn |= (insn & (0x1f << 21)) >> 5; 8238 insn |= got_addr & 0xffff; 8239 bfd_put_32 (output_bfd, insn, p + 4); 8240 8241 bfd_put_32 (output_bfd, B | ((-4 - off) & 0x3ffffff), p + 8); 8242 picfixup_size += 12; 8243 8244 /* Use one of the spare relocs, so --emit-relocs 8245 output is reasonable. */ 8246 memmove (rel + 1, rel, (relend - rel - 1) * sizeof (*rel)); 8247 wrel++, rel++; 8248 rel->r_offset = wrel[-1].r_offset + 4; 8249 rel->r_info = ELF32_R_INFO (0, R_PPC_ADDR16_LO); 8250 rel->r_addend = wrel[-1].r_addend; 8251 8252 /* Continue on as if we had a got reloc, to output 8253 dynamic reloc. */ 8254 r_type = R_PPC_GOT16_LO; 8255 } 8256 else 8257 info->callbacks->einfo 8258 (_("%P: %H: error: %s with unexpected instruction %x\n"), 8259 input_bfd, input_section, rel->r_offset, 8260 "R_PPC_ADDR16_HA", insn); 8261 } 8262 else if (r_type == R_PPC_ADDR16_LO) 8263 { 8264 insn = bfd_get_32 (output_bfd, 8265 contents + rel->r_offset - d_offset); 8266 if ((insn & (0x3f << 26)) == 14u << 26 /* addi */ 8267 || (insn & (0x3f << 26)) == 32u << 26 /* lwz */ 8268 || (insn & (0x3f << 26)) == 34u << 26 /* lbz */ 8269 || (insn & (0x3f << 26)) == 36u << 26 /* stw */ 8270 || (insn & (0x3f << 26)) == 38u << 26 /* stb */ 8271 || (insn & (0x3f << 26)) == 40u << 26 /* lhz */ 8272 || (insn & (0x3f << 26)) == 42u << 26 /* lha */ 8273 || (insn & (0x3f << 26)) == 44u << 26 /* sth */ 8274 || (insn & (0x3f << 26)) == 46u << 26 /* lmw */ 8275 || (insn & (0x3f << 26)) == 47u << 26 /* stmw */ 8276 || (insn & (0x3f << 26)) == 48u << 26 /* lfs */ 8277 || (insn & (0x3f << 26)) == 50u << 26 /* lfd */ 8278 || (insn & (0x3f << 26)) == 52u << 26 /* stfs */ 8279 || (insn & (0x3f << 26)) == 54u << 26 /* stfd */ 8280 || ((insn & (0x3f << 26)) == 58u << 26 /* lwa,ld,lmd */ 8281 && (insn & 3) != 1) 8282 || ((insn & (0x3f << 26)) == 62u << 26 /* std, stmd */ 8283 && ((insn & 3) == 0 || (insn & 3) == 3))) 8284 { 8285 /* Arrange to apply the reloc addend, if any. */ 8286 relocation = 0; 8287 unresolved_reloc = FALSE; 8288 rel->r_info = ELF32_R_INFO (0, r_type); 8289 } 8290 else 8291 info->callbacks->einfo 8292 (_("%P: %H: error: %s with unexpected instruction %x\n"), 8293 input_bfd, input_section, rel->r_offset, 8294 "R_PPC_ADDR16_LO", insn); 8295 } 8296 } 8297 8298 ifunc = NULL; 8299 if (!htab->is_vxworks) 8300 { 8301 struct plt_entry *ent; 8302 8303 if (h != NULL) 8304 { 8305 if (h->type == STT_GNU_IFUNC) 8306 ifunc = &h->plt.plist; 8307 } 8308 else if (local_got_offsets != NULL 8309 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 8310 { 8311 struct plt_entry **local_plt; 8312 8313 local_plt = (struct plt_entry **) (local_got_offsets 8314 + symtab_hdr->sh_info); 8315 ifunc = local_plt + r_symndx; 8316 } 8317 8318 ent = NULL; 8319 if (ifunc != NULL 8320 && (!bfd_link_pic (info) 8321 || is_branch_reloc (r_type))) 8322 { 8323 addend = 0; 8324 if (r_type == R_PPC_PLTREL24 && bfd_link_pic (info)) 8325 addend = rel->r_addend; 8326 ent = find_plt_ent (ifunc, got2, addend); 8327 } 8328 if (ent != NULL) 8329 { 8330 if (h == NULL && (ent->plt.offset & 1) == 0) 8331 { 8332 Elf_Internal_Rela rela; 8333 bfd_byte *loc; 8334 8335 rela.r_offset = (htab->iplt->output_section->vma 8336 + htab->iplt->output_offset 8337 + ent->plt.offset); 8338 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE); 8339 rela.r_addend = relocation; 8340 loc = htab->reliplt->contents; 8341 loc += (htab->reliplt->reloc_count++ 8342 * sizeof (Elf32_External_Rela)); 8343 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 8344 8345 ent->plt.offset |= 1; 8346 } 8347 if (h == NULL && (ent->glink_offset & 1) == 0) 8348 { 8349 unsigned char *p = ((unsigned char *) htab->glink->contents 8350 + ent->glink_offset); 8351 write_glink_stub (ent, htab->iplt, p, info); 8352 ent->glink_offset |= 1; 8353 } 8354 8355 unresolved_reloc = FALSE; 8356 if (htab->plt_type == PLT_NEW 8357 || !htab->elf.dynamic_sections_created 8358 || h == NULL 8359 || h->dynindx == -1) 8360 relocation = (htab->glink->output_section->vma 8361 + htab->glink->output_offset 8362 + (ent->glink_offset & ~1)); 8363 else 8364 relocation = (htab->plt->output_section->vma 8365 + htab->plt->output_offset 8366 + ent->plt.offset); 8367 } 8368 } 8369 8370 addend = rel->r_addend; 8371 tls_type = 0; 8372 howto = NULL; 8373 if (r_type < R_PPC_max) 8374 howto = ppc_elf_howto_table[r_type]; 8375 switch (r_type) 8376 { 8377 default: 8378 info->callbacks->einfo 8379 (_("%P: %B: unknown relocation type %d for symbol %s\n"), 8380 input_bfd, (int) r_type, sym_name); 8381 8382 bfd_set_error (bfd_error_bad_value); 8383 ret = FALSE; 8384 goto copy_reloc; 8385 8386 case R_PPC_NONE: 8387 case R_PPC_TLS: 8388 case R_PPC_TLSGD: 8389 case R_PPC_TLSLD: 8390 case R_PPC_EMB_MRKREF: 8391 case R_PPC_GNU_VTINHERIT: 8392 case R_PPC_GNU_VTENTRY: 8393 goto copy_reloc; 8394 8395 /* GOT16 relocations. Like an ADDR16 using the symbol's 8396 address in the GOT as relocation value instead of the 8397 symbol's value itself. Also, create a GOT entry for the 8398 symbol and put the symbol value there. */ 8399 case R_PPC_GOT_TLSGD16: 8400 case R_PPC_GOT_TLSGD16_LO: 8401 case R_PPC_GOT_TLSGD16_HI: 8402 case R_PPC_GOT_TLSGD16_HA: 8403 tls_type = TLS_TLS | TLS_GD; 8404 goto dogot; 8405 8406 case R_PPC_GOT_TLSLD16: 8407 case R_PPC_GOT_TLSLD16_LO: 8408 case R_PPC_GOT_TLSLD16_HI: 8409 case R_PPC_GOT_TLSLD16_HA: 8410 tls_type = TLS_TLS | TLS_LD; 8411 goto dogot; 8412 8413 case R_PPC_GOT_TPREL16: 8414 case R_PPC_GOT_TPREL16_LO: 8415 case R_PPC_GOT_TPREL16_HI: 8416 case R_PPC_GOT_TPREL16_HA: 8417 tls_type = TLS_TLS | TLS_TPREL; 8418 goto dogot; 8419 8420 case R_PPC_GOT_DTPREL16: 8421 case R_PPC_GOT_DTPREL16_LO: 8422 case R_PPC_GOT_DTPREL16_HI: 8423 case R_PPC_GOT_DTPREL16_HA: 8424 tls_type = TLS_TLS | TLS_DTPREL; 8425 goto dogot; 8426 8427 case R_PPC_GOT16: 8428 case R_PPC_GOT16_LO: 8429 case R_PPC_GOT16_HI: 8430 case R_PPC_GOT16_HA: 8431 tls_mask = 0; 8432 dogot: 8433 { 8434 /* Relocation is to the entry for this symbol in the global 8435 offset table. */ 8436 bfd_vma off; 8437 bfd_vma *offp; 8438 unsigned long indx; 8439 8440 if (htab->got == NULL) 8441 abort (); 8442 8443 indx = 0; 8444 if (tls_type == (TLS_TLS | TLS_LD) 8445 && (h == NULL 8446 || !h->def_dynamic)) 8447 offp = &htab->tlsld_got.offset; 8448 else if (h != NULL) 8449 { 8450 bfd_boolean dyn; 8451 dyn = htab->elf.dynamic_sections_created; 8452 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 8453 || (bfd_link_pic (info) 8454 && SYMBOL_REFERENCES_LOCAL (info, h))) 8455 /* This is actually a static link, or it is a 8456 -Bsymbolic link and the symbol is defined 8457 locally, or the symbol was forced to be local 8458 because of a version file. */ 8459 ; 8460 else 8461 { 8462 BFD_ASSERT (h->dynindx != -1); 8463 indx = h->dynindx; 8464 unresolved_reloc = FALSE; 8465 } 8466 offp = &h->got.offset; 8467 } 8468 else 8469 { 8470 if (local_got_offsets == NULL) 8471 abort (); 8472 offp = &local_got_offsets[r_symndx]; 8473 } 8474 8475 /* The offset must always be a multiple of 4. We use the 8476 least significant bit to record whether we have already 8477 processed this entry. */ 8478 off = *offp; 8479 if ((off & 1) != 0) 8480 off &= ~1; 8481 else 8482 { 8483 unsigned int tls_m = (tls_mask 8484 & (TLS_LD | TLS_GD | TLS_DTPREL 8485 | TLS_TPREL | TLS_TPRELGD)); 8486 8487 if (offp == &htab->tlsld_got.offset) 8488 tls_m = TLS_LD; 8489 else if (h == NULL 8490 || !h->def_dynamic) 8491 tls_m &= ~TLS_LD; 8492 8493 /* We might have multiple got entries for this sym. 8494 Initialize them all. */ 8495 do 8496 { 8497 int tls_ty = 0; 8498 8499 if ((tls_m & TLS_LD) != 0) 8500 { 8501 tls_ty = TLS_TLS | TLS_LD; 8502 tls_m &= ~TLS_LD; 8503 } 8504 else if ((tls_m & TLS_GD) != 0) 8505 { 8506 tls_ty = TLS_TLS | TLS_GD; 8507 tls_m &= ~TLS_GD; 8508 } 8509 else if ((tls_m & TLS_DTPREL) != 0) 8510 { 8511 tls_ty = TLS_TLS | TLS_DTPREL; 8512 tls_m &= ~TLS_DTPREL; 8513 } 8514 else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0) 8515 { 8516 tls_ty = TLS_TLS | TLS_TPREL; 8517 tls_m = 0; 8518 } 8519 8520 /* Generate relocs for the dynamic linker. */ 8521 if ((bfd_link_pic (info) || indx != 0) 8522 && (offp == &htab->tlsld_got.offset 8523 || h == NULL 8524 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8525 || h->root.type != bfd_link_hash_undefweak)) 8526 { 8527 asection *rsec = htab->relgot; 8528 bfd_byte * loc; 8529 8530 if (ifunc != NULL) 8531 rsec = htab->reliplt; 8532 outrel.r_offset = (htab->got->output_section->vma 8533 + htab->got->output_offset 8534 + off); 8535 outrel.r_addend = 0; 8536 if (tls_ty & (TLS_LD | TLS_GD)) 8537 { 8538 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32); 8539 if (tls_ty == (TLS_TLS | TLS_GD)) 8540 { 8541 loc = rsec->contents; 8542 loc += (rsec->reloc_count++ 8543 * sizeof (Elf32_External_Rela)); 8544 bfd_elf32_swap_reloca_out (output_bfd, 8545 &outrel, loc); 8546 outrel.r_offset += 4; 8547 outrel.r_info 8548 = ELF32_R_INFO (indx, R_PPC_DTPREL32); 8549 } 8550 } 8551 else if (tls_ty == (TLS_TLS | TLS_DTPREL)) 8552 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32); 8553 else if (tls_ty == (TLS_TLS | TLS_TPREL)) 8554 outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32); 8555 else if (indx != 0) 8556 outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT); 8557 else if (ifunc != NULL) 8558 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE); 8559 else 8560 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 8561 if (indx == 0 && tls_ty != (TLS_TLS | TLS_LD)) 8562 { 8563 outrel.r_addend += relocation; 8564 if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL)) 8565 { 8566 if (htab->elf.tls_sec == NULL) 8567 outrel.r_addend = 0; 8568 else 8569 outrel.r_addend -= htab->elf.tls_sec->vma; 8570 } 8571 } 8572 loc = rsec->contents; 8573 loc += (rsec->reloc_count++ 8574 * sizeof (Elf32_External_Rela)); 8575 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 8576 } 8577 8578 /* Init the .got section contents if we're not 8579 emitting a reloc. */ 8580 else 8581 { 8582 bfd_vma value = relocation; 8583 8584 if (tls_ty == (TLS_TLS | TLS_LD)) 8585 value = 1; 8586 else if (tls_ty != 0) 8587 { 8588 if (htab->elf.tls_sec == NULL) 8589 value = 0; 8590 else 8591 { 8592 value -= htab->elf.tls_sec->vma + DTP_OFFSET; 8593 if (tls_ty == (TLS_TLS | TLS_TPREL)) 8594 value += DTP_OFFSET - TP_OFFSET; 8595 } 8596 8597 if (tls_ty == (TLS_TLS | TLS_GD)) 8598 { 8599 bfd_put_32 (output_bfd, value, 8600 htab->got->contents + off + 4); 8601 value = 1; 8602 } 8603 } 8604 bfd_put_32 (output_bfd, value, 8605 htab->got->contents + off); 8606 } 8607 8608 off += 4; 8609 if (tls_ty & (TLS_LD | TLS_GD)) 8610 off += 4; 8611 } 8612 while (tls_m != 0); 8613 8614 off = *offp; 8615 *offp = off | 1; 8616 } 8617 8618 if (off >= (bfd_vma) -2) 8619 abort (); 8620 8621 if ((tls_type & TLS_TLS) != 0) 8622 { 8623 if (tls_type != (TLS_TLS | TLS_LD)) 8624 { 8625 if ((tls_mask & TLS_LD) != 0 8626 && !(h == NULL 8627 || !h->def_dynamic)) 8628 off += 8; 8629 if (tls_type != (TLS_TLS | TLS_GD)) 8630 { 8631 if ((tls_mask & TLS_GD) != 0) 8632 off += 8; 8633 if (tls_type != (TLS_TLS | TLS_DTPREL)) 8634 { 8635 if ((tls_mask & TLS_DTPREL) != 0) 8636 off += 4; 8637 } 8638 } 8639 } 8640 } 8641 8642 /* If here for a picfixup, we're done. */ 8643 if (r_type != ELF32_R_TYPE (rel->r_info)) 8644 goto copy_reloc; 8645 8646 relocation = (htab->got->output_section->vma 8647 + htab->got->output_offset 8648 + off 8649 - SYM_VAL (htab->elf.hgot)); 8650 8651 /* Addends on got relocations don't make much sense. 8652 x+off@got is actually x@got+off, and since the got is 8653 generated by a hash table traversal, the value in the 8654 got at entry m+n bears little relation to the entry m. */ 8655 if (addend != 0) 8656 info->callbacks->einfo 8657 (_("%P: %H: non-zero addend on %s reloc against `%s'\n"), 8658 input_bfd, input_section, rel->r_offset, 8659 howto->name, 8660 sym_name); 8661 } 8662 break; 8663 8664 /* Relocations that need no special processing. */ 8665 case R_PPC_LOCAL24PC: 8666 /* It makes no sense to point a local relocation 8667 at a symbol not in this object. */ 8668 if (unresolved_reloc) 8669 { 8670 (*info->callbacks->undefined_symbol) (info, 8671 h->root.root.string, 8672 input_bfd, 8673 input_section, 8674 rel->r_offset, 8675 TRUE); 8676 goto copy_reloc; 8677 } 8678 break; 8679 8680 case R_PPC_DTPREL16: 8681 case R_PPC_DTPREL16_LO: 8682 case R_PPC_DTPREL16_HI: 8683 case R_PPC_DTPREL16_HA: 8684 if (htab->elf.tls_sec != NULL) 8685 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 8686 break; 8687 8688 /* Relocations that may need to be propagated if this is a shared 8689 object. */ 8690 case R_PPC_TPREL16: 8691 case R_PPC_TPREL16_LO: 8692 case R_PPC_TPREL16_HI: 8693 case R_PPC_TPREL16_HA: 8694 if (h != NULL 8695 && h->root.type == bfd_link_hash_undefweak 8696 && h->dynindx == -1) 8697 { 8698 /* Make this relocation against an undefined weak symbol 8699 resolve to zero. This is really just a tweak, since 8700 code using weak externs ought to check that they are 8701 defined before using them. */ 8702 bfd_byte *p = contents + rel->r_offset - d_offset; 8703 unsigned int insn = bfd_get_32 (output_bfd, p); 8704 insn = _bfd_elf_ppc_at_tprel_transform (insn, 2); 8705 if (insn != 0) 8706 bfd_put_32 (output_bfd, insn, p); 8707 break; 8708 } 8709 if (htab->elf.tls_sec != NULL) 8710 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 8711 /* The TPREL16 relocs shouldn't really be used in shared 8712 libs as they will result in DT_TEXTREL being set, but 8713 support them anyway. */ 8714 goto dodyn; 8715 8716 case R_PPC_TPREL32: 8717 if (htab->elf.tls_sec != NULL) 8718 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 8719 goto dodyn; 8720 8721 case R_PPC_DTPREL32: 8722 if (htab->elf.tls_sec != NULL) 8723 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 8724 goto dodyn; 8725 8726 case R_PPC_DTPMOD32: 8727 relocation = 1; 8728 addend = 0; 8729 goto dodyn; 8730 8731 case R_PPC_REL16: 8732 case R_PPC_REL16_LO: 8733 case R_PPC_REL16_HI: 8734 case R_PPC_REL16_HA: 8735 case R_PPC_REL16DX_HA: 8736 break; 8737 8738 case R_PPC_REL32: 8739 if (h == NULL || h == htab->elf.hgot) 8740 break; 8741 /* fall through */ 8742 8743 case R_PPC_ADDR32: 8744 case R_PPC_ADDR16: 8745 case R_PPC_ADDR16_LO: 8746 case R_PPC_ADDR16_HI: 8747 case R_PPC_ADDR16_HA: 8748 case R_PPC_UADDR32: 8749 case R_PPC_UADDR16: 8750 goto dodyn; 8751 8752 case R_PPC_VLE_REL8: 8753 case R_PPC_VLE_REL15: 8754 case R_PPC_VLE_REL24: 8755 case R_PPC_REL24: 8756 case R_PPC_REL14: 8757 case R_PPC_REL14_BRTAKEN: 8758 case R_PPC_REL14_BRNTAKEN: 8759 /* If these relocations are not to a named symbol, they can be 8760 handled right here, no need to bother the dynamic linker. */ 8761 if (SYMBOL_CALLS_LOCAL (info, h) 8762 || h == htab->elf.hgot) 8763 break; 8764 /* fall through */ 8765 8766 case R_PPC_ADDR24: 8767 case R_PPC_ADDR14: 8768 case R_PPC_ADDR14_BRTAKEN: 8769 case R_PPC_ADDR14_BRNTAKEN: 8770 if (h != NULL && !bfd_link_pic (info)) 8771 break; 8772 /* fall through */ 8773 8774 dodyn: 8775 if ((input_section->flags & SEC_ALLOC) == 0 8776 || is_vxworks_tls) 8777 break; 8778 8779 if ((bfd_link_pic (info) 8780 && !(h != NULL 8781 && ((h->root.type == bfd_link_hash_undefined 8782 && (ELF_ST_VISIBILITY (h->other) == STV_HIDDEN 8783 || ELF_ST_VISIBILITY (h->other) == STV_INTERNAL)) 8784 || (h->root.type == bfd_link_hash_undefweak 8785 && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT))) 8786 && (must_be_dyn_reloc (info, r_type) 8787 || !SYMBOL_CALLS_LOCAL (info, h))) 8788 || (ELIMINATE_COPY_RELOCS 8789 && !bfd_link_pic (info) 8790 && h != NULL 8791 && h->dynindx != -1 8792 && !h->non_got_ref 8793 && !h->def_regular 8794 && !(h->protected_def 8795 && ppc_elf_hash_entry (h)->has_addr16_ha 8796 && ppc_elf_hash_entry (h)->has_addr16_lo 8797 && htab->params->pic_fixup > 0))) 8798 { 8799 int skip; 8800 bfd_byte *loc; 8801 asection *sreloc; 8802 #ifdef DEBUG 8803 fprintf (stderr, "ppc_elf_relocate_section needs to " 8804 "create relocation for %s\n", 8805 (h && h->root.root.string 8806 ? h->root.root.string : "<unknown>")); 8807 #endif 8808 8809 /* When generating a shared object, these relocations 8810 are copied into the output file to be resolved at run 8811 time. */ 8812 sreloc = elf_section_data (input_section)->sreloc; 8813 if (ifunc) 8814 sreloc = htab->reliplt; 8815 if (sreloc == NULL) 8816 return FALSE; 8817 8818 skip = 0; 8819 outrel.r_offset = _bfd_elf_section_offset (output_bfd, info, 8820 input_section, 8821 rel->r_offset); 8822 if (outrel.r_offset == (bfd_vma) -1 8823 || outrel.r_offset == (bfd_vma) -2) 8824 skip = (int) outrel.r_offset; 8825 outrel.r_offset += (input_section->output_section->vma 8826 + input_section->output_offset); 8827 8828 if (skip) 8829 memset (&outrel, 0, sizeof outrel); 8830 else if ((h != NULL 8831 && (h->root.type == bfd_link_hash_undefined 8832 || h->root.type == bfd_link_hash_undefweak)) 8833 || !SYMBOL_REFERENCES_LOCAL (info, h)) 8834 { 8835 BFD_ASSERT (h->dynindx != -1); 8836 unresolved_reloc = FALSE; 8837 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 8838 outrel.r_addend = rel->r_addend; 8839 } 8840 else 8841 { 8842 outrel.r_addend = relocation + rel->r_addend; 8843 8844 if (r_type != R_PPC_ADDR32) 8845 { 8846 long indx = 0; 8847 8848 if (ifunc != NULL) 8849 { 8850 /* If we get here when building a static 8851 executable, then the libc startup function 8852 responsible for applying indirect function 8853 relocations is going to complain about 8854 the reloc type. 8855 If we get here when building a dynamic 8856 executable, it will be because we have 8857 a text relocation. The dynamic loader 8858 will set the text segment writable and 8859 non-executable to apply text relocations. 8860 So we'll segfault when trying to run the 8861 indirection function to resolve the reloc. */ 8862 info->callbacks->einfo 8863 (_("%P: %H: relocation %s for indirect " 8864 "function %s unsupported\n"), 8865 input_bfd, input_section, rel->r_offset, 8866 howto->name, 8867 sym_name); 8868 ret = FALSE; 8869 } 8870 else if (r_symndx == STN_UNDEF || bfd_is_abs_section (sec)) 8871 ; 8872 else if (sec == NULL || sec->owner == NULL) 8873 { 8874 bfd_set_error (bfd_error_bad_value); 8875 ret = FALSE; 8876 } 8877 else 8878 { 8879 asection *osec; 8880 8881 /* We are turning this relocation into one 8882 against a section symbol. It would be 8883 proper to subtract the symbol's value, 8884 osec->vma, from the emitted reloc addend, 8885 but ld.so expects buggy relocs. 8886 FIXME: Why not always use a zero index? */ 8887 osec = sec->output_section; 8888 indx = elf_section_data (osec)->dynindx; 8889 if (indx == 0) 8890 { 8891 osec = htab->elf.text_index_section; 8892 indx = elf_section_data (osec)->dynindx; 8893 } 8894 BFD_ASSERT (indx != 0); 8895 #ifdef DEBUG 8896 if (indx == 0) 8897 printf ("indx=%ld section=%s flags=%08x name=%s\n", 8898 indx, osec->name, osec->flags, 8899 h->root.root.string); 8900 #endif 8901 } 8902 8903 outrel.r_info = ELF32_R_INFO (indx, r_type); 8904 } 8905 else if (ifunc != NULL) 8906 outrel.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE); 8907 else 8908 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 8909 } 8910 8911 loc = sreloc->contents; 8912 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 8913 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 8914 8915 if (skip == -1) 8916 goto copy_reloc; 8917 8918 /* This reloc will be computed at runtime. We clear the memory 8919 so that it contains predictable value. */ 8920 if (! skip 8921 && ((input_section->flags & SEC_ALLOC) != 0 8922 || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE)) 8923 { 8924 relocation = howto->pc_relative ? outrel.r_offset : 0; 8925 addend = 0; 8926 break; 8927 } 8928 } 8929 break; 8930 8931 case R_PPC_RELAX_PLT: 8932 case R_PPC_RELAX_PLTREL24: 8933 if (h != NULL) 8934 { 8935 struct plt_entry *ent; 8936 bfd_vma got2_addend = 0; 8937 8938 if (r_type == R_PPC_RELAX_PLTREL24) 8939 { 8940 if (bfd_link_pic (info)) 8941 got2_addend = addend; 8942 addend = 0; 8943 } 8944 ent = find_plt_ent (&h->plt.plist, got2, got2_addend); 8945 if (htab->plt_type == PLT_NEW) 8946 relocation = (htab->glink->output_section->vma 8947 + htab->glink->output_offset 8948 + ent->glink_offset); 8949 else 8950 relocation = (htab->plt->output_section->vma 8951 + htab->plt->output_offset 8952 + ent->plt.offset); 8953 } 8954 /* Fall thru */ 8955 8956 case R_PPC_RELAX: 8957 { 8958 const int *stub; 8959 size_t size; 8960 size_t insn_offset = rel->r_offset; 8961 unsigned int insn; 8962 8963 if (bfd_link_pic (info)) 8964 { 8965 relocation -= (input_section->output_section->vma 8966 + input_section->output_offset 8967 + rel->r_offset - 4); 8968 stub = shared_stub_entry; 8969 bfd_put_32 (output_bfd, stub[0], contents + insn_offset - 12); 8970 bfd_put_32 (output_bfd, stub[1], contents + insn_offset - 8); 8971 bfd_put_32 (output_bfd, stub[2], contents + insn_offset - 4); 8972 stub += 3; 8973 size = ARRAY_SIZE (shared_stub_entry) - 3; 8974 } 8975 else 8976 { 8977 stub = stub_entry; 8978 size = ARRAY_SIZE (stub_entry); 8979 } 8980 8981 relocation += addend; 8982 if (bfd_link_relocatable (info)) 8983 relocation = 0; 8984 8985 /* First insn is HA, second is LO. */ 8986 insn = *stub++; 8987 insn |= ((relocation + 0x8000) >> 16) & 0xffff; 8988 bfd_put_32 (output_bfd, insn, contents + insn_offset); 8989 insn_offset += 4; 8990 8991 insn = *stub++; 8992 insn |= relocation & 0xffff; 8993 bfd_put_32 (output_bfd, insn, contents + insn_offset); 8994 insn_offset += 4; 8995 size -= 2; 8996 8997 while (size != 0) 8998 { 8999 insn = *stub++; 9000 --size; 9001 bfd_put_32 (output_bfd, insn, contents + insn_offset); 9002 insn_offset += 4; 9003 } 9004 9005 /* Rewrite the reloc and convert one of the trailing nop 9006 relocs to describe this relocation. */ 9007 BFD_ASSERT (ELF32_R_TYPE (relend[-1].r_info) == R_PPC_NONE); 9008 /* The relocs are at the bottom 2 bytes */ 9009 wrel->r_offset = rel->r_offset + d_offset; 9010 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_HA); 9011 wrel->r_addend = rel->r_addend; 9012 memmove (wrel + 1, wrel, (relend - wrel - 1) * sizeof (*wrel)); 9013 wrel++, rel++; 9014 wrel->r_offset += 4; 9015 wrel->r_info = ELF32_R_INFO (r_symndx, R_PPC_ADDR16_LO); 9016 } 9017 continue; 9018 9019 /* Indirect .sdata relocation. */ 9020 case R_PPC_EMB_SDAI16: 9021 BFD_ASSERT (htab->sdata[0].section != NULL); 9022 if (!is_static_defined (htab->sdata[0].sym)) 9023 { 9024 unresolved_reloc = TRUE; 9025 break; 9026 } 9027 relocation 9028 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0], 9029 h, relocation, rel); 9030 addend = 0; 9031 break; 9032 9033 /* Indirect .sdata2 relocation. */ 9034 case R_PPC_EMB_SDA2I16: 9035 BFD_ASSERT (htab->sdata[1].section != NULL); 9036 if (!is_static_defined (htab->sdata[1].sym)) 9037 { 9038 unresolved_reloc = TRUE; 9039 break; 9040 } 9041 relocation 9042 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1], 9043 h, relocation, rel); 9044 addend = 0; 9045 break; 9046 9047 /* Handle the TOC16 reloc. We want to use the offset within the .got 9048 section, not the actual VMA. This is appropriate when generating 9049 an embedded ELF object, for which the .got section acts like the 9050 AIX .toc section. */ 9051 case R_PPC_TOC16: /* phony GOT16 relocations */ 9052 if (sec == NULL || sec->output_section == NULL) 9053 { 9054 unresolved_reloc = TRUE; 9055 break; 9056 } 9057 BFD_ASSERT (strcmp (bfd_get_section_name (sec->owner, sec), 9058 ".got") == 0 9059 || strcmp (bfd_get_section_name (sec->owner, sec), 9060 ".cgot") == 0); 9061 9062 addend -= sec->output_section->vma + sec->output_offset + 0x8000; 9063 break; 9064 9065 case R_PPC_PLTREL24: 9066 if (h != NULL && ifunc == NULL) 9067 { 9068 struct plt_entry *ent; 9069 9070 ent = find_plt_ent (&h->plt.plist, got2, 9071 bfd_link_pic (info) ? addend : 0); 9072 if (ent == NULL 9073 || htab->plt == NULL) 9074 { 9075 /* We didn't make a PLT entry for this symbol. This 9076 happens when statically linking PIC code, or when 9077 using -Bsymbolic. */ 9078 } 9079 else 9080 { 9081 /* Relocation is to the entry for this symbol in the 9082 procedure linkage table. */ 9083 unresolved_reloc = FALSE; 9084 if (htab->plt_type == PLT_NEW) 9085 relocation = (htab->glink->output_section->vma 9086 + htab->glink->output_offset 9087 + ent->glink_offset); 9088 else 9089 relocation = (htab->plt->output_section->vma 9090 + htab->plt->output_offset 9091 + ent->plt.offset); 9092 } 9093 } 9094 9095 /* R_PPC_PLTREL24 is rather special. If non-zero, the 9096 addend specifies the GOT pointer offset within .got2. 9097 Don't apply it to the relocation field. */ 9098 addend = 0; 9099 break; 9100 9101 /* Relocate against _SDA_BASE_. */ 9102 case R_PPC_SDAREL16: 9103 { 9104 const char *name; 9105 struct elf_link_hash_entry *sda = htab->sdata[0].sym; 9106 9107 if (sec == NULL 9108 || sec->output_section == NULL 9109 || !is_static_defined (sda)) 9110 { 9111 unresolved_reloc = TRUE; 9112 break; 9113 } 9114 addend -= SYM_VAL (sda); 9115 9116 name = bfd_get_section_name (output_bfd, sec->output_section); 9117 if (!(strcmp (name, ".sdata") == 0 9118 || strcmp (name, ".sbss") == 0)) 9119 { 9120 info->callbacks->einfo 9121 (_("%P: %B: the target (%s) of a %s relocation is " 9122 "in the wrong output section (%s)\n"), 9123 input_bfd, 9124 sym_name, 9125 howto->name, 9126 name); 9127 } 9128 } 9129 break; 9130 9131 /* Relocate against _SDA2_BASE_. */ 9132 case R_PPC_EMB_SDA2REL: 9133 { 9134 const char *name; 9135 struct elf_link_hash_entry *sda = htab->sdata[1].sym; 9136 9137 if (sec == NULL 9138 || sec->output_section == NULL 9139 || !is_static_defined (sda)) 9140 { 9141 unresolved_reloc = TRUE; 9142 break; 9143 } 9144 addend -= SYM_VAL (sda); 9145 9146 name = bfd_get_section_name (output_bfd, sec->output_section); 9147 if (!(strcmp (name, ".sdata2") == 0 9148 || strcmp (name, ".sbss2") == 0)) 9149 { 9150 info->callbacks->einfo 9151 (_("%P: %B: the target (%s) of a %s relocation is " 9152 "in the wrong output section (%s)\n"), 9153 input_bfd, 9154 sym_name, 9155 howto->name, 9156 name); 9157 } 9158 } 9159 break; 9160 9161 case R_PPC_VLE_LO16A: 9162 relocation = relocation + addend; 9163 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9164 relocation, split16a_type); 9165 goto copy_reloc; 9166 9167 case R_PPC_VLE_LO16D: 9168 relocation = relocation + addend; 9169 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9170 relocation, split16d_type); 9171 goto copy_reloc; 9172 9173 case R_PPC_VLE_HI16A: 9174 relocation = (relocation + addend) >> 16; 9175 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9176 relocation, split16a_type); 9177 goto copy_reloc; 9178 9179 case R_PPC_VLE_HI16D: 9180 relocation = (relocation + addend) >> 16; 9181 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9182 relocation, split16d_type); 9183 goto copy_reloc; 9184 9185 case R_PPC_VLE_HA16A: 9186 relocation = (relocation + addend + 0x8000) >> 16; 9187 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9188 relocation, split16a_type); 9189 goto copy_reloc; 9190 9191 case R_PPC_VLE_HA16D: 9192 relocation = (relocation + addend + 0x8000) >> 16; 9193 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9194 relocation, split16d_type); 9195 goto copy_reloc; 9196 9197 /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */ 9198 case R_PPC_EMB_SDA21: 9199 case R_PPC_VLE_SDA21: 9200 case R_PPC_EMB_RELSDA: 9201 case R_PPC_VLE_SDA21_LO: 9202 { 9203 const char *name; 9204 int reg; 9205 unsigned int insn; 9206 struct elf_link_hash_entry *sda = NULL; 9207 9208 if (sec == NULL || sec->output_section == NULL) 9209 { 9210 unresolved_reloc = TRUE; 9211 break; 9212 } 9213 9214 name = bfd_get_section_name (output_bfd, sec->output_section); 9215 if (strcmp (name, ".sdata") == 0 9216 || strcmp (name, ".sbss") == 0) 9217 { 9218 reg = 13; 9219 sda = htab->sdata[0].sym; 9220 } 9221 else if (strcmp (name, ".sdata2") == 0 9222 || strcmp (name, ".sbss2") == 0) 9223 { 9224 reg = 2; 9225 sda = htab->sdata[1].sym; 9226 } 9227 else if (strcmp (name, ".PPC.EMB.sdata0") == 0 9228 || strcmp (name, ".PPC.EMB.sbss0") == 0) 9229 { 9230 reg = 0; 9231 } 9232 else 9233 { 9234 info->callbacks->einfo 9235 (_("%P: %B: the target (%s) of a %s relocation is " 9236 "in the wrong output section (%s)\n"), 9237 input_bfd, 9238 sym_name, 9239 howto->name, 9240 name); 9241 9242 bfd_set_error (bfd_error_bad_value); 9243 ret = FALSE; 9244 goto copy_reloc; 9245 } 9246 9247 if (sda != NULL) 9248 { 9249 if (!is_static_defined (sda)) 9250 { 9251 unresolved_reloc = TRUE; 9252 break; 9253 } 9254 addend -= SYM_VAL (sda); 9255 } 9256 9257 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 9258 if (reg == 0 9259 && (r_type == R_PPC_VLE_SDA21 9260 || r_type == R_PPC_VLE_SDA21_LO)) 9261 { 9262 relocation = relocation + addend; 9263 addend = 0; 9264 9265 /* Force e_li insn, keeping RT from original insn. */ 9266 insn &= 0x1f << 21; 9267 insn |= 28u << 26; 9268 9269 /* We have an li20 field, bits 17..20, 11..15, 21..31. */ 9270 /* Top 4 bits of value to 17..20. */ 9271 insn |= (relocation & 0xf0000) >> 5; 9272 /* Next 5 bits of the value to 11..15. */ 9273 insn |= (relocation & 0xf800) << 5; 9274 /* And the final 11 bits of the value to bits 21 to 31. */ 9275 insn |= relocation & 0x7ff; 9276 9277 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 9278 9279 if (r_type == R_PPC_VLE_SDA21 9280 && ((relocation + 0x80000) & 0xffffffff) > 0x100000) 9281 goto overflow; 9282 goto copy_reloc; 9283 } 9284 else if (r_type == R_PPC_EMB_SDA21 9285 || r_type == R_PPC_VLE_SDA21 9286 || r_type == R_PPC_VLE_SDA21_LO) 9287 { 9288 /* Fill in register field. */ 9289 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT); 9290 } 9291 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 9292 } 9293 break; 9294 9295 case R_PPC_VLE_SDAREL_LO16A: 9296 case R_PPC_VLE_SDAREL_LO16D: 9297 case R_PPC_VLE_SDAREL_HI16A: 9298 case R_PPC_VLE_SDAREL_HI16D: 9299 case R_PPC_VLE_SDAREL_HA16A: 9300 case R_PPC_VLE_SDAREL_HA16D: 9301 { 9302 bfd_vma value; 9303 const char *name; 9304 //int reg; 9305 struct elf_link_hash_entry *sda = NULL; 9306 9307 if (sec == NULL || sec->output_section == NULL) 9308 { 9309 unresolved_reloc = TRUE; 9310 break; 9311 } 9312 9313 name = bfd_get_section_name (output_bfd, sec->output_section); 9314 if (strcmp (name, ".sdata") == 0 9315 || strcmp (name, ".sbss") == 0) 9316 { 9317 //reg = 13; 9318 sda = htab->sdata[0].sym; 9319 } 9320 else if (strcmp (name, ".sdata2") == 0 9321 || strcmp (name, ".sbss2") == 0) 9322 { 9323 //reg = 2; 9324 sda = htab->sdata[1].sym; 9325 } 9326 else 9327 { 9328 (*_bfd_error_handler) 9329 (_("%B: the target (%s) of a %s relocation is " 9330 "in the wrong output section (%s)"), 9331 input_bfd, 9332 sym_name, 9333 howto->name, 9334 name); 9335 9336 bfd_set_error (bfd_error_bad_value); 9337 ret = FALSE; 9338 goto copy_reloc; 9339 } 9340 9341 if (sda != NULL) 9342 { 9343 if (!is_static_defined (sda)) 9344 { 9345 unresolved_reloc = TRUE; 9346 break; 9347 } 9348 } 9349 9350 value = (sda->root.u.def.section->output_section->vma 9351 + sda->root.u.def.section->output_offset 9352 + addend); 9353 9354 if (r_type == R_PPC_VLE_SDAREL_LO16A) 9355 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9356 value, split16a_type); 9357 else if (r_type == R_PPC_VLE_SDAREL_LO16D) 9358 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9359 value, split16d_type); 9360 else if (r_type == R_PPC_VLE_SDAREL_HI16A) 9361 { 9362 value = value >> 16; 9363 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9364 value, split16a_type); 9365 } 9366 else if (r_type == R_PPC_VLE_SDAREL_HI16D) 9367 { 9368 value = value >> 16; 9369 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9370 value, split16d_type); 9371 } 9372 else if (r_type == R_PPC_VLE_SDAREL_HA16A) 9373 { 9374 value = (value + 0x8000) >> 16; 9375 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9376 value, split16a_type); 9377 } 9378 else if (r_type == R_PPC_VLE_SDAREL_HA16D) 9379 { 9380 value = (value + 0x8000) >> 16; 9381 ppc_elf_vle_split16 (output_bfd, contents + rel->r_offset, 9382 value, split16d_type); 9383 } 9384 } 9385 goto copy_reloc; 9386 9387 /* Relocate against the beginning of the section. */ 9388 case R_PPC_SECTOFF: 9389 case R_PPC_SECTOFF_LO: 9390 case R_PPC_SECTOFF_HI: 9391 case R_PPC_SECTOFF_HA: 9392 if (sec == NULL || sec->output_section == NULL) 9393 { 9394 unresolved_reloc = TRUE; 9395 break; 9396 } 9397 addend -= sec->output_section->vma; 9398 break; 9399 9400 /* Negative relocations. */ 9401 case R_PPC_EMB_NADDR32: 9402 case R_PPC_EMB_NADDR16: 9403 case R_PPC_EMB_NADDR16_LO: 9404 case R_PPC_EMB_NADDR16_HI: 9405 case R_PPC_EMB_NADDR16_HA: 9406 addend -= 2 * relocation; 9407 break; 9408 9409 case R_PPC_COPY: 9410 case R_PPC_GLOB_DAT: 9411 case R_PPC_JMP_SLOT: 9412 case R_PPC_RELATIVE: 9413 case R_PPC_IRELATIVE: 9414 case R_PPC_PLT32: 9415 case R_PPC_PLTREL32: 9416 case R_PPC_PLT16_LO: 9417 case R_PPC_PLT16_HI: 9418 case R_PPC_PLT16_HA: 9419 case R_PPC_ADDR30: 9420 case R_PPC_EMB_RELSEC16: 9421 case R_PPC_EMB_RELST_LO: 9422 case R_PPC_EMB_RELST_HI: 9423 case R_PPC_EMB_RELST_HA: 9424 case R_PPC_EMB_BIT_FLD: 9425 info->callbacks->einfo 9426 (_("%P: %B: relocation %s is not yet supported for symbol %s\n"), 9427 input_bfd, 9428 howto->name, 9429 sym_name); 9430 9431 bfd_set_error (bfd_error_invalid_operation); 9432 ret = FALSE; 9433 goto copy_reloc; 9434 } 9435 9436 /* Do any further special processing. */ 9437 switch (r_type) 9438 { 9439 default: 9440 break; 9441 9442 case R_PPC_ADDR16_HA: 9443 case R_PPC_REL16_HA: 9444 case R_PPC_REL16DX_HA: 9445 case R_PPC_SECTOFF_HA: 9446 case R_PPC_TPREL16_HA: 9447 case R_PPC_DTPREL16_HA: 9448 case R_PPC_EMB_NADDR16_HA: 9449 case R_PPC_EMB_RELST_HA: 9450 /* It's just possible that this symbol is a weak symbol 9451 that's not actually defined anywhere. In that case, 9452 'sec' would be NULL, and we should leave the symbol 9453 alone (it will be set to zero elsewhere in the link). */ 9454 if (sec == NULL) 9455 break; 9456 /* Fall thru */ 9457 9458 case R_PPC_PLT16_HA: 9459 case R_PPC_GOT16_HA: 9460 case R_PPC_GOT_TLSGD16_HA: 9461 case R_PPC_GOT_TLSLD16_HA: 9462 case R_PPC_GOT_TPREL16_HA: 9463 case R_PPC_GOT_DTPREL16_HA: 9464 /* Add 0x10000 if sign bit in 0:15 is set. 9465 Bits 0:15 are not used. */ 9466 addend += 0x8000; 9467 break; 9468 9469 case R_PPC_ADDR16: 9470 case R_PPC_ADDR16_LO: 9471 case R_PPC_GOT16: 9472 case R_PPC_GOT16_LO: 9473 case R_PPC_SDAREL16: 9474 case R_PPC_SECTOFF: 9475 case R_PPC_SECTOFF_LO: 9476 case R_PPC_DTPREL16: 9477 case R_PPC_DTPREL16_LO: 9478 case R_PPC_TPREL16: 9479 case R_PPC_TPREL16_LO: 9480 case R_PPC_GOT_TLSGD16: 9481 case R_PPC_GOT_TLSGD16_LO: 9482 case R_PPC_GOT_TLSLD16: 9483 case R_PPC_GOT_TLSLD16_LO: 9484 case R_PPC_GOT_DTPREL16: 9485 case R_PPC_GOT_DTPREL16_LO: 9486 case R_PPC_GOT_TPREL16: 9487 case R_PPC_GOT_TPREL16_LO: 9488 { 9489 /* The 32-bit ABI lacks proper relocations to deal with 9490 certain 64-bit instructions. Prevent damage to bits 9491 that make up part of the insn opcode. */ 9492 unsigned int insn, mask, lobit; 9493 9494 insn = bfd_get_32 (output_bfd, 9495 contents + rel->r_offset - d_offset); 9496 mask = 0; 9497 if (is_insn_ds_form (insn)) 9498 mask = 3; 9499 else if (is_insn_dq_form (insn)) 9500 mask = 15; 9501 else 9502 break; 9503 relocation += addend; 9504 addend = insn & mask; 9505 lobit = mask & relocation; 9506 if (lobit != 0) 9507 { 9508 relocation ^= lobit; 9509 info->callbacks->einfo 9510 (_("%P: %H: error: %s against `%s' not a multiple of %u\n"), 9511 input_bfd, input_section, rel->r_offset, 9512 howto->name, sym_name, mask + 1); 9513 bfd_set_error (bfd_error_bad_value); 9514 ret = FALSE; 9515 } 9516 } 9517 break; 9518 } 9519 9520 #ifdef DEBUG 9521 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, " 9522 "offset = %ld, addend = %ld\n", 9523 howto->name, 9524 (int) r_type, 9525 sym_name, 9526 r_symndx, 9527 (long) rel->r_offset, 9528 (long) addend); 9529 #endif 9530 9531 if (unresolved_reloc 9532 && !((input_section->flags & SEC_DEBUGGING) != 0 9533 && h->def_dynamic) 9534 && _bfd_elf_section_offset (output_bfd, info, input_section, 9535 rel->r_offset) != (bfd_vma) -1) 9536 { 9537 info->callbacks->einfo 9538 (_("%P: %H: unresolvable %s relocation against symbol `%s'\n"), 9539 input_bfd, input_section, rel->r_offset, 9540 howto->name, 9541 sym_name); 9542 ret = FALSE; 9543 } 9544 9545 /* 16-bit fields in insns mostly have signed values, but a 9546 few insns have 16-bit unsigned values. Really, we should 9547 have different reloc types. */ 9548 if (howto->complain_on_overflow != complain_overflow_dont 9549 && howto->dst_mask == 0xffff 9550 && (input_section->flags & SEC_CODE) != 0) 9551 { 9552 enum complain_overflow complain = complain_overflow_signed; 9553 9554 if ((elf_section_flags (input_section) & SHF_PPC_VLE) == 0) 9555 { 9556 unsigned int insn; 9557 9558 insn = bfd_get_32 (input_bfd, contents + (rel->r_offset & ~3)); 9559 if ((insn & (0x3f << 26)) == 10u << 26 /* cmpli */) 9560 complain = complain_overflow_bitfield; 9561 else if ((insn & (0x3f << 26)) == 28u << 26 /* andi */ 9562 || (insn & (0x3f << 26)) == 24u << 26 /* ori */ 9563 || (insn & (0x3f << 26)) == 26u << 26 /* xori */) 9564 complain = complain_overflow_unsigned; 9565 } 9566 if (howto->complain_on_overflow != complain) 9567 { 9568 alt_howto = *howto; 9569 alt_howto.complain_on_overflow = complain; 9570 howto = &alt_howto; 9571 } 9572 } 9573 9574 if (r_type == R_PPC_REL16DX_HA) 9575 { 9576 /* Split field reloc isn't handled by _bfd_final_link_relocate. */ 9577 if (rel->r_offset + 4 > input_section->size) 9578 r = bfd_reloc_outofrange; 9579 else 9580 { 9581 unsigned int insn; 9582 9583 relocation += addend; 9584 relocation -= (rel->r_offset 9585 + input_section->output_offset 9586 + input_section->output_section->vma); 9587 relocation >>= 16; 9588 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 9589 insn &= ~0x1fffc1; 9590 insn |= (relocation & 0xffc1) | ((relocation & 0x3e) << 15); 9591 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 9592 r = bfd_reloc_ok; 9593 } 9594 } 9595 else 9596 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents, 9597 rel->r_offset, relocation, addend); 9598 9599 if (r != bfd_reloc_ok) 9600 { 9601 if (r == bfd_reloc_overflow) 9602 { 9603 overflow: 9604 /* On code like "if (foo) foo();" don't report overflow 9605 on a branch to zero when foo is undefined. */ 9606 if (!warned 9607 && !(h != NULL 9608 && (h->root.type == bfd_link_hash_undefweak 9609 || h->root.type == bfd_link_hash_undefined) 9610 && is_branch_reloc (r_type))) 9611 info->callbacks->reloc_overflow 9612 (info, (h ? &h->root : NULL), sym_name, howto->name, 9613 rel->r_addend, input_bfd, input_section, rel->r_offset); 9614 } 9615 else 9616 { 9617 info->callbacks->einfo 9618 (_("%P: %H: %s reloc against `%s': error %d\n"), 9619 input_bfd, input_section, rel->r_offset, 9620 howto->name, sym_name, (int) r); 9621 ret = FALSE; 9622 } 9623 } 9624 copy_reloc: 9625 if (wrel != rel) 9626 *wrel = *rel; 9627 } 9628 9629 if (wrel != rel) 9630 { 9631 Elf_Internal_Shdr *rel_hdr; 9632 size_t deleted = rel - wrel; 9633 9634 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); 9635 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 9636 if (rel_hdr->sh_size == 0) 9637 { 9638 /* It is too late to remove an empty reloc section. Leave 9639 one NONE reloc. 9640 ??? What is wrong with an empty section??? */ 9641 rel_hdr->sh_size = rel_hdr->sh_entsize; 9642 deleted -= 1; 9643 wrel++; 9644 } 9645 relend = wrel; 9646 rel_hdr = _bfd_elf_single_rel_hdr (input_section); 9647 rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted; 9648 input_section->reloc_count -= deleted; 9649 } 9650 9651 #ifdef DEBUG 9652 fprintf (stderr, "\n"); 9653 #endif 9654 9655 if (input_section->sec_info_type == SEC_INFO_TYPE_TARGET 9656 && input_section->size != input_section->rawsize 9657 && (strcmp (input_section->output_section->name, ".init") == 0 9658 || strcmp (input_section->output_section->name, ".fini") == 0)) 9659 { 9660 /* Branch around the trampolines. */ 9661 unsigned int insn = B + input_section->size - input_section->rawsize; 9662 bfd_put_32 (input_bfd, insn, contents + input_section->rawsize); 9663 } 9664 9665 if (htab->params->ppc476_workaround 9666 && input_section->sec_info_type == SEC_INFO_TYPE_TARGET 9667 && (!bfd_link_relocatable (info) 9668 || (input_section->output_section->alignment_power 9669 >= htab->params->pagesize_p2))) 9670 { 9671 bfd_vma start_addr, end_addr, addr; 9672 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2; 9673 9674 if (relax_info->workaround_size != 0) 9675 { 9676 bfd_byte *p; 9677 unsigned int n; 9678 bfd_byte fill[4]; 9679 9680 bfd_put_32 (input_bfd, BA, fill); 9681 p = contents + input_section->size - relax_info->workaround_size; 9682 n = relax_info->workaround_size >> 2; 9683 while (n--) 9684 { 9685 memcpy (p, fill, 4); 9686 p += 4; 9687 } 9688 } 9689 9690 /* The idea is: Replace the last instruction on a page with a 9691 branch to a patch area. Put the insn there followed by a 9692 branch back to the next page. Complicated a little by 9693 needing to handle moved conditional branches, and by not 9694 wanting to touch data-in-text. */ 9695 9696 start_addr = (input_section->output_section->vma 9697 + input_section->output_offset); 9698 end_addr = (start_addr + input_section->size 9699 - relax_info->workaround_size); 9700 for (addr = ((start_addr & -pagesize) + pagesize - 4); 9701 addr < end_addr; 9702 addr += pagesize) 9703 { 9704 bfd_vma offset = addr - start_addr; 9705 Elf_Internal_Rela *lo, *hi; 9706 bfd_boolean is_data; 9707 bfd_vma patch_off, patch_addr; 9708 unsigned int insn; 9709 9710 /* Do we have a data reloc at this offset? If so, leave 9711 the word alone. */ 9712 is_data = FALSE; 9713 lo = relocs; 9714 hi = relend; 9715 rel = NULL; 9716 while (lo < hi) 9717 { 9718 rel = lo + (hi - lo) / 2; 9719 if (rel->r_offset < offset) 9720 lo = rel + 1; 9721 else if (rel->r_offset > offset + 3) 9722 hi = rel; 9723 else 9724 { 9725 switch (ELF32_R_TYPE (rel->r_info)) 9726 { 9727 case R_PPC_ADDR32: 9728 case R_PPC_UADDR32: 9729 case R_PPC_REL32: 9730 case R_PPC_ADDR30: 9731 is_data = TRUE; 9732 break; 9733 default: 9734 break; 9735 } 9736 break; 9737 } 9738 } 9739 if (is_data) 9740 continue; 9741 9742 /* Some instructions can be left alone too. Unconditional 9743 branches, except for bcctr with BO=0x14 (bctr, bctrl), 9744 avoid the icache failure. 9745 9746 The problem occurs due to prefetch across a page boundary 9747 where stale instructions can be fetched from the next 9748 page, and the mechanism for flushing these bad 9749 instructions fails under certain circumstances. The 9750 unconditional branches: 9751 1) Branch: b, bl, ba, bla, 9752 2) Branch Conditional: bc, bca, bcl, bcla, 9753 3) Branch Conditional to Link Register: bclr, bclrl, 9754 where (2) and (3) have BO=0x14 making them unconditional, 9755 prevent the bad prefetch because the prefetch itself is 9756 affected by these instructions. This happens even if the 9757 instruction is not executed. 9758 9759 A bctr example: 9760 . 9761 . lis 9,new_page@ha 9762 . addi 9,9,new_page@l 9763 . mtctr 9 9764 . bctr 9765 . nop 9766 . nop 9767 . new_page: 9768 . 9769 The bctr is not predicted taken due to ctr not being 9770 ready, so prefetch continues on past the bctr into the 9771 new page which might have stale instructions. If they 9772 fail to be flushed, then they will be executed after the 9773 bctr executes. Either of the following modifications 9774 prevent the bad prefetch from happening in the first 9775 place: 9776 . 9777 . lis 9,new_page@ha lis 9,new_page@ha 9778 . addi 9,9,new_page@l addi 9,9,new_page@l 9779 . mtctr 9 mtctr 9 9780 . bctr bctr 9781 . nop b somewhere_else 9782 . b somewhere_else nop 9783 . new_page: new_page: 9784 . */ 9785 insn = bfd_get_32 (input_bfd, contents + offset); 9786 if ((insn & (0x3f << 26)) == (18u << 26) /* b,bl,ba,bla */ 9787 || ((insn & (0x3f << 26)) == (16u << 26) /* bc,bcl,bca,bcla*/ 9788 && (insn & (0x14 << 21)) == (0x14 << 21)) /* with BO=0x14 */ 9789 || ((insn & (0x3f << 26)) == (19u << 26) 9790 && (insn & (0x3ff << 1)) == (16u << 1) /* bclr,bclrl */ 9791 && (insn & (0x14 << 21)) == (0x14 << 21)))/* with BO=0x14 */ 9792 continue; 9793 9794 patch_addr = (start_addr + input_section->size 9795 - relax_info->workaround_size); 9796 patch_addr = (patch_addr + 15) & -16; 9797 patch_off = patch_addr - start_addr; 9798 bfd_put_32 (input_bfd, B + patch_off - offset, contents + offset); 9799 9800 if (rel != NULL 9801 && rel->r_offset >= offset 9802 && rel->r_offset < offset + 4) 9803 { 9804 asection *sreloc; 9805 9806 /* If the insn we are patching had a reloc, adjust the 9807 reloc r_offset so that the reloc applies to the moved 9808 location. This matters for -r and --emit-relocs. */ 9809 if (rel + 1 != relend) 9810 { 9811 Elf_Internal_Rela tmp = *rel; 9812 9813 /* Keep the relocs sorted by r_offset. */ 9814 memmove (rel, rel + 1, (relend - (rel + 1)) * sizeof (*rel)); 9815 relend[-1] = tmp; 9816 } 9817 relend[-1].r_offset += patch_off - offset; 9818 9819 /* Adjust REL16 addends too. */ 9820 switch (ELF32_R_TYPE (relend[-1].r_info)) 9821 { 9822 case R_PPC_REL16: 9823 case R_PPC_REL16_LO: 9824 case R_PPC_REL16_HI: 9825 case R_PPC_REL16_HA: 9826 relend[-1].r_addend += patch_off - offset; 9827 break; 9828 default: 9829 break; 9830 } 9831 9832 /* If we are building a PIE or shared library with 9833 non-PIC objects, perhaps we had a dynamic reloc too? 9834 If so, the dynamic reloc must move with the insn. */ 9835 sreloc = elf_section_data (input_section)->sreloc; 9836 if (sreloc != NULL) 9837 { 9838 Elf32_External_Rela *slo, *shi, *srelend; 9839 bfd_vma soffset; 9840 9841 slo = (Elf32_External_Rela *) sreloc->contents; 9842 shi = srelend = slo + sreloc->reloc_count; 9843 soffset = (offset + input_section->output_section->vma 9844 + input_section->output_offset); 9845 while (slo < shi) 9846 { 9847 Elf32_External_Rela *srel = slo + (shi - slo) / 2; 9848 bfd_elf32_swap_reloca_in (output_bfd, (bfd_byte *) srel, 9849 &outrel); 9850 if (outrel.r_offset < soffset) 9851 slo = srel + 1; 9852 else if (outrel.r_offset > soffset + 3) 9853 shi = srel; 9854 else 9855 { 9856 if (srel + 1 != srelend) 9857 { 9858 memmove (srel, srel + 1, 9859 (srelend - (srel + 1)) * sizeof (*srel)); 9860 srel = srelend - 1; 9861 } 9862 outrel.r_offset += patch_off - offset; 9863 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 9864 (bfd_byte *) srel); 9865 break; 9866 } 9867 } 9868 } 9869 } 9870 else 9871 rel = NULL; 9872 9873 if ((insn & (0x3f << 26)) == (16u << 26) /* bc */ 9874 && (insn & 2) == 0 /* relative */) 9875 { 9876 bfd_vma delta = ((insn & 0xfffc) ^ 0x8000) - 0x8000; 9877 9878 delta += offset - patch_off; 9879 if (bfd_link_relocatable (info) && rel != NULL) 9880 delta = 0; 9881 if (!bfd_link_relocatable (info) && rel != NULL) 9882 { 9883 enum elf_ppc_reloc_type r_type; 9884 9885 r_type = ELF32_R_TYPE (relend[-1].r_info); 9886 if (r_type == R_PPC_REL14_BRTAKEN) 9887 insn |= BRANCH_PREDICT_BIT; 9888 else if (r_type == R_PPC_REL14_BRNTAKEN) 9889 insn &= ~BRANCH_PREDICT_BIT; 9890 else 9891 BFD_ASSERT (r_type == R_PPC_REL14); 9892 9893 if ((r_type == R_PPC_REL14_BRTAKEN 9894 || r_type == R_PPC_REL14_BRNTAKEN) 9895 && delta + 0x8000 < 0x10000 9896 && (bfd_signed_vma) delta < 0) 9897 insn ^= BRANCH_PREDICT_BIT; 9898 } 9899 if (delta + 0x8000 < 0x10000) 9900 { 9901 bfd_put_32 (input_bfd, 9902 (insn & ~0xfffc) | (delta & 0xfffc), 9903 contents + patch_off); 9904 patch_off += 4; 9905 bfd_put_32 (input_bfd, 9906 B | ((offset + 4 - patch_off) & 0x3fffffc), 9907 contents + patch_off); 9908 patch_off += 4; 9909 } 9910 else 9911 { 9912 if (rel != NULL) 9913 { 9914 unsigned int r_sym = ELF32_R_SYM (relend[-1].r_info); 9915 9916 relend[-1].r_offset += 8; 9917 relend[-1].r_info = ELF32_R_INFO (r_sym, R_PPC_REL24); 9918 } 9919 bfd_put_32 (input_bfd, 9920 (insn & ~0xfffc) | 8, 9921 contents + patch_off); 9922 patch_off += 4; 9923 bfd_put_32 (input_bfd, 9924 B | ((offset + 4 - patch_off) & 0x3fffffc), 9925 contents + patch_off); 9926 patch_off += 4; 9927 bfd_put_32 (input_bfd, 9928 B | ((delta - 8) & 0x3fffffc), 9929 contents + patch_off); 9930 patch_off += 4; 9931 } 9932 } 9933 else 9934 { 9935 bfd_put_32 (input_bfd, insn, contents + patch_off); 9936 patch_off += 4; 9937 bfd_put_32 (input_bfd, 9938 B | ((offset + 4 - patch_off) & 0x3fffffc), 9939 contents + patch_off); 9940 patch_off += 4; 9941 } 9942 BFD_ASSERT (patch_off <= input_section->size); 9943 relax_info->workaround_size = input_section->size - patch_off; 9944 } 9945 } 9946 9947 return ret; 9948 } 9949 9950 /* Finish up dynamic symbol handling. We set the contents of various 9952 dynamic sections here. */ 9953 9954 static bfd_boolean 9955 ppc_elf_finish_dynamic_symbol (bfd *output_bfd, 9956 struct bfd_link_info *info, 9957 struct elf_link_hash_entry *h, 9958 Elf_Internal_Sym *sym) 9959 { 9960 struct ppc_elf_link_hash_table *htab; 9961 struct plt_entry *ent; 9962 bfd_boolean doneone; 9963 9964 #ifdef DEBUG 9965 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", 9966 h->root.root.string); 9967 #endif 9968 9969 htab = ppc_elf_hash_table (info); 9970 BFD_ASSERT (htab->elf.dynobj != NULL); 9971 9972 doneone = FALSE; 9973 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 9974 if (ent->plt.offset != (bfd_vma) -1) 9975 { 9976 if (!doneone) 9977 { 9978 Elf_Internal_Rela rela; 9979 bfd_byte *loc; 9980 bfd_vma reloc_index; 9981 9982 if (htab->plt_type == PLT_NEW 9983 || !htab->elf.dynamic_sections_created 9984 || h->dynindx == -1) 9985 reloc_index = ent->plt.offset / 4; 9986 else 9987 { 9988 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size) 9989 / htab->plt_slot_size); 9990 if (reloc_index > PLT_NUM_SINGLE_ENTRIES 9991 && htab->plt_type == PLT_OLD) 9992 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2; 9993 } 9994 9995 /* This symbol has an entry in the procedure linkage table. 9996 Set it up. */ 9997 if (htab->plt_type == PLT_VXWORKS 9998 && htab->elf.dynamic_sections_created 9999 && h->dynindx != -1) 10000 { 10001 bfd_vma got_offset; 10002 const bfd_vma *plt_entry; 10003 10004 /* The first three entries in .got.plt are reserved. */ 10005 got_offset = (reloc_index + 3) * 4; 10006 10007 /* Use the right PLT. */ 10008 plt_entry = bfd_link_pic (info) ? ppc_elf_vxworks_pic_plt_entry 10009 : ppc_elf_vxworks_plt_entry; 10010 10011 /* Fill in the .plt on VxWorks. */ 10012 if (bfd_link_pic (info)) 10013 { 10014 bfd_put_32 (output_bfd, 10015 plt_entry[0] | PPC_HA (got_offset), 10016 htab->plt->contents + ent->plt.offset + 0); 10017 bfd_put_32 (output_bfd, 10018 plt_entry[1] | PPC_LO (got_offset), 10019 htab->plt->contents + ent->plt.offset + 4); 10020 } 10021 else 10022 { 10023 bfd_vma got_loc = got_offset + SYM_VAL (htab->elf.hgot); 10024 10025 bfd_put_32 (output_bfd, 10026 plt_entry[0] | PPC_HA (got_loc), 10027 htab->plt->contents + ent->plt.offset + 0); 10028 bfd_put_32 (output_bfd, 10029 plt_entry[1] | PPC_LO (got_loc), 10030 htab->plt->contents + ent->plt.offset + 4); 10031 } 10032 10033 bfd_put_32 (output_bfd, plt_entry[2], 10034 htab->plt->contents + ent->plt.offset + 8); 10035 bfd_put_32 (output_bfd, plt_entry[3], 10036 htab->plt->contents + ent->plt.offset + 12); 10037 10038 /* This instruction is an immediate load. The value loaded is 10039 the byte offset of the R_PPC_JMP_SLOT relocation from the 10040 start of the .rela.plt section. The value is stored in the 10041 low-order 16 bits of the load instruction. */ 10042 /* NOTE: It appears that this is now an index rather than a 10043 prescaled offset. */ 10044 bfd_put_32 (output_bfd, 10045 plt_entry[4] | reloc_index, 10046 htab->plt->contents + ent->plt.offset + 16); 10047 /* This instruction is a PC-relative branch whose target is 10048 the start of the PLT section. The address of this branch 10049 instruction is 20 bytes beyond the start of this PLT entry. 10050 The address is encoded in bits 6-29, inclusive. The value 10051 stored is right-shifted by two bits, permitting a 26-bit 10052 offset. */ 10053 bfd_put_32 (output_bfd, 10054 (plt_entry[5] 10055 | (-(ent->plt.offset + 20) & 0x03fffffc)), 10056 htab->plt->contents + ent->plt.offset + 20); 10057 bfd_put_32 (output_bfd, plt_entry[6], 10058 htab->plt->contents + ent->plt.offset + 24); 10059 bfd_put_32 (output_bfd, plt_entry[7], 10060 htab->plt->contents + ent->plt.offset + 28); 10061 10062 /* Fill in the GOT entry corresponding to this PLT slot with 10063 the address immediately after the "bctr" instruction 10064 in this PLT entry. */ 10065 bfd_put_32 (output_bfd, (htab->plt->output_section->vma 10066 + htab->plt->output_offset 10067 + ent->plt.offset + 16), 10068 htab->sgotplt->contents + got_offset); 10069 10070 if (!bfd_link_pic (info)) 10071 { 10072 /* Fill in a couple of entries in .rela.plt.unloaded. */ 10073 loc = htab->srelplt2->contents 10074 + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index 10075 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS) 10076 * sizeof (Elf32_External_Rela)); 10077 10078 /* Provide the @ha relocation for the first instruction. */ 10079 rela.r_offset = (htab->plt->output_section->vma 10080 + htab->plt->output_offset 10081 + ent->plt.offset + 2); 10082 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, 10083 R_PPC_ADDR16_HA); 10084 rela.r_addend = got_offset; 10085 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10086 loc += sizeof (Elf32_External_Rela); 10087 10088 /* Provide the @l relocation for the second instruction. */ 10089 rela.r_offset = (htab->plt->output_section->vma 10090 + htab->plt->output_offset 10091 + ent->plt.offset + 6); 10092 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, 10093 R_PPC_ADDR16_LO); 10094 rela.r_addend = got_offset; 10095 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10096 loc += sizeof (Elf32_External_Rela); 10097 10098 /* Provide a relocation for the GOT entry corresponding to this 10099 PLT slot. Point it at the middle of the .plt entry. */ 10100 rela.r_offset = (htab->sgotplt->output_section->vma 10101 + htab->sgotplt->output_offset 10102 + got_offset); 10103 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, 10104 R_PPC_ADDR32); 10105 rela.r_addend = ent->plt.offset + 16; 10106 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10107 } 10108 10109 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT. 10110 In particular, the offset for the relocation is not the 10111 address of the PLT entry for this function, as specified 10112 by the ABI. Instead, the offset is set to the address of 10113 the GOT slot for this function. See EABI 4.4.4.1. */ 10114 rela.r_offset = (htab->sgotplt->output_section->vma 10115 + htab->sgotplt->output_offset 10116 + got_offset); 10117 10118 } 10119 else 10120 { 10121 asection *splt = htab->plt; 10122 if (!htab->elf.dynamic_sections_created 10123 || h->dynindx == -1) 10124 splt = htab->iplt; 10125 10126 rela.r_offset = (splt->output_section->vma 10127 + splt->output_offset 10128 + ent->plt.offset); 10129 if (htab->plt_type == PLT_OLD 10130 || !htab->elf.dynamic_sections_created 10131 || h->dynindx == -1) 10132 { 10133 /* We don't need to fill in the .plt. The ppc dynamic 10134 linker will fill it in. */ 10135 } 10136 else 10137 { 10138 bfd_vma val = (htab->glink_pltresolve + ent->plt.offset 10139 + htab->glink->output_section->vma 10140 + htab->glink->output_offset); 10141 bfd_put_32 (output_bfd, val, 10142 splt->contents + ent->plt.offset); 10143 } 10144 } 10145 10146 /* Fill in the entry in the .rela.plt section. */ 10147 rela.r_addend = 0; 10148 if (!htab->elf.dynamic_sections_created 10149 || h->dynindx == -1) 10150 { 10151 BFD_ASSERT (h->type == STT_GNU_IFUNC 10152 && h->def_regular 10153 && (h->root.type == bfd_link_hash_defined 10154 || h->root.type == bfd_link_hash_defweak)); 10155 rela.r_info = ELF32_R_INFO (0, R_PPC_IRELATIVE); 10156 rela.r_addend = SYM_VAL (h); 10157 } 10158 else 10159 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT); 10160 10161 if (!htab->elf.dynamic_sections_created 10162 || h->dynindx == -1) 10163 loc = (htab->reliplt->contents 10164 + (htab->reliplt->reloc_count++ 10165 * sizeof (Elf32_External_Rela))); 10166 else 10167 loc = (htab->relplt->contents 10168 + reloc_index * sizeof (Elf32_External_Rela)); 10169 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10170 10171 if (!h->def_regular) 10172 { 10173 /* Mark the symbol as undefined, rather than as 10174 defined in the .plt section. Leave the value if 10175 there were any relocations where pointer equality 10176 matters (this is a clue for the dynamic linker, to 10177 make function pointer comparisons work between an 10178 application and shared library), otherwise set it 10179 to zero. */ 10180 sym->st_shndx = SHN_UNDEF; 10181 if (!h->pointer_equality_needed) 10182 sym->st_value = 0; 10183 else if (!h->ref_regular_nonweak) 10184 { 10185 /* This breaks function pointer comparisons, but 10186 that is better than breaking tests for a NULL 10187 function pointer. */ 10188 sym->st_value = 0; 10189 } 10190 } 10191 else if (h->type == STT_GNU_IFUNC 10192 && !bfd_link_pic (info)) 10193 { 10194 /* Set the value of ifunc symbols in a non-pie 10195 executable to the glink entry. This is to avoid 10196 text relocations. We can't do this for ifunc in 10197 allocate_dynrelocs, as we do for normal dynamic 10198 function symbols with plt entries, because we need 10199 to keep the original value around for the ifunc 10200 relocation. */ 10201 sym->st_shndx = (_bfd_elf_section_from_bfd_section 10202 (output_bfd, htab->glink->output_section)); 10203 sym->st_value = (ent->glink_offset 10204 + htab->glink->output_offset 10205 + htab->glink->output_section->vma); 10206 } 10207 doneone = TRUE; 10208 } 10209 10210 if (htab->plt_type == PLT_NEW 10211 || !htab->elf.dynamic_sections_created 10212 || h->dynindx == -1) 10213 { 10214 unsigned char *p; 10215 asection *splt = htab->plt; 10216 if (!htab->elf.dynamic_sections_created 10217 || h->dynindx == -1) 10218 splt = htab->iplt; 10219 10220 p = (unsigned char *) htab->glink->contents + ent->glink_offset; 10221 10222 if (h == htab->tls_get_addr && !htab->params->no_tls_get_addr_opt) 10223 { 10224 bfd_put_32 (output_bfd, LWZ_11_3, p); 10225 p += 4; 10226 bfd_put_32 (output_bfd, LWZ_12_3 + 4, p); 10227 p += 4; 10228 bfd_put_32 (output_bfd, MR_0_3, p); 10229 p += 4; 10230 bfd_put_32 (output_bfd, CMPWI_11_0, p); 10231 p += 4; 10232 bfd_put_32 (output_bfd, ADD_3_12_2, p); 10233 p += 4; 10234 bfd_put_32 (output_bfd, BEQLR, p); 10235 p += 4; 10236 bfd_put_32 (output_bfd, MR_3_0, p); 10237 p += 4; 10238 bfd_put_32 (output_bfd, NOP, p); 10239 p += 4; 10240 } 10241 10242 write_glink_stub (ent, splt, p, info); 10243 10244 if (!bfd_link_pic (info)) 10245 /* We only need one non-PIC glink stub. */ 10246 break; 10247 } 10248 else 10249 break; 10250 } 10251 10252 if (h->needs_copy) 10253 { 10254 asection *s; 10255 Elf_Internal_Rela rela; 10256 bfd_byte *loc; 10257 10258 /* This symbols needs a copy reloc. Set it up. */ 10259 10260 #ifdef DEBUG 10261 fprintf (stderr, ", copy"); 10262 #endif 10263 10264 BFD_ASSERT (h->dynindx != -1); 10265 10266 if (ppc_elf_hash_entry (h)->has_sda_refs) 10267 s = htab->relsbss; 10268 else 10269 s = htab->relbss; 10270 BFD_ASSERT (s != NULL); 10271 10272 rela.r_offset = SYM_VAL (h); 10273 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY); 10274 rela.r_addend = 0; 10275 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 10276 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10277 } 10278 10279 #ifdef DEBUG 10280 fprintf (stderr, "\n"); 10281 #endif 10282 10283 return TRUE; 10284 } 10285 10286 static enum elf_reloc_type_class 10288 ppc_elf_reloc_type_class (const struct bfd_link_info *info, 10289 const asection *rel_sec, 10290 const Elf_Internal_Rela *rela) 10291 { 10292 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 10293 10294 if (rel_sec == htab->reliplt) 10295 return reloc_class_ifunc; 10296 10297 switch (ELF32_R_TYPE (rela->r_info)) 10298 { 10299 case R_PPC_RELATIVE: 10300 return reloc_class_relative; 10301 case R_PPC_JMP_SLOT: 10302 return reloc_class_plt; 10303 case R_PPC_COPY: 10304 return reloc_class_copy; 10305 default: 10306 return reloc_class_normal; 10307 } 10308 } 10309 10310 /* Finish up the dynamic sections. */ 10312 10313 static bfd_boolean 10314 ppc_elf_finish_dynamic_sections (bfd *output_bfd, 10315 struct bfd_link_info *info) 10316 { 10317 asection *sdyn; 10318 asection *splt; 10319 struct ppc_elf_link_hash_table *htab; 10320 bfd_vma got; 10321 bfd *dynobj; 10322 bfd_boolean ret = TRUE; 10323 10324 #ifdef DEBUG 10325 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n"); 10326 #endif 10327 10328 htab = ppc_elf_hash_table (info); 10329 dynobj = elf_hash_table (info)->dynobj; 10330 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 10331 got = 0; 10332 if (htab->elf.hgot != NULL) 10333 got = SYM_VAL (htab->elf.hgot); 10334 10335 if (htab->elf.dynamic_sections_created) 10336 { 10337 Elf32_External_Dyn *dyncon, *dynconend; 10338 10339 BFD_ASSERT (htab->plt != NULL && sdyn != NULL); 10340 10341 dyncon = (Elf32_External_Dyn *) sdyn->contents; 10342 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 10343 for (; dyncon < dynconend; dyncon++) 10344 { 10345 Elf_Internal_Dyn dyn; 10346 asection *s; 10347 10348 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 10349 10350 switch (dyn.d_tag) 10351 { 10352 case DT_PLTGOT: 10353 if (htab->is_vxworks) 10354 s = htab->sgotplt; 10355 else 10356 s = htab->plt; 10357 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 10358 break; 10359 10360 case DT_PLTRELSZ: 10361 dyn.d_un.d_val = htab->relplt->size; 10362 break; 10363 10364 case DT_JMPREL: 10365 s = htab->relplt; 10366 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 10367 break; 10368 10369 case DT_PPC_GOT: 10370 dyn.d_un.d_ptr = got; 10371 break; 10372 10373 case DT_RELASZ: 10374 if (htab->is_vxworks) 10375 { 10376 if (htab->relplt) 10377 dyn.d_un.d_ptr -= htab->relplt->size; 10378 break; 10379 } 10380 continue; 10381 10382 default: 10383 if (htab->is_vxworks 10384 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 10385 break; 10386 continue; 10387 } 10388 10389 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 10390 } 10391 } 10392 10393 if (htab->got != NULL 10394 && htab->got->output_section != bfd_abs_section_ptr) 10395 { 10396 if (htab->elf.hgot->root.u.def.section == htab->got 10397 || htab->elf.hgot->root.u.def.section == htab->sgotplt) 10398 { 10399 unsigned char *p = htab->elf.hgot->root.u.def.section->contents; 10400 10401 p += htab->elf.hgot->root.u.def.value; 10402 if (htab->plt_type == PLT_OLD) 10403 { 10404 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 10405 so that a function can easily find the address of 10406 _GLOBAL_OFFSET_TABLE_. */ 10407 BFD_ASSERT (htab->elf.hgot->root.u.def.value - 4 10408 < htab->elf.hgot->root.u.def.section->size); 10409 bfd_put_32 (output_bfd, 0x4e800021, p - 4); 10410 } 10411 10412 if (sdyn != NULL) 10413 { 10414 bfd_vma val = sdyn->output_section->vma + sdyn->output_offset; 10415 BFD_ASSERT (htab->elf.hgot->root.u.def.value 10416 < htab->elf.hgot->root.u.def.section->size); 10417 bfd_put_32 (output_bfd, val, p); 10418 } 10419 } 10420 else 10421 { 10422 info->callbacks->einfo (_("%P: %s not defined in linker created %s\n"), 10423 htab->elf.hgot->root.root.string, 10424 (htab->sgotplt != NULL 10425 ? htab->sgotplt->name : htab->got->name)); 10426 bfd_set_error (bfd_error_bad_value); 10427 ret = FALSE; 10428 } 10429 10430 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4; 10431 } 10432 10433 /* Fill in the first entry in the VxWorks procedure linkage table. */ 10434 splt = NULL; 10435 if (htab->is_vxworks) 10436 splt = bfd_get_linker_section (dynobj, ".plt"); 10437 if (splt != NULL 10438 && splt->size != 0 10439 && splt->output_section != bfd_abs_section_ptr) 10440 { 10441 /* Use the right PLT. */ 10442 const bfd_vma *plt_entry = (bfd_link_pic (info) 10443 ? ppc_elf_vxworks_pic_plt0_entry 10444 : ppc_elf_vxworks_plt0_entry); 10445 10446 if (!bfd_link_pic (info)) 10447 { 10448 bfd_vma got_value = SYM_VAL (htab->elf.hgot); 10449 10450 bfd_put_32 (output_bfd, plt_entry[0] | PPC_HA (got_value), 10451 splt->contents + 0); 10452 bfd_put_32 (output_bfd, plt_entry[1] | PPC_LO (got_value), 10453 splt->contents + 4); 10454 } 10455 else 10456 { 10457 bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0); 10458 bfd_put_32 (output_bfd, plt_entry[1], splt->contents + 4); 10459 } 10460 bfd_put_32 (output_bfd, plt_entry[2], splt->contents + 8); 10461 bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12); 10462 bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16); 10463 bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20); 10464 bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24); 10465 bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28); 10466 10467 if (! bfd_link_pic (info)) 10468 { 10469 Elf_Internal_Rela rela; 10470 bfd_byte *loc; 10471 10472 loc = htab->srelplt2->contents; 10473 10474 /* Output the @ha relocation for the first instruction. */ 10475 rela.r_offset = (htab->plt->output_section->vma 10476 + htab->plt->output_offset 10477 + 2); 10478 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); 10479 rela.r_addend = 0; 10480 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10481 loc += sizeof (Elf32_External_Rela); 10482 10483 /* Output the @l relocation for the second instruction. */ 10484 rela.r_offset = (htab->plt->output_section->vma 10485 + htab->plt->output_offset 10486 + 6); 10487 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); 10488 rela.r_addend = 0; 10489 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 10490 loc += sizeof (Elf32_External_Rela); 10491 10492 /* Fix up the remaining relocations. They may have the wrong 10493 symbol index for _G_O_T_ or _P_L_T_ depending on the order 10494 in which symbols were output. */ 10495 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 10496 { 10497 Elf_Internal_Rela rel; 10498 10499 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 10500 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); 10501 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 10502 loc += sizeof (Elf32_External_Rela); 10503 10504 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 10505 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); 10506 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 10507 loc += sizeof (Elf32_External_Rela); 10508 10509 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 10510 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32); 10511 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 10512 loc += sizeof (Elf32_External_Rela); 10513 } 10514 } 10515 } 10516 10517 if (htab->glink != NULL 10518 && htab->glink->contents != NULL 10519 && htab->elf.dynamic_sections_created) 10520 { 10521 unsigned char *p; 10522 unsigned char *endp; 10523 bfd_vma res0; 10524 unsigned int i; 10525 10526 /* 10527 * PIC glink code is the following: 10528 * 10529 * # ith PLT code stub. 10530 * addis 11,30,(plt+(i-1)*4-got)@ha 10531 * lwz 11,(plt+(i-1)*4-got)@l(11) 10532 * mtctr 11 10533 * bctr 10534 * 10535 * # A table of branches, one for each plt entry. 10536 * # The idea is that the plt call stub loads ctr and r11 with these 10537 * # addresses, so (r11 - res_0) gives the plt index * 4. 10538 * res_0: b PLTresolve 10539 * res_1: b PLTresolve 10540 * . 10541 * # Some number of entries towards the end can be nops 10542 * res_n_m3: nop 10543 * res_n_m2: nop 10544 * res_n_m1: 10545 * 10546 * PLTresolve: 10547 * addis 11,11,(1f-res_0)@ha 10548 * mflr 0 10549 * bcl 20,31,1f 10550 * 1: addi 11,11,(1b-res_0)@l 10551 * mflr 12 10552 * mtlr 0 10553 * sub 11,11,12 # r11 = index * 4 10554 * addis 12,12,(got+4-1b)@ha 10555 * lwz 0,(got+4-1b)@l(12) # got[1] address of dl_runtime_resolve 10556 * lwz 12,(got+8-1b)@l(12) # got[2] contains the map address 10557 * mtctr 0 10558 * add 0,11,11 10559 * add 11,0,11 # r11 = index * 12 = reloc offset. 10560 * bctr 10561 */ 10562 static const unsigned int pic_plt_resolve[] = 10563 { 10564 ADDIS_11_11, 10565 MFLR_0, 10566 BCL_20_31, 10567 ADDI_11_11, 10568 MFLR_12, 10569 MTLR_0, 10570 SUB_11_11_12, 10571 ADDIS_12_12, 10572 LWZ_0_12, 10573 LWZ_12_12, 10574 MTCTR_0, 10575 ADD_0_11_11, 10576 ADD_11_0_11, 10577 BCTR, 10578 NOP, 10579 NOP 10580 }; 10581 10582 /* 10583 * Non-PIC glink code is a little simpler. 10584 * 10585 * # ith PLT code stub. 10586 * lis 11,(plt+(i-1)*4)@ha 10587 * lwz 11,(plt+(i-1)*4)@l(11) 10588 * mtctr 11 10589 * bctr 10590 * 10591 * The branch table is the same, then comes 10592 * 10593 * PLTresolve: 10594 * lis 12,(got+4)@ha 10595 * addis 11,11,(-res_0)@ha 10596 * lwz 0,(got+4)@l(12) # got[1] address of dl_runtime_resolve 10597 * addi 11,11,(-res_0)@l # r11 = index * 4 10598 * mtctr 0 10599 * add 0,11,11 10600 * lwz 12,(got+8)@l(12) # got[2] contains the map address 10601 * add 11,0,11 # r11 = index * 12 = reloc offset. 10602 * bctr 10603 */ 10604 static const unsigned int plt_resolve[] = 10605 { 10606 LIS_12, 10607 ADDIS_11_11, 10608 LWZ_0_12, 10609 ADDI_11_11, 10610 MTCTR_0, 10611 ADD_0_11_11, 10612 LWZ_12_12, 10613 ADD_11_0_11, 10614 BCTR, 10615 NOP, 10616 NOP, 10617 NOP, 10618 NOP, 10619 NOP, 10620 NOP, 10621 NOP 10622 }; 10623 10624 if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4) 10625 abort (); 10626 if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4) 10627 abort (); 10628 10629 /* Build the branch table, one for each plt entry (less one), 10630 and perhaps some padding. */ 10631 p = htab->glink->contents; 10632 p += htab->glink_pltresolve; 10633 endp = htab->glink->contents; 10634 endp += htab->glink->size - GLINK_PLTRESOLVE; 10635 while (p < endp - (htab->params->ppc476_workaround ? 0 : 8 * 4)) 10636 { 10637 bfd_put_32 (output_bfd, B + endp - p, p); 10638 p += 4; 10639 } 10640 while (p < endp) 10641 { 10642 bfd_put_32 (output_bfd, NOP, p); 10643 p += 4; 10644 } 10645 10646 res0 = (htab->glink_pltresolve 10647 + htab->glink->output_section->vma 10648 + htab->glink->output_offset); 10649 10650 if (htab->params->ppc476_workaround) 10651 { 10652 /* Ensure that a call stub at the end of a page doesn't 10653 result in prefetch over the end of the page into the 10654 glink branch table. */ 10655 bfd_vma pagesize = (bfd_vma) 1 << htab->params->pagesize_p2; 10656 bfd_vma page_addr; 10657 bfd_vma glink_start = (htab->glink->output_section->vma 10658 + htab->glink->output_offset); 10659 10660 for (page_addr = res0 & -pagesize; 10661 page_addr > glink_start; 10662 page_addr -= pagesize) 10663 { 10664 /* We have a plt call stub that may need fixing. */ 10665 bfd_byte *loc; 10666 unsigned int insn; 10667 10668 loc = htab->glink->contents + page_addr - 4 - glink_start; 10669 insn = bfd_get_32 (output_bfd, loc); 10670 if (insn == BCTR) 10671 { 10672 /* By alignment, we know that there must be at least 10673 one other call stub before this one. */ 10674 insn = bfd_get_32 (output_bfd, loc - 16); 10675 if (insn == BCTR) 10676 bfd_put_32 (output_bfd, B | (-16 & 0x3fffffc), loc); 10677 else 10678 bfd_put_32 (output_bfd, B | (-20 & 0x3fffffc), loc); 10679 } 10680 } 10681 } 10682 10683 /* Last comes the PLTresolve stub. */ 10684 if (bfd_link_pic (info)) 10685 { 10686 bfd_vma bcl; 10687 10688 for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++) 10689 { 10690 unsigned int insn = pic_plt_resolve[i]; 10691 10692 if (htab->params->ppc476_workaround && insn == NOP) 10693 insn = BA + 0; 10694 bfd_put_32 (output_bfd, insn, p); 10695 p += 4; 10696 } 10697 p -= 4 * ARRAY_SIZE (pic_plt_resolve); 10698 10699 bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4 10700 + htab->glink->output_section->vma 10701 + htab->glink->output_offset); 10702 10703 bfd_put_32 (output_bfd, 10704 ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4); 10705 bfd_put_32 (output_bfd, 10706 ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4); 10707 bfd_put_32 (output_bfd, 10708 ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4); 10709 if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl)) 10710 { 10711 bfd_put_32 (output_bfd, 10712 LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); 10713 bfd_put_32 (output_bfd, 10714 LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4); 10715 } 10716 else 10717 { 10718 bfd_put_32 (output_bfd, 10719 LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); 10720 bfd_put_32 (output_bfd, 10721 LWZ_12_12 + 4, p + 9*4); 10722 } 10723 } 10724 else 10725 { 10726 for (i = 0; i < ARRAY_SIZE (plt_resolve); i++) 10727 { 10728 unsigned int insn = plt_resolve[i]; 10729 10730 if (htab->params->ppc476_workaround && insn == NOP) 10731 insn = BA + 0; 10732 bfd_put_32 (output_bfd, insn, p); 10733 p += 4; 10734 } 10735 p -= 4 * ARRAY_SIZE (plt_resolve); 10736 10737 bfd_put_32 (output_bfd, 10738 LIS_12 + PPC_HA (got + 4), p + 0*4); 10739 bfd_put_32 (output_bfd, 10740 ADDIS_11_11 + PPC_HA (-res0), p + 1*4); 10741 bfd_put_32 (output_bfd, 10742 ADDI_11_11 + PPC_LO (-res0), p + 3*4); 10743 if (PPC_HA (got + 4) == PPC_HA (got + 8)) 10744 { 10745 bfd_put_32 (output_bfd, 10746 LWZ_0_12 + PPC_LO (got + 4), p + 2*4); 10747 bfd_put_32 (output_bfd, 10748 LWZ_12_12 + PPC_LO (got + 8), p + 6*4); 10749 } 10750 else 10751 { 10752 bfd_put_32 (output_bfd, 10753 LWZU_0_12 + PPC_LO (got + 4), p + 2*4); 10754 bfd_put_32 (output_bfd, 10755 LWZ_12_12 + 4, p + 6*4); 10756 } 10757 } 10758 } 10759 10760 if (htab->glink_eh_frame != NULL 10761 && htab->glink_eh_frame->contents != NULL) 10762 { 10763 unsigned char *p = htab->glink_eh_frame->contents; 10764 bfd_vma val; 10765 10766 p += sizeof (glink_eh_frame_cie); 10767 /* FDE length. */ 10768 p += 4; 10769 /* CIE pointer. */ 10770 p += 4; 10771 /* Offset to .glink. */ 10772 val = (htab->glink->output_section->vma 10773 + htab->glink->output_offset); 10774 val -= (htab->glink_eh_frame->output_section->vma 10775 + htab->glink_eh_frame->output_offset); 10776 val -= p - htab->glink_eh_frame->contents; 10777 bfd_put_32 (htab->elf.dynobj, val, p); 10778 10779 if (htab->glink_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME 10780 && !_bfd_elf_write_section_eh_frame (output_bfd, info, 10781 htab->glink_eh_frame, 10782 htab->glink_eh_frame->contents)) 10783 return FALSE; 10784 } 10785 10786 return ret; 10787 } 10788 10789 #define TARGET_LITTLE_SYM powerpc_elf32_le_vec 10791 #define TARGET_LITTLE_NAME "elf32-powerpcle" 10792 #define TARGET_BIG_SYM powerpc_elf32_vec 10793 #define TARGET_BIG_NAME "elf32-powerpc" 10794 #define ELF_ARCH bfd_arch_powerpc 10795 #define ELF_TARGET_ID PPC32_ELF_DATA 10796 #define ELF_MACHINE_CODE EM_PPC 10797 #ifdef __QNXTARGET__ 10798 #define ELF_MAXPAGESIZE 0x1000 10799 #define ELF_COMMONPAGESIZE 0x1000 10800 #else 10801 #define ELF_MAXPAGESIZE 0x10000 10802 #define ELF_COMMONPAGESIZE 0x10000 10803 #endif 10804 #define ELF_MINPAGESIZE 0x1000 10805 #define elf_info_to_howto ppc_elf_info_to_howto 10806 10807 #ifdef EM_CYGNUS_POWERPC 10808 #define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC 10809 #endif 10810 10811 #ifdef EM_PPC_OLD 10812 #define ELF_MACHINE_ALT2 EM_PPC_OLD 10813 #endif 10814 10815 #define elf_backend_plt_not_loaded 1 10816 #define elf_backend_can_gc_sections 1 10817 #define elf_backend_can_refcount 1 10818 #define elf_backend_rela_normal 1 10819 #define elf_backend_caches_rawsize 1 10820 10821 #define bfd_elf32_mkobject ppc_elf_mkobject 10822 #define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data 10823 #define bfd_elf32_bfd_relax_section ppc_elf_relax_section 10824 #define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup 10825 #define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup 10826 #define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags 10827 #define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create 10828 #define bfd_elf32_get_synthetic_symtab ppc_elf_get_synthetic_symtab 10829 10830 #define elf_backend_object_p ppc_elf_object_p 10831 #define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook 10832 #define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook 10833 #define elf_backend_section_from_shdr ppc_elf_section_from_shdr 10834 #define elf_backend_relocate_section ppc_elf_relocate_section 10835 #define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections 10836 #define elf_backend_check_relocs ppc_elf_check_relocs 10837 #define elf_backend_copy_indirect_symbol ppc_elf_copy_indirect_symbol 10838 #define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol 10839 #define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook 10840 #define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections 10841 #define elf_backend_hash_symbol ppc_elf_hash_symbol 10842 #define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol 10843 #define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections 10844 #define elf_backend_fake_sections ppc_elf_fake_sections 10845 #define elf_backend_additional_program_headers ppc_elf_additional_program_headers 10846 #define elf_backend_modify_segment_map ppc_elf_modify_segment_map 10847 #define elf_backend_grok_prstatus ppc_elf_grok_prstatus 10848 #define elf_backend_grok_psinfo ppc_elf_grok_psinfo 10849 #define elf_backend_write_core_note ppc_elf_write_core_note 10850 #define elf_backend_reloc_type_class ppc_elf_reloc_type_class 10851 #define elf_backend_begin_write_processing ppc_elf_begin_write_processing 10852 #define elf_backend_final_write_processing ppc_elf_final_write_processing 10853 #define elf_backend_write_section ppc_elf_write_section 10854 #define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr 10855 #define elf_backend_plt_sym_val ppc_elf_plt_sym_val 10856 #define elf_backend_action_discarded ppc_elf_action_discarded 10857 #define elf_backend_init_index_section _bfd_elf_init_1_index_section 10858 #define elf_backend_lookup_section_flags_hook ppc_elf_lookup_section_flags 10859 #define elf_backend_section_processing ppc_elf_section_processing 10860 10861 #include "elf32-target.h" 10862 10863 /* FreeBSD Target */ 10864 10865 #undef TARGET_LITTLE_SYM 10866 #undef TARGET_LITTLE_NAME 10867 10868 #undef TARGET_BIG_SYM 10869 #define TARGET_BIG_SYM powerpc_elf32_fbsd_vec 10870 #undef TARGET_BIG_NAME 10871 #define TARGET_BIG_NAME "elf32-powerpc-freebsd" 10872 10873 #undef ELF_OSABI 10874 #define ELF_OSABI ELFOSABI_FREEBSD 10875 10876 #undef elf32_bed 10877 #define elf32_bed elf32_powerpc_fbsd_bed 10878 10879 #include "elf32-target.h" 10880 10881 /* VxWorks Target */ 10882 10883 #undef TARGET_LITTLE_SYM 10884 #undef TARGET_LITTLE_NAME 10885 10886 #undef TARGET_BIG_SYM 10887 #define TARGET_BIG_SYM powerpc_elf32_vxworks_vec 10888 #undef TARGET_BIG_NAME 10889 #define TARGET_BIG_NAME "elf32-powerpc-vxworks" 10890 10891 #undef ELF_OSABI 10892 10893 /* VxWorks uses the elf default section flags for .plt. */ 10894 static const struct bfd_elf_special_section * 10895 ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 10896 { 10897 if (sec->name == NULL) 10898 return NULL; 10899 10900 if (strcmp (sec->name, ".plt") == 0) 10901 return _bfd_elf_get_sec_type_attr (abfd, sec); 10902 10903 return ppc_elf_get_sec_type_attr (abfd, sec); 10904 } 10905 10906 /* Like ppc_elf_link_hash_table_create, but overrides 10907 appropriately for VxWorks. */ 10908 static struct bfd_link_hash_table * 10909 ppc_elf_vxworks_link_hash_table_create (bfd *abfd) 10910 { 10911 struct bfd_link_hash_table *ret; 10912 10913 ret = ppc_elf_link_hash_table_create (abfd); 10914 if (ret) 10915 { 10916 struct ppc_elf_link_hash_table *htab 10917 = (struct ppc_elf_link_hash_table *)ret; 10918 htab->is_vxworks = 1; 10919 htab->plt_type = PLT_VXWORKS; 10920 htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE; 10921 htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE; 10922 htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE; 10923 } 10924 return ret; 10925 } 10926 10927 /* Tweak magic VxWorks symbols as they are loaded. */ 10928 static bfd_boolean 10929 ppc_elf_vxworks_add_symbol_hook (bfd *abfd, 10930 struct bfd_link_info *info, 10931 Elf_Internal_Sym *sym, 10932 const char **namep ATTRIBUTE_UNUSED, 10933 flagword *flagsp ATTRIBUTE_UNUSED, 10934 asection **secp, 10935 bfd_vma *valp) 10936 { 10937 if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, 10938 valp)) 10939 return FALSE; 10940 10941 return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp); 10942 } 10943 10944 static void 10945 ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) 10946 { 10947 ppc_elf_final_write_processing(abfd, linker); 10948 elf_vxworks_final_write_processing(abfd, linker); 10949 } 10950 10951 /* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so 10952 define it. */ 10953 #undef elf_backend_want_plt_sym 10954 #define elf_backend_want_plt_sym 1 10955 #undef elf_backend_want_got_plt 10956 #define elf_backend_want_got_plt 1 10957 #undef elf_backend_got_symbol_offset 10958 #define elf_backend_got_symbol_offset 0 10959 #undef elf_backend_plt_not_loaded 10960 #define elf_backend_plt_not_loaded 0 10961 #undef elf_backend_plt_readonly 10962 #define elf_backend_plt_readonly 1 10963 #undef elf_backend_got_header_size 10964 #define elf_backend_got_header_size 12 10965 10966 #undef bfd_elf32_get_synthetic_symtab 10967 10968 #undef bfd_elf32_bfd_link_hash_table_create 10969 #define bfd_elf32_bfd_link_hash_table_create \ 10970 ppc_elf_vxworks_link_hash_table_create 10971 #undef elf_backend_add_symbol_hook 10972 #define elf_backend_add_symbol_hook \ 10973 ppc_elf_vxworks_add_symbol_hook 10974 #undef elf_backend_link_output_symbol_hook 10975 #define elf_backend_link_output_symbol_hook \ 10976 elf_vxworks_link_output_symbol_hook 10977 #undef elf_backend_final_write_processing 10978 #define elf_backend_final_write_processing \ 10979 ppc_elf_vxworks_final_write_processing 10980 #undef elf_backend_get_sec_type_attr 10981 #define elf_backend_get_sec_type_attr \ 10982 ppc_elf_vxworks_get_sec_type_attr 10983 #undef elf_backend_emit_relocs 10984 #define elf_backend_emit_relocs \ 10985 elf_vxworks_emit_relocs 10986 10987 #undef elf32_bed 10988 #define elf32_bed ppc_elf_vxworks_bed 10989 #undef elf_backend_post_process_headers 10990 10991 #include "elf32-target.h" 10992
