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