1/* PowerPC-specific support for 32-bit ELF 2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 3 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support. 5 6 This file is part of BFD, the Binary File Descriptor library. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the 20 Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor, 21 Boston, MA 02110-1301, USA. */ 22 23 24/* This file is based on a preliminary PowerPC ELF ABI. The 25 information may not match the final PowerPC ELF ABI. It includes 26 suggestions from the in-progress Embedded PowerPC ABI, and that 27 information may also not match. */ 28 29#include "sysdep.h" 30#include <stdarg.h> 31#include "bfd.h" 32#include "bfdlink.h" 33#include "libbfd.h" 34#include "elf-bfd.h" 35#include "elf/ppc.h" 36#include "elf32-ppc.h" 37#include "elf-vxworks.h" 38 39/* RELA relocations are used here. */ 40 41static bfd_reloc_status_type ppc_elf_addr16_ha_reloc 42 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 43static bfd_reloc_status_type ppc_elf_unhandled_reloc 44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 45 46/* Branch prediction bit for branch taken relocs. */ 47#define BRANCH_PREDICT_BIT 0x200000 48/* Mask to set RA in memory instructions. */ 49#define RA_REGISTER_MASK 0x001f0000 50/* Value to shift register by to insert RA. */ 51#define RA_REGISTER_SHIFT 16 52 53/* The name of the dynamic interpreter. This is put in the .interp 54 section. */ 55#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 56 57/* For old-style PLT. */ 58/* The number of single-slot PLT entries (the rest use two slots). */ 59#define PLT_NUM_SINGLE_ENTRIES 8192 60 61/* For new-style .glink and .plt. */ 62#define GLINK_PLTRESOLVE 16*4 63#define GLINK_ENTRY_SIZE 4*4 64 65/* VxWorks uses its own plt layout, filled in by the static linker. */ 66 67/* The standard VxWorks PLT entry. */ 68#define VXWORKS_PLT_ENTRY_SIZE 32 69static const bfd_vma ppc_elf_vxworks_plt_entry 70 [VXWORKS_PLT_ENTRY_SIZE / 4] = 71 { 72 0x3d800000, /* lis r12,0 */ 73 0x818c0000, /* lwz r12,0(r12) */ 74 0x7d8903a6, /* mtctr r12 */ 75 0x4e800420, /* bctr */ 76 0x39600000, /* li r11,0 */ 77 0x48000000, /* b 14 <.PLT0resolve+0x4> */ 78 0x60000000, /* nop */ 79 0x60000000, /* nop */ 80 }; 81static const bfd_vma ppc_elf_vxworks_pic_plt_entry 82 [VXWORKS_PLT_ENTRY_SIZE / 4] = 83 { 84 0x3d9e0000, /* addis r12,r30,0 */ 85 0x818c0000, /* lwz r12,0(r12) */ 86 0x7d8903a6, /* mtctr r12 */ 87 0x4e800420, /* bctr */ 88 0x39600000, /* li r11,0 */ 89 0x48000000, /* b 14 <.PLT0resolve+0x4> 14: R_PPC_REL24 .PLTresolve */ 90 0x60000000, /* nop */ 91 0x60000000, /* nop */ 92 }; 93 94/* The initial VxWorks PLT entry. */ 95#define VXWORKS_PLT_INITIAL_ENTRY_SIZE 32 96static const bfd_vma ppc_elf_vxworks_plt0_entry 97 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = 98 { 99 0x3d800000, /* lis r12,0 */ 100 0x398c0000, /* addi r12,r12,0 */ 101 0x800c0008, /* lwz r0,8(r12) */ 102 0x7c0903a6, /* mtctr r0 */ 103 0x818c0004, /* lwz r12,4(r12) */ 104 0x4e800420, /* bctr */ 105 0x60000000, /* nop */ 106 0x60000000, /* nop */ 107 }; 108static const bfd_vma ppc_elf_vxworks_pic_plt0_entry 109 [VXWORKS_PLT_INITIAL_ENTRY_SIZE / 4] = 110 { 111 0x819e0008, /* lwz r12,8(r30) */ 112 0x7d8903a6, /* mtctr r12 */ 113 0x819e0004, /* lwz r12,4(r30) */ 114 0x4e800420, /* bctr */ 115 0x60000000, /* nop */ 116 0x60000000, /* nop */ 117 0x60000000, /* nop */ 118 0x60000000, /* nop */ 119 }; 120 121/* For executables, we have some additional relocations in 122 .rela.plt.unloaded, for the kernel loader. */ 123 124/* The number of non-JMP_SLOT relocations per PLT0 slot. */ 125#define VXWORKS_PLT_NON_JMP_SLOT_RELOCS 3 126/* The number of relocations in the PLTResolve slot. */ 127#define VXWORKS_PLTRESOLVE_RELOCS 2 128/* The number of relocations in the PLTResolve slot when when creating 129 a shared library. */ 130#define VXWORKS_PLTRESOLVE_RELOCS_SHLIB 0 131 132/* Some instructions. */ 133#define ADDIS_11_11 0x3d6b0000 134#define ADDIS_11_30 0x3d7e0000 135#define ADDIS_12_12 0x3d8c0000 136#define ADDI_11_11 0x396b0000 137#define ADD_0_11_11 0x7c0b5a14 138#define ADD_11_0_11 0x7d605a14 139#define B 0x48000000 140#define BCL_20_31 0x429f0005 141#define BCTR 0x4e800420 142#define LIS_11 0x3d600000 143#define LIS_12 0x3d800000 144#define LWZU_0_12 0x840c0000 145#define LWZ_0_12 0x800c0000 146#define LWZ_11_11 0x816b0000 147#define LWZ_11_30 0x817e0000 148#define LWZ_12_12 0x818c0000 149#define MFLR_0 0x7c0802a6 150#define MFLR_12 0x7d8802a6 151#define MTCTR_0 0x7c0903a6 152#define MTCTR_11 0x7d6903a6 153#define MTLR_0 0x7c0803a6 154#define NOP 0x60000000 155#define SUB_11_11_12 0x7d6c5850 156 157/* Offset of tp and dtp pointers from start of TLS block. */ 158#define TP_OFFSET 0x7000 159#define DTP_OFFSET 0x8000 160 161static reloc_howto_type *ppc_elf_howto_table[R_PPC_max]; 162 163static reloc_howto_type ppc_elf_howto_raw[] = { 164 /* This reloc does nothing. */ 165 HOWTO (R_PPC_NONE, /* type */ 166 0, /* rightshift */ 167 2, /* size (0 = byte, 1 = short, 2 = long) */ 168 32, /* bitsize */ 169 FALSE, /* pc_relative */ 170 0, /* bitpos */ 171 complain_overflow_bitfield, /* complain_on_overflow */ 172 bfd_elf_generic_reloc, /* special_function */ 173 "R_PPC_NONE", /* name */ 174 FALSE, /* partial_inplace */ 175 0, /* src_mask */ 176 0, /* dst_mask */ 177 FALSE), /* pcrel_offset */ 178 179 /* A standard 32 bit relocation. */ 180 HOWTO (R_PPC_ADDR32, /* type */ 181 0, /* rightshift */ 182 2, /* size (0 = byte, 1 = short, 2 = long) */ 183 32, /* bitsize */ 184 FALSE, /* pc_relative */ 185 0, /* bitpos */ 186 complain_overflow_bitfield, /* complain_on_overflow */ 187 bfd_elf_generic_reloc, /* special_function */ 188 "R_PPC_ADDR32", /* name */ 189 FALSE, /* partial_inplace */ 190 0, /* src_mask */ 191 0xffffffff, /* dst_mask */ 192 FALSE), /* pcrel_offset */ 193 194 /* An absolute 26 bit branch; the lower two bits must be zero. 195 FIXME: we don't check that, we just clear them. */ 196 HOWTO (R_PPC_ADDR24, /* type */ 197 0, /* rightshift */ 198 2, /* size (0 = byte, 1 = short, 2 = long) */ 199 26, /* bitsize */ 200 FALSE, /* pc_relative */ 201 0, /* bitpos */ 202 complain_overflow_bitfield, /* complain_on_overflow */ 203 bfd_elf_generic_reloc, /* special_function */ 204 "R_PPC_ADDR24", /* name */ 205 FALSE, /* partial_inplace */ 206 0, /* src_mask */ 207 0x3fffffc, /* dst_mask */ 208 FALSE), /* pcrel_offset */ 209 210 /* A standard 16 bit relocation. */ 211 HOWTO (R_PPC_ADDR16, /* type */ 212 0, /* rightshift */ 213 1, /* size (0 = byte, 1 = short, 2 = long) */ 214 16, /* bitsize */ 215 FALSE, /* pc_relative */ 216 0, /* bitpos */ 217 complain_overflow_bitfield, /* complain_on_overflow */ 218 bfd_elf_generic_reloc, /* special_function */ 219 "R_PPC_ADDR16", /* name */ 220 FALSE, /* partial_inplace */ 221 0, /* src_mask */ 222 0xffff, /* dst_mask */ 223 FALSE), /* pcrel_offset */ 224 225 /* A 16 bit relocation without overflow. */ 226 HOWTO (R_PPC_ADDR16_LO, /* type */ 227 0, /* rightshift */ 228 1, /* size (0 = byte, 1 = short, 2 = long) */ 229 16, /* bitsize */ 230 FALSE, /* pc_relative */ 231 0, /* bitpos */ 232 complain_overflow_dont,/* complain_on_overflow */ 233 bfd_elf_generic_reloc, /* special_function */ 234 "R_PPC_ADDR16_LO", /* name */ 235 FALSE, /* partial_inplace */ 236 0, /* src_mask */ 237 0xffff, /* dst_mask */ 238 FALSE), /* pcrel_offset */ 239 240 /* The high order 16 bits of an address. */ 241 HOWTO (R_PPC_ADDR16_HI, /* type */ 242 16, /* rightshift */ 243 1, /* size (0 = byte, 1 = short, 2 = long) */ 244 16, /* bitsize */ 245 FALSE, /* pc_relative */ 246 0, /* bitpos */ 247 complain_overflow_dont, /* complain_on_overflow */ 248 bfd_elf_generic_reloc, /* special_function */ 249 "R_PPC_ADDR16_HI", /* name */ 250 FALSE, /* partial_inplace */ 251 0, /* src_mask */ 252 0xffff, /* dst_mask */ 253 FALSE), /* pcrel_offset */ 254 255 /* The high order 16 bits of an address, plus 1 if the contents of 256 the low 16 bits, treated as a signed number, is negative. */ 257 HOWTO (R_PPC_ADDR16_HA, /* type */ 258 16, /* rightshift */ 259 1, /* size (0 = byte, 1 = short, 2 = long) */ 260 16, /* bitsize */ 261 FALSE, /* pc_relative */ 262 0, /* bitpos */ 263 complain_overflow_dont, /* complain_on_overflow */ 264 ppc_elf_addr16_ha_reloc, /* special_function */ 265 "R_PPC_ADDR16_HA", /* name */ 266 FALSE, /* partial_inplace */ 267 0, /* src_mask */ 268 0xffff, /* dst_mask */ 269 FALSE), /* pcrel_offset */ 270 271 /* An absolute 16 bit branch; the lower two bits must be zero. 272 FIXME: we don't check that, we just clear them. */ 273 HOWTO (R_PPC_ADDR14, /* type */ 274 0, /* rightshift */ 275 2, /* size (0 = byte, 1 = short, 2 = long) */ 276 16, /* bitsize */ 277 FALSE, /* pc_relative */ 278 0, /* bitpos */ 279 complain_overflow_bitfield, /* complain_on_overflow */ 280 bfd_elf_generic_reloc, /* special_function */ 281 "R_PPC_ADDR14", /* name */ 282 FALSE, /* partial_inplace */ 283 0, /* src_mask */ 284 0xfffc, /* dst_mask */ 285 FALSE), /* pcrel_offset */ 286 287 /* An absolute 16 bit branch, for which bit 10 should be set to 288 indicate that the branch is expected to be taken. The lower two 289 bits must be zero. */ 290 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */ 291 0, /* rightshift */ 292 2, /* size (0 = byte, 1 = short, 2 = long) */ 293 16, /* bitsize */ 294 FALSE, /* pc_relative */ 295 0, /* bitpos */ 296 complain_overflow_bitfield, /* complain_on_overflow */ 297 bfd_elf_generic_reloc, /* special_function */ 298 "R_PPC_ADDR14_BRTAKEN",/* name */ 299 FALSE, /* partial_inplace */ 300 0, /* src_mask */ 301 0xfffc, /* dst_mask */ 302 FALSE), /* pcrel_offset */ 303 304 /* An absolute 16 bit branch, for which bit 10 should be set to 305 indicate that the branch is not expected to be taken. The lower 306 two bits must be zero. */ 307 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */ 308 0, /* rightshift */ 309 2, /* size (0 = byte, 1 = short, 2 = long) */ 310 16, /* bitsize */ 311 FALSE, /* pc_relative */ 312 0, /* bitpos */ 313 complain_overflow_bitfield, /* complain_on_overflow */ 314 bfd_elf_generic_reloc, /* special_function */ 315 "R_PPC_ADDR14_BRNTAKEN",/* name */ 316 FALSE, /* partial_inplace */ 317 0, /* src_mask */ 318 0xfffc, /* dst_mask */ 319 FALSE), /* pcrel_offset */ 320 321 /* A relative 26 bit branch; the lower two bits must be zero. */ 322 HOWTO (R_PPC_REL24, /* type */ 323 0, /* rightshift */ 324 2, /* size (0 = byte, 1 = short, 2 = long) */ 325 26, /* bitsize */ 326 TRUE, /* pc_relative */ 327 0, /* bitpos */ 328 complain_overflow_signed, /* complain_on_overflow */ 329 bfd_elf_generic_reloc, /* special_function */ 330 "R_PPC_REL24", /* name */ 331 FALSE, /* partial_inplace */ 332 0, /* src_mask */ 333 0x3fffffc, /* dst_mask */ 334 TRUE), /* pcrel_offset */ 335 336 /* A relative 16 bit branch; the lower two bits must be zero. */ 337 HOWTO (R_PPC_REL14, /* type */ 338 0, /* rightshift */ 339 2, /* size (0 = byte, 1 = short, 2 = long) */ 340 16, /* bitsize */ 341 TRUE, /* pc_relative */ 342 0, /* bitpos */ 343 complain_overflow_signed, /* complain_on_overflow */ 344 bfd_elf_generic_reloc, /* special_function */ 345 "R_PPC_REL14", /* name */ 346 FALSE, /* partial_inplace */ 347 0, /* src_mask */ 348 0xfffc, /* dst_mask */ 349 TRUE), /* pcrel_offset */ 350 351 /* A relative 16 bit branch. Bit 10 should be set to indicate that 352 the branch is expected to be taken. The lower two bits must be 353 zero. */ 354 HOWTO (R_PPC_REL14_BRTAKEN, /* type */ 355 0, /* rightshift */ 356 2, /* size (0 = byte, 1 = short, 2 = long) */ 357 16, /* bitsize */ 358 TRUE, /* pc_relative */ 359 0, /* bitpos */ 360 complain_overflow_signed, /* complain_on_overflow */ 361 bfd_elf_generic_reloc, /* special_function */ 362 "R_PPC_REL14_BRTAKEN", /* name */ 363 FALSE, /* partial_inplace */ 364 0, /* src_mask */ 365 0xfffc, /* dst_mask */ 366 TRUE), /* pcrel_offset */ 367 368 /* A relative 16 bit branch. Bit 10 should be set to indicate that 369 the branch is not expected to be taken. The lower two bits must 370 be zero. */ 371 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */ 372 0, /* rightshift */ 373 2, /* size (0 = byte, 1 = short, 2 = long) */ 374 16, /* bitsize */ 375 TRUE, /* pc_relative */ 376 0, /* bitpos */ 377 complain_overflow_signed, /* complain_on_overflow */ 378 bfd_elf_generic_reloc, /* special_function */ 379 "R_PPC_REL14_BRNTAKEN",/* name */ 380 FALSE, /* partial_inplace */ 381 0, /* src_mask */ 382 0xfffc, /* dst_mask */ 383 TRUE), /* pcrel_offset */ 384 385 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the 386 symbol. */ 387 HOWTO (R_PPC_GOT16, /* type */ 388 0, /* rightshift */ 389 1, /* size (0 = byte, 1 = short, 2 = long) */ 390 16, /* bitsize */ 391 FALSE, /* pc_relative */ 392 0, /* bitpos */ 393 complain_overflow_signed, /* complain_on_overflow */ 394 bfd_elf_generic_reloc, /* special_function */ 395 "R_PPC_GOT16", /* name */ 396 FALSE, /* partial_inplace */ 397 0, /* src_mask */ 398 0xffff, /* dst_mask */ 399 FALSE), /* pcrel_offset */ 400 401 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for 402 the symbol. */ 403 HOWTO (R_PPC_GOT16_LO, /* type */ 404 0, /* rightshift */ 405 1, /* size (0 = byte, 1 = short, 2 = long) */ 406 16, /* bitsize */ 407 FALSE, /* pc_relative */ 408 0, /* bitpos */ 409 complain_overflow_dont, /* complain_on_overflow */ 410 bfd_elf_generic_reloc, /* special_function */ 411 "R_PPC_GOT16_LO", /* name */ 412 FALSE, /* partial_inplace */ 413 0, /* src_mask */ 414 0xffff, /* dst_mask */ 415 FALSE), /* pcrel_offset */ 416 417 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for 418 the symbol. */ 419 HOWTO (R_PPC_GOT16_HI, /* type */ 420 16, /* rightshift */ 421 1, /* size (0 = byte, 1 = short, 2 = long) */ 422 16, /* bitsize */ 423 FALSE, /* pc_relative */ 424 0, /* bitpos */ 425 complain_overflow_bitfield, /* complain_on_overflow */ 426 bfd_elf_generic_reloc, /* special_function */ 427 "R_PPC_GOT16_HI", /* name */ 428 FALSE, /* partial_inplace */ 429 0, /* src_mask */ 430 0xffff, /* dst_mask */ 431 FALSE), /* pcrel_offset */ 432 433 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for 434 the symbol. */ 435 HOWTO (R_PPC_GOT16_HA, /* type */ 436 16, /* rightshift */ 437 1, /* size (0 = byte, 1 = short, 2 = long) */ 438 16, /* bitsize */ 439 FALSE, /* pc_relative */ 440 0, /* bitpos */ 441 complain_overflow_bitfield, /* complain_on_overflow */ 442 ppc_elf_addr16_ha_reloc, /* special_function */ 443 "R_PPC_GOT16_HA", /* name */ 444 FALSE, /* partial_inplace */ 445 0, /* src_mask */ 446 0xffff, /* dst_mask */ 447 FALSE), /* pcrel_offset */ 448 449 /* Like R_PPC_REL24, but referring to the procedure linkage table 450 entry for the symbol. */ 451 HOWTO (R_PPC_PLTREL24, /* type */ 452 0, /* rightshift */ 453 2, /* size (0 = byte, 1 = short, 2 = long) */ 454 26, /* bitsize */ 455 TRUE, /* pc_relative */ 456 0, /* bitpos */ 457 complain_overflow_signed, /* complain_on_overflow */ 458 bfd_elf_generic_reloc, /* special_function */ 459 "R_PPC_PLTREL24", /* name */ 460 FALSE, /* partial_inplace */ 461 0, /* src_mask */ 462 0x3fffffc, /* dst_mask */ 463 TRUE), /* pcrel_offset */ 464 465 /* This is used only by the dynamic linker. The symbol should exist 466 both in the object being run and in some shared library. The 467 dynamic linker copies the data addressed by the symbol from the 468 shared library into the object, because the object being 469 run has to have the data at some particular address. */ 470 HOWTO (R_PPC_COPY, /* type */ 471 0, /* rightshift */ 472 2, /* size (0 = byte, 1 = short, 2 = long) */ 473 32, /* bitsize */ 474 FALSE, /* pc_relative */ 475 0, /* bitpos */ 476 complain_overflow_bitfield, /* complain_on_overflow */ 477 bfd_elf_generic_reloc, /* special_function */ 478 "R_PPC_COPY", /* name */ 479 FALSE, /* partial_inplace */ 480 0, /* src_mask */ 481 0, /* dst_mask */ 482 FALSE), /* pcrel_offset */ 483 484 /* Like R_PPC_ADDR32, but used when setting global offset table 485 entries. */ 486 HOWTO (R_PPC_GLOB_DAT, /* type */ 487 0, /* rightshift */ 488 2, /* size (0 = byte, 1 = short, 2 = long) */ 489 32, /* bitsize */ 490 FALSE, /* pc_relative */ 491 0, /* bitpos */ 492 complain_overflow_bitfield, /* complain_on_overflow */ 493 bfd_elf_generic_reloc, /* special_function */ 494 "R_PPC_GLOB_DAT", /* name */ 495 FALSE, /* partial_inplace */ 496 0, /* src_mask */ 497 0xffffffff, /* dst_mask */ 498 FALSE), /* pcrel_offset */ 499 500 /* Marks a procedure linkage table entry for a symbol. */ 501 HOWTO (R_PPC_JMP_SLOT, /* type */ 502 0, /* rightshift */ 503 2, /* size (0 = byte, 1 = short, 2 = long) */ 504 32, /* bitsize */ 505 FALSE, /* pc_relative */ 506 0, /* bitpos */ 507 complain_overflow_bitfield, /* complain_on_overflow */ 508 bfd_elf_generic_reloc, /* special_function */ 509 "R_PPC_JMP_SLOT", /* name */ 510 FALSE, /* partial_inplace */ 511 0, /* src_mask */ 512 0, /* dst_mask */ 513 FALSE), /* pcrel_offset */ 514 515 /* Used only by the dynamic linker. When the object is run, this 516 longword is set to the load address of the object, plus the 517 addend. */ 518 HOWTO (R_PPC_RELATIVE, /* type */ 519 0, /* rightshift */ 520 2, /* size (0 = byte, 1 = short, 2 = long) */ 521 32, /* bitsize */ 522 FALSE, /* pc_relative */ 523 0, /* bitpos */ 524 complain_overflow_bitfield, /* complain_on_overflow */ 525 bfd_elf_generic_reloc, /* special_function */ 526 "R_PPC_RELATIVE", /* name */ 527 FALSE, /* partial_inplace */ 528 0, /* src_mask */ 529 0xffffffff, /* dst_mask */ 530 FALSE), /* pcrel_offset */ 531 532 /* Like R_PPC_REL24, but uses the value of the symbol within the 533 object rather than the final value. Normally used for 534 _GLOBAL_OFFSET_TABLE_. */ 535 HOWTO (R_PPC_LOCAL24PC, /* type */ 536 0, /* rightshift */ 537 2, /* size (0 = byte, 1 = short, 2 = long) */ 538 26, /* bitsize */ 539 TRUE, /* pc_relative */ 540 0, /* bitpos */ 541 complain_overflow_signed, /* complain_on_overflow */ 542 bfd_elf_generic_reloc, /* special_function */ 543 "R_PPC_LOCAL24PC", /* name */ 544 FALSE, /* partial_inplace */ 545 0, /* src_mask */ 546 0x3fffffc, /* dst_mask */ 547 TRUE), /* pcrel_offset */ 548 549 /* Like R_PPC_ADDR32, but may be unaligned. */ 550 HOWTO (R_PPC_UADDR32, /* type */ 551 0, /* rightshift */ 552 2, /* size (0 = byte, 1 = short, 2 = long) */ 553 32, /* bitsize */ 554 FALSE, /* pc_relative */ 555 0, /* bitpos */ 556 complain_overflow_bitfield, /* complain_on_overflow */ 557 bfd_elf_generic_reloc, /* special_function */ 558 "R_PPC_UADDR32", /* name */ 559 FALSE, /* partial_inplace */ 560 0, /* src_mask */ 561 0xffffffff, /* dst_mask */ 562 FALSE), /* pcrel_offset */ 563 564 /* Like R_PPC_ADDR16, but may be unaligned. */ 565 HOWTO (R_PPC_UADDR16, /* type */ 566 0, /* rightshift */ 567 1, /* size (0 = byte, 1 = short, 2 = long) */ 568 16, /* bitsize */ 569 FALSE, /* pc_relative */ 570 0, /* bitpos */ 571 complain_overflow_bitfield, /* complain_on_overflow */ 572 bfd_elf_generic_reloc, /* special_function */ 573 "R_PPC_UADDR16", /* name */ 574 FALSE, /* partial_inplace */ 575 0, /* src_mask */ 576 0xffff, /* dst_mask */ 577 FALSE), /* pcrel_offset */ 578 579 /* 32-bit PC relative */ 580 HOWTO (R_PPC_REL32, /* type */ 581 0, /* rightshift */ 582 2, /* size (0 = byte, 1 = short, 2 = long) */ 583 32, /* bitsize */ 584 TRUE, /* pc_relative */ 585 0, /* bitpos */ 586 complain_overflow_bitfield, /* complain_on_overflow */ 587 bfd_elf_generic_reloc, /* special_function */ 588 "R_PPC_REL32", /* name */ 589 FALSE, /* partial_inplace */ 590 0, /* src_mask */ 591 0xffffffff, /* dst_mask */ 592 TRUE), /* pcrel_offset */ 593 594 /* 32-bit relocation to the symbol's procedure linkage table. 595 FIXME: not supported. */ 596 HOWTO (R_PPC_PLT32, /* type */ 597 0, /* rightshift */ 598 2, /* size (0 = byte, 1 = short, 2 = long) */ 599 32, /* bitsize */ 600 FALSE, /* pc_relative */ 601 0, /* bitpos */ 602 complain_overflow_bitfield, /* complain_on_overflow */ 603 bfd_elf_generic_reloc, /* special_function */ 604 "R_PPC_PLT32", /* name */ 605 FALSE, /* partial_inplace */ 606 0, /* src_mask */ 607 0, /* dst_mask */ 608 FALSE), /* pcrel_offset */ 609 610 /* 32-bit PC relative relocation to the symbol's procedure linkage table. 611 FIXME: not supported. */ 612 HOWTO (R_PPC_PLTREL32, /* type */ 613 0, /* rightshift */ 614 2, /* size (0 = byte, 1 = short, 2 = long) */ 615 32, /* bitsize */ 616 TRUE, /* pc_relative */ 617 0, /* bitpos */ 618 complain_overflow_bitfield, /* complain_on_overflow */ 619 bfd_elf_generic_reloc, /* special_function */ 620 "R_PPC_PLTREL32", /* name */ 621 FALSE, /* partial_inplace */ 622 0, /* src_mask */ 623 0, /* dst_mask */ 624 TRUE), /* pcrel_offset */ 625 626 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for 627 the symbol. */ 628 HOWTO (R_PPC_PLT16_LO, /* type */ 629 0, /* rightshift */ 630 1, /* size (0 = byte, 1 = short, 2 = long) */ 631 16, /* bitsize */ 632 FALSE, /* pc_relative */ 633 0, /* bitpos */ 634 complain_overflow_dont, /* complain_on_overflow */ 635 bfd_elf_generic_reloc, /* special_function */ 636 "R_PPC_PLT16_LO", /* name */ 637 FALSE, /* partial_inplace */ 638 0, /* src_mask */ 639 0xffff, /* dst_mask */ 640 FALSE), /* pcrel_offset */ 641 642 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for 643 the symbol. */ 644 HOWTO (R_PPC_PLT16_HI, /* type */ 645 16, /* rightshift */ 646 1, /* size (0 = byte, 1 = short, 2 = long) */ 647 16, /* bitsize */ 648 FALSE, /* pc_relative */ 649 0, /* bitpos */ 650 complain_overflow_bitfield, /* complain_on_overflow */ 651 bfd_elf_generic_reloc, /* special_function */ 652 "R_PPC_PLT16_HI", /* name */ 653 FALSE, /* partial_inplace */ 654 0, /* src_mask */ 655 0xffff, /* dst_mask */ 656 FALSE), /* pcrel_offset */ 657 658 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for 659 the symbol. */ 660 HOWTO (R_PPC_PLT16_HA, /* type */ 661 16, /* rightshift */ 662 1, /* size (0 = byte, 1 = short, 2 = long) */ 663 16, /* bitsize */ 664 FALSE, /* pc_relative */ 665 0, /* bitpos */ 666 complain_overflow_bitfield, /* complain_on_overflow */ 667 ppc_elf_addr16_ha_reloc, /* special_function */ 668 "R_PPC_PLT16_HA", /* name */ 669 FALSE, /* partial_inplace */ 670 0, /* src_mask */ 671 0xffff, /* dst_mask */ 672 FALSE), /* pcrel_offset */ 673 674 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with 675 small data items. */ 676 HOWTO (R_PPC_SDAREL16, /* type */ 677 0, /* rightshift */ 678 1, /* size (0 = byte, 1 = short, 2 = long) */ 679 16, /* bitsize */ 680 FALSE, /* pc_relative */ 681 0, /* bitpos */ 682 complain_overflow_signed, /* complain_on_overflow */ 683 bfd_elf_generic_reloc, /* special_function */ 684 "R_PPC_SDAREL16", /* name */ 685 FALSE, /* partial_inplace */ 686 0, /* src_mask */ 687 0xffff, /* dst_mask */ 688 FALSE), /* pcrel_offset */ 689 690 /* 16-bit section relative relocation. */ 691 HOWTO (R_PPC_SECTOFF, /* type */ 692 0, /* rightshift */ 693 1, /* size (0 = byte, 1 = short, 2 = long) */ 694 16, /* bitsize */ 695 FALSE, /* pc_relative */ 696 0, /* bitpos */ 697 complain_overflow_bitfield, /* complain_on_overflow */ 698 bfd_elf_generic_reloc, /* special_function */ 699 "R_PPC_SECTOFF", /* name */ 700 FALSE, /* partial_inplace */ 701 0, /* src_mask */ 702 0xffff, /* dst_mask */ 703 FALSE), /* pcrel_offset */ 704 705 /* 16-bit lower half section relative relocation. */ 706 HOWTO (R_PPC_SECTOFF_LO, /* type */ 707 0, /* rightshift */ 708 1, /* size (0 = byte, 1 = short, 2 = long) */ 709 16, /* bitsize */ 710 FALSE, /* pc_relative */ 711 0, /* bitpos */ 712 complain_overflow_dont, /* complain_on_overflow */ 713 bfd_elf_generic_reloc, /* special_function */ 714 "R_PPC_SECTOFF_LO", /* name */ 715 FALSE, /* partial_inplace */ 716 0, /* src_mask */ 717 0xffff, /* dst_mask */ 718 FALSE), /* pcrel_offset */ 719 720 /* 16-bit upper half section relative relocation. */ 721 HOWTO (R_PPC_SECTOFF_HI, /* type */ 722 16, /* rightshift */ 723 1, /* size (0 = byte, 1 = short, 2 = long) */ 724 16, /* bitsize */ 725 FALSE, /* pc_relative */ 726 0, /* bitpos */ 727 complain_overflow_bitfield, /* complain_on_overflow */ 728 bfd_elf_generic_reloc, /* special_function */ 729 "R_PPC_SECTOFF_HI", /* name */ 730 FALSE, /* partial_inplace */ 731 0, /* src_mask */ 732 0xffff, /* dst_mask */ 733 FALSE), /* pcrel_offset */ 734 735 /* 16-bit upper half adjusted section relative relocation. */ 736 HOWTO (R_PPC_SECTOFF_HA, /* type */ 737 16, /* rightshift */ 738 1, /* size (0 = byte, 1 = short, 2 = long) */ 739 16, /* bitsize */ 740 FALSE, /* pc_relative */ 741 0, /* bitpos */ 742 complain_overflow_bitfield, /* complain_on_overflow */ 743 ppc_elf_addr16_ha_reloc, /* special_function */ 744 "R_PPC_SECTOFF_HA", /* name */ 745 FALSE, /* partial_inplace */ 746 0, /* src_mask */ 747 0xffff, /* dst_mask */ 748 FALSE), /* pcrel_offset */ 749 750 /* Marker reloc for TLS. */ 751 HOWTO (R_PPC_TLS, 752 0, /* rightshift */ 753 2, /* size (0 = byte, 1 = short, 2 = long) */ 754 32, /* bitsize */ 755 FALSE, /* pc_relative */ 756 0, /* bitpos */ 757 complain_overflow_dont, /* complain_on_overflow */ 758 bfd_elf_generic_reloc, /* special_function */ 759 "R_PPC_TLS", /* name */ 760 FALSE, /* partial_inplace */ 761 0, /* src_mask */ 762 0, /* dst_mask */ 763 FALSE), /* pcrel_offset */ 764 765 /* Computes the load module index of the load module that contains the 766 definition of its TLS sym. */ 767 HOWTO (R_PPC_DTPMOD32, 768 0, /* rightshift */ 769 2, /* size (0 = byte, 1 = short, 2 = long) */ 770 32, /* bitsize */ 771 FALSE, /* pc_relative */ 772 0, /* bitpos */ 773 complain_overflow_dont, /* complain_on_overflow */ 774 ppc_elf_unhandled_reloc, /* special_function */ 775 "R_PPC_DTPMOD32", /* name */ 776 FALSE, /* partial_inplace */ 777 0, /* src_mask */ 778 0xffffffff, /* dst_mask */ 779 FALSE), /* pcrel_offset */ 780 781 /* Computes a dtv-relative displacement, the difference between the value 782 of sym+add and the base address of the thread-local storage block that 783 contains the definition of sym, minus 0x8000. */ 784 HOWTO (R_PPC_DTPREL32, 785 0, /* rightshift */ 786 2, /* size (0 = byte, 1 = short, 2 = long) */ 787 32, /* bitsize */ 788 FALSE, /* pc_relative */ 789 0, /* bitpos */ 790 complain_overflow_dont, /* complain_on_overflow */ 791 ppc_elf_unhandled_reloc, /* special_function */ 792 "R_PPC_DTPREL32", /* name */ 793 FALSE, /* partial_inplace */ 794 0, /* src_mask */ 795 0xffffffff, /* dst_mask */ 796 FALSE), /* pcrel_offset */ 797 798 /* A 16 bit dtprel reloc. */ 799 HOWTO (R_PPC_DTPREL16, 800 0, /* rightshift */ 801 1, /* size (0 = byte, 1 = short, 2 = long) */ 802 16, /* bitsize */ 803 FALSE, /* pc_relative */ 804 0, /* bitpos */ 805 complain_overflow_signed, /* complain_on_overflow */ 806 ppc_elf_unhandled_reloc, /* special_function */ 807 "R_PPC_DTPREL16", /* name */ 808 FALSE, /* partial_inplace */ 809 0, /* src_mask */ 810 0xffff, /* dst_mask */ 811 FALSE), /* pcrel_offset */ 812 813 /* Like DTPREL16, but no overflow. */ 814 HOWTO (R_PPC_DTPREL16_LO, 815 0, /* rightshift */ 816 1, /* size (0 = byte, 1 = short, 2 = long) */ 817 16, /* bitsize */ 818 FALSE, /* pc_relative */ 819 0, /* bitpos */ 820 complain_overflow_dont, /* complain_on_overflow */ 821 ppc_elf_unhandled_reloc, /* special_function */ 822 "R_PPC_DTPREL16_LO", /* name */ 823 FALSE, /* partial_inplace */ 824 0, /* src_mask */ 825 0xffff, /* dst_mask */ 826 FALSE), /* pcrel_offset */ 827 828 /* Like DTPREL16_LO, but next higher group of 16 bits. */ 829 HOWTO (R_PPC_DTPREL16_HI, 830 16, /* rightshift */ 831 1, /* size (0 = byte, 1 = short, 2 = long) */ 832 16, /* bitsize */ 833 FALSE, /* pc_relative */ 834 0, /* bitpos */ 835 complain_overflow_dont, /* complain_on_overflow */ 836 ppc_elf_unhandled_reloc, /* special_function */ 837 "R_PPC_DTPREL16_HI", /* name */ 838 FALSE, /* partial_inplace */ 839 0, /* src_mask */ 840 0xffff, /* dst_mask */ 841 FALSE), /* pcrel_offset */ 842 843 /* Like DTPREL16_HI, but adjust for low 16 bits. */ 844 HOWTO (R_PPC_DTPREL16_HA, 845 16, /* rightshift */ 846 1, /* size (0 = byte, 1 = short, 2 = long) */ 847 16, /* bitsize */ 848 FALSE, /* pc_relative */ 849 0, /* bitpos */ 850 complain_overflow_dont, /* complain_on_overflow */ 851 ppc_elf_unhandled_reloc, /* special_function */ 852 "R_PPC_DTPREL16_HA", /* name */ 853 FALSE, /* partial_inplace */ 854 0, /* src_mask */ 855 0xffff, /* dst_mask */ 856 FALSE), /* pcrel_offset */ 857 858 /* Computes a tp-relative displacement, the difference between the value of 859 sym+add and the value of the thread pointer (r13). */ 860 HOWTO (R_PPC_TPREL32, 861 0, /* rightshift */ 862 2, /* size (0 = byte, 1 = short, 2 = long) */ 863 32, /* bitsize */ 864 FALSE, /* pc_relative */ 865 0, /* bitpos */ 866 complain_overflow_dont, /* complain_on_overflow */ 867 ppc_elf_unhandled_reloc, /* special_function */ 868 "R_PPC_TPREL32", /* name */ 869 FALSE, /* partial_inplace */ 870 0, /* src_mask */ 871 0xffffffff, /* dst_mask */ 872 FALSE), /* pcrel_offset */ 873 874 /* A 16 bit tprel reloc. */ 875 HOWTO (R_PPC_TPREL16, 876 0, /* rightshift */ 877 1, /* size (0 = byte, 1 = short, 2 = long) */ 878 16, /* bitsize */ 879 FALSE, /* pc_relative */ 880 0, /* bitpos */ 881 complain_overflow_signed, /* complain_on_overflow */ 882 ppc_elf_unhandled_reloc, /* special_function */ 883 "R_PPC_TPREL16", /* name */ 884 FALSE, /* partial_inplace */ 885 0, /* src_mask */ 886 0xffff, /* dst_mask */ 887 FALSE), /* pcrel_offset */ 888 889 /* Like TPREL16, but no overflow. */ 890 HOWTO (R_PPC_TPREL16_LO, 891 0, /* rightshift */ 892 1, /* size (0 = byte, 1 = short, 2 = long) */ 893 16, /* bitsize */ 894 FALSE, /* pc_relative */ 895 0, /* bitpos */ 896 complain_overflow_dont, /* complain_on_overflow */ 897 ppc_elf_unhandled_reloc, /* special_function */ 898 "R_PPC_TPREL16_LO", /* name */ 899 FALSE, /* partial_inplace */ 900 0, /* src_mask */ 901 0xffff, /* dst_mask */ 902 FALSE), /* pcrel_offset */ 903 904 /* Like TPREL16_LO, but next higher group of 16 bits. */ 905 HOWTO (R_PPC_TPREL16_HI, 906 16, /* rightshift */ 907 1, /* size (0 = byte, 1 = short, 2 = long) */ 908 16, /* bitsize */ 909 FALSE, /* pc_relative */ 910 0, /* bitpos */ 911 complain_overflow_dont, /* complain_on_overflow */ 912 ppc_elf_unhandled_reloc, /* special_function */ 913 "R_PPC_TPREL16_HI", /* name */ 914 FALSE, /* partial_inplace */ 915 0, /* src_mask */ 916 0xffff, /* dst_mask */ 917 FALSE), /* pcrel_offset */ 918 919 /* Like TPREL16_HI, but adjust for low 16 bits. */ 920 HOWTO (R_PPC_TPREL16_HA, 921 16, /* rightshift */ 922 1, /* size (0 = byte, 1 = short, 2 = long) */ 923 16, /* bitsize */ 924 FALSE, /* pc_relative */ 925 0, /* bitpos */ 926 complain_overflow_dont, /* complain_on_overflow */ 927 ppc_elf_unhandled_reloc, /* special_function */ 928 "R_PPC_TPREL16_HA", /* name */ 929 FALSE, /* partial_inplace */ 930 0, /* src_mask */ 931 0xffff, /* dst_mask */ 932 FALSE), /* pcrel_offset */ 933 934 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 935 with values (sym+add)@dtpmod and (sym+add)@dtprel, and computes the offset 936 to the first entry. */ 937 HOWTO (R_PPC_GOT_TLSGD16, 938 0, /* rightshift */ 939 1, /* size (0 = byte, 1 = short, 2 = long) */ 940 16, /* bitsize */ 941 FALSE, /* pc_relative */ 942 0, /* bitpos */ 943 complain_overflow_signed, /* complain_on_overflow */ 944 ppc_elf_unhandled_reloc, /* special_function */ 945 "R_PPC_GOT_TLSGD16", /* name */ 946 FALSE, /* partial_inplace */ 947 0, /* src_mask */ 948 0xffff, /* dst_mask */ 949 FALSE), /* pcrel_offset */ 950 951 /* Like GOT_TLSGD16, but no overflow. */ 952 HOWTO (R_PPC_GOT_TLSGD16_LO, 953 0, /* rightshift */ 954 1, /* size (0 = byte, 1 = short, 2 = long) */ 955 16, /* bitsize */ 956 FALSE, /* pc_relative */ 957 0, /* bitpos */ 958 complain_overflow_dont, /* complain_on_overflow */ 959 ppc_elf_unhandled_reloc, /* special_function */ 960 "R_PPC_GOT_TLSGD16_LO", /* name */ 961 FALSE, /* partial_inplace */ 962 0, /* src_mask */ 963 0xffff, /* dst_mask */ 964 FALSE), /* pcrel_offset */ 965 966 /* Like GOT_TLSGD16_LO, but next higher group of 16 bits. */ 967 HOWTO (R_PPC_GOT_TLSGD16_HI, 968 16, /* rightshift */ 969 1, /* size (0 = byte, 1 = short, 2 = long) */ 970 16, /* bitsize */ 971 FALSE, /* pc_relative */ 972 0, /* bitpos */ 973 complain_overflow_dont, /* complain_on_overflow */ 974 ppc_elf_unhandled_reloc, /* special_function */ 975 "R_PPC_GOT_TLSGD16_HI", /* name */ 976 FALSE, /* partial_inplace */ 977 0, /* src_mask */ 978 0xffff, /* dst_mask */ 979 FALSE), /* pcrel_offset */ 980 981 /* Like GOT_TLSGD16_HI, but adjust for low 16 bits. */ 982 HOWTO (R_PPC_GOT_TLSGD16_HA, 983 16, /* rightshift */ 984 1, /* size (0 = byte, 1 = short, 2 = long) */ 985 16, /* bitsize */ 986 FALSE, /* pc_relative */ 987 0, /* bitpos */ 988 complain_overflow_dont, /* complain_on_overflow */ 989 ppc_elf_unhandled_reloc, /* special_function */ 990 "R_PPC_GOT_TLSGD16_HA", /* name */ 991 FALSE, /* partial_inplace */ 992 0, /* src_mask */ 993 0xffff, /* dst_mask */ 994 FALSE), /* pcrel_offset */ 995 996 /* Allocates two contiguous entries in the GOT to hold a tls_index structure, 997 with values (sym+add)@dtpmod and zero, and computes the offset to the 998 first entry. */ 999 HOWTO (R_PPC_GOT_TLSLD16, 1000 0, /* rightshift */ 1001 1, /* size (0 = byte, 1 = short, 2 = long) */ 1002 16, /* bitsize */ 1003 FALSE, /* pc_relative */ 1004 0, /* bitpos */ 1005 complain_overflow_signed, /* complain_on_overflow */ 1006 ppc_elf_unhandled_reloc, /* special_function */ 1007 "R_PPC_GOT_TLSLD16", /* name */ 1008 FALSE, /* partial_inplace */ 1009 0, /* src_mask */ 1010 0xffff, /* dst_mask */ 1011 FALSE), /* pcrel_offset */ 1012 1013 /* Like GOT_TLSLD16, but no overflow. */ 1014 HOWTO (R_PPC_GOT_TLSLD16_LO, 1015 0, /* rightshift */ 1016 1, /* size (0 = byte, 1 = short, 2 = long) */ 1017 16, /* bitsize */ 1018 FALSE, /* pc_relative */ 1019 0, /* bitpos */ 1020 complain_overflow_dont, /* complain_on_overflow */ 1021 ppc_elf_unhandled_reloc, /* special_function */ 1022 "R_PPC_GOT_TLSLD16_LO", /* name */ 1023 FALSE, /* partial_inplace */ 1024 0, /* src_mask */ 1025 0xffff, /* dst_mask */ 1026 FALSE), /* pcrel_offset */ 1027 1028 /* Like GOT_TLSLD16_LO, but next higher group of 16 bits. */ 1029 HOWTO (R_PPC_GOT_TLSLD16_HI, 1030 16, /* rightshift */ 1031 1, /* size (0 = byte, 1 = short, 2 = long) */ 1032 16, /* bitsize */ 1033 FALSE, /* pc_relative */ 1034 0, /* bitpos */ 1035 complain_overflow_dont, /* complain_on_overflow */ 1036 ppc_elf_unhandled_reloc, /* special_function */ 1037 "R_PPC_GOT_TLSLD16_HI", /* name */ 1038 FALSE, /* partial_inplace */ 1039 0, /* src_mask */ 1040 0xffff, /* dst_mask */ 1041 FALSE), /* pcrel_offset */ 1042 1043 /* Like GOT_TLSLD16_HI, but adjust for low 16 bits. */ 1044 HOWTO (R_PPC_GOT_TLSLD16_HA, 1045 16, /* rightshift */ 1046 1, /* size (0 = byte, 1 = short, 2 = long) */ 1047 16, /* bitsize */ 1048 FALSE, /* pc_relative */ 1049 0, /* bitpos */ 1050 complain_overflow_dont, /* complain_on_overflow */ 1051 ppc_elf_unhandled_reloc, /* special_function */ 1052 "R_PPC_GOT_TLSLD16_HA", /* name */ 1053 FALSE, /* partial_inplace */ 1054 0, /* src_mask */ 1055 0xffff, /* dst_mask */ 1056 FALSE), /* pcrel_offset */ 1057 1058 /* Allocates an entry in the GOT with value (sym+add)@dtprel, and computes 1059 the offset to the entry. */ 1060 HOWTO (R_PPC_GOT_DTPREL16, 1061 0, /* rightshift */ 1062 1, /* size (0 = byte, 1 = short, 2 = long) */ 1063 16, /* bitsize */ 1064 FALSE, /* pc_relative */ 1065 0, /* bitpos */ 1066 complain_overflow_signed, /* complain_on_overflow */ 1067 ppc_elf_unhandled_reloc, /* special_function */ 1068 "R_PPC_GOT_DTPREL16", /* name */ 1069 FALSE, /* partial_inplace */ 1070 0, /* src_mask */ 1071 0xffff, /* dst_mask */ 1072 FALSE), /* pcrel_offset */ 1073 1074 /* Like GOT_DTPREL16, but no overflow. */ 1075 HOWTO (R_PPC_GOT_DTPREL16_LO, 1076 0, /* rightshift */ 1077 1, /* size (0 = byte, 1 = short, 2 = long) */ 1078 16, /* bitsize */ 1079 FALSE, /* pc_relative */ 1080 0, /* bitpos */ 1081 complain_overflow_dont, /* complain_on_overflow */ 1082 ppc_elf_unhandled_reloc, /* special_function */ 1083 "R_PPC_GOT_DTPREL16_LO", /* name */ 1084 FALSE, /* partial_inplace */ 1085 0, /* src_mask */ 1086 0xffff, /* dst_mask */ 1087 FALSE), /* pcrel_offset */ 1088 1089 /* Like GOT_DTPREL16_LO, but next higher group of 16 bits. */ 1090 HOWTO (R_PPC_GOT_DTPREL16_HI, 1091 16, /* rightshift */ 1092 1, /* size (0 = byte, 1 = short, 2 = long) */ 1093 16, /* bitsize */ 1094 FALSE, /* pc_relative */ 1095 0, /* bitpos */ 1096 complain_overflow_dont, /* complain_on_overflow */ 1097 ppc_elf_unhandled_reloc, /* special_function */ 1098 "R_PPC_GOT_DTPREL16_HI", /* name */ 1099 FALSE, /* partial_inplace */ 1100 0, /* src_mask */ 1101 0xffff, /* dst_mask */ 1102 FALSE), /* pcrel_offset */ 1103 1104 /* Like GOT_DTPREL16_HI, but adjust for low 16 bits. */ 1105 HOWTO (R_PPC_GOT_DTPREL16_HA, 1106 16, /* rightshift */ 1107 1, /* size (0 = byte, 1 = short, 2 = long) */ 1108 16, /* bitsize */ 1109 FALSE, /* pc_relative */ 1110 0, /* bitpos */ 1111 complain_overflow_dont, /* complain_on_overflow */ 1112 ppc_elf_unhandled_reloc, /* special_function */ 1113 "R_PPC_GOT_DTPREL16_HA", /* name */ 1114 FALSE, /* partial_inplace */ 1115 0, /* src_mask */ 1116 0xffff, /* dst_mask */ 1117 FALSE), /* pcrel_offset */ 1118 1119 /* Allocates an entry in the GOT with value (sym+add)@tprel, and computes the 1120 offset to the entry. */ 1121 HOWTO (R_PPC_GOT_TPREL16, 1122 0, /* rightshift */ 1123 1, /* size (0 = byte, 1 = short, 2 = long) */ 1124 16, /* bitsize */ 1125 FALSE, /* pc_relative */ 1126 0, /* bitpos */ 1127 complain_overflow_signed, /* complain_on_overflow */ 1128 ppc_elf_unhandled_reloc, /* special_function */ 1129 "R_PPC_GOT_TPREL16", /* name */ 1130 FALSE, /* partial_inplace */ 1131 0, /* src_mask */ 1132 0xffff, /* dst_mask */ 1133 FALSE), /* pcrel_offset */ 1134 1135 /* Like GOT_TPREL16, but no overflow. */ 1136 HOWTO (R_PPC_GOT_TPREL16_LO, 1137 0, /* rightshift */ 1138 1, /* size (0 = byte, 1 = short, 2 = long) */ 1139 16, /* bitsize */ 1140 FALSE, /* pc_relative */ 1141 0, /* bitpos */ 1142 complain_overflow_dont, /* complain_on_overflow */ 1143 ppc_elf_unhandled_reloc, /* special_function */ 1144 "R_PPC_GOT_TPREL16_LO", /* name */ 1145 FALSE, /* partial_inplace */ 1146 0, /* src_mask */ 1147 0xffff, /* dst_mask */ 1148 FALSE), /* pcrel_offset */ 1149 1150 /* Like GOT_TPREL16_LO, but next higher group of 16 bits. */ 1151 HOWTO (R_PPC_GOT_TPREL16_HI, 1152 16, /* rightshift */ 1153 1, /* size (0 = byte, 1 = short, 2 = long) */ 1154 16, /* bitsize */ 1155 FALSE, /* pc_relative */ 1156 0, /* bitpos */ 1157 complain_overflow_dont, /* complain_on_overflow */ 1158 ppc_elf_unhandled_reloc, /* special_function */ 1159 "R_PPC_GOT_TPREL16_HI", /* name */ 1160 FALSE, /* partial_inplace */ 1161 0, /* src_mask */ 1162 0xffff, /* dst_mask */ 1163 FALSE), /* pcrel_offset */ 1164 1165 /* Like GOT_TPREL16_HI, but adjust for low 16 bits. */ 1166 HOWTO (R_PPC_GOT_TPREL16_HA, 1167 16, /* rightshift */ 1168 1, /* size (0 = byte, 1 = short, 2 = long) */ 1169 16, /* bitsize */ 1170 FALSE, /* pc_relative */ 1171 0, /* bitpos */ 1172 complain_overflow_dont, /* complain_on_overflow */ 1173 ppc_elf_unhandled_reloc, /* special_function */ 1174 "R_PPC_GOT_TPREL16_HA", /* name */ 1175 FALSE, /* partial_inplace */ 1176 0, /* src_mask */ 1177 0xffff, /* dst_mask */ 1178 FALSE), /* pcrel_offset */ 1179 1180 /* The remaining relocs are from the Embedded ELF ABI, and are not 1181 in the SVR4 ELF ABI. */ 1182 1183 /* 32 bit value resulting from the addend minus the symbol. */ 1184 HOWTO (R_PPC_EMB_NADDR32, /* type */ 1185 0, /* rightshift */ 1186 2, /* size (0 = byte, 1 = short, 2 = long) */ 1187 32, /* bitsize */ 1188 FALSE, /* pc_relative */ 1189 0, /* bitpos */ 1190 complain_overflow_bitfield, /* complain_on_overflow */ 1191 bfd_elf_generic_reloc, /* special_function */ 1192 "R_PPC_EMB_NADDR32", /* name */ 1193 FALSE, /* partial_inplace */ 1194 0, /* src_mask */ 1195 0xffffffff, /* dst_mask */ 1196 FALSE), /* pcrel_offset */ 1197 1198 /* 16 bit value resulting from the addend minus the symbol. */ 1199 HOWTO (R_PPC_EMB_NADDR16, /* type */ 1200 0, /* rightshift */ 1201 1, /* size (0 = byte, 1 = short, 2 = long) */ 1202 16, /* bitsize */ 1203 FALSE, /* pc_relative */ 1204 0, /* bitpos */ 1205 complain_overflow_bitfield, /* complain_on_overflow */ 1206 bfd_elf_generic_reloc, /* special_function */ 1207 "R_PPC_EMB_NADDR16", /* name */ 1208 FALSE, /* partial_inplace */ 1209 0, /* src_mask */ 1210 0xffff, /* dst_mask */ 1211 FALSE), /* pcrel_offset */ 1212 1213 /* 16 bit value resulting from the addend minus the symbol. */ 1214 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */ 1215 0, /* rightshift */ 1216 1, /* size (0 = byte, 1 = short, 2 = long) */ 1217 16, /* bitsize */ 1218 FALSE, /* pc_relative */ 1219 0, /* bitpos */ 1220 complain_overflow_dont,/* complain_on_overflow */ 1221 bfd_elf_generic_reloc, /* special_function */ 1222 "R_PPC_EMB_ADDR16_LO", /* name */ 1223 FALSE, /* partial_inplace */ 1224 0, /* src_mask */ 1225 0xffff, /* dst_mask */ 1226 FALSE), /* pcrel_offset */ 1227 1228 /* The high order 16 bits of the addend minus the symbol. */ 1229 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */ 1230 16, /* rightshift */ 1231 1, /* size (0 = byte, 1 = short, 2 = long) */ 1232 16, /* bitsize */ 1233 FALSE, /* pc_relative */ 1234 0, /* bitpos */ 1235 complain_overflow_dont, /* complain_on_overflow */ 1236 bfd_elf_generic_reloc, /* special_function */ 1237 "R_PPC_EMB_NADDR16_HI", /* name */ 1238 FALSE, /* partial_inplace */ 1239 0, /* src_mask */ 1240 0xffff, /* dst_mask */ 1241 FALSE), /* pcrel_offset */ 1242 1243 /* The high order 16 bits of the result of the addend minus the address, 1244 plus 1 if the contents of the low 16 bits, treated as a signed number, 1245 is negative. */ 1246 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */ 1247 16, /* rightshift */ 1248 1, /* size (0 = byte, 1 = short, 2 = long) */ 1249 16, /* bitsize */ 1250 FALSE, /* pc_relative */ 1251 0, /* bitpos */ 1252 complain_overflow_dont, /* complain_on_overflow */ 1253 ppc_elf_addr16_ha_reloc, /* special_function */ 1254 "R_PPC_EMB_NADDR16_HA", /* name */ 1255 FALSE, /* partial_inplace */ 1256 0, /* src_mask */ 1257 0xffff, /* dst_mask */ 1258 FALSE), /* pcrel_offset */ 1259 1260 /* 16 bit value resulting from allocating a 4 byte word to hold an 1261 address in the .sdata section, and returning the offset from 1262 _SDA_BASE_ for that relocation. */ 1263 HOWTO (R_PPC_EMB_SDAI16, /* type */ 1264 0, /* rightshift */ 1265 1, /* size (0 = byte, 1 = short, 2 = long) */ 1266 16, /* bitsize */ 1267 FALSE, /* pc_relative */ 1268 0, /* bitpos */ 1269 complain_overflow_bitfield, /* complain_on_overflow */ 1270 bfd_elf_generic_reloc, /* special_function */ 1271 "R_PPC_EMB_SDAI16", /* name */ 1272 FALSE, /* partial_inplace */ 1273 0, /* src_mask */ 1274 0xffff, /* dst_mask */ 1275 FALSE), /* pcrel_offset */ 1276 1277 /* 16 bit value resulting from allocating a 4 byte word to hold an 1278 address in the .sdata2 section, and returning the offset from 1279 _SDA2_BASE_ for that relocation. */ 1280 HOWTO (R_PPC_EMB_SDA2I16, /* type */ 1281 0, /* rightshift */ 1282 1, /* size (0 = byte, 1 = short, 2 = long) */ 1283 16, /* bitsize */ 1284 FALSE, /* pc_relative */ 1285 0, /* bitpos */ 1286 complain_overflow_bitfield, /* complain_on_overflow */ 1287 bfd_elf_generic_reloc, /* special_function */ 1288 "R_PPC_EMB_SDA2I16", /* name */ 1289 FALSE, /* partial_inplace */ 1290 0, /* src_mask */ 1291 0xffff, /* dst_mask */ 1292 FALSE), /* pcrel_offset */ 1293 1294 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with 1295 small data items. */ 1296 HOWTO (R_PPC_EMB_SDA2REL, /* type */ 1297 0, /* rightshift */ 1298 1, /* size (0 = byte, 1 = short, 2 = long) */ 1299 16, /* bitsize */ 1300 FALSE, /* pc_relative */ 1301 0, /* bitpos */ 1302 complain_overflow_signed, /* complain_on_overflow */ 1303 bfd_elf_generic_reloc, /* special_function */ 1304 "R_PPC_EMB_SDA2REL", /* name */ 1305 FALSE, /* partial_inplace */ 1306 0, /* src_mask */ 1307 0xffff, /* dst_mask */ 1308 FALSE), /* pcrel_offset */ 1309 1310 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit 1311 signed offset from the appropriate base, and filling in the register 1312 field with the appropriate register (0, 2, or 13). */ 1313 HOWTO (R_PPC_EMB_SDA21, /* type */ 1314 0, /* rightshift */ 1315 2, /* size (0 = byte, 1 = short, 2 = long) */ 1316 16, /* bitsize */ 1317 FALSE, /* pc_relative */ 1318 0, /* bitpos */ 1319 complain_overflow_signed, /* complain_on_overflow */ 1320 bfd_elf_generic_reloc, /* special_function */ 1321 "R_PPC_EMB_SDA21", /* name */ 1322 FALSE, /* partial_inplace */ 1323 0, /* src_mask */ 1324 0xffff, /* dst_mask */ 1325 FALSE), /* pcrel_offset */ 1326 1327 /* Relocation not handled: R_PPC_EMB_MRKREF */ 1328 /* Relocation not handled: R_PPC_EMB_RELSEC16 */ 1329 /* Relocation not handled: R_PPC_EMB_RELST_LO */ 1330 /* Relocation not handled: R_PPC_EMB_RELST_HI */ 1331 /* Relocation not handled: R_PPC_EMB_RELST_HA */ 1332 /* Relocation not handled: R_PPC_EMB_BIT_FLD */ 1333 1334 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling 1335 in the 16 bit signed offset from the appropriate base, and filling in the 1336 register field with the appropriate register (0, 2, or 13). */ 1337 HOWTO (R_PPC_EMB_RELSDA, /* type */ 1338 0, /* rightshift */ 1339 1, /* size (0 = byte, 1 = short, 2 = long) */ 1340 16, /* bitsize */ 1341 TRUE, /* pc_relative */ 1342 0, /* bitpos */ 1343 complain_overflow_signed, /* complain_on_overflow */ 1344 bfd_elf_generic_reloc, /* special_function */ 1345 "R_PPC_EMB_RELSDA", /* name */ 1346 FALSE, /* partial_inplace */ 1347 0, /* src_mask */ 1348 0xffff, /* dst_mask */ 1349 FALSE), /* pcrel_offset */ 1350 1351 /* A 16 bit relative relocation. */ 1352 HOWTO (R_PPC_REL16, /* type */ 1353 0, /* rightshift */ 1354 1, /* size (0 = byte, 1 = short, 2 = long) */ 1355 16, /* bitsize */ 1356 TRUE, /* pc_relative */ 1357 0, /* bitpos */ 1358 complain_overflow_bitfield, /* complain_on_overflow */ 1359 bfd_elf_generic_reloc, /* special_function */ 1360 "R_PPC_REL16", /* name */ 1361 FALSE, /* partial_inplace */ 1362 0, /* src_mask */ 1363 0xffff, /* dst_mask */ 1364 TRUE), /* pcrel_offset */ 1365 1366 /* A 16 bit relative relocation without overflow. */ 1367 HOWTO (R_PPC_REL16_LO, /* type */ 1368 0, /* rightshift */ 1369 1, /* size (0 = byte, 1 = short, 2 = long) */ 1370 16, /* bitsize */ 1371 TRUE, /* pc_relative */ 1372 0, /* bitpos */ 1373 complain_overflow_dont,/* complain_on_overflow */ 1374 bfd_elf_generic_reloc, /* special_function */ 1375 "R_PPC_REL16_LO", /* name */ 1376 FALSE, /* partial_inplace */ 1377 0, /* src_mask */ 1378 0xffff, /* dst_mask */ 1379 TRUE), /* pcrel_offset */ 1380 1381 /* The high order 16 bits of a relative address. */ 1382 HOWTO (R_PPC_REL16_HI, /* type */ 1383 16, /* rightshift */ 1384 1, /* size (0 = byte, 1 = short, 2 = long) */ 1385 16, /* bitsize */ 1386 TRUE, /* pc_relative */ 1387 0, /* bitpos */ 1388 complain_overflow_dont, /* complain_on_overflow */ 1389 bfd_elf_generic_reloc, /* special_function */ 1390 "R_PPC_REL16_HI", /* name */ 1391 FALSE, /* partial_inplace */ 1392 0, /* src_mask */ 1393 0xffff, /* dst_mask */ 1394 TRUE), /* pcrel_offset */ 1395 1396 /* The high order 16 bits of a relative address, plus 1 if the contents of 1397 the low 16 bits, treated as a signed number, is negative. */ 1398 HOWTO (R_PPC_REL16_HA, /* type */ 1399 16, /* rightshift */ 1400 1, /* size (0 = byte, 1 = short, 2 = long) */ 1401 16, /* bitsize */ 1402 TRUE, /* pc_relative */ 1403 0, /* bitpos */ 1404 complain_overflow_dont, /* complain_on_overflow */ 1405 ppc_elf_addr16_ha_reloc, /* special_function */ 1406 "R_PPC_REL16_HA", /* name */ 1407 FALSE, /* partial_inplace */ 1408 0, /* src_mask */ 1409 0xffff, /* dst_mask */ 1410 TRUE), /* pcrel_offset */ 1411 1412 /* GNU extension to record C++ vtable hierarchy. */ 1413 HOWTO (R_PPC_GNU_VTINHERIT, /* type */ 1414 0, /* rightshift */ 1415 0, /* size (0 = byte, 1 = short, 2 = long) */ 1416 0, /* bitsize */ 1417 FALSE, /* pc_relative */ 1418 0, /* bitpos */ 1419 complain_overflow_dont, /* complain_on_overflow */ 1420 NULL, /* special_function */ 1421 "R_PPC_GNU_VTINHERIT", /* name */ 1422 FALSE, /* partial_inplace */ 1423 0, /* src_mask */ 1424 0, /* dst_mask */ 1425 FALSE), /* pcrel_offset */ 1426 1427 /* GNU extension to record C++ vtable member usage. */ 1428 HOWTO (R_PPC_GNU_VTENTRY, /* type */ 1429 0, /* rightshift */ 1430 0, /* size (0 = byte, 1 = short, 2 = long) */ 1431 0, /* bitsize */ 1432 FALSE, /* pc_relative */ 1433 0, /* bitpos */ 1434 complain_overflow_dont, /* complain_on_overflow */ 1435 NULL, /* special_function */ 1436 "R_PPC_GNU_VTENTRY", /* name */ 1437 FALSE, /* partial_inplace */ 1438 0, /* src_mask */ 1439 0, /* dst_mask */ 1440 FALSE), /* pcrel_offset */ 1441 1442 /* Phony reloc to handle AIX style TOC entries. */ 1443 HOWTO (R_PPC_TOC16, /* type */ 1444 0, /* rightshift */ 1445 1, /* size (0 = byte, 1 = short, 2 = long) */ 1446 16, /* bitsize */ 1447 FALSE, /* pc_relative */ 1448 0, /* bitpos */ 1449 complain_overflow_signed, /* complain_on_overflow */ 1450 bfd_elf_generic_reloc, /* special_function */ 1451 "R_PPC_TOC16", /* name */ 1452 FALSE, /* partial_inplace */ 1453 0, /* src_mask */ 1454 0xffff, /* dst_mask */ 1455 FALSE), /* pcrel_offset */ 1456}; 1457 1458/* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */ 1459 1460static void 1461ppc_elf_howto_init (void) 1462{ 1463 unsigned int i, type; 1464 1465 for (i = 0; 1466 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); 1467 i++) 1468 { 1469 type = ppc_elf_howto_raw[i].type; 1470 if (type >= (sizeof (ppc_elf_howto_table) 1471 / sizeof (ppc_elf_howto_table[0]))) 1472 abort (); 1473 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i]; 1474 } 1475} 1476 1477static reloc_howto_type * 1478ppc_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1479 bfd_reloc_code_real_type code) 1480{ 1481 enum elf_ppc_reloc_type r; 1482 1483 /* Initialize howto table if not already done. */ 1484 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 1485 ppc_elf_howto_init (); 1486 1487 switch (code) 1488 { 1489 default: 1490 return NULL; 1491 1492 case BFD_RELOC_NONE: r = R_PPC_NONE; break; 1493 case BFD_RELOC_32: r = R_PPC_ADDR32; break; 1494 case BFD_RELOC_PPC_BA26: r = R_PPC_ADDR24; break; 1495 case BFD_RELOC_16: r = R_PPC_ADDR16; break; 1496 case BFD_RELOC_LO16: r = R_PPC_ADDR16_LO; break; 1497 case BFD_RELOC_HI16: r = R_PPC_ADDR16_HI; break; 1498 case BFD_RELOC_HI16_S: r = R_PPC_ADDR16_HA; break; 1499 case BFD_RELOC_PPC_BA16: r = R_PPC_ADDR14; break; 1500 case BFD_RELOC_PPC_BA16_BRTAKEN: r = R_PPC_ADDR14_BRTAKEN; break; 1501 case BFD_RELOC_PPC_BA16_BRNTAKEN: r = R_PPC_ADDR14_BRNTAKEN; break; 1502 case BFD_RELOC_PPC_B26: r = R_PPC_REL24; break; 1503 case BFD_RELOC_PPC_B16: r = R_PPC_REL14; break; 1504 case BFD_RELOC_PPC_B16_BRTAKEN: r = R_PPC_REL14_BRTAKEN; break; 1505 case BFD_RELOC_PPC_B16_BRNTAKEN: r = R_PPC_REL14_BRNTAKEN; break; 1506 case BFD_RELOC_16_GOTOFF: r = R_PPC_GOT16; break; 1507 case BFD_RELOC_LO16_GOTOFF: r = R_PPC_GOT16_LO; break; 1508 case BFD_RELOC_HI16_GOTOFF: r = R_PPC_GOT16_HI; break; 1509 case BFD_RELOC_HI16_S_GOTOFF: r = R_PPC_GOT16_HA; break; 1510 case BFD_RELOC_24_PLT_PCREL: r = R_PPC_PLTREL24; break; 1511 case BFD_RELOC_PPC_COPY: r = R_PPC_COPY; break; 1512 case BFD_RELOC_PPC_GLOB_DAT: r = R_PPC_GLOB_DAT; break; 1513 case BFD_RELOC_PPC_LOCAL24PC: r = R_PPC_LOCAL24PC; break; 1514 case BFD_RELOC_32_PCREL: r = R_PPC_REL32; break; 1515 case BFD_RELOC_32_PLTOFF: r = R_PPC_PLT32; break; 1516 case BFD_RELOC_32_PLT_PCREL: r = R_PPC_PLTREL32; break; 1517 case BFD_RELOC_LO16_PLTOFF: r = R_PPC_PLT16_LO; break; 1518 case BFD_RELOC_HI16_PLTOFF: r = R_PPC_PLT16_HI; break; 1519 case BFD_RELOC_HI16_S_PLTOFF: r = R_PPC_PLT16_HA; break; 1520 case BFD_RELOC_GPREL16: r = R_PPC_SDAREL16; break; 1521 case BFD_RELOC_16_BASEREL: r = R_PPC_SECTOFF; break; 1522 case BFD_RELOC_LO16_BASEREL: r = R_PPC_SECTOFF_LO; break; 1523 case BFD_RELOC_HI16_BASEREL: r = R_PPC_SECTOFF_HI; break; 1524 case BFD_RELOC_HI16_S_BASEREL: r = R_PPC_SECTOFF_HA; break; 1525 case BFD_RELOC_CTOR: r = R_PPC_ADDR32; break; 1526 case BFD_RELOC_PPC_TOC16: r = R_PPC_TOC16; break; 1527 case BFD_RELOC_PPC_TLS: r = R_PPC_TLS; break; 1528 case BFD_RELOC_PPC_DTPMOD: r = R_PPC_DTPMOD32; break; 1529 case BFD_RELOC_PPC_TPREL16: r = R_PPC_TPREL16; break; 1530 case BFD_RELOC_PPC_TPREL16_LO: r = R_PPC_TPREL16_LO; break; 1531 case BFD_RELOC_PPC_TPREL16_HI: r = R_PPC_TPREL16_HI; break; 1532 case BFD_RELOC_PPC_TPREL16_HA: r = R_PPC_TPREL16_HA; break; 1533 case BFD_RELOC_PPC_TPREL: r = R_PPC_TPREL32; break; 1534 case BFD_RELOC_PPC_DTPREL16: r = R_PPC_DTPREL16; break; 1535 case BFD_RELOC_PPC_DTPREL16_LO: r = R_PPC_DTPREL16_LO; break; 1536 case BFD_RELOC_PPC_DTPREL16_HI: r = R_PPC_DTPREL16_HI; break; 1537 case BFD_RELOC_PPC_DTPREL16_HA: r = R_PPC_DTPREL16_HA; break; 1538 case BFD_RELOC_PPC_DTPREL: r = R_PPC_DTPREL32; break; 1539 case BFD_RELOC_PPC_GOT_TLSGD16: r = R_PPC_GOT_TLSGD16; break; 1540 case BFD_RELOC_PPC_GOT_TLSGD16_LO: r = R_PPC_GOT_TLSGD16_LO; break; 1541 case BFD_RELOC_PPC_GOT_TLSGD16_HI: r = R_PPC_GOT_TLSGD16_HI; break; 1542 case BFD_RELOC_PPC_GOT_TLSGD16_HA: r = R_PPC_GOT_TLSGD16_HA; break; 1543 case BFD_RELOC_PPC_GOT_TLSLD16: r = R_PPC_GOT_TLSLD16; break; 1544 case BFD_RELOC_PPC_GOT_TLSLD16_LO: r = R_PPC_GOT_TLSLD16_LO; break; 1545 case BFD_RELOC_PPC_GOT_TLSLD16_HI: r = R_PPC_GOT_TLSLD16_HI; break; 1546 case BFD_RELOC_PPC_GOT_TLSLD16_HA: r = R_PPC_GOT_TLSLD16_HA; break; 1547 case BFD_RELOC_PPC_GOT_TPREL16: r = R_PPC_GOT_TPREL16; break; 1548 case BFD_RELOC_PPC_GOT_TPREL16_LO: r = R_PPC_GOT_TPREL16_LO; break; 1549 case BFD_RELOC_PPC_GOT_TPREL16_HI: r = R_PPC_GOT_TPREL16_HI; break; 1550 case BFD_RELOC_PPC_GOT_TPREL16_HA: r = R_PPC_GOT_TPREL16_HA; break; 1551 case BFD_RELOC_PPC_GOT_DTPREL16: r = R_PPC_GOT_DTPREL16; break; 1552 case BFD_RELOC_PPC_GOT_DTPREL16_LO: r = R_PPC_GOT_DTPREL16_LO; break; 1553 case BFD_RELOC_PPC_GOT_DTPREL16_HI: r = R_PPC_GOT_DTPREL16_HI; break; 1554 case BFD_RELOC_PPC_GOT_DTPREL16_HA: r = R_PPC_GOT_DTPREL16_HA; break; 1555 case BFD_RELOC_PPC_EMB_NADDR32: r = R_PPC_EMB_NADDR32; break; 1556 case BFD_RELOC_PPC_EMB_NADDR16: r = R_PPC_EMB_NADDR16; break; 1557 case BFD_RELOC_PPC_EMB_NADDR16_LO: r = R_PPC_EMB_NADDR16_LO; break; 1558 case BFD_RELOC_PPC_EMB_NADDR16_HI: r = R_PPC_EMB_NADDR16_HI; break; 1559 case BFD_RELOC_PPC_EMB_NADDR16_HA: r = R_PPC_EMB_NADDR16_HA; break; 1560 case BFD_RELOC_PPC_EMB_SDAI16: r = R_PPC_EMB_SDAI16; break; 1561 case BFD_RELOC_PPC_EMB_SDA2I16: r = R_PPC_EMB_SDA2I16; break; 1562 case BFD_RELOC_PPC_EMB_SDA2REL: r = R_PPC_EMB_SDA2REL; break; 1563 case BFD_RELOC_PPC_EMB_SDA21: r = R_PPC_EMB_SDA21; break; 1564 case BFD_RELOC_PPC_EMB_MRKREF: r = R_PPC_EMB_MRKREF; break; 1565 case BFD_RELOC_PPC_EMB_RELSEC16: r = R_PPC_EMB_RELSEC16; break; 1566 case BFD_RELOC_PPC_EMB_RELST_LO: r = R_PPC_EMB_RELST_LO; break; 1567 case BFD_RELOC_PPC_EMB_RELST_HI: r = R_PPC_EMB_RELST_HI; break; 1568 case BFD_RELOC_PPC_EMB_RELST_HA: r = R_PPC_EMB_RELST_HA; break; 1569 case BFD_RELOC_PPC_EMB_BIT_FLD: r = R_PPC_EMB_BIT_FLD; break; 1570 case BFD_RELOC_PPC_EMB_RELSDA: r = R_PPC_EMB_RELSDA; break; 1571 case BFD_RELOC_16_PCREL: r = R_PPC_REL16; break; 1572 case BFD_RELOC_LO16_PCREL: r = R_PPC_REL16_LO; break; 1573 case BFD_RELOC_HI16_PCREL: r = R_PPC_REL16_HI; break; 1574 case BFD_RELOC_HI16_S_PCREL: r = R_PPC_REL16_HA; break; 1575 case BFD_RELOC_VTABLE_INHERIT: r = R_PPC_GNU_VTINHERIT; break; 1576 case BFD_RELOC_VTABLE_ENTRY: r = R_PPC_GNU_VTENTRY; break; 1577 } 1578 1579 return ppc_elf_howto_table[r]; 1580}; 1581 1582static reloc_howto_type * 1583ppc_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1584 const char *r_name) 1585{ 1586 unsigned int i; 1587 1588 for (i = 0; 1589 i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); 1590 i++) 1591 if (ppc_elf_howto_raw[i].name != NULL 1592 && strcasecmp (ppc_elf_howto_raw[i].name, r_name) == 0) 1593 return &ppc_elf_howto_raw[i]; 1594 1595 return NULL; 1596} 1597 1598/* Set the howto pointer for a PowerPC ELF reloc. */ 1599 1600static void 1601ppc_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 1602 arelent *cache_ptr, 1603 Elf_Internal_Rela *dst) 1604{ 1605 /* Initialize howto table if not already done. */ 1606 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 1607 ppc_elf_howto_init (); 1608 1609 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max); 1610 cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)]; 1611 1612 /* Just because the above assert didn't trigger doesn't mean that 1613 ELF32_R_TYPE (dst->r_info) is necessarily a valid relocation. */ 1614 if (!cache_ptr->howto) 1615 { 1616 (*_bfd_error_handler) (_("%B: invalid relocation type %d"), 1617 abfd, ELF32_R_TYPE (dst->r_info)); 1618 bfd_set_error (bfd_error_bad_value); 1619 1620 cache_ptr->howto = ppc_elf_howto_table[R_PPC_NONE]; 1621 } 1622} 1623 1624/* Handle the R_PPC_ADDR16_HA and R_PPC_REL16_HA relocs. */ 1625 1626static bfd_reloc_status_type 1627ppc_elf_addr16_ha_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1628 arelent *reloc_entry, 1629 asymbol *symbol, 1630 void *data ATTRIBUTE_UNUSED, 1631 asection *input_section, 1632 bfd *output_bfd, 1633 char **error_message ATTRIBUTE_UNUSED) 1634{ 1635 bfd_vma relocation; 1636 1637 if (output_bfd != NULL) 1638 { 1639 reloc_entry->address += input_section->output_offset; 1640 return bfd_reloc_ok; 1641 } 1642 1643 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 1644 return bfd_reloc_outofrange; 1645 1646 if (bfd_is_com_section (symbol->section)) 1647 relocation = 0; 1648 else 1649 relocation = symbol->value; 1650 1651 relocation += symbol->section->output_section->vma; 1652 relocation += symbol->section->output_offset; 1653 relocation += reloc_entry->addend; 1654 if (reloc_entry->howto->pc_relative) 1655 relocation -= reloc_entry->address; 1656 1657 reloc_entry->addend += (relocation & 0x8000) << 1; 1658 1659 return bfd_reloc_continue; 1660} 1661 1662static bfd_reloc_status_type 1663ppc_elf_unhandled_reloc (bfd *abfd, 1664 arelent *reloc_entry, 1665 asymbol *symbol, 1666 void *data, 1667 asection *input_section, 1668 bfd *output_bfd, 1669 char **error_message) 1670{ 1671 /* If this is a relocatable link (output_bfd test tells us), just 1672 call the generic function. Any adjustment will be done at final 1673 link time. */ 1674 if (output_bfd != NULL) 1675 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 1676 input_section, output_bfd, error_message); 1677 1678 if (error_message != NULL) 1679 { 1680 static char buf[60]; 1681 sprintf (buf, _("generic linker can't handle %s"), 1682 reloc_entry->howto->name); 1683 *error_message = buf; 1684 } 1685 return bfd_reloc_dangerous; 1686} 1687 1688/* Sections created by the linker. */ 1689 1690typedef struct elf_linker_section 1691{ 1692 /* Pointer to the bfd section. */ 1693 asection *section; 1694 /* Section name. */ 1695 const char *name; 1696 /* Associated bss section name. */ 1697 const char *bss_name; 1698 /* Associated symbol name. */ 1699 const char *sym_name; 1700 /* Associated symbol. */ 1701 struct elf_link_hash_entry *sym; 1702} elf_linker_section_t; 1703 1704/* Linked list of allocated pointer entries. This hangs off of the 1705 symbol lists, and provides allows us to return different pointers, 1706 based on different addend's. */ 1707 1708typedef struct elf_linker_section_pointers 1709{ 1710 /* next allocated pointer for this symbol */ 1711 struct elf_linker_section_pointers *next; 1712 /* offset of pointer from beginning of section */ 1713 bfd_vma offset; 1714 /* addend used */ 1715 bfd_vma addend; 1716 /* which linker section this is */ 1717 elf_linker_section_t *lsect; 1718} elf_linker_section_pointers_t; 1719 1720struct ppc_elf_obj_tdata 1721{ 1722 struct elf_obj_tdata elf; 1723 1724 /* A mapping from local symbols to offsets into the various linker 1725 sections added. This is index by the symbol index. */ 1726 elf_linker_section_pointers_t **linker_section_pointers; 1727 1728 /* Flags used to auto-detect plt type. */ 1729 unsigned int makes_plt_call : 1; 1730 unsigned int has_rel16 : 1; 1731}; 1732 1733#define ppc_elf_tdata(bfd) \ 1734 ((struct ppc_elf_obj_tdata *) (bfd)->tdata.any) 1735 1736#define elf_local_ptr_offsets(bfd) \ 1737 (ppc_elf_tdata (bfd)->linker_section_pointers) 1738 1739/* Override the generic function because we store some extras. */ 1740 1741static bfd_boolean 1742ppc_elf_mkobject (bfd *abfd) 1743{ 1744 if (abfd->tdata.any == NULL) 1745 { 1746 bfd_size_type amt = sizeof (struct ppc_elf_obj_tdata); 1747 abfd->tdata.any = bfd_zalloc (abfd, amt); 1748 if (abfd->tdata.any == NULL) 1749 return FALSE; 1750 } 1751 return bfd_elf_mkobject (abfd); 1752} 1753 1754/* Fix bad default arch selected for a 32 bit input bfd when the 1755 default is 64 bit. */ 1756 1757static bfd_boolean 1758ppc_elf_object_p (bfd *abfd) 1759{ 1760 if (abfd->arch_info->the_default && abfd->arch_info->bits_per_word == 64) 1761 { 1762 Elf_Internal_Ehdr *i_ehdr = elf_elfheader (abfd); 1763 1764 if (i_ehdr->e_ident[EI_CLASS] == ELFCLASS32) 1765 { 1766 /* Relies on arch after 64 bit default being 32 bit default. */ 1767 abfd->arch_info = abfd->arch_info->next; 1768 BFD_ASSERT (abfd->arch_info->bits_per_word == 32); 1769 } 1770 } 1771 return TRUE; 1772} 1773 1774/* Function to set whether a module needs the -mrelocatable bit set. */ 1775 1776static bfd_boolean 1777ppc_elf_set_private_flags (bfd *abfd, flagword flags) 1778{ 1779 BFD_ASSERT (!elf_flags_init (abfd) 1780 || elf_elfheader (abfd)->e_flags == flags); 1781 1782 elf_elfheader (abfd)->e_flags = flags; 1783 elf_flags_init (abfd) = TRUE; 1784 return TRUE; 1785} 1786 1787/* Support for core dump NOTE sections. */ 1788 1789static bfd_boolean 1790ppc_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 1791{ 1792 int offset; 1793 unsigned int size; 1794 1795 switch (note->descsz) 1796 { 1797 default: 1798 return FALSE; 1799 1800 case 268: /* Linux/PPC. */ 1801 /* pr_cursig */ 1802 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 1803 1804 /* pr_pid */ 1805 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); 1806 1807 /* pr_reg */ 1808 offset = 72; 1809 size = 192; 1810 1811 break; 1812 } 1813 1814 /* Make a ".reg/999" section. */ 1815 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 1816 size, note->descpos + offset); 1817} 1818 1819static bfd_boolean 1820ppc_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 1821{ 1822 switch (note->descsz) 1823 { 1824 default: 1825 return FALSE; 1826 1827 case 128: /* Linux/PPC elf_prpsinfo. */ 1828 elf_tdata (abfd)->core_program 1829 = _bfd_elfcore_strndup (abfd, note->descdata + 32, 16); 1830 elf_tdata (abfd)->core_command 1831 = _bfd_elfcore_strndup (abfd, note->descdata + 48, 80); 1832 } 1833 1834 /* Note that for some reason, a spurious space is tacked 1835 onto the end of the args in some (at least one anyway) 1836 implementations, so strip it off if it exists. */ 1837 1838 { 1839 char *command = elf_tdata (abfd)->core_command; 1840 int n = strlen (command); 1841 1842 if (0 < n && command[n - 1] == ' ') 1843 command[n - 1] = '\0'; 1844 } 1845 1846 return TRUE; 1847} 1848 1849static char * 1850ppc_elf_write_core_note (bfd *abfd, char *buf, int *bufsiz, int note_type, ...) 1851{ 1852 switch (note_type) 1853 { 1854 default: 1855 return NULL; 1856 1857 case NT_PRPSINFO: 1858 { 1859 char data[128]; 1860 va_list ap; 1861 1862 va_start (ap, note_type); 1863 memset (data, 0, 32); 1864 strncpy (data + 32, va_arg (ap, const char *), 16); 1865 strncpy (data + 48, va_arg (ap, const char *), 80); 1866 va_end (ap); 1867 return elfcore_write_note (abfd, buf, bufsiz, 1868 "CORE", note_type, data, sizeof (data)); 1869 } 1870 1871 case NT_PRSTATUS: 1872 { 1873 char data[268]; 1874 va_list ap; 1875 long pid; 1876 int cursig; 1877 const void *greg; 1878 1879 va_start (ap, note_type); 1880 memset (data, 0, 72); 1881 pid = va_arg (ap, long); 1882 bfd_put_32 (abfd, pid, data + 24); 1883 cursig = va_arg (ap, int); 1884 bfd_put_16 (abfd, cursig, data + 12); 1885 greg = va_arg (ap, const void *); 1886 memcpy (data + 72, greg, 192); 1887 memset (data + 264, 0, 4); 1888 va_end (ap); 1889 return elfcore_write_note (abfd, buf, bufsiz, 1890 "CORE", note_type, data, sizeof (data)); 1891 } 1892 } 1893} 1894 1895/* Return address for Ith PLT stub in section PLT, for relocation REL 1896 or (bfd_vma) -1 if it should not be included. */ 1897 1898static bfd_vma 1899ppc_elf_plt_sym_val (bfd_vma i ATTRIBUTE_UNUSED, 1900 const asection *plt ATTRIBUTE_UNUSED, 1901 const arelent *rel) 1902{ 1903 return rel->address; 1904} 1905 1906/* Handle a PowerPC specific section when reading an object file. This 1907 is called when bfd_section_from_shdr finds a section with an unknown 1908 type. */ 1909 1910static bfd_boolean 1911ppc_elf_section_from_shdr (bfd *abfd, 1912 Elf_Internal_Shdr *hdr, 1913 const char *name, 1914 int shindex) 1915{ 1916 asection *newsect; 1917 flagword flags; 1918 1919 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 1920 return FALSE; 1921 1922 newsect = hdr->bfd_section; 1923 flags = bfd_get_section_flags (abfd, newsect); 1924 if (hdr->sh_flags & SHF_EXCLUDE) 1925 flags |= SEC_EXCLUDE; 1926 1927 if (hdr->sh_type == SHT_ORDERED) 1928 flags |= SEC_SORT_ENTRIES; 1929 1930 bfd_set_section_flags (abfd, newsect, flags); 1931 return TRUE; 1932} 1933 1934/* Set up any other section flags and such that may be necessary. */ 1935 1936static bfd_boolean 1937ppc_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 1938 Elf_Internal_Shdr *shdr, 1939 asection *asect) 1940{ 1941 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE) 1942 shdr->sh_flags |= SHF_EXCLUDE; 1943 1944 if ((asect->flags & SEC_SORT_ENTRIES) != 0) 1945 shdr->sh_type = SHT_ORDERED; 1946 1947 return TRUE; 1948} 1949 1950/* If we have .sbss2 or .PPC.EMB.sbss0 output sections, we 1951 need to bump up the number of section headers. */ 1952 1953static int 1954ppc_elf_additional_program_headers (bfd *abfd, 1955 struct bfd_link_info *info ATTRIBUTE_UNUSED) 1956{ 1957 asection *s; 1958 int ret = 0; 1959 1960 s = bfd_get_section_by_name (abfd, ".sbss2"); 1961 if (s != NULL && (s->flags & SEC_ALLOC) != 0) 1962 ++ret; 1963 1964 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0"); 1965 if (s != NULL && (s->flags & SEC_ALLOC) != 0) 1966 ++ret; 1967 1968 return ret; 1969} 1970 1971/* Add extra PPC sections -- Note, for now, make .sbss2 and 1972 .PPC.EMB.sbss0 a normal section, and not a bss section so 1973 that the linker doesn't crater when trying to make more than 1974 2 sections. */ 1975 1976static const struct bfd_elf_special_section ppc_elf_special_sections[] = 1977{ 1978 { STRING_COMMA_LEN (".plt"), 0, SHT_NOBITS, SHF_ALLOC + SHF_EXECINSTR }, 1979 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE }, 1980 { STRING_COMMA_LEN (".sbss2"), -2, SHT_PROGBITS, SHF_ALLOC }, 1981 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE }, 1982 { STRING_COMMA_LEN (".sdata2"), -2, SHT_PROGBITS, SHF_ALLOC }, 1983 { STRING_COMMA_LEN (".tags"), 0, SHT_ORDERED, SHF_ALLOC }, 1984 { STRING_COMMA_LEN (".PPC.EMB.apuinfo"), 0, SHT_NOTE, 0 }, 1985 { STRING_COMMA_LEN (".PPC.EMB.sbss0"), 0, SHT_PROGBITS, SHF_ALLOC }, 1986 { STRING_COMMA_LEN (".PPC.EMB.sdata0"), 0, SHT_PROGBITS, SHF_ALLOC }, 1987 { NULL, 0, 0, 0, 0 } 1988}; 1989 1990/* This is what we want for new plt/got. */ 1991static struct bfd_elf_special_section ppc_alt_plt = 1992 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC }; 1993 1994static const struct bfd_elf_special_section * 1995ppc_elf_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 1996{ 1997 const struct bfd_elf_special_section *ssect; 1998 1999 /* See if this is one of the special sections. */ 2000 if (sec->name == NULL) 2001 return NULL; 2002 2003 ssect = _bfd_elf_get_special_section (sec->name, ppc_elf_special_sections, 2004 sec->use_rela_p); 2005 if (ssect != NULL) 2006 { 2007 if (ssect == ppc_elf_special_sections && (sec->flags & SEC_LOAD) != 0) 2008 ssect = &ppc_alt_plt; 2009 return ssect; 2010 } 2011 2012 return _bfd_elf_get_sec_type_attr (abfd, sec); 2013} 2014 2015/* Very simple linked list structure for recording apuinfo values. */ 2016typedef struct apuinfo_list 2017{ 2018 struct apuinfo_list *next; 2019 unsigned long value; 2020} 2021apuinfo_list; 2022 2023static apuinfo_list *head; 2024 2025 2026static void 2027apuinfo_list_init (void) 2028{ 2029 head = NULL; 2030} 2031 2032static void 2033apuinfo_list_add (unsigned long value) 2034{ 2035 apuinfo_list *entry = head; 2036 2037 while (entry != NULL) 2038 { 2039 if (entry->value == value) 2040 return; 2041 entry = entry->next; 2042 } 2043 2044 entry = bfd_malloc (sizeof (* entry)); 2045 if (entry == NULL) 2046 return; 2047 2048 entry->value = value; 2049 entry->next = head; 2050 head = entry; 2051} 2052 2053static unsigned 2054apuinfo_list_length (void) 2055{ 2056 apuinfo_list *entry; 2057 unsigned long count; 2058 2059 for (entry = head, count = 0; 2060 entry; 2061 entry = entry->next) 2062 ++ count; 2063 2064 return count; 2065} 2066 2067static inline unsigned long 2068apuinfo_list_element (unsigned long number) 2069{ 2070 apuinfo_list * entry; 2071 2072 for (entry = head; 2073 entry && number --; 2074 entry = entry->next) 2075 ; 2076 2077 return entry ? entry->value : 0; 2078} 2079 2080static void 2081apuinfo_list_finish (void) 2082{ 2083 apuinfo_list *entry; 2084 2085 for (entry = head; entry;) 2086 { 2087 apuinfo_list *next = entry->next; 2088 free (entry); 2089 entry = next; 2090 } 2091 2092 head = NULL; 2093} 2094 2095#define APUINFO_SECTION_NAME ".PPC.EMB.apuinfo" 2096#define APUINFO_LABEL "APUinfo" 2097 2098/* Scan the input BFDs and create a linked list of 2099 the APUinfo values that will need to be emitted. */ 2100 2101static void 2102ppc_elf_begin_write_processing (bfd *abfd, struct bfd_link_info *link_info) 2103{ 2104 bfd *ibfd; 2105 asection *asec; 2106 char *buffer; 2107 unsigned num_input_sections; 2108 bfd_size_type output_section_size; 2109 unsigned i; 2110 unsigned num_entries; 2111 unsigned long offset; 2112 unsigned long length; 2113 const char *error_message = NULL; 2114 2115 if (link_info == NULL) 2116 return; 2117 2118 /* Scan the input bfds, looking for apuinfo sections. */ 2119 num_input_sections = 0; 2120 output_section_size = 0; 2121 2122 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) 2123 { 2124 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); 2125 if (asec) 2126 { 2127 ++ num_input_sections; 2128 output_section_size += asec->size; 2129 } 2130 } 2131 2132 /* We need at least one input sections 2133 in order to make merging worthwhile. */ 2134 if (num_input_sections < 1) 2135 return; 2136 2137 /* Just make sure that the output section exists as well. */ 2138 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2139 if (asec == NULL) 2140 return; 2141 2142 /* Allocate a buffer for the contents of the input sections. */ 2143 buffer = bfd_malloc (output_section_size); 2144 if (buffer == NULL) 2145 return; 2146 2147 offset = 0; 2148 apuinfo_list_init (); 2149 2150 /* Read in the input sections contents. */ 2151 for (ibfd = link_info->input_bfds; ibfd; ibfd = ibfd->link_next) 2152 { 2153 unsigned long datum; 2154 char *ptr; 2155 2156 asec = bfd_get_section_by_name (ibfd, APUINFO_SECTION_NAME); 2157 if (asec == NULL) 2158 continue; 2159 2160 length = asec->size; 2161 if (length < 24) 2162 { 2163 error_message = _("corrupt or empty %s section in %B"); 2164 goto fail; 2165 } 2166 2167 if (bfd_seek (ibfd, asec->filepos, SEEK_SET) != 0 2168 || (bfd_bread (buffer + offset, length, ibfd) != length)) 2169 { 2170 error_message = _("unable to read in %s section from %B"); 2171 goto fail; 2172 } 2173 2174 /* Process the contents of the section. */ 2175 ptr = buffer + offset; 2176 error_message = _("corrupt %s section in %B"); 2177 2178 /* Verify the contents of the header. Note - we have to 2179 extract the values this way in order to allow for a 2180 host whose endian-ness is different from the target. */ 2181 datum = bfd_get_32 (ibfd, ptr); 2182 if (datum != sizeof APUINFO_LABEL) 2183 goto fail; 2184 2185 datum = bfd_get_32 (ibfd, ptr + 8); 2186 if (datum != 0x2) 2187 goto fail; 2188 2189 if (strcmp (ptr + 12, APUINFO_LABEL) != 0) 2190 goto fail; 2191 2192 /* Get the number of bytes used for apuinfo entries. */ 2193 datum = bfd_get_32 (ibfd, ptr + 4); 2194 if (datum + 20 != length) 2195 goto fail; 2196 2197 /* Make sure that we do not run off the end of the section. */ 2198 if (offset + length > output_section_size) 2199 goto fail; 2200 2201 /* Scan the apuinfo section, building a list of apuinfo numbers. */ 2202 for (i = 0; i < datum; i += 4) 2203 apuinfo_list_add (bfd_get_32 (ibfd, ptr + 20 + i)); 2204 2205 /* Update the offset. */ 2206 offset += length; 2207 } 2208 2209 error_message = NULL; 2210 2211 /* Compute the size of the output section. */ 2212 num_entries = apuinfo_list_length (); 2213 output_section_size = 20 + num_entries * 4; 2214 2215 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2216 2217 if (! bfd_set_section_size (abfd, asec, output_section_size)) 2218 ibfd = abfd, 2219 error_message = _("warning: unable to set size of %s section in %B"); 2220 2221 fail: 2222 free (buffer); 2223 2224 if (error_message) 2225 (*_bfd_error_handler) (error_message, ibfd, APUINFO_SECTION_NAME); 2226} 2227 2228/* Prevent the output section from accumulating the input sections' 2229 contents. We have already stored this in our linked list structure. */ 2230 2231static bfd_boolean 2232ppc_elf_write_section (bfd *abfd ATTRIBUTE_UNUSED, 2233 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 2234 asection *asec, 2235 bfd_byte *contents ATTRIBUTE_UNUSED) 2236{ 2237 return (apuinfo_list_length () 2238 && strcmp (asec->name, APUINFO_SECTION_NAME) == 0); 2239} 2240 2241/* Finally we can generate the output section. */ 2242 2243static void 2244ppc_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED) 2245{ 2246 bfd_byte *buffer; 2247 asection *asec; 2248 unsigned i; 2249 unsigned num_entries; 2250 bfd_size_type length; 2251 2252 asec = bfd_get_section_by_name (abfd, APUINFO_SECTION_NAME); 2253 if (asec == NULL) 2254 return; 2255 2256 if (apuinfo_list_length () == 0) 2257 return; 2258 2259 length = asec->size; 2260 if (length < 20) 2261 return; 2262 2263 buffer = bfd_malloc (length); 2264 if (buffer == NULL) 2265 { 2266 (*_bfd_error_handler) 2267 (_("failed to allocate space for new APUinfo section.")); 2268 return; 2269 } 2270 2271 /* Create the apuinfo header. */ 2272 num_entries = apuinfo_list_length (); 2273 bfd_put_32 (abfd, sizeof APUINFO_LABEL, buffer); 2274 bfd_put_32 (abfd, num_entries * 4, buffer + 4); 2275 bfd_put_32 (abfd, 0x2, buffer + 8); 2276 strcpy ((char *) buffer + 12, APUINFO_LABEL); 2277 2278 length = 20; 2279 for (i = 0; i < num_entries; i++) 2280 { 2281 bfd_put_32 (abfd, apuinfo_list_element (i), buffer + length); 2282 length += 4; 2283 } 2284 2285 if (length != asec->size) 2286 (*_bfd_error_handler) (_("failed to compute new APUinfo section.")); 2287 2288 if (! bfd_set_section_contents (abfd, asec, buffer, (file_ptr) 0, length)) 2289 (*_bfd_error_handler) (_("failed to install new APUinfo section.")); 2290 2291 free (buffer); 2292 2293 apuinfo_list_finish (); 2294} 2295 2296/* The following functions are specific to the ELF linker, while 2297 functions above are used generally. They appear in this file more 2298 or less in the order in which they are called. eg. 2299 ppc_elf_check_relocs is called early in the link process, 2300 ppc_elf_finish_dynamic_sections is one of the last functions 2301 called. */ 2302 2303/* The PPC linker needs to keep track of the number of relocs that it 2304 decides to copy as dynamic relocs in check_relocs for each symbol. 2305 This is so that it can later discard them if they are found to be 2306 unnecessary. We store the information in a field extending the 2307 regular ELF linker hash table. */ 2308 2309struct ppc_elf_dyn_relocs 2310{ 2311 struct ppc_elf_dyn_relocs *next; 2312 2313 /* The input section of the reloc. */ 2314 asection *sec; 2315 2316 /* Total number of relocs copied for the input section. */ 2317 bfd_size_type count; 2318 2319 /* Number of pc-relative relocs copied for the input section. */ 2320 bfd_size_type pc_count; 2321}; 2322 2323/* Track PLT entries needed for a given symbol. We might need more 2324 than one glink entry per symbol. */ 2325struct plt_entry 2326{ 2327 struct plt_entry *next; 2328 2329 /* -fPIC uses multiple GOT sections, one per file, called ".got2". 2330 This field stores the offset into .got2 used to initialise the 2331 GOT pointer reg. It will always be at least 32768 (and for 2332 current gcc this is the only offset used). */ 2333 bfd_vma addend; 2334 2335 /* The .got2 section. */ 2336 asection *sec; 2337 2338 /* PLT refcount or offset. */ 2339 union 2340 { 2341 bfd_signed_vma refcount; 2342 bfd_vma offset; 2343 } plt; 2344 2345 /* .glink stub offset. */ 2346 bfd_vma glink_offset; 2347}; 2348 2349/* Of those relocs that might be copied as dynamic relocs, this macro 2350 selects those that must be copied when linking a shared library, 2351 even when the symbol is local. */ 2352 2353#define MUST_BE_DYN_RELOC(RTYPE) \ 2354 ((RTYPE) != R_PPC_REL24 \ 2355 && (RTYPE) != R_PPC_REL14 \ 2356 && (RTYPE) != R_PPC_REL14_BRTAKEN \ 2357 && (RTYPE) != R_PPC_REL14_BRNTAKEN \ 2358 && (RTYPE) != R_PPC_REL32) 2359 2360/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 2361 copying dynamic variables from a shared lib into an app's dynbss 2362 section, and instead use a dynamic relocation to point into the 2363 shared lib. */ 2364#define ELIMINATE_COPY_RELOCS 1 2365 2366/* PPC ELF linker hash entry. */ 2367 2368struct ppc_elf_link_hash_entry 2369{ 2370 struct elf_link_hash_entry elf; 2371 2372 /* If this symbol is used in the linker created sections, the processor 2373 specific backend uses this field to map the field into the offset 2374 from the beginning of the section. */ 2375 elf_linker_section_pointers_t *linker_section_pointer; 2376 2377 /* Track dynamic relocs copied for this symbol. */ 2378 struct ppc_elf_dyn_relocs *dyn_relocs; 2379 2380 /* Contexts in which symbol is used in the GOT (or TOC). 2381 TLS_GD .. TLS_TLS bits are or'd into the mask as the 2382 corresponding relocs are encountered during check_relocs. 2383 tls_optimize clears TLS_GD .. TLS_TPREL when optimizing to 2384 indicate the corresponding GOT entry type is not needed. */ 2385#define TLS_GD 1 /* GD reloc. */ 2386#define TLS_LD 2 /* LD reloc. */ 2387#define TLS_TPREL 4 /* TPREL reloc, => IE. */ 2388#define TLS_DTPREL 8 /* DTPREL reloc, => LD. */ 2389#define TLS_TLS 16 /* Any TLS reloc. */ 2390#define TLS_TPRELGD 32 /* TPREL reloc resulting from GD->IE. */ 2391 char tls_mask; 2392 2393 /* Nonzero if we have seen a small data relocation referring to this 2394 symbol. */ 2395 unsigned char has_sda_refs; 2396}; 2397 2398#define ppc_elf_hash_entry(ent) ((struct ppc_elf_link_hash_entry *) (ent)) 2399 2400/* PPC ELF linker hash table. */ 2401 2402struct ppc_elf_link_hash_table 2403{ 2404 struct elf_link_hash_table elf; 2405 2406 /* Short-cuts to get to dynamic linker sections. */ 2407 asection *got; 2408 asection *relgot; 2409 asection *glink; 2410 asection *plt; 2411 asection *relplt; 2412 asection *dynbss; 2413 asection *relbss; 2414 asection *dynsbss; 2415 asection *relsbss; 2416 elf_linker_section_t sdata[2]; 2417 asection *sbss; 2418 2419 /* The (unloaded but important) .rela.plt.unloaded on VxWorks. */ 2420 asection *srelplt2; 2421 2422 /* The .got.plt section (VxWorks only)*/ 2423 asection *sgotplt; 2424 2425 /* Shortcut to .__tls_get_addr. */ 2426 struct elf_link_hash_entry *tls_get_addr; 2427 2428 /* The bfd that forced an old-style PLT. */ 2429 bfd *old_bfd; 2430 2431 /* TLS local dynamic got entry handling. */ 2432 union { 2433 bfd_signed_vma refcount; 2434 bfd_vma offset; 2435 } tlsld_got; 2436 2437 /* Offset of PltResolve function in glink. */ 2438 bfd_vma glink_pltresolve; 2439 2440 /* Size of reserved GOT entries. */ 2441 unsigned int got_header_size; 2442 /* Non-zero if allocating the header left a gap. */ 2443 unsigned int got_gap; 2444 2445 /* The type of PLT we have chosen to use. */ 2446 enum ppc_elf_plt_type plt_type; 2447 2448 /* Set if we should emit symbols for stubs. */ 2449 unsigned int emit_stub_syms:1; 2450 2451 /* True if the target system is VxWorks. */ 2452 unsigned int is_vxworks:1; 2453 2454 /* The size of PLT entries. */ 2455 int plt_entry_size; 2456 /* The distance between adjacent PLT slots. */ 2457 int plt_slot_size; 2458 /* The size of the first PLT entry. */ 2459 int plt_initial_entry_size; 2460 2461 /* Small local sym to section mapping cache. */ 2462 struct sym_sec_cache sym_sec; 2463}; 2464 2465/* Get the PPC ELF linker hash table from a link_info structure. */ 2466 2467#define ppc_elf_hash_table(p) \ 2468 ((struct ppc_elf_link_hash_table *) (p)->hash) 2469 2470/* Create an entry in a PPC ELF linker hash table. */ 2471 2472static struct bfd_hash_entry * 2473ppc_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 2474 struct bfd_hash_table *table, 2475 const char *string) 2476{ 2477 /* Allocate the structure if it has not already been allocated by a 2478 subclass. */ 2479 if (entry == NULL) 2480 { 2481 entry = bfd_hash_allocate (table, 2482 sizeof (struct ppc_elf_link_hash_entry)); 2483 if (entry == NULL) 2484 return entry; 2485 } 2486 2487 /* Call the allocation method of the superclass. */ 2488 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 2489 if (entry != NULL) 2490 { 2491 ppc_elf_hash_entry (entry)->linker_section_pointer = NULL; 2492 ppc_elf_hash_entry (entry)->dyn_relocs = NULL; 2493 ppc_elf_hash_entry (entry)->tls_mask = 0; 2494 } 2495 2496 return entry; 2497} 2498 2499/* Create a PPC ELF linker hash table. */ 2500 2501static struct bfd_link_hash_table * 2502ppc_elf_link_hash_table_create (bfd *abfd) 2503{ 2504 struct ppc_elf_link_hash_table *ret; 2505 2506 ret = bfd_zmalloc (sizeof (struct ppc_elf_link_hash_table)); 2507 if (ret == NULL) 2508 return NULL; 2509 2510 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 2511 ppc_elf_link_hash_newfunc, 2512 sizeof (struct ppc_elf_link_hash_entry))) 2513 { 2514 free (ret); 2515 return NULL; 2516 } 2517 2518 ret->elf.init_plt_refcount.refcount = 0; 2519 ret->elf.init_plt_refcount.glist = NULL; 2520 ret->elf.init_plt_offset.offset = 0; 2521 ret->elf.init_plt_offset.glist = NULL; 2522 2523 ret->sdata[0].name = ".sdata"; 2524 ret->sdata[0].sym_name = "_SDA_BASE_"; 2525 ret->sdata[0].bss_name = ".sbss"; 2526 2527 ret->sdata[1].name = ".sdata2"; 2528 ret->sdata[1].sym_name = "_SDA2_BASE_"; 2529 ret->sdata[1].bss_name = ".sbss2"; 2530 2531 ret->plt_entry_size = 12; 2532 ret->plt_slot_size = 8; 2533 ret->plt_initial_entry_size = 72; 2534 2535 return &ret->elf.root; 2536} 2537 2538/* Create .got and the related sections. */ 2539 2540static bfd_boolean 2541ppc_elf_create_got (bfd *abfd, struct bfd_link_info *info) 2542{ 2543 struct ppc_elf_link_hash_table *htab; 2544 asection *s; 2545 flagword flags; 2546 2547 if (!_bfd_elf_create_got_section (abfd, info)) 2548 return FALSE; 2549 2550 htab = ppc_elf_hash_table (info); 2551 htab->got = s = bfd_get_section_by_name (abfd, ".got"); 2552 if (s == NULL) 2553 abort (); 2554 2555 if (htab->is_vxworks) 2556 { 2557 htab->sgotplt = bfd_get_section_by_name (abfd, ".got.plt"); 2558 if (!htab->sgotplt) 2559 abort (); 2560 } 2561 else 2562 { 2563 /* The powerpc .got has a blrl instruction in it. Mark it 2564 executable. */ 2565 flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS 2566 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 2567 if (!bfd_set_section_flags (abfd, s, flags)) 2568 return FALSE; 2569 } 2570 2571 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2572 | SEC_LINKER_CREATED | SEC_READONLY); 2573 htab->relgot = bfd_make_section_with_flags (abfd, ".rela.got", flags); 2574 if (!htab->relgot 2575 || ! bfd_set_section_alignment (abfd, htab->relgot, 2)) 2576 return FALSE; 2577 2578 return TRUE; 2579} 2580 2581/* We have to create .dynsbss and .rela.sbss here so that they get mapped 2582 to output sections (just like _bfd_elf_create_dynamic_sections has 2583 to create .dynbss and .rela.bss). */ 2584 2585static bfd_boolean 2586ppc_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 2587{ 2588 struct ppc_elf_link_hash_table *htab; 2589 asection *s; 2590 flagword flags; 2591 2592 htab = ppc_elf_hash_table (info); 2593 2594 if (htab->got == NULL 2595 && !ppc_elf_create_got (abfd, info)) 2596 return FALSE; 2597 2598 if (!_bfd_elf_create_dynamic_sections (abfd, info)) 2599 return FALSE; 2600 2601 flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_HAS_CONTENTS 2602 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 2603 2604 s = bfd_make_section_anyway_with_flags (abfd, ".glink", flags | SEC_CODE); 2605 htab->glink = s; 2606 if (s == NULL 2607 || !bfd_set_section_alignment (abfd, s, 4)) 2608 return FALSE; 2609 2610 htab->dynbss = bfd_get_section_by_name (abfd, ".dynbss"); 2611 s = bfd_make_section_with_flags (abfd, ".dynsbss", 2612 SEC_ALLOC | SEC_LINKER_CREATED); 2613 htab->dynsbss = s; 2614 if (s == NULL) 2615 return FALSE; 2616 2617 if (! info->shared) 2618 { 2619 htab->relbss = bfd_get_section_by_name (abfd, ".rela.bss"); 2620 s = bfd_make_section_with_flags (abfd, ".rela.sbss", flags); 2621 htab->relsbss = s; 2622 if (s == NULL 2623 || ! bfd_set_section_alignment (abfd, s, 2)) 2624 return FALSE; 2625 } 2626 2627 if (htab->is_vxworks 2628 && !elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) 2629 return FALSE; 2630 2631 htab->relplt = bfd_get_section_by_name (abfd, ".rela.plt"); 2632 htab->plt = s = bfd_get_section_by_name (abfd, ".plt"); 2633 if (s == NULL) 2634 abort (); 2635 2636 flags = SEC_ALLOC | SEC_CODE | SEC_LINKER_CREATED; 2637 if (htab->plt_type == PLT_VXWORKS) 2638 /* The VxWorks PLT is a loaded section with contents. */ 2639 flags |= SEC_HAS_CONTENTS | SEC_LOAD | SEC_READONLY; 2640 return bfd_set_section_flags (abfd, s, flags); 2641} 2642 2643/* Copy the extra info we tack onto an elf_link_hash_entry. */ 2644 2645static void 2646ppc_elf_copy_indirect_symbol (struct bfd_link_info *info, 2647 struct elf_link_hash_entry *dir, 2648 struct elf_link_hash_entry *ind) 2649{ 2650 struct ppc_elf_link_hash_entry *edir, *eind; 2651 2652 edir = (struct ppc_elf_link_hash_entry *) dir; 2653 eind = (struct ppc_elf_link_hash_entry *) ind; 2654 2655 if (eind->dyn_relocs != NULL) 2656 { 2657 if (edir->dyn_relocs != NULL) 2658 { 2659 struct ppc_elf_dyn_relocs **pp; 2660 struct ppc_elf_dyn_relocs *p; 2661 2662 /* Add reloc counts against the indirect sym to the direct sym 2663 list. Merge any entries against the same section. */ 2664 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 2665 { 2666 struct ppc_elf_dyn_relocs *q; 2667 2668 for (q = edir->dyn_relocs; q != NULL; q = q->next) 2669 if (q->sec == p->sec) 2670 { 2671 q->pc_count += p->pc_count; 2672 q->count += p->count; 2673 *pp = p->next; 2674 break; 2675 } 2676 if (q == NULL) 2677 pp = &p->next; 2678 } 2679 *pp = edir->dyn_relocs; 2680 } 2681 2682 edir->dyn_relocs = eind->dyn_relocs; 2683 eind->dyn_relocs = NULL; 2684 } 2685 2686 edir->tls_mask |= eind->tls_mask; 2687 edir->has_sda_refs |= eind->has_sda_refs; 2688 2689 /* If called to transfer flags for a weakdef during processing 2690 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 2691 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 2692 if (!(ELIMINATE_COPY_RELOCS 2693 && eind->elf.root.type != bfd_link_hash_indirect 2694 && edir->elf.dynamic_adjusted)) 2695 edir->elf.non_got_ref |= eind->elf.non_got_ref; 2696 2697 edir->elf.ref_dynamic |= eind->elf.ref_dynamic; 2698 edir->elf.ref_regular |= eind->elf.ref_regular; 2699 edir->elf.ref_regular_nonweak |= eind->elf.ref_regular_nonweak; 2700 edir->elf.needs_plt |= eind->elf.needs_plt; 2701 2702 /* If we were called to copy over info for a weak sym, that's all. */ 2703 if (eind->elf.root.type != bfd_link_hash_indirect) 2704 return; 2705 2706 /* Copy over the GOT refcount entries that we may have already seen to 2707 the symbol which just became indirect. */ 2708 edir->elf.got.refcount += eind->elf.got.refcount; 2709 eind->elf.got.refcount = 0; 2710 2711 /* And plt entries. */ 2712 if (eind->elf.plt.plist != NULL) 2713 { 2714 if (edir->elf.plt.plist != NULL) 2715 { 2716 struct plt_entry **entp; 2717 struct plt_entry *ent; 2718 2719 for (entp = &eind->elf.plt.plist; (ent = *entp) != NULL; ) 2720 { 2721 struct plt_entry *dent; 2722 2723 for (dent = edir->elf.plt.plist; dent != NULL; dent = dent->next) 2724 if (dent->sec == ent->sec && dent->addend == ent->addend) 2725 { 2726 dent->plt.refcount += ent->plt.refcount; 2727 *entp = ent->next; 2728 break; 2729 } 2730 if (dent == NULL) 2731 entp = &ent->next; 2732 } 2733 *entp = edir->elf.plt.plist; 2734 } 2735 2736 edir->elf.plt.plist = eind->elf.plt.plist; 2737 eind->elf.plt.plist = NULL; 2738 } 2739 2740 if (eind->elf.dynindx != -1) 2741 { 2742 if (edir->elf.dynindx != -1) 2743 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr, 2744 edir->elf.dynstr_index); 2745 edir->elf.dynindx = eind->elf.dynindx; 2746 edir->elf.dynstr_index = eind->elf.dynstr_index; 2747 eind->elf.dynindx = -1; 2748 eind->elf.dynstr_index = 0; 2749 } 2750} 2751 2752/* Return 1 if target is one of ours. */ 2753 2754static bfd_boolean 2755is_ppc_elf_target (const struct bfd_target *targ) 2756{ 2757 extern const bfd_target bfd_elf32_powerpc_vec; 2758 extern const bfd_target bfd_elf32_powerpc_vxworks_vec; 2759 extern const bfd_target bfd_elf32_powerpcle_vec; 2760 2761 return (targ == &bfd_elf32_powerpc_vec 2762 || targ == &bfd_elf32_powerpc_vxworks_vec 2763 || targ == &bfd_elf32_powerpcle_vec); 2764} 2765 2766/* Hook called by the linker routine which adds symbols from an object 2767 file. We use it to put .comm items in .sbss, and not .bss. */ 2768 2769static bfd_boolean 2770ppc_elf_add_symbol_hook (bfd *abfd, 2771 struct bfd_link_info *info, 2772 Elf_Internal_Sym *sym, 2773 const char **namep ATTRIBUTE_UNUSED, 2774 flagword *flagsp ATTRIBUTE_UNUSED, 2775 asection **secp, 2776 bfd_vma *valp) 2777{ 2778 if (sym->st_shndx == SHN_COMMON 2779 && !info->relocatable 2780 && sym->st_size <= elf_gp_size (abfd) 2781 && is_ppc_elf_target (info->hash->creator)) 2782 { 2783 /* Common symbols less than or equal to -G nn bytes are automatically 2784 put into .sbss. */ 2785 struct ppc_elf_link_hash_table *htab; 2786 2787 htab = ppc_elf_hash_table (info); 2788 if (htab->sbss == NULL) 2789 { 2790 flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED; 2791 2792 if (!htab->elf.dynobj) 2793 htab->elf.dynobj = abfd; 2794 2795 htab->sbss = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2796 ".sbss", 2797 flags); 2798 if (htab->sbss == NULL) 2799 return FALSE; 2800 } 2801 2802 *secp = htab->sbss; 2803 *valp = sym->st_size; 2804 } 2805 2806 return TRUE; 2807} 2808 2809static bfd_boolean 2810create_sdata_sym (struct ppc_elf_link_hash_table *htab, 2811 elf_linker_section_t *lsect) 2812{ 2813 lsect->sym = elf_link_hash_lookup (&htab->elf, lsect->sym_name, 2814 TRUE, FALSE, TRUE); 2815 if (lsect->sym == NULL) 2816 return FALSE; 2817 if (lsect->sym->root.type == bfd_link_hash_new) 2818 lsect->sym->non_elf = 0; 2819 lsect->sym->ref_regular = 1; 2820 return TRUE; 2821} 2822 2823/* Create a special linker section. */ 2824 2825static bfd_boolean 2826ppc_elf_create_linker_section (bfd *abfd, 2827 struct bfd_link_info *info, 2828 flagword flags, 2829 elf_linker_section_t *lsect) 2830{ 2831 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 2832 asection *s; 2833 2834 flags |= (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2835 | SEC_LINKER_CREATED); 2836 2837 /* Record the first bfd that needs the special sections. */ 2838 if (!htab->elf.dynobj) 2839 htab->elf.dynobj = abfd; 2840 2841 s = bfd_make_section_anyway_with_flags (htab->elf.dynobj, 2842 lsect->name, 2843 flags); 2844 if (s == NULL 2845 || !bfd_set_section_alignment (htab->elf.dynobj, s, 2)) 2846 return FALSE; 2847 lsect->section = s; 2848 2849 return create_sdata_sym (htab, lsect); 2850} 2851 2852/* Find a linker generated pointer with a given addend and type. */ 2853 2854static elf_linker_section_pointers_t * 2855elf_find_pointer_linker_section 2856 (elf_linker_section_pointers_t *linker_pointers, 2857 bfd_vma addend, 2858 elf_linker_section_t *lsect) 2859{ 2860 for ( ; linker_pointers != NULL; linker_pointers = linker_pointers->next) 2861 if (lsect == linker_pointers->lsect && addend == linker_pointers->addend) 2862 return linker_pointers; 2863 2864 return NULL; 2865} 2866 2867/* Allocate a pointer to live in a linker created section. */ 2868 2869static bfd_boolean 2870elf_create_pointer_linker_section (bfd *abfd, 2871 elf_linker_section_t *lsect, 2872 struct elf_link_hash_entry *h, 2873 const Elf_Internal_Rela *rel) 2874{ 2875 elf_linker_section_pointers_t **ptr_linker_section_ptr = NULL; 2876 elf_linker_section_pointers_t *linker_section_ptr; 2877 unsigned long r_symndx = ELF32_R_SYM (rel->r_info); 2878 bfd_size_type amt; 2879 2880 BFD_ASSERT (lsect != NULL); 2881 2882 /* Is this a global symbol? */ 2883 if (h != NULL) 2884 { 2885 struct ppc_elf_link_hash_entry *eh; 2886 2887 /* Has this symbol already been allocated? If so, our work is done. */ 2888 eh = (struct ppc_elf_link_hash_entry *) h; 2889 if (elf_find_pointer_linker_section (eh->linker_section_pointer, 2890 rel->r_addend, 2891 lsect)) 2892 return TRUE; 2893 2894 ptr_linker_section_ptr = &eh->linker_section_pointer; 2895 } 2896 else 2897 { 2898 /* Allocation of a pointer to a local symbol. */ 2899 elf_linker_section_pointers_t **ptr = elf_local_ptr_offsets (abfd); 2900 2901 /* Allocate a table to hold the local symbols if first time. */ 2902 if (!ptr) 2903 { 2904 unsigned int num_symbols = elf_tdata (abfd)->symtab_hdr.sh_info; 2905 2906 amt = num_symbols; 2907 amt *= sizeof (elf_linker_section_pointers_t *); 2908 ptr = bfd_zalloc (abfd, amt); 2909 2910 if (!ptr) 2911 return FALSE; 2912 2913 elf_local_ptr_offsets (abfd) = ptr; 2914 } 2915 2916 /* Has this symbol already been allocated? If so, our work is done. */ 2917 if (elf_find_pointer_linker_section (ptr[r_symndx], 2918 rel->r_addend, 2919 lsect)) 2920 return TRUE; 2921 2922 ptr_linker_section_ptr = &ptr[r_symndx]; 2923 } 2924 2925 /* Allocate space for a pointer in the linker section, and allocate 2926 a new pointer record from internal memory. */ 2927 BFD_ASSERT (ptr_linker_section_ptr != NULL); 2928 amt = sizeof (elf_linker_section_pointers_t); 2929 linker_section_ptr = bfd_alloc (abfd, amt); 2930 2931 if (!linker_section_ptr) 2932 return FALSE; 2933 2934 linker_section_ptr->next = *ptr_linker_section_ptr; 2935 linker_section_ptr->addend = rel->r_addend; 2936 linker_section_ptr->lsect = lsect; 2937 *ptr_linker_section_ptr = linker_section_ptr; 2938 2939 linker_section_ptr->offset = lsect->section->size; 2940 lsect->section->size += 4; 2941 2942#ifdef DEBUG 2943 fprintf (stderr, 2944 "Create pointer in linker section %s, offset = %ld, section size = %ld\n", 2945 lsect->name, (long) linker_section_ptr->offset, 2946 (long) lsect->section->size); 2947#endif 2948 2949 return TRUE; 2950} 2951 2952static bfd_boolean 2953update_local_sym_info (bfd *abfd, 2954 Elf_Internal_Shdr *symtab_hdr, 2955 unsigned long r_symndx, 2956 int tls_type) 2957{ 2958 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd); 2959 char *local_got_tls_masks; 2960 2961 if (local_got_refcounts == NULL) 2962 { 2963 bfd_size_type size = symtab_hdr->sh_info; 2964 2965 size *= sizeof (*local_got_refcounts) + sizeof (*local_got_tls_masks); 2966 local_got_refcounts = bfd_zalloc (abfd, size); 2967 if (local_got_refcounts == NULL) 2968 return FALSE; 2969 elf_local_got_refcounts (abfd) = local_got_refcounts; 2970 } 2971 2972 local_got_refcounts[r_symndx] += 1; 2973 local_got_tls_masks = (char *) (local_got_refcounts + symtab_hdr->sh_info); 2974 local_got_tls_masks[r_symndx] |= tls_type; 2975 return TRUE; 2976} 2977 2978static bfd_boolean 2979update_plt_info (bfd *abfd, struct elf_link_hash_entry *h, 2980 asection *sec, bfd_vma addend) 2981{ 2982 struct plt_entry *ent; 2983 2984 if (addend < 32768) 2985 sec = NULL; 2986 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 2987 if (ent->sec == sec && ent->addend == addend) 2988 break; 2989 if (ent == NULL) 2990 { 2991 bfd_size_type amt = sizeof (*ent); 2992 ent = bfd_alloc (abfd, amt); 2993 if (ent == NULL) 2994 return FALSE; 2995 ent->next = h->plt.plist; 2996 ent->sec = sec; 2997 ent->addend = addend; 2998 ent->plt.refcount = 0; 2999 h->plt.plist = ent; 3000 } 3001 ent->plt.refcount += 1; 3002 return TRUE; 3003} 3004 3005static struct plt_entry * 3006find_plt_ent (struct elf_link_hash_entry *h, asection *sec, bfd_vma addend) 3007{ 3008 struct plt_entry *ent; 3009 3010 if (addend < 32768) 3011 sec = NULL; 3012 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 3013 if (ent->sec == sec && ent->addend == addend) 3014 break; 3015 return ent; 3016} 3017 3018static void 3019bad_shared_reloc (bfd *abfd, enum elf_ppc_reloc_type r_type) 3020{ 3021 (*_bfd_error_handler) 3022 (_("%B: relocation %s cannot be used when making a shared object"), 3023 abfd, 3024 ppc_elf_howto_table[r_type]->name); 3025 bfd_set_error (bfd_error_bad_value); 3026} 3027 3028/* Look through the relocs for a section during the first phase, and 3029 allocate space in the global offset table or procedure linkage 3030 table. */ 3031 3032static bfd_boolean 3033ppc_elf_check_relocs (bfd *abfd, 3034 struct bfd_link_info *info, 3035 asection *sec, 3036 const Elf_Internal_Rela *relocs) 3037{ 3038 struct ppc_elf_link_hash_table *htab; 3039 Elf_Internal_Shdr *symtab_hdr; 3040 struct elf_link_hash_entry **sym_hashes; 3041 const Elf_Internal_Rela *rel; 3042 const Elf_Internal_Rela *rel_end; 3043 asection *got2, *sreloc; 3044 3045 if (info->relocatable) 3046 return TRUE; 3047 3048 /* Don't do anything special with non-loaded, non-alloced sections. 3049 In particular, any relocs in such sections should not affect GOT 3050 and PLT reference counting (ie. we don't allow them to create GOT 3051 or PLT entries), there's no possibility or desire to optimize TLS 3052 relocs, and there's not much point in propagating relocs to shared 3053 libs that the dynamic linker won't relocate. */ 3054 if ((sec->flags & SEC_ALLOC) == 0) 3055 return TRUE; 3056 3057#ifdef DEBUG 3058 _bfd_error_handler ("ppc_elf_check_relocs called for section %A in %B", 3059 sec, abfd); 3060#endif 3061 3062 /* Initialize howto table if not already done. */ 3063 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 3064 ppc_elf_howto_init (); 3065 3066 htab = ppc_elf_hash_table (info); 3067 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3068 sym_hashes = elf_sym_hashes (abfd); 3069 got2 = bfd_get_section_by_name (abfd, ".got2"); 3070 sreloc = NULL; 3071 3072 rel_end = relocs + sec->reloc_count; 3073 for (rel = relocs; rel < rel_end; rel++) 3074 { 3075 unsigned long r_symndx; 3076 enum elf_ppc_reloc_type r_type; 3077 struct elf_link_hash_entry *h; 3078 int tls_type = 0; 3079 3080 r_symndx = ELF32_R_SYM (rel->r_info); 3081 if (r_symndx < symtab_hdr->sh_info) 3082 h = NULL; 3083 else 3084 { 3085 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3086 while (h->root.type == bfd_link_hash_indirect 3087 || h->root.type == bfd_link_hash_warning) 3088 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3089 } 3090 3091 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got. 3092 This shows up in particular in an R_PPC_ADDR32 in the eabi 3093 startup code. */ 3094 if (h != NULL 3095 && htab->got == NULL 3096 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3097 { 3098 if (htab->elf.dynobj == NULL) 3099 htab->elf.dynobj = abfd; 3100 if (!ppc_elf_create_got (htab->elf.dynobj, info)) 3101 return FALSE; 3102 BFD_ASSERT (h == htab->elf.hgot); 3103 } 3104 3105 r_type = ELF32_R_TYPE (rel->r_info); 3106 switch (r_type) 3107 { 3108 case R_PPC_GOT_TLSLD16: 3109 case R_PPC_GOT_TLSLD16_LO: 3110 case R_PPC_GOT_TLSLD16_HI: 3111 case R_PPC_GOT_TLSLD16_HA: 3112 htab->tlsld_got.refcount += 1; 3113 tls_type = TLS_TLS | TLS_LD; 3114 goto dogottls; 3115 3116 case R_PPC_GOT_TLSGD16: 3117 case R_PPC_GOT_TLSGD16_LO: 3118 case R_PPC_GOT_TLSGD16_HI: 3119 case R_PPC_GOT_TLSGD16_HA: 3120 tls_type = TLS_TLS | TLS_GD; 3121 goto dogottls; 3122 3123 case R_PPC_GOT_TPREL16: 3124 case R_PPC_GOT_TPREL16_LO: 3125 case R_PPC_GOT_TPREL16_HI: 3126 case R_PPC_GOT_TPREL16_HA: 3127 if (info->shared) 3128 info->flags |= DF_STATIC_TLS; 3129 tls_type = TLS_TLS | TLS_TPREL; 3130 goto dogottls; 3131 3132 case R_PPC_GOT_DTPREL16: 3133 case R_PPC_GOT_DTPREL16_LO: 3134 case R_PPC_GOT_DTPREL16_HI: 3135 case R_PPC_GOT_DTPREL16_HA: 3136 tls_type = TLS_TLS | TLS_DTPREL; 3137 dogottls: 3138 sec->has_tls_reloc = 1; 3139 /* Fall thru */ 3140 3141 /* GOT16 relocations */ 3142 case R_PPC_GOT16: 3143 case R_PPC_GOT16_LO: 3144 case R_PPC_GOT16_HI: 3145 case R_PPC_GOT16_HA: 3146 /* This symbol requires a global offset table entry. */ 3147 if (htab->got == NULL) 3148 { 3149 if (htab->elf.dynobj == NULL) 3150 htab->elf.dynobj = abfd; 3151 if (!ppc_elf_create_got (htab->elf.dynobj, info)) 3152 return FALSE; 3153 } 3154 if (h != NULL) 3155 { 3156 h->got.refcount += 1; 3157 ppc_elf_hash_entry (h)->tls_mask |= tls_type; 3158 } 3159 else 3160 /* This is a global offset table entry for a local symbol. */ 3161 if (!update_local_sym_info (abfd, symtab_hdr, r_symndx, tls_type)) 3162 return FALSE; 3163 break; 3164 3165 /* Indirect .sdata relocation. */ 3166 case R_PPC_EMB_SDAI16: 3167 if (info->shared) 3168 { 3169 bad_shared_reloc (abfd, r_type); 3170 return FALSE; 3171 } 3172 if (htab->sdata[0].section == NULL 3173 && !ppc_elf_create_linker_section (abfd, info, 0, 3174 &htab->sdata[0])) 3175 return FALSE; 3176 if (!elf_create_pointer_linker_section (abfd, &htab->sdata[0], 3177 h, rel)) 3178 return FALSE; 3179 if (h != NULL) 3180 { 3181 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 3182 h->non_got_ref = TRUE; 3183 } 3184 break; 3185 3186 /* Indirect .sdata2 relocation. */ 3187 case R_PPC_EMB_SDA2I16: 3188 if (info->shared) 3189 { 3190 bad_shared_reloc (abfd, r_type); 3191 return FALSE; 3192 } 3193 if (htab->sdata[1].section == NULL 3194 && !ppc_elf_create_linker_section (abfd, info, SEC_READONLY, 3195 &htab->sdata[1])) 3196 return FALSE; 3197 if (!elf_create_pointer_linker_section (abfd, &htab->sdata[1], 3198 h, rel)) 3199 return FALSE; 3200 if (h != NULL) 3201 { 3202 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 3203 h->non_got_ref = TRUE; 3204 } 3205 break; 3206 3207 case R_PPC_SDAREL16: 3208 if (info->shared) 3209 { 3210 bad_shared_reloc (abfd, r_type); 3211 return FALSE; 3212 } 3213 if (htab->sdata[0].sym == NULL 3214 && !create_sdata_sym (htab, &htab->sdata[0])) 3215 return FALSE; 3216 if (h != NULL) 3217 { 3218 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 3219 h->non_got_ref = TRUE; 3220 } 3221 break; 3222 3223 case R_PPC_EMB_SDA2REL: 3224 if (info->shared) 3225 { 3226 bad_shared_reloc (abfd, r_type); 3227 return FALSE; 3228 } 3229 if (htab->sdata[1].sym == NULL 3230 && !create_sdata_sym (htab, &htab->sdata[1])) 3231 return FALSE; 3232 if (h != NULL) 3233 { 3234 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 3235 h->non_got_ref = TRUE; 3236 } 3237 break; 3238 3239 case R_PPC_EMB_SDA21: 3240 case R_PPC_EMB_RELSDA: 3241 if (info->shared) 3242 { 3243 bad_shared_reloc (abfd, r_type); 3244 return FALSE; 3245 } 3246 if (htab->sdata[0].sym == NULL 3247 && !create_sdata_sym (htab, &htab->sdata[0])) 3248 return FALSE; 3249 if (htab->sdata[1].sym == NULL 3250 && !create_sdata_sym (htab, &htab->sdata[1])) 3251 return FALSE; 3252 if (h != NULL) 3253 { 3254 ppc_elf_hash_entry (h)->has_sda_refs = TRUE; 3255 h->non_got_ref = TRUE; 3256 } 3257 break; 3258 3259 case R_PPC_EMB_NADDR32: 3260 case R_PPC_EMB_NADDR16: 3261 case R_PPC_EMB_NADDR16_LO: 3262 case R_PPC_EMB_NADDR16_HI: 3263 case R_PPC_EMB_NADDR16_HA: 3264 if (info->shared) 3265 { 3266 bad_shared_reloc (abfd, r_type); 3267 return FALSE; 3268 } 3269 if (h != NULL) 3270 h->non_got_ref = TRUE; 3271 break; 3272 3273 case R_PPC_PLT32: 3274 case R_PPC_PLTREL24: 3275 case R_PPC_PLTREL32: 3276 case R_PPC_PLT16_LO: 3277 case R_PPC_PLT16_HI: 3278 case R_PPC_PLT16_HA: 3279#ifdef DEBUG 3280 fprintf (stderr, "Reloc requires a PLT entry\n"); 3281#endif 3282 /* This symbol requires a procedure linkage table entry. We 3283 actually build the entry in finish_dynamic_symbol, 3284 because this might be a case of linking PIC code without 3285 linking in any dynamic objects, in which case we don't 3286 need to generate a procedure linkage table after all. */ 3287 3288 if (h == NULL) 3289 { 3290 /* It does not make sense to have a procedure linkage 3291 table entry for a local symbol. */ 3292 (*_bfd_error_handler) (_("%B(%A+0x%lx): %s reloc against " 3293 "local symbol"), 3294 abfd, 3295 sec, 3296 (long) rel->r_offset, 3297 ppc_elf_howto_table[r_type]->name); 3298 bfd_set_error (bfd_error_bad_value); 3299 return FALSE; 3300 } 3301 else 3302 { 3303 bfd_vma addend = 0; 3304 3305 if (r_type == R_PPC_PLTREL24) 3306 { 3307 ppc_elf_tdata (abfd)->makes_plt_call = 1; 3308 addend = rel->r_addend; 3309 } 3310 h->needs_plt = 1; 3311 if (!update_plt_info (abfd, h, got2, addend)) 3312 return FALSE; 3313 } 3314 break; 3315 3316 /* The following relocations don't need to propagate the 3317 relocation if linking a shared object since they are 3318 section relative. */ 3319 case R_PPC_SECTOFF: 3320 case R_PPC_SECTOFF_LO: 3321 case R_PPC_SECTOFF_HI: 3322 case R_PPC_SECTOFF_HA: 3323 case R_PPC_DTPREL16: 3324 case R_PPC_DTPREL16_LO: 3325 case R_PPC_DTPREL16_HI: 3326 case R_PPC_DTPREL16_HA: 3327 case R_PPC_TOC16: 3328 break; 3329 3330 case R_PPC_REL16: 3331 case R_PPC_REL16_LO: 3332 case R_PPC_REL16_HI: 3333 case R_PPC_REL16_HA: 3334 ppc_elf_tdata (abfd)->has_rel16 = 1; 3335 break; 3336 3337 /* These are just markers. */ 3338 case R_PPC_TLS: 3339 case R_PPC_EMB_MRKREF: 3340 case R_PPC_NONE: 3341 case R_PPC_max: 3342 break; 3343 3344 /* These should only appear in dynamic objects. */ 3345 case R_PPC_COPY: 3346 case R_PPC_GLOB_DAT: 3347 case R_PPC_JMP_SLOT: 3348 case R_PPC_RELATIVE: 3349 break; 3350 3351 /* These aren't handled yet. We'll report an error later. */ 3352 case R_PPC_ADDR30: 3353 case R_PPC_EMB_RELSEC16: 3354 case R_PPC_EMB_RELST_LO: 3355 case R_PPC_EMB_RELST_HI: 3356 case R_PPC_EMB_RELST_HA: 3357 case R_PPC_EMB_BIT_FLD: 3358 break; 3359 3360 /* This refers only to functions defined in the shared library. */ 3361 case R_PPC_LOCAL24PC: 3362 if (h && h == htab->elf.hgot && htab->plt_type == PLT_UNSET) 3363 { 3364 htab->plt_type = PLT_OLD; 3365 htab->old_bfd = abfd; 3366 } 3367 break; 3368 3369 /* This relocation describes the C++ object vtable hierarchy. 3370 Reconstruct it for later use during GC. */ 3371 case R_PPC_GNU_VTINHERIT: 3372 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 3373 return FALSE; 3374 break; 3375 3376 /* This relocation describes which C++ vtable entries are actually 3377 used. Record for later use during GC. */ 3378 case R_PPC_GNU_VTENTRY: 3379 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 3380 return FALSE; 3381 break; 3382 3383 /* We shouldn't really be seeing these. */ 3384 case R_PPC_TPREL32: 3385 if (info->shared) 3386 info->flags |= DF_STATIC_TLS; 3387 goto dodyn; 3388 3389 /* Nor these. */ 3390 case R_PPC_DTPMOD32: 3391 case R_PPC_DTPREL32: 3392 goto dodyn; 3393 3394 case R_PPC_TPREL16: 3395 case R_PPC_TPREL16_LO: 3396 case R_PPC_TPREL16_HI: 3397 case R_PPC_TPREL16_HA: 3398 if (info->shared) 3399 info->flags |= DF_STATIC_TLS; 3400 goto dodyn; 3401 3402 case R_PPC_REL32: 3403 if (h == NULL 3404 && got2 != NULL 3405 && (sec->flags & SEC_CODE) != 0 3406 && (info->shared || info->pie) 3407 && htab->plt_type == PLT_UNSET) 3408 { 3409 /* Old -fPIC gcc code has .long LCTOC1-LCFx just before 3410 the start of a function, which assembles to a REL32 3411 reference to .got2. If we detect one of these, then 3412 force the old PLT layout because the linker cannot 3413 reliably deduce the GOT pointer value needed for 3414 PLT call stubs. */ 3415 asection *s; 3416 3417 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, sec, 3418 r_symndx); 3419 if (s == got2) 3420 { 3421 htab->plt_type = PLT_OLD; 3422 htab->old_bfd = abfd; 3423 } 3424 } 3425 if (h == NULL || h == htab->elf.hgot) 3426 break; 3427 goto dodyn1; 3428 3429 case R_PPC_REL24: 3430 case R_PPC_REL14: 3431 case R_PPC_REL14_BRTAKEN: 3432 case R_PPC_REL14_BRNTAKEN: 3433 if (h == NULL) 3434 break; 3435 if (h == htab->elf.hgot) 3436 { 3437 if (htab->plt_type == PLT_UNSET) 3438 { 3439 htab->plt_type = PLT_OLD; 3440 htab->old_bfd = abfd; 3441 } 3442 break; 3443 } 3444 /* fall through */ 3445 3446 case R_PPC_ADDR32: 3447 case R_PPC_ADDR24: 3448 case R_PPC_ADDR16: 3449 case R_PPC_ADDR16_LO: 3450 case R_PPC_ADDR16_HI: 3451 case R_PPC_ADDR16_HA: 3452 case R_PPC_ADDR14: 3453 case R_PPC_ADDR14_BRTAKEN: 3454 case R_PPC_ADDR14_BRNTAKEN: 3455 case R_PPC_UADDR32: 3456 case R_PPC_UADDR16: 3457 dodyn1: 3458 if (h != NULL && !info->shared) 3459 { 3460 /* We may need a plt entry if the symbol turns out to be 3461 a function defined in a dynamic object. */ 3462 if (!update_plt_info (abfd, h, NULL, 0)) 3463 return FALSE; 3464 3465 /* We may need a copy reloc too. */ 3466 h->non_got_ref = 1; 3467 } 3468 3469 dodyn: 3470 /* If we are creating a shared library, and this is a reloc 3471 against a global symbol, or a non PC relative reloc 3472 against a local symbol, then we need to copy the reloc 3473 into the shared library. However, if we are linking with 3474 -Bsymbolic, we do not need to copy a reloc against a 3475 global symbol which is defined in an object we are 3476 including in the link (i.e., DEF_REGULAR is set). At 3477 this point we have not seen all the input files, so it is 3478 possible that DEF_REGULAR is not set now but will be set 3479 later (it is never cleared). In case of a weak definition, 3480 DEF_REGULAR may be cleared later by a strong definition in 3481 a shared library. We account for that possibility below by 3482 storing information in the dyn_relocs field of the hash 3483 table entry. A similar situation occurs when creating 3484 shared libraries and symbol visibility changes render the 3485 symbol local. 3486 3487 If on the other hand, we are creating an executable, we 3488 may need to keep relocations for symbols satisfied by a 3489 dynamic library if we manage to avoid copy relocs for the 3490 symbol. */ 3491 if ((info->shared 3492 && (MUST_BE_DYN_RELOC (r_type) 3493 || (h != NULL 3494 && (! info->symbolic 3495 || h->root.type == bfd_link_hash_defweak 3496 || !h->def_regular)))) 3497 || (ELIMINATE_COPY_RELOCS 3498 && !info->shared 3499 && h != NULL 3500 && (h->root.type == bfd_link_hash_defweak 3501 || !h->def_regular))) 3502 { 3503 struct ppc_elf_dyn_relocs *p; 3504 struct ppc_elf_dyn_relocs **head; 3505 3506#ifdef DEBUG 3507 fprintf (stderr, 3508 "ppc_elf_check_relocs needs to " 3509 "create relocation for %s\n", 3510 (h && h->root.root.string 3511 ? h->root.root.string : "<unknown>")); 3512#endif 3513 if (sreloc == NULL) 3514 { 3515 const char *name; 3516 3517 name = (bfd_elf_string_from_elf_section 3518 (abfd, 3519 elf_elfheader (abfd)->e_shstrndx, 3520 elf_section_data (sec)->rel_hdr.sh_name)); 3521 if (name == NULL) 3522 return FALSE; 3523 3524 BFD_ASSERT (CONST_STRNEQ (name, ".rela") 3525 && strcmp (bfd_get_section_name (abfd, sec), 3526 name + 5) == 0); 3527 3528 if (htab->elf.dynobj == NULL) 3529 htab->elf.dynobj = abfd; 3530 sreloc = bfd_get_section_by_name (htab->elf.dynobj, name); 3531 if (sreloc == NULL) 3532 { 3533 flagword flags; 3534 3535 flags = (SEC_HAS_CONTENTS | SEC_READONLY 3536 | SEC_IN_MEMORY | SEC_LINKER_CREATED 3537 | SEC_ALLOC | SEC_LOAD); 3538 sreloc = bfd_make_section_with_flags (htab->elf.dynobj, 3539 name, 3540 flags); 3541 if (sreloc == NULL 3542 || ! bfd_set_section_alignment (htab->elf.dynobj, 3543 sreloc, 2)) 3544 return FALSE; 3545 } 3546 elf_section_data (sec)->sreloc = sreloc; 3547 } 3548 3549 /* If this is a global symbol, we count the number of 3550 relocations we need for this symbol. */ 3551 if (h != NULL) 3552 { 3553 head = &ppc_elf_hash_entry (h)->dyn_relocs; 3554 } 3555 else 3556 { 3557 /* Track dynamic relocs needed for local syms too. 3558 We really need local syms available to do this 3559 easily. Oh well. */ 3560 3561 asection *s; 3562 void *vpp; 3563 3564 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 3565 sec, r_symndx); 3566 if (s == NULL) 3567 return FALSE; 3568 3569 vpp = &elf_section_data (s)->local_dynrel; 3570 head = (struct ppc_elf_dyn_relocs **) vpp; 3571 } 3572 3573 p = *head; 3574 if (p == NULL || p->sec != sec) 3575 { 3576 p = bfd_alloc (htab->elf.dynobj, sizeof *p); 3577 if (p == NULL) 3578 return FALSE; 3579 p->next = *head; 3580 *head = p; 3581 p->sec = sec; 3582 p->count = 0; 3583 p->pc_count = 0; 3584 } 3585 3586 p->count += 1; 3587 if (!MUST_BE_DYN_RELOC (r_type)) 3588 p->pc_count += 1; 3589 } 3590 3591 break; 3592 } 3593 } 3594 3595 return TRUE; 3596} 3597 3598 3599/* Merge object attributes from IBFD into OBFD. Raise an error if 3600 there are conflicting attributes. */ 3601static bfd_boolean 3602ppc_elf_merge_obj_attributes (bfd *ibfd, bfd *obfd) 3603{ 3604 obj_attribute *in_attr; 3605 obj_attribute *out_attr; 3606 3607 if (!elf_known_obj_attributes_proc (obfd)[0].i) 3608 { 3609 /* This is the first object. Copy the attributes. */ 3610 _bfd_elf_copy_obj_attributes (ibfd, obfd); 3611 3612 /* Use the Tag_null value to indicate the attributes have been 3613 initialized. */ 3614 elf_known_obj_attributes_proc (obfd)[0].i = 1; 3615 3616 return TRUE; 3617 } 3618 3619 /* Check for conflicting Tag_GNU_Power_ABI_FP attributes and merge 3620 non-conflicting ones. */ 3621 in_attr = elf_known_obj_attributes (ibfd)[OBJ_ATTR_GNU]; 3622 out_attr = elf_known_obj_attributes (obfd)[OBJ_ATTR_GNU]; 3623 if (in_attr[Tag_GNU_Power_ABI_FP].i != out_attr[Tag_GNU_Power_ABI_FP].i) 3624 { 3625 out_attr[Tag_GNU_Power_ABI_FP].type = 1; 3626 if (out_attr[Tag_GNU_Power_ABI_FP].i == 0) 3627 out_attr[Tag_GNU_Power_ABI_FP].i = in_attr[Tag_GNU_Power_ABI_FP].i; 3628 else if (in_attr[Tag_GNU_Power_ABI_FP].i == 0) 3629 ; 3630 else if (out_attr[Tag_GNU_Power_ABI_FP].i == 1 3631 && in_attr[Tag_GNU_Power_ABI_FP].i == 2) 3632 _bfd_error_handler 3633 (_("Warning: %B uses hard float, %B uses soft float"), obfd, ibfd); 3634 else if (out_attr[Tag_GNU_Power_ABI_FP].i == 2 3635 && in_attr[Tag_GNU_Power_ABI_FP].i == 1) 3636 _bfd_error_handler 3637 (_("Warning: %B uses hard float, %B uses soft float"), ibfd, obfd); 3638 else if (in_attr[Tag_GNU_Power_ABI_FP].i > 2) 3639 _bfd_error_handler 3640 (_("Warning: %B uses unknown floating point ABI %d"), ibfd, 3641 in_attr[Tag_GNU_Power_ABI_FP].i); 3642 else 3643 _bfd_error_handler 3644 (_("Warning: %B uses unknown floating point ABI %d"), obfd, 3645 out_attr[Tag_GNU_Power_ABI_FP].i); 3646 } 3647 3648 /* Merge Tag_compatibility attributes and any common GNU ones. */ 3649 _bfd_elf_merge_object_attributes (ibfd, obfd); 3650 3651 return TRUE; 3652} 3653 3654/* Merge backend specific data from an object file to the output 3655 object file when linking. */ 3656 3657static bfd_boolean 3658ppc_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 3659{ 3660 flagword old_flags; 3661 flagword new_flags; 3662 bfd_boolean error; 3663 3664 if (!is_ppc_elf_target (ibfd->xvec) 3665 || !is_ppc_elf_target (obfd->xvec)) 3666 return TRUE; 3667 3668 /* Check if we have the same endianess. */ 3669 if (! _bfd_generic_verify_endian_match (ibfd, obfd)) 3670 return FALSE; 3671 3672 if (!ppc_elf_merge_obj_attributes (ibfd, obfd)) 3673 return FALSE; 3674 3675 new_flags = elf_elfheader (ibfd)->e_flags; 3676 old_flags = elf_elfheader (obfd)->e_flags; 3677 if (!elf_flags_init (obfd)) 3678 { 3679 /* First call, no flags set. */ 3680 elf_flags_init (obfd) = TRUE; 3681 elf_elfheader (obfd)->e_flags = new_flags; 3682 } 3683 3684 /* Compatible flags are ok. */ 3685 else if (new_flags == old_flags) 3686 ; 3687 3688 /* Incompatible flags. */ 3689 else 3690 { 3691 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib 3692 to be linked with either. */ 3693 error = FALSE; 3694 if ((new_flags & EF_PPC_RELOCATABLE) != 0 3695 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0) 3696 { 3697 error = TRUE; 3698 (*_bfd_error_handler) 3699 (_("%B: compiled with -mrelocatable and linked with " 3700 "modules compiled normally"), ibfd); 3701 } 3702 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0 3703 && (old_flags & EF_PPC_RELOCATABLE) != 0) 3704 { 3705 error = TRUE; 3706 (*_bfd_error_handler) 3707 (_("%B: compiled normally and linked with " 3708 "modules compiled with -mrelocatable"), ibfd); 3709 } 3710 3711 /* The output is -mrelocatable-lib iff both the input files are. */ 3712 if (! (new_flags & EF_PPC_RELOCATABLE_LIB)) 3713 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB; 3714 3715 /* The output is -mrelocatable iff it can't be -mrelocatable-lib, 3716 but each input file is either -mrelocatable or -mrelocatable-lib. */ 3717 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB) 3718 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)) 3719 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))) 3720 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE; 3721 3722 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if 3723 any module uses it. */ 3724 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB); 3725 3726 new_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 3727 old_flags &= ~(EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 3728 3729 /* Warn about any other mismatches. */ 3730 if (new_flags != old_flags) 3731 { 3732 error = TRUE; 3733 (*_bfd_error_handler) 3734 (_("%B: uses different e_flags (0x%lx) fields " 3735 "than previous modules (0x%lx)"), 3736 ibfd, (long) new_flags, (long) old_flags); 3737 } 3738 3739 if (error) 3740 { 3741 bfd_set_error (bfd_error_bad_value); 3742 return FALSE; 3743 } 3744 } 3745 3746 return TRUE; 3747} 3748 3749/* Choose which PLT scheme to use, and set .plt flags appropriately. 3750 Returns -1 on error, 0 for old PLT, 1 for new PLT. */ 3751int 3752ppc_elf_select_plt_layout (bfd *output_bfd ATTRIBUTE_UNUSED, 3753 struct bfd_link_info *info, 3754 enum ppc_elf_plt_type plt_style, 3755 int emit_stub_syms) 3756{ 3757 struct ppc_elf_link_hash_table *htab; 3758 flagword flags; 3759 3760 htab = ppc_elf_hash_table (info); 3761 3762 if (htab->plt_type == PLT_UNSET) 3763 { 3764 if (plt_style == PLT_OLD) 3765 htab->plt_type = PLT_OLD; 3766 else 3767 { 3768 bfd *ibfd; 3769 enum ppc_elf_plt_type plt_type = plt_style; 3770 3771 /* Look through the reloc flags left by ppc_elf_check_relocs. 3772 Use the old style bss plt if a file makes plt calls 3773 without using the new relocs, and if ld isn't given 3774 --secure-plt and we never see REL16 relocs. */ 3775 if (plt_type == PLT_UNSET) 3776 plt_type = PLT_OLD; 3777 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next) 3778 if (is_ppc_elf_target (ibfd->xvec)) 3779 { 3780 if (ppc_elf_tdata (ibfd)->has_rel16) 3781 plt_type = PLT_NEW; 3782 else if (ppc_elf_tdata (ibfd)->makes_plt_call) 3783 { 3784 plt_type = PLT_OLD; 3785 htab->old_bfd = ibfd; 3786 break; 3787 } 3788 } 3789 htab->plt_type = plt_type; 3790 } 3791 } 3792 if (htab->plt_type == PLT_OLD && plt_style == PLT_NEW) 3793 info->callbacks->info (_("Using bss-plt due to %B"), htab->old_bfd); 3794 3795 htab->emit_stub_syms = emit_stub_syms; 3796 3797 BFD_ASSERT (htab->plt_type != PLT_VXWORKS); 3798 3799 if (htab->plt_type == PLT_NEW) 3800 { 3801 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 3802 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 3803 3804 /* The new PLT is a loaded section. */ 3805 if (htab->plt != NULL 3806 && !bfd_set_section_flags (htab->elf.dynobj, htab->plt, flags)) 3807 return -1; 3808 3809 /* The new GOT is not executable. */ 3810 if (htab->got != NULL 3811 && !bfd_set_section_flags (htab->elf.dynobj, htab->got, flags)) 3812 return -1; 3813 } 3814 else 3815 { 3816 /* Stop an unused .glink section from affecting .text alignment. */ 3817 if (htab->glink != NULL 3818 && !bfd_set_section_alignment (htab->elf.dynobj, htab->glink, 0)) 3819 return -1; 3820 } 3821 return htab->plt_type == PLT_NEW; 3822} 3823 3824/* Return the section that should be marked against GC for a given 3825 relocation. */ 3826 3827static asection * 3828ppc_elf_gc_mark_hook (asection *sec, 3829 struct bfd_link_info *info, 3830 Elf_Internal_Rela *rel, 3831 struct elf_link_hash_entry *h, 3832 Elf_Internal_Sym *sym) 3833{ 3834 if (h != NULL) 3835 switch (ELF32_R_TYPE (rel->r_info)) 3836 { 3837 case R_PPC_GNU_VTINHERIT: 3838 case R_PPC_GNU_VTENTRY: 3839 return NULL; 3840 } 3841 3842 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 3843} 3844 3845/* Update the got, plt and dynamic reloc reference counts for the 3846 section being removed. */ 3847 3848static bfd_boolean 3849ppc_elf_gc_sweep_hook (bfd *abfd, 3850 struct bfd_link_info *info, 3851 asection *sec, 3852 const Elf_Internal_Rela *relocs) 3853{ 3854 struct ppc_elf_link_hash_table *htab; 3855 Elf_Internal_Shdr *symtab_hdr; 3856 struct elf_link_hash_entry **sym_hashes; 3857 bfd_signed_vma *local_got_refcounts; 3858 const Elf_Internal_Rela *rel, *relend; 3859 asection *got2; 3860 3861 if ((sec->flags & SEC_ALLOC) == 0) 3862 return TRUE; 3863 3864 elf_section_data (sec)->local_dynrel = NULL; 3865 3866 htab = ppc_elf_hash_table (info); 3867 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 3868 sym_hashes = elf_sym_hashes (abfd); 3869 local_got_refcounts = elf_local_got_refcounts (abfd); 3870 got2 = bfd_get_section_by_name (abfd, ".got2"); 3871 3872 relend = relocs + sec->reloc_count; 3873 for (rel = relocs; rel < relend; rel++) 3874 { 3875 unsigned long r_symndx; 3876 enum elf_ppc_reloc_type r_type; 3877 struct elf_link_hash_entry *h = NULL; 3878 3879 r_symndx = ELF32_R_SYM (rel->r_info); 3880 if (r_symndx >= symtab_hdr->sh_info) 3881 { 3882 struct ppc_elf_dyn_relocs **pp, *p; 3883 struct ppc_elf_link_hash_entry *eh; 3884 3885 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3886 while (h->root.type == bfd_link_hash_indirect 3887 || h->root.type == bfd_link_hash_warning) 3888 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3889 eh = (struct ppc_elf_link_hash_entry *) h; 3890 3891 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 3892 if (p->sec == sec) 3893 { 3894 /* Everything must go for SEC. */ 3895 *pp = p->next; 3896 break; 3897 } 3898 } 3899 3900 r_type = ELF32_R_TYPE (rel->r_info); 3901 switch (r_type) 3902 { 3903 case R_PPC_GOT_TLSLD16: 3904 case R_PPC_GOT_TLSLD16_LO: 3905 case R_PPC_GOT_TLSLD16_HI: 3906 case R_PPC_GOT_TLSLD16_HA: 3907 htab->tlsld_got.refcount -= 1; 3908 /* Fall thru */ 3909 3910 case R_PPC_GOT_TLSGD16: 3911 case R_PPC_GOT_TLSGD16_LO: 3912 case R_PPC_GOT_TLSGD16_HI: 3913 case R_PPC_GOT_TLSGD16_HA: 3914 case R_PPC_GOT_TPREL16: 3915 case R_PPC_GOT_TPREL16_LO: 3916 case R_PPC_GOT_TPREL16_HI: 3917 case R_PPC_GOT_TPREL16_HA: 3918 case R_PPC_GOT_DTPREL16: 3919 case R_PPC_GOT_DTPREL16_LO: 3920 case R_PPC_GOT_DTPREL16_HI: 3921 case R_PPC_GOT_DTPREL16_HA: 3922 case R_PPC_GOT16: 3923 case R_PPC_GOT16_LO: 3924 case R_PPC_GOT16_HI: 3925 case R_PPC_GOT16_HA: 3926 if (h != NULL) 3927 { 3928 if (h->got.refcount > 0) 3929 h->got.refcount--; 3930 } 3931 else if (local_got_refcounts != NULL) 3932 { 3933 if (local_got_refcounts[r_symndx] > 0) 3934 local_got_refcounts[r_symndx]--; 3935 } 3936 break; 3937 3938 case R_PPC_REL24: 3939 case R_PPC_REL14: 3940 case R_PPC_REL14_BRTAKEN: 3941 case R_PPC_REL14_BRNTAKEN: 3942 case R_PPC_REL32: 3943 if (h == NULL || h == htab->elf.hgot) 3944 break; 3945 /* Fall thru */ 3946 3947 case R_PPC_ADDR32: 3948 case R_PPC_ADDR24: 3949 case R_PPC_ADDR16: 3950 case R_PPC_ADDR16_LO: 3951 case R_PPC_ADDR16_HI: 3952 case R_PPC_ADDR16_HA: 3953 case R_PPC_ADDR14: 3954 case R_PPC_ADDR14_BRTAKEN: 3955 case R_PPC_ADDR14_BRNTAKEN: 3956 case R_PPC_UADDR32: 3957 case R_PPC_UADDR16: 3958 if (info->shared) 3959 break; 3960 3961 case R_PPC_PLT32: 3962 case R_PPC_PLTREL24: 3963 case R_PPC_PLTREL32: 3964 case R_PPC_PLT16_LO: 3965 case R_PPC_PLT16_HI: 3966 case R_PPC_PLT16_HA: 3967 if (h != NULL) 3968 { 3969 bfd_vma addend = r_type == R_PPC_PLTREL24 ? rel->r_addend : 0; 3970 struct plt_entry *ent = find_plt_ent (h, got2, addend); 3971 if (ent->plt.refcount > 0) 3972 ent->plt.refcount -= 1; 3973 } 3974 break; 3975 3976 default: 3977 break; 3978 } 3979 } 3980 return TRUE; 3981} 3982 3983/* Set htab->tls_get_addr and call the generic ELF tls_setup function. */ 3984 3985asection * 3986ppc_elf_tls_setup (bfd *obfd, struct bfd_link_info *info) 3987{ 3988 struct ppc_elf_link_hash_table *htab; 3989 3990 htab = ppc_elf_hash_table (info); 3991 if (htab->plt_type == PLT_NEW 3992 && htab->plt != NULL 3993 && htab->plt->output_section != NULL) 3994 { 3995 elf_section_type (htab->plt->output_section) = SHT_PROGBITS; 3996 elf_section_flags (htab->plt->output_section) = SHF_ALLOC + SHF_WRITE; 3997 } 3998 3999 htab->tls_get_addr = elf_link_hash_lookup (&htab->elf, "__tls_get_addr", 4000 FALSE, FALSE, TRUE); 4001 return _bfd_elf_tls_setup (obfd, info); 4002} 4003 4004/* Run through all the TLS relocs looking for optimization 4005 opportunities. */ 4006 4007bfd_boolean 4008ppc_elf_tls_optimize (bfd *obfd ATTRIBUTE_UNUSED, 4009 struct bfd_link_info *info) 4010{ 4011 bfd *ibfd; 4012 asection *sec; 4013 struct ppc_elf_link_hash_table *htab; 4014 4015 if (info->relocatable || info->shared) 4016 return TRUE; 4017 4018 htab = ppc_elf_hash_table (info); 4019 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 4020 { 4021 Elf_Internal_Sym *locsyms = NULL; 4022 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 4023 4024 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 4025 if (sec->has_tls_reloc && !bfd_is_abs_section (sec->output_section)) 4026 { 4027 Elf_Internal_Rela *relstart, *rel, *relend; 4028 int expecting_tls_get_addr; 4029 4030 /* Read the relocations. */ 4031 relstart = _bfd_elf_link_read_relocs (ibfd, sec, NULL, NULL, 4032 info->keep_memory); 4033 if (relstart == NULL) 4034 return FALSE; 4035 4036 expecting_tls_get_addr = 0; 4037 relend = relstart + sec->reloc_count; 4038 for (rel = relstart; rel < relend; rel++) 4039 { 4040 enum elf_ppc_reloc_type r_type; 4041 unsigned long r_symndx; 4042 struct elf_link_hash_entry *h = NULL; 4043 char *tls_mask; 4044 char tls_set, tls_clear; 4045 bfd_boolean is_local; 4046 4047 r_symndx = ELF32_R_SYM (rel->r_info); 4048 if (r_symndx >= symtab_hdr->sh_info) 4049 { 4050 struct elf_link_hash_entry **sym_hashes; 4051 4052 sym_hashes = elf_sym_hashes (ibfd); 4053 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 4054 while (h->root.type == bfd_link_hash_indirect 4055 || h->root.type == bfd_link_hash_warning) 4056 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4057 } 4058 4059 is_local = FALSE; 4060 if (h == NULL 4061 || !h->def_dynamic) 4062 is_local = TRUE; 4063 4064 r_type = ELF32_R_TYPE (rel->r_info); 4065 switch (r_type) 4066 { 4067 case R_PPC_GOT_TLSLD16: 4068 case R_PPC_GOT_TLSLD16_LO: 4069 case R_PPC_GOT_TLSLD16_HI: 4070 case R_PPC_GOT_TLSLD16_HA: 4071 /* These relocs should never be against a symbol 4072 defined in a shared lib. Leave them alone if 4073 that turns out to be the case. */ 4074 expecting_tls_get_addr = 0; 4075 htab->tlsld_got.refcount -= 1; 4076 if (!is_local) 4077 continue; 4078 4079 /* LD -> LE */ 4080 tls_set = 0; 4081 tls_clear = TLS_LD; 4082 expecting_tls_get_addr = 1; 4083 break; 4084 4085 case R_PPC_GOT_TLSGD16: 4086 case R_PPC_GOT_TLSGD16_LO: 4087 case R_PPC_GOT_TLSGD16_HI: 4088 case R_PPC_GOT_TLSGD16_HA: 4089 if (is_local) 4090 /* GD -> LE */ 4091 tls_set = 0; 4092 else 4093 /* GD -> IE */ 4094 tls_set = TLS_TLS | TLS_TPRELGD; 4095 tls_clear = TLS_GD; 4096 expecting_tls_get_addr = 1; 4097 break; 4098 4099 case R_PPC_GOT_TPREL16: 4100 case R_PPC_GOT_TPREL16_LO: 4101 case R_PPC_GOT_TPREL16_HI: 4102 case R_PPC_GOT_TPREL16_HA: 4103 expecting_tls_get_addr = 0; 4104 if (is_local) 4105 { 4106 /* IE -> LE */ 4107 tls_set = 0; 4108 tls_clear = TLS_TPREL; 4109 break; 4110 } 4111 else 4112 continue; 4113 4114 case R_PPC_REL14: 4115 case R_PPC_REL14_BRTAKEN: 4116 case R_PPC_REL14_BRNTAKEN: 4117 case R_PPC_REL24: 4118 if (expecting_tls_get_addr 4119 && h != NULL 4120 && h == htab->tls_get_addr) 4121 { 4122 struct plt_entry *ent = find_plt_ent (h, NULL, 0); 4123 if (ent != NULL && ent->plt.refcount > 0) 4124 ent->plt.refcount -= 1; 4125 } 4126 expecting_tls_get_addr = 0; 4127 continue; 4128 4129 default: 4130 expecting_tls_get_addr = 0; 4131 continue; 4132 } 4133 4134 if (h != NULL) 4135 { 4136 if (tls_set == 0) 4137 { 4138 /* We managed to get rid of a got entry. */ 4139 if (h->got.refcount > 0) 4140 h->got.refcount -= 1; 4141 } 4142 tls_mask = &ppc_elf_hash_entry (h)->tls_mask; 4143 } 4144 else 4145 { 4146 Elf_Internal_Sym *sym; 4147 bfd_signed_vma *lgot_refs; 4148 char *lgot_masks; 4149 4150 if (locsyms == NULL) 4151 { 4152 locsyms = (Elf_Internal_Sym *) symtab_hdr->contents; 4153 if (locsyms == NULL) 4154 locsyms = bfd_elf_get_elf_syms (ibfd, symtab_hdr, 4155 symtab_hdr->sh_info, 4156 0, NULL, NULL, NULL); 4157 if (locsyms == NULL) 4158 { 4159 if (elf_section_data (sec)->relocs != relstart) 4160 free (relstart); 4161 return FALSE; 4162 } 4163 } 4164 sym = locsyms + r_symndx; 4165 lgot_refs = elf_local_got_refcounts (ibfd); 4166 if (lgot_refs == NULL) 4167 abort (); 4168 if (tls_set == 0) 4169 { 4170 /* We managed to get rid of a got entry. */ 4171 if (lgot_refs[r_symndx] > 0) 4172 lgot_refs[r_symndx] -= 1; 4173 } 4174 lgot_masks = (char *) (lgot_refs + symtab_hdr->sh_info); 4175 tls_mask = &lgot_masks[r_symndx]; 4176 } 4177 4178 *tls_mask |= tls_set; 4179 *tls_mask &= ~tls_clear; 4180 } 4181 4182 if (elf_section_data (sec)->relocs != relstart) 4183 free (relstart); 4184 } 4185 4186 if (locsyms != NULL 4187 && (symtab_hdr->contents != (unsigned char *) locsyms)) 4188 { 4189 if (!info->keep_memory) 4190 free (locsyms); 4191 else 4192 symtab_hdr->contents = (unsigned char *) locsyms; 4193 } 4194 } 4195 return TRUE; 4196} 4197 4198/* Adjust a symbol defined by a dynamic object and referenced by a 4199 regular object. The current definition is in some section of the 4200 dynamic object, but we're not including those sections. We have to 4201 change the definition to something the rest of the link can 4202 understand. */ 4203 4204static bfd_boolean 4205ppc_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 4206 struct elf_link_hash_entry *h) 4207{ 4208 struct ppc_elf_link_hash_table *htab; 4209 asection *s; 4210 4211#ifdef DEBUG 4212 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", 4213 h->root.root.string); 4214#endif 4215 4216 /* Make sure we know what is going on here. */ 4217 htab = ppc_elf_hash_table (info); 4218 BFD_ASSERT (htab->elf.dynobj != NULL 4219 && (h->needs_plt 4220 || h->u.weakdef != NULL 4221 || (h->def_dynamic 4222 && h->ref_regular 4223 && !h->def_regular))); 4224 4225 /* Deal with function syms. */ 4226 if (h->type == STT_FUNC 4227 || h->needs_plt) 4228 { 4229 /* Clear procedure linkage table information for any symbol that 4230 won't need a .plt entry. */ 4231 struct plt_entry *ent; 4232 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 4233 if (ent->plt.refcount > 0) 4234 break; 4235 if (ent == NULL 4236 || SYMBOL_CALLS_LOCAL (info, h) 4237 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 4238 && h->root.type == bfd_link_hash_undefweak)) 4239 { 4240 /* A PLT entry is not required/allowed when: 4241 4242 1. We are not using ld.so; because then the PLT entry 4243 can't be set up, so we can't use one. In this case, 4244 ppc_elf_adjust_dynamic_symbol won't even be called. 4245 4246 2. GC has rendered the entry unused. 4247 4248 3. We know for certain that a call to this symbol 4249 will go to this object, or will remain undefined. */ 4250 h->plt.plist = NULL; 4251 h->needs_plt = 0; 4252 } 4253 return TRUE; 4254 } 4255 else 4256 h->plt.plist = NULL; 4257 4258 /* If this is a weak symbol, and there is a real definition, the 4259 processor independent code will have arranged for us to see the 4260 real definition first, and we can just use the same value. */ 4261 if (h->u.weakdef != NULL) 4262 { 4263 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 4264 || h->u.weakdef->root.type == bfd_link_hash_defweak); 4265 h->root.u.def.section = h->u.weakdef->root.u.def.section; 4266 h->root.u.def.value = h->u.weakdef->root.u.def.value; 4267 if (ELIMINATE_COPY_RELOCS) 4268 h->non_got_ref = h->u.weakdef->non_got_ref; 4269 return TRUE; 4270 } 4271 4272 /* This is a reference to a symbol defined by a dynamic object which 4273 is not a function. */ 4274 4275 /* If we are creating a shared library, we must presume that the 4276 only references to the symbol are via the global offset table. 4277 For such cases we need not do anything here; the relocations will 4278 be handled correctly by relocate_section. */ 4279 if (info->shared) 4280 return TRUE; 4281 4282 /* If there are no references to this symbol that do not use the 4283 GOT, we don't need to generate a copy reloc. */ 4284 if (!h->non_got_ref) 4285 return TRUE; 4286 4287 /* If we didn't find any dynamic relocs in read-only sections, then 4288 we'll be keeping the dynamic relocs and avoiding the copy reloc. 4289 We can't do this if there are any small data relocations. This 4290 doesn't work on VxWorks, where we can not have dynamic 4291 relocations (other than copy and jump slot relocations) in an 4292 executable. */ 4293 if (ELIMINATE_COPY_RELOCS 4294 && !ppc_elf_hash_entry (h)->has_sda_refs 4295 && !htab->is_vxworks) 4296 { 4297 struct ppc_elf_dyn_relocs *p; 4298 for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) 4299 { 4300 s = p->sec->output_section; 4301 if (s != NULL && (s->flags & SEC_READONLY) != 0) 4302 break; 4303 } 4304 4305 if (p == NULL) 4306 { 4307 h->non_got_ref = 0; 4308 return TRUE; 4309 } 4310 } 4311 4312 if (h->size == 0) 4313 { 4314 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"), 4315 h->root.root.string); 4316 return TRUE; 4317 } 4318 4319 /* We must allocate the symbol in our .dynbss section, which will 4320 become part of the .bss section of the executable. There will be 4321 an entry for this symbol in the .dynsym section. The dynamic 4322 object will contain position independent code, so all references 4323 from the dynamic object to this symbol will go through the global 4324 offset table. The dynamic linker will use the .dynsym entry to 4325 determine the address it must put in the global offset table, so 4326 both the dynamic object and the regular object will refer to the 4327 same memory location for the variable. 4328 4329 Of course, if the symbol is referenced using SDAREL relocs, we 4330 must instead allocate it in .sbss. */ 4331 4332 if (ppc_elf_hash_entry (h)->has_sda_refs) 4333 s = htab->dynsbss; 4334 else 4335 s = htab->dynbss; 4336 BFD_ASSERT (s != NULL); 4337 4338 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to 4339 copy the initial value out of the dynamic object and into the 4340 runtime process image. We need to remember the offset into the 4341 .rela.bss section we are going to use. */ 4342 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 4343 { 4344 asection *srel; 4345 4346 if (ppc_elf_hash_entry (h)->has_sda_refs) 4347 srel = htab->relsbss; 4348 else 4349 srel = htab->relbss; 4350 BFD_ASSERT (srel != NULL); 4351 srel->size += sizeof (Elf32_External_Rela); 4352 h->needs_copy = 1; 4353 } 4354 4355 return _bfd_elf_adjust_dynamic_copy (h, s); 4356} 4357 4358/* Generate a symbol to mark plt call stubs. For non-PIC code the sym is 4359 xxxxxxxx.plt_call32.<callee> where xxxxxxxx is a hex number, usually 0, 4360 specifying the addend on the plt relocation. For -fpic code, the sym 4361 is xxxxxxxx.plt_pic32.<callee>, and for -fPIC 4362 xxxxxxxx.got2.plt_pic32.<callee>. */ 4363 4364static bfd_boolean 4365add_stub_sym (struct plt_entry *ent, 4366 struct elf_link_hash_entry *h, 4367 struct bfd_link_info *info) 4368{ 4369 struct elf_link_hash_entry *sh; 4370 size_t len1, len2, len3; 4371 char *name; 4372 const char *stub; 4373 struct ppc_elf_link_hash_table *htab = ppc_elf_hash_table (info); 4374 4375 if (info->shared || info->pie) 4376 stub = ".plt_pic32."; 4377 else 4378 stub = ".plt_call32."; 4379 4380 len1 = strlen (h->root.root.string); 4381 len2 = strlen (stub); 4382 len3 = 0; 4383 if (ent->sec) 4384 len3 = strlen (ent->sec->name); 4385 name = bfd_malloc (len1 + len2 + len3 + 9); 4386 if (name == NULL) 4387 return FALSE; 4388 sprintf (name, "%08x", (unsigned) ent->addend & 0xffffffff); 4389 if (ent->sec) 4390 memcpy (name + 8, ent->sec->name, len3); 4391 memcpy (name + 8 + len3, stub, len2); 4392 memcpy (name + 8 + len3 + len2, h->root.root.string, len1 + 1); 4393 sh = elf_link_hash_lookup (&htab->elf, name, TRUE, FALSE, FALSE); 4394 if (sh == NULL) 4395 return FALSE; 4396 if (sh->root.type == bfd_link_hash_new) 4397 { 4398 sh->root.type = bfd_link_hash_defined; 4399 sh->root.u.def.section = htab->glink; 4400 sh->root.u.def.value = ent->glink_offset; 4401 sh->ref_regular = 1; 4402 sh->def_regular = 1; 4403 sh->ref_regular_nonweak = 1; 4404 sh->forced_local = 1; 4405 sh->non_elf = 0; 4406 } 4407 return TRUE; 4408} 4409 4410/* Allocate NEED contiguous space in .got, and return the offset. 4411 Handles allocation of the got header when crossing 32k. */ 4412 4413static bfd_vma 4414allocate_got (struct ppc_elf_link_hash_table *htab, unsigned int need) 4415{ 4416 bfd_vma where; 4417 unsigned int max_before_header; 4418 4419 if (htab->plt_type == PLT_VXWORKS) 4420 { 4421 where = htab->got->size; 4422 htab->got->size += need; 4423 } 4424 else 4425 { 4426 max_before_header = htab->plt_type == PLT_NEW ? 32768 : 32764; 4427 if (need <= htab->got_gap) 4428 { 4429 where = max_before_header - htab->got_gap; 4430 htab->got_gap -= need; 4431 } 4432 else 4433 { 4434 if (htab->got->size + need > max_before_header 4435 && htab->got->size <= max_before_header) 4436 { 4437 htab->got_gap = max_before_header - htab->got->size; 4438 htab->got->size = max_before_header + htab->got_header_size; 4439 } 4440 where = htab->got->size; 4441 htab->got->size += need; 4442 } 4443 } 4444 return where; 4445} 4446 4447/* Allocate space in associated reloc sections for dynamic relocs. */ 4448 4449static bfd_boolean 4450allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 4451{ 4452 struct bfd_link_info *info = inf; 4453 struct ppc_elf_link_hash_entry *eh; 4454 struct ppc_elf_link_hash_table *htab; 4455 struct ppc_elf_dyn_relocs *p; 4456 4457 if (h->root.type == bfd_link_hash_indirect) 4458 return TRUE; 4459 4460 if (h->root.type == bfd_link_hash_warning) 4461 /* When warning symbols are created, they **replace** the "real" 4462 entry in the hash table, thus we never get to see the real 4463 symbol in a hash traversal. So look at it now. */ 4464 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4465 4466 htab = ppc_elf_hash_table (info); 4467 if (htab->elf.dynamic_sections_created) 4468 { 4469 struct plt_entry *ent; 4470 bfd_boolean doneone = FALSE; 4471 bfd_vma plt_offset = 0, glink_offset = 0; 4472 4473 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 4474 if (ent->plt.refcount > 0) 4475 { 4476 /* Make sure this symbol is output as a dynamic symbol. */ 4477 if (h->dynindx == -1 4478 && !h->forced_local) 4479 { 4480 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4481 return FALSE; 4482 } 4483 4484 if (info->shared 4485 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 4486 { 4487 asection *s = htab->plt; 4488 4489 if (htab->plt_type == PLT_NEW) 4490 { 4491 if (!doneone) 4492 { 4493 plt_offset = s->size; 4494 s->size += 4; 4495 } 4496 ent->plt.offset = plt_offset; 4497 4498 s = htab->glink; 4499 if (!doneone || info->shared || info->pie) 4500 { 4501 glink_offset = s->size; 4502 s->size += GLINK_ENTRY_SIZE; 4503 } 4504 if (!doneone 4505 && !info->shared 4506 && !h->def_regular) 4507 { 4508 h->root.u.def.section = s; 4509 h->root.u.def.value = glink_offset; 4510 } 4511 ent->glink_offset = glink_offset; 4512 4513 if (htab->emit_stub_syms 4514 && !add_stub_sym (ent, h, info)) 4515 return FALSE; 4516 } 4517 else 4518 { 4519 if (!doneone) 4520 { 4521 /* If this is the first .plt entry, make room 4522 for the special first entry. */ 4523 if (s->size == 0) 4524 s->size += htab->plt_initial_entry_size; 4525 4526 /* The PowerPC PLT is actually composed of two 4527 parts, the first part is 2 words (for a load 4528 and a jump), and then there is a remaining 4529 word available at the end. */ 4530 plt_offset = (htab->plt_initial_entry_size 4531 + (htab->plt_slot_size 4532 * ((s->size 4533 - htab->plt_initial_entry_size) 4534 / htab->plt_entry_size))); 4535 4536 /* If this symbol is not defined in a regular 4537 file, and we are not generating a shared 4538 library, then set the symbol to this location 4539 in the .plt. This is required to make 4540 function pointers compare as equal between 4541 the normal executable and the shared library. */ 4542 if (! info->shared 4543 && !h->def_regular) 4544 { 4545 h->root.u.def.section = s; 4546 h->root.u.def.value = plt_offset; 4547 } 4548 4549 /* Make room for this entry. */ 4550 s->size += htab->plt_entry_size; 4551 /* After the 8192nd entry, room for two entries 4552 is allocated. */ 4553 if (htab->plt_type == PLT_OLD 4554 && (s->size - htab->plt_initial_entry_size) 4555 / htab->plt_entry_size 4556 > PLT_NUM_SINGLE_ENTRIES) 4557 s->size += htab->plt_entry_size; 4558 } 4559 ent->plt.offset = plt_offset; 4560 } 4561 4562 /* We also need to make an entry in the .rela.plt section. */ 4563 if (!doneone) 4564 { 4565 htab->relplt->size += sizeof (Elf32_External_Rela); 4566 4567 if (htab->plt_type == PLT_VXWORKS) 4568 { 4569 /* Allocate space for the unloaded relocations. */ 4570 if (!info->shared) 4571 { 4572 if (ent->plt.offset 4573 == (bfd_vma) htab->plt_initial_entry_size) 4574 { 4575 htab->srelplt2->size 4576 += sizeof (Elf32_External_Rela) 4577 * VXWORKS_PLTRESOLVE_RELOCS; 4578 } 4579 4580 htab->srelplt2->size 4581 += sizeof (Elf32_External_Rela) 4582 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS; 4583 } 4584 4585 /* Every PLT entry has an associated GOT entry in 4586 .got.plt. */ 4587 htab->sgotplt->size += 4; 4588 } 4589 doneone = TRUE; 4590 } 4591 } 4592 else 4593 ent->plt.offset = (bfd_vma) -1; 4594 } 4595 else 4596 ent->plt.offset = (bfd_vma) -1; 4597 4598 if (!doneone) 4599 { 4600 h->plt.plist = NULL; 4601 h->needs_plt = 0; 4602 } 4603 } 4604 else 4605 { 4606 h->plt.plist = NULL; 4607 h->needs_plt = 0; 4608 } 4609 4610 eh = (struct ppc_elf_link_hash_entry *) h; 4611 if (eh->elf.got.refcount > 0) 4612 { 4613 /* Make sure this symbol is output as a dynamic symbol. */ 4614 if (eh->elf.dynindx == -1 4615 && !eh->elf.forced_local) 4616 { 4617 if (!bfd_elf_link_record_dynamic_symbol (info, &eh->elf)) 4618 return FALSE; 4619 } 4620 4621 if (eh->tls_mask == (TLS_TLS | TLS_LD) 4622 && !eh->elf.def_dynamic) 4623 /* If just an LD reloc, we'll just use htab->tlsld_got.offset. */ 4624 eh->elf.got.offset = (bfd_vma) -1; 4625 else 4626 { 4627 bfd_boolean dyn; 4628 unsigned int need = 0; 4629 if ((eh->tls_mask & TLS_TLS) != 0) 4630 { 4631 if ((eh->tls_mask & TLS_LD) != 0) 4632 need += 8; 4633 if ((eh->tls_mask & TLS_GD) != 0) 4634 need += 8; 4635 if ((eh->tls_mask & (TLS_TPREL | TLS_TPRELGD)) != 0) 4636 need += 4; 4637 if ((eh->tls_mask & TLS_DTPREL) != 0) 4638 need += 4; 4639 } 4640 else 4641 need += 4; 4642 eh->elf.got.offset = allocate_got (htab, need); 4643 dyn = htab->elf.dynamic_sections_created; 4644 if ((info->shared 4645 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, &eh->elf)) 4646 && (ELF_ST_VISIBILITY (eh->elf.other) == STV_DEFAULT 4647 || eh->elf.root.type != bfd_link_hash_undefweak)) 4648 { 4649 /* All the entries we allocated need relocs. 4650 Except LD only needs one. */ 4651 if ((eh->tls_mask & TLS_LD) != 0) 4652 need -= 4; 4653 htab->relgot->size += need * (sizeof (Elf32_External_Rela) / 4); 4654 } 4655 } 4656 } 4657 else 4658 eh->elf.got.offset = (bfd_vma) -1; 4659 4660 if (eh->dyn_relocs == NULL) 4661 return TRUE; 4662 4663 /* In the shared -Bsymbolic case, discard space allocated for 4664 dynamic pc-relative relocs against symbols which turn out to be 4665 defined in regular objects. For the normal shared case, discard 4666 space for relocs that have become local due to symbol visibility 4667 changes. */ 4668 4669 if (info->shared) 4670 { 4671 /* Relocs that use pc_count are those that appear on a call insn, 4672 or certain REL relocs (see MUST_BE_DYN_RELOC) that can be 4673 generated via assembly. We want calls to protected symbols to 4674 resolve directly to the function rather than going via the plt. 4675 If people want function pointer comparisons to work as expected 4676 then they should avoid writing weird assembly. */ 4677 if (SYMBOL_CALLS_LOCAL (info, h)) 4678 { 4679 struct ppc_elf_dyn_relocs **pp; 4680 4681 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 4682 { 4683 p->count -= p->pc_count; 4684 p->pc_count = 0; 4685 if (p->count == 0) 4686 *pp = p->next; 4687 else 4688 pp = &p->next; 4689 } 4690 } 4691 4692 /* Also discard relocs on undefined weak syms with non-default 4693 visibility. */ 4694 if (eh->dyn_relocs != NULL 4695 && h->root.type == bfd_link_hash_undefweak) 4696 { 4697 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 4698 eh->dyn_relocs = NULL; 4699 4700 /* Make sure undefined weak symbols are output as a dynamic 4701 symbol in PIEs. */ 4702 else if (h->dynindx == -1 4703 && !h->forced_local) 4704 { 4705 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4706 return FALSE; 4707 } 4708 } 4709 } 4710 else if (ELIMINATE_COPY_RELOCS) 4711 { 4712 /* For the non-shared case, discard space for relocs against 4713 symbols which turn out to need copy relocs or are not 4714 dynamic. */ 4715 4716 if (!h->non_got_ref 4717 && h->def_dynamic 4718 && !h->def_regular) 4719 { 4720 /* Make sure this symbol is output as a dynamic symbol. 4721 Undefined weak syms won't yet be marked as dynamic. */ 4722 if (h->dynindx == -1 4723 && !h->forced_local) 4724 { 4725 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4726 return FALSE; 4727 } 4728 4729 /* If that succeeded, we know we'll be keeping all the 4730 relocs. */ 4731 if (h->dynindx != -1) 4732 goto keep; 4733 } 4734 4735 eh->dyn_relocs = NULL; 4736 4737 keep: ; 4738 } 4739 4740 /* Finally, allocate space. */ 4741 for (p = eh->dyn_relocs; p != NULL; p = p->next) 4742 { 4743 asection *sreloc = elf_section_data (p->sec)->sreloc; 4744 sreloc->size += p->count * sizeof (Elf32_External_Rela); 4745 } 4746 4747 return TRUE; 4748} 4749 4750/* Find any dynamic relocs that apply to read-only sections. */ 4751 4752static bfd_boolean 4753readonly_dynrelocs (struct elf_link_hash_entry *h, void *info) 4754{ 4755 struct ppc_elf_dyn_relocs *p; 4756 4757 if (h->root.type == bfd_link_hash_indirect) 4758 return TRUE; 4759 4760 if (h->root.type == bfd_link_hash_warning) 4761 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4762 4763 for (p = ppc_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next) 4764 { 4765 asection *s = p->sec->output_section; 4766 4767 if (s != NULL 4768 && ((s->flags & (SEC_READONLY | SEC_ALLOC)) 4769 == (SEC_READONLY | SEC_ALLOC))) 4770 { 4771 ((struct bfd_link_info *) info)->flags |= DF_TEXTREL; 4772 4773 /* Not an error, just cut short the traversal. */ 4774 return FALSE; 4775 } 4776 } 4777 return TRUE; 4778} 4779 4780/* Set the sizes of the dynamic sections. */ 4781 4782static bfd_boolean 4783ppc_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 4784 struct bfd_link_info *info) 4785{ 4786 struct ppc_elf_link_hash_table *htab; 4787 asection *s; 4788 bfd_boolean relocs; 4789 bfd *ibfd; 4790 4791#ifdef DEBUG 4792 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n"); 4793#endif 4794 4795 htab = ppc_elf_hash_table (info); 4796 BFD_ASSERT (htab->elf.dynobj != NULL); 4797 4798 if (elf_hash_table (info)->dynamic_sections_created) 4799 { 4800 /* Set the contents of the .interp section to the interpreter. */ 4801 if (info->executable) 4802 { 4803 s = bfd_get_section_by_name (htab->elf.dynobj, ".interp"); 4804 BFD_ASSERT (s != NULL); 4805 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 4806 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 4807 } 4808 } 4809 4810 if (htab->plt_type == PLT_OLD) 4811 htab->got_header_size = 16; 4812 else if (htab->plt_type == PLT_NEW) 4813 htab->got_header_size = 12; 4814 4815 /* Set up .got offsets for local syms, and space for local dynamic 4816 relocs. */ 4817 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 4818 { 4819 bfd_signed_vma *local_got; 4820 bfd_signed_vma *end_local_got; 4821 char *lgot_masks; 4822 bfd_size_type locsymcount; 4823 Elf_Internal_Shdr *symtab_hdr; 4824 4825 if (!is_ppc_elf_target (ibfd->xvec)) 4826 continue; 4827 4828 for (s = ibfd->sections; s != NULL; s = s->next) 4829 { 4830 struct ppc_elf_dyn_relocs *p; 4831 4832 for (p = ((struct ppc_elf_dyn_relocs *) 4833 elf_section_data (s)->local_dynrel); 4834 p != NULL; 4835 p = p->next) 4836 { 4837 if (!bfd_is_abs_section (p->sec) 4838 && bfd_is_abs_section (p->sec->output_section)) 4839 { 4840 /* Input section has been discarded, either because 4841 it is a copy of a linkonce section or due to 4842 linker script /DISCARD/, so we'll be discarding 4843 the relocs too. */ 4844 } 4845 else if (p->count != 0) 4846 { 4847 elf_section_data (p->sec)->sreloc->size 4848 += p->count * sizeof (Elf32_External_Rela); 4849 if ((p->sec->output_section->flags 4850 & (SEC_READONLY | SEC_ALLOC)) 4851 == (SEC_READONLY | SEC_ALLOC)) 4852 info->flags |= DF_TEXTREL; 4853 } 4854 } 4855 } 4856 4857 local_got = elf_local_got_refcounts (ibfd); 4858 if (!local_got) 4859 continue; 4860 4861 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 4862 locsymcount = symtab_hdr->sh_info; 4863 end_local_got = local_got + locsymcount; 4864 lgot_masks = (char *) end_local_got; 4865 for (; local_got < end_local_got; ++local_got, ++lgot_masks) 4866 if (*local_got > 0) 4867 { 4868 if (*lgot_masks == (TLS_TLS | TLS_LD)) 4869 { 4870 /* If just an LD reloc, we'll just use 4871 htab->tlsld_got.offset. */ 4872 htab->tlsld_got.refcount += 1; 4873 *local_got = (bfd_vma) -1; 4874 } 4875 else 4876 { 4877 unsigned int need = 0; 4878 if ((*lgot_masks & TLS_TLS) != 0) 4879 { 4880 if ((*lgot_masks & TLS_GD) != 0) 4881 need += 8; 4882 if ((*lgot_masks & (TLS_TPREL | TLS_TPRELGD)) != 0) 4883 need += 4; 4884 if ((*lgot_masks & TLS_DTPREL) != 0) 4885 need += 4; 4886 } 4887 else 4888 need += 4; 4889 *local_got = allocate_got (htab, need); 4890 if (info->shared) 4891 htab->relgot->size += (need 4892 * (sizeof (Elf32_External_Rela) / 4)); 4893 } 4894 } 4895 else 4896 *local_got = (bfd_vma) -1; 4897 } 4898 4899 if (htab->tlsld_got.refcount > 0) 4900 { 4901 htab->tlsld_got.offset = allocate_got (htab, 8); 4902 if (info->shared) 4903 htab->relgot->size += sizeof (Elf32_External_Rela); 4904 } 4905 else 4906 htab->tlsld_got.offset = (bfd_vma) -1; 4907 4908 /* Allocate space for global sym dynamic relocs. */ 4909 elf_link_hash_traverse (elf_hash_table (info), allocate_dynrelocs, info); 4910 4911 if (htab->got != NULL && htab->plt_type != PLT_VXWORKS) 4912 { 4913 unsigned int g_o_t = 32768; 4914 4915 /* If we haven't allocated the header, do so now. When we get here, 4916 for old plt/got the got size will be 0 to 32764 (not allocated), 4917 or 32780 to 65536 (header allocated). For new plt/got, the 4918 corresponding ranges are 0 to 32768 and 32780 to 65536. */ 4919 if (htab->got->size <= 32768) 4920 { 4921 g_o_t = htab->got->size; 4922 if (htab->plt_type == PLT_OLD) 4923 g_o_t += 4; 4924 htab->got->size += htab->got_header_size; 4925 } 4926 4927 htab->elf.hgot->root.u.def.value = g_o_t; 4928 } 4929 4930 if (htab->glink != NULL && htab->glink->size != 0) 4931 { 4932 htab->glink_pltresolve = htab->glink->size; 4933 /* Space for the branch table. */ 4934 htab->glink->size += htab->glink->size / (GLINK_ENTRY_SIZE / 4) - 4; 4935 /* Pad out to align the start of PLTresolve. */ 4936 htab->glink->size += -htab->glink->size & 15; 4937 htab->glink->size += GLINK_PLTRESOLVE; 4938 4939 if (htab->emit_stub_syms) 4940 { 4941 struct elf_link_hash_entry *sh; 4942 sh = elf_link_hash_lookup (&htab->elf, "__glink", 4943 TRUE, FALSE, FALSE); 4944 if (sh == NULL) 4945 return FALSE; 4946 if (sh->root.type == bfd_link_hash_new) 4947 { 4948 sh->root.type = bfd_link_hash_defined; 4949 sh->root.u.def.section = htab->glink; 4950 sh->root.u.def.value = htab->glink_pltresolve; 4951 sh->ref_regular = 1; 4952 sh->def_regular = 1; 4953 sh->ref_regular_nonweak = 1; 4954 sh->forced_local = 1; 4955 sh->non_elf = 0; 4956 } 4957 sh = elf_link_hash_lookup (&htab->elf, "__glink_PLTresolve", 4958 TRUE, FALSE, FALSE); 4959 if (sh == NULL) 4960 return FALSE; 4961 if (sh->root.type == bfd_link_hash_new) 4962 { 4963 sh->root.type = bfd_link_hash_defined; 4964 sh->root.u.def.section = htab->glink; 4965 sh->root.u.def.value = htab->glink->size - GLINK_PLTRESOLVE; 4966 sh->ref_regular = 1; 4967 sh->def_regular = 1; 4968 sh->ref_regular_nonweak = 1; 4969 sh->forced_local = 1; 4970 sh->non_elf = 0; 4971 } 4972 } 4973 } 4974 4975 /* We've now determined the sizes of the various dynamic sections. 4976 Allocate memory for them. */ 4977 relocs = FALSE; 4978 for (s = htab->elf.dynobj->sections; s != NULL; s = s->next) 4979 { 4980 bfd_boolean strip_section = TRUE; 4981 4982 if ((s->flags & SEC_LINKER_CREATED) == 0) 4983 continue; 4984 4985 if (s == htab->plt 4986 || s == htab->glink 4987 || s == htab->got 4988 || s == htab->sgotplt 4989 || s == htab->sbss 4990 || s == htab->dynbss 4991 || s == htab->dynsbss) 4992 { 4993 /* We'd like to strip these sections if they aren't needed, but if 4994 we've exported dynamic symbols from them we must leave them. 4995 It's too late to tell BFD to get rid of the symbols. */ 4996 if ((s == htab->plt || s == htab->got) && htab->elf.hplt != NULL) 4997 strip_section = FALSE; 4998 /* Strip this section if we don't need it; see the 4999 comment below. */ 5000 } 5001 else if (s == htab->sdata[0].section 5002 || s == htab->sdata[1].section) 5003 { 5004 /* Strip these too. */ 5005 } 5006 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 5007 { 5008 if (s->size != 0) 5009 { 5010 /* Remember whether there are any relocation sections. */ 5011 relocs = TRUE; 5012 5013 /* We use the reloc_count field as a counter if we need 5014 to copy relocs into the output file. */ 5015 s->reloc_count = 0; 5016 } 5017 } 5018 else 5019 { 5020 /* It's not one of our sections, so don't allocate space. */ 5021 continue; 5022 } 5023 5024 if (s->size == 0 && strip_section) 5025 { 5026 /* If we don't need this section, strip it from the 5027 output file. This is mostly to handle .rela.bss and 5028 .rela.plt. We must create both sections in 5029 create_dynamic_sections, because they must be created 5030 before the linker maps input sections to output 5031 sections. The linker does that before 5032 adjust_dynamic_symbol is called, and it is that 5033 function which decides whether anything needs to go 5034 into these sections. */ 5035 s->flags |= SEC_EXCLUDE; 5036 continue; 5037 } 5038 5039 if ((s->flags & SEC_HAS_CONTENTS) == 0) 5040 continue; 5041 5042 /* Allocate memory for the section contents. */ 5043 s->contents = bfd_zalloc (htab->elf.dynobj, s->size); 5044 if (s->contents == NULL) 5045 return FALSE; 5046 } 5047 5048 if (htab->elf.dynamic_sections_created) 5049 { 5050 /* Add some entries to the .dynamic section. We fill in the 5051 values later, in ppc_elf_finish_dynamic_sections, but we 5052 must add the entries now so that we get the correct size for 5053 the .dynamic section. The DT_DEBUG entry is filled in by the 5054 dynamic linker and used by the debugger. */ 5055#define add_dynamic_entry(TAG, VAL) \ 5056 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 5057 5058 if (info->executable) 5059 { 5060 if (!add_dynamic_entry (DT_DEBUG, 0)) 5061 return FALSE; 5062 } 5063 5064 if (htab->plt != NULL && htab->plt->size != 0) 5065 { 5066 if (!add_dynamic_entry (DT_PLTGOT, 0) 5067 || !add_dynamic_entry (DT_PLTRELSZ, 0) 5068 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 5069 || !add_dynamic_entry (DT_JMPREL, 0)) 5070 return FALSE; 5071 } 5072 5073 if (htab->glink != NULL && htab->glink->size != 0) 5074 { 5075 if (!add_dynamic_entry (DT_PPC_GOT, 0)) 5076 return FALSE; 5077 } 5078 5079 if (relocs) 5080 { 5081 if (!add_dynamic_entry (DT_RELA, 0) 5082 || !add_dynamic_entry (DT_RELASZ, 0) 5083 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))) 5084 return FALSE; 5085 } 5086 5087 /* If any dynamic relocs apply to a read-only section, then we 5088 need a DT_TEXTREL entry. */ 5089 if ((info->flags & DF_TEXTREL) == 0) 5090 elf_link_hash_traverse (elf_hash_table (info), readonly_dynrelocs, 5091 info); 5092 5093 if ((info->flags & DF_TEXTREL) != 0) 5094 { 5095 if (!add_dynamic_entry (DT_TEXTREL, 0)) 5096 return FALSE; 5097 } 5098 } 5099#undef add_dynamic_entry 5100 5101 return TRUE; 5102} 5103 5104#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0])) 5105 5106static const int shared_stub_entry[] = 5107 { 5108 0x7c0802a6, /* mflr 0 */ 5109 0x429f0005, /* bcl 20, 31, .Lxxx */ 5110 0x7d6802a6, /* mflr 11 */ 5111 0x3d6b0000, /* addis 11, 11, (xxx-.Lxxx)@ha */ 5112 0x396b0018, /* addi 11, 11, (xxx-.Lxxx)@l */ 5113 0x7c0803a6, /* mtlr 0 */ 5114 0x7d6903a6, /* mtctr 11 */ 5115 0x4e800420, /* bctr */ 5116 }; 5117 5118static const int stub_entry[] = 5119 { 5120 0x3d600000, /* lis 11,xxx@ha */ 5121 0x396b0000, /* addi 11,11,xxx@l */ 5122 0x7d6903a6, /* mtctr 11 */ 5123 0x4e800420, /* bctr */ 5124 }; 5125 5126static bfd_boolean 5127ppc_elf_relax_section (bfd *abfd, 5128 asection *isec, 5129 struct bfd_link_info *link_info, 5130 bfd_boolean *again) 5131{ 5132 struct one_fixup 5133 { 5134 struct one_fixup *next; 5135 asection *tsec; 5136 bfd_vma toff; 5137 bfd_vma trampoff; 5138 }; 5139 5140 Elf_Internal_Shdr *symtab_hdr; 5141 bfd_byte *contents = NULL; 5142 Elf_Internal_Sym *isymbuf = NULL; 5143 Elf_Internal_Rela *internal_relocs = NULL; 5144 Elf_Internal_Rela *irel, *irelend; 5145 struct one_fixup *fixups = NULL; 5146 bfd_boolean changed; 5147 struct ppc_elf_link_hash_table *htab; 5148 bfd_size_type trampoff; 5149 asection *got2; 5150 5151 *again = FALSE; 5152 5153 /* Nothing to do if there are no relocations, and no need to do 5154 anything with non-alloc sections. */ 5155 if ((isec->flags & SEC_ALLOC) == 0 5156 || (isec->flags & SEC_RELOC) == 0 5157 || isec->reloc_count == 0) 5158 return TRUE; 5159 5160 trampoff = (isec->size + 3) & (bfd_vma) -4; 5161 /* Space for a branch around any trampolines. */ 5162 trampoff += 4; 5163 5164 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5165 5166 /* Get a copy of the native relocations. */ 5167 internal_relocs = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, 5168 link_info->keep_memory); 5169 if (internal_relocs == NULL) 5170 goto error_return; 5171 5172 htab = ppc_elf_hash_table (link_info); 5173 got2 = bfd_get_section_by_name (abfd, ".got2"); 5174 5175 irelend = internal_relocs + isec->reloc_count; 5176 for (irel = internal_relocs; irel < irelend; irel++) 5177 { 5178 unsigned long r_type = ELF32_R_TYPE (irel->r_info); 5179 bfd_vma symaddr, reladdr, toff, roff; 5180 asection *tsec; 5181 struct one_fixup *f; 5182 size_t insn_offset = 0; 5183 bfd_vma max_branch_offset, val; 5184 bfd_byte *hit_addr; 5185 unsigned long t0; 5186 unsigned char sym_type; 5187 5188 switch (r_type) 5189 { 5190 case R_PPC_REL24: 5191 case R_PPC_LOCAL24PC: 5192 case R_PPC_PLTREL24: 5193 max_branch_offset = 1 << 25; 5194 break; 5195 5196 case R_PPC_REL14: 5197 case R_PPC_REL14_BRTAKEN: 5198 case R_PPC_REL14_BRNTAKEN: 5199 max_branch_offset = 1 << 15; 5200 break; 5201 5202 default: 5203 continue; 5204 } 5205 5206 /* Get the value of the symbol referred to by the reloc. */ 5207 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 5208 { 5209 /* A local symbol. */ 5210 Elf_Internal_Sym *isym; 5211 5212 /* Read this BFD's local symbols. */ 5213 if (isymbuf == NULL) 5214 { 5215 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 5216 if (isymbuf == NULL) 5217 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 5218 symtab_hdr->sh_info, 0, 5219 NULL, NULL, NULL); 5220 if (isymbuf == 0) 5221 goto error_return; 5222 } 5223 isym = isymbuf + ELF32_R_SYM (irel->r_info); 5224 if (isym->st_shndx == SHN_UNDEF) 5225 continue; /* We can't do anything with undefined symbols. */ 5226 else if (isym->st_shndx == SHN_ABS) 5227 tsec = bfd_abs_section_ptr; 5228 else if (isym->st_shndx == SHN_COMMON) 5229 tsec = bfd_com_section_ptr; 5230 else 5231 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); 5232 5233 toff = isym->st_value; 5234 sym_type = ELF_ST_TYPE (isym->st_info); 5235 } 5236 else 5237 { 5238 /* Global symbol handling. */ 5239 unsigned long indx; 5240 struct elf_link_hash_entry *h; 5241 5242 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 5243 h = elf_sym_hashes (abfd)[indx]; 5244 5245 while (h->root.type == bfd_link_hash_indirect 5246 || h->root.type == bfd_link_hash_warning) 5247 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5248 5249 tsec = NULL; 5250 toff = 0; 5251 if (r_type == R_PPC_PLTREL24 5252 && htab->plt != NULL) 5253 { 5254 struct plt_entry *ent = find_plt_ent (h, got2, irel->r_addend); 5255 5256 if (ent != NULL) 5257 { 5258 if (htab->plt_type == PLT_NEW) 5259 { 5260 tsec = htab->glink; 5261 toff = ent->glink_offset; 5262 } 5263 else 5264 { 5265 tsec = htab->plt; 5266 toff = ent->plt.offset; 5267 } 5268 } 5269 } 5270 if (tsec != NULL) 5271 ; 5272 else if (h->root.type == bfd_link_hash_defined 5273 || h->root.type == bfd_link_hash_defweak) 5274 { 5275 tsec = h->root.u.def.section; 5276 toff = h->root.u.def.value; 5277 } 5278 else 5279 continue; 5280 5281 sym_type = h->type; 5282 } 5283 5284 /* If the branch and target are in the same section, you have 5285 no hope of adding stubs. We'll error out later should the 5286 branch overflow. */ 5287 if (tsec == isec) 5288 continue; 5289 5290 /* There probably isn't any reason to handle symbols in 5291 SEC_MERGE sections; SEC_MERGE doesn't seem a likely 5292 attribute for a code section, and we are only looking at 5293 branches. However, implement it correctly here as a 5294 reference for other target relax_section functions. */ 5295 if (0 && tsec->sec_info_type == ELF_INFO_TYPE_MERGE) 5296 { 5297 /* At this stage in linking, no SEC_MERGE symbol has been 5298 adjusted, so all references to such symbols need to be 5299 passed through _bfd_merged_section_offset. (Later, in 5300 relocate_section, all SEC_MERGE symbols *except* for 5301 section symbols have been adjusted.) 5302 5303 gas may reduce relocations against symbols in SEC_MERGE 5304 sections to a relocation against the section symbol when 5305 the original addend was zero. When the reloc is against 5306 a section symbol we should include the addend in the 5307 offset passed to _bfd_merged_section_offset, since the 5308 location of interest is the original symbol. On the 5309 other hand, an access to "sym+addend" where "sym" is not 5310 a section symbol should not include the addend; Such an 5311 access is presumed to be an offset from "sym"; The 5312 location of interest is just "sym". */ 5313 if (sym_type == STT_SECTION) 5314 toff += irel->r_addend; 5315 5316 toff = _bfd_merged_section_offset (abfd, &tsec, 5317 elf_section_data (tsec)->sec_info, 5318 toff); 5319 5320 if (sym_type != STT_SECTION) 5321 toff += irel->r_addend; 5322 } 5323 /* PLTREL24 addends are special. */ 5324 else if (r_type != R_PPC_PLTREL24) 5325 toff += irel->r_addend; 5326 5327 /* Attempted -shared link of non-pic code loses. */ 5328 if (tsec->output_section == NULL) 5329 continue; 5330 5331 symaddr = tsec->output_section->vma + tsec->output_offset + toff; 5332 5333 roff = irel->r_offset; 5334 reladdr = isec->output_section->vma + isec->output_offset + roff; 5335 5336 /* If the branch is in range, no need to do anything. */ 5337 if (symaddr - reladdr + max_branch_offset < 2 * max_branch_offset) 5338 continue; 5339 5340 /* Look for an existing fixup to this address. */ 5341 for (f = fixups; f ; f = f->next) 5342 if (f->tsec == tsec && f->toff == toff) 5343 break; 5344 5345 if (f == NULL) 5346 { 5347 size_t size; 5348 unsigned long stub_rtype; 5349 5350 val = trampoff - roff; 5351 if (val >= max_branch_offset) 5352 /* Oh dear, we can't reach a trampoline. Don't try to add 5353 one. We'll report an error later. */ 5354 continue; 5355 5356 if (link_info->shared) 5357 { 5358 size = 4 * ARRAY_SIZE (shared_stub_entry); 5359 insn_offset = 12; 5360 stub_rtype = R_PPC_RELAX32PC; 5361 } 5362 else 5363 { 5364 size = 4 * ARRAY_SIZE (stub_entry); 5365 insn_offset = 0; 5366 stub_rtype = R_PPC_RELAX32; 5367 } 5368 5369 if (R_PPC_RELAX32_PLT - R_PPC_RELAX32 5370 != R_PPC_RELAX32PC_PLT - R_PPC_RELAX32PC) 5371 abort (); 5372 if (tsec == htab->plt 5373 || tsec == htab->glink) 5374 stub_rtype += R_PPC_RELAX32_PLT - R_PPC_RELAX32; 5375 5376 /* Hijack the old relocation. Since we need two 5377 relocations for this use a "composite" reloc. */ 5378 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 5379 stub_rtype); 5380 irel->r_offset = trampoff + insn_offset; 5381 5382 /* Record the fixup so we don't do it again this section. */ 5383 f = bfd_malloc (sizeof (*f)); 5384 f->next = fixups; 5385 f->tsec = tsec; 5386 f->toff = toff; 5387 f->trampoff = trampoff; 5388 fixups = f; 5389 5390 trampoff += size; 5391 } 5392 else 5393 { 5394 val = f->trampoff - roff; 5395 if (val >= max_branch_offset) 5396 continue; 5397 5398 /* Nop out the reloc, since we're finalizing things here. */ 5399 irel->r_info = ELF32_R_INFO (0, R_PPC_NONE); 5400 } 5401 5402 /* Get the section contents. */ 5403 if (contents == NULL) 5404 { 5405 /* Get cached copy if it exists. */ 5406 if (elf_section_data (isec)->this_hdr.contents != NULL) 5407 contents = elf_section_data (isec)->this_hdr.contents; 5408 else 5409 { 5410 /* Go get them off disk. */ 5411 if (!bfd_malloc_and_get_section (abfd, isec, &contents)) 5412 goto error_return; 5413 } 5414 } 5415 5416 /* Fix up the existing branch to hit the trampoline. */ 5417 hit_addr = contents + roff; 5418 switch (r_type) 5419 { 5420 case R_PPC_REL24: 5421 case R_PPC_LOCAL24PC: 5422 case R_PPC_PLTREL24: 5423 t0 = bfd_get_32 (abfd, hit_addr); 5424 t0 &= ~0x3fffffc; 5425 t0 |= val & 0x3fffffc; 5426 bfd_put_32 (abfd, t0, hit_addr); 5427 break; 5428 5429 case R_PPC_REL14: 5430 case R_PPC_REL14_BRTAKEN: 5431 case R_PPC_REL14_BRNTAKEN: 5432 t0 = bfd_get_32 (abfd, hit_addr); 5433 t0 &= ~0xfffc; 5434 t0 |= val & 0xfffc; 5435 bfd_put_32 (abfd, t0, hit_addr); 5436 break; 5437 } 5438 } 5439 5440 /* Write out the trampolines. */ 5441 changed = fixups != NULL; 5442 if (fixups != NULL) 5443 { 5444 const int *stub; 5445 bfd_byte *dest; 5446 bfd_vma val; 5447 int i, size; 5448 5449 do 5450 { 5451 struct one_fixup *f = fixups; 5452 fixups = fixups->next; 5453 free (f); 5454 } 5455 while (fixups); 5456 5457 contents = bfd_realloc (contents, trampoff); 5458 if (contents == NULL) 5459 goto error_return; 5460 5461 isec->size = (isec->size + 3) & (bfd_vma) -4; 5462 /* Branch around the trampolines. */ 5463 val = trampoff - isec->size + 0x48000000; 5464 dest = contents + isec->size; 5465 isec->size = trampoff; 5466 bfd_put_32 (abfd, val, dest); 5467 dest += 4; 5468 5469 if (link_info->shared) 5470 { 5471 stub = shared_stub_entry; 5472 size = ARRAY_SIZE (shared_stub_entry); 5473 } 5474 else 5475 { 5476 stub = stub_entry; 5477 size = ARRAY_SIZE (stub_entry); 5478 } 5479 5480 i = 0; 5481 while (dest < contents + trampoff) 5482 { 5483 bfd_put_32 (abfd, stub[i], dest); 5484 i++; 5485 if (i == size) 5486 i = 0; 5487 dest += 4; 5488 } 5489 BFD_ASSERT (i == 0); 5490 } 5491 5492 if (isymbuf != NULL 5493 && symtab_hdr->contents != (unsigned char *) isymbuf) 5494 { 5495 if (! link_info->keep_memory) 5496 free (isymbuf); 5497 else 5498 { 5499 /* Cache the symbols for elf_link_input_bfd. */ 5500 symtab_hdr->contents = (unsigned char *) isymbuf; 5501 } 5502 } 5503 5504 if (contents != NULL 5505 && elf_section_data (isec)->this_hdr.contents != contents) 5506 { 5507 if (!changed && !link_info->keep_memory) 5508 free (contents); 5509 else 5510 { 5511 /* Cache the section contents for elf_link_input_bfd. */ 5512 elf_section_data (isec)->this_hdr.contents = contents; 5513 } 5514 } 5515 5516 if (elf_section_data (isec)->relocs != internal_relocs) 5517 { 5518 if (!changed) 5519 free (internal_relocs); 5520 else 5521 elf_section_data (isec)->relocs = internal_relocs; 5522 } 5523 5524 *again = changed; 5525 return TRUE; 5526 5527 error_return: 5528 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents) 5529 free (isymbuf); 5530 if (contents != NULL 5531 && elf_section_data (isec)->this_hdr.contents != contents) 5532 free (contents); 5533 if (internal_relocs != NULL 5534 && elf_section_data (isec)->relocs != internal_relocs) 5535 free (internal_relocs); 5536 return FALSE; 5537} 5538 5539/* What to do when ld finds relocations against symbols defined in 5540 discarded sections. */ 5541 5542static unsigned int 5543ppc_elf_action_discarded (asection *sec) 5544{ 5545 if (strcmp (".fixup", sec->name) == 0) 5546 return 0; 5547 5548 if (strcmp (".got2", sec->name) == 0) 5549 return 0; 5550 5551 return _bfd_elf_default_action_discarded (sec); 5552} 5553 5554/* Fill in the address for a pointer generated in a linker section. */ 5555 5556static bfd_vma 5557elf_finish_pointer_linker_section (bfd *input_bfd, 5558 elf_linker_section_t *lsect, 5559 struct elf_link_hash_entry *h, 5560 bfd_vma relocation, 5561 const Elf_Internal_Rela *rel) 5562{ 5563 elf_linker_section_pointers_t *linker_section_ptr; 5564 5565 BFD_ASSERT (lsect != NULL); 5566 5567 if (h != NULL) 5568 { 5569 /* Handle global symbol. */ 5570 struct ppc_elf_link_hash_entry *eh; 5571 5572 eh = (struct ppc_elf_link_hash_entry *) h; 5573 BFD_ASSERT (eh->elf.def_regular); 5574 linker_section_ptr = eh->linker_section_pointer; 5575 } 5576 else 5577 { 5578 /* Handle local symbol. */ 5579 unsigned long r_symndx = ELF32_R_SYM (rel->r_info); 5580 5581 BFD_ASSERT (elf_local_ptr_offsets (input_bfd) != NULL); 5582 linker_section_ptr = elf_local_ptr_offsets (input_bfd)[r_symndx]; 5583 } 5584 5585 linker_section_ptr = elf_find_pointer_linker_section (linker_section_ptr, 5586 rel->r_addend, 5587 lsect); 5588 BFD_ASSERT (linker_section_ptr != NULL); 5589 5590 /* Offset will always be a multiple of four, so use the bottom bit 5591 as a "written" flag. */ 5592 if ((linker_section_ptr->offset & 1) == 0) 5593 { 5594 bfd_put_32 (lsect->section->owner, 5595 relocation + linker_section_ptr->addend, 5596 lsect->section->contents + linker_section_ptr->offset); 5597 linker_section_ptr->offset += 1; 5598 } 5599 5600 relocation = (lsect->section->output_offset 5601 + linker_section_ptr->offset - 1 5602 - 0x8000); 5603 5604#ifdef DEBUG 5605 fprintf (stderr, 5606 "Finish pointer in linker section %s, offset = %ld (0x%lx)\n", 5607 lsect->name, (long) relocation, (long) relocation); 5608#endif 5609 5610 /* Subtract out the addend, because it will get added back in by the normal 5611 processing. */ 5612 return relocation - linker_section_ptr->addend; 5613} 5614 5615/* The RELOCATE_SECTION function is called by the ELF backend linker 5616 to handle the relocations for a section. 5617 5618 The relocs are always passed as Rela structures; if the section 5619 actually uses Rel structures, the r_addend field will always be 5620 zero. 5621 5622 This function is responsible for adjust the section contents as 5623 necessary, and (if using Rela relocs and generating a 5624 relocatable output file) adjusting the reloc addend as 5625 necessary. 5626 5627 This function does not have to worry about setting the reloc 5628 address or the reloc symbol index. 5629 5630 LOCAL_SYMS is a pointer to the swapped in local symbols. 5631 5632 LOCAL_SECTIONS is an array giving the section in the input file 5633 corresponding to the st_shndx field of each local symbol. 5634 5635 The global hash table entry for the global symbols can be found 5636 via elf_sym_hashes (input_bfd). 5637 5638 When generating relocatable output, this function must handle 5639 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 5640 going to be the section symbol corresponding to the output 5641 section, which means that the addend must be adjusted 5642 accordingly. */ 5643 5644static bfd_boolean 5645ppc_elf_relocate_section (bfd *output_bfd, 5646 struct bfd_link_info *info, 5647 bfd *input_bfd, 5648 asection *input_section, 5649 bfd_byte *contents, 5650 Elf_Internal_Rela *relocs, 5651 Elf_Internal_Sym *local_syms, 5652 asection **local_sections) 5653{ 5654 Elf_Internal_Shdr *symtab_hdr; 5655 struct elf_link_hash_entry **sym_hashes; 5656 struct ppc_elf_link_hash_table *htab; 5657 Elf_Internal_Rela *rel; 5658 Elf_Internal_Rela *relend; 5659 Elf_Internal_Rela outrel; 5660 bfd_byte *loc; 5661 asection *got2, *sreloc = NULL; 5662 bfd_vma *local_got_offsets; 5663 bfd_boolean ret = TRUE; 5664 bfd_vma d_offset = (bfd_big_endian (output_bfd) ? 2 : 0); 5665 5666#ifdef DEBUG 5667 _bfd_error_handler ("ppc_elf_relocate_section called for %B section %A, " 5668 "%ld relocations%s", 5669 input_bfd, input_section, 5670 (long) input_section->reloc_count, 5671 (info->relocatable) ? " (relocatable)" : ""); 5672#endif 5673 5674 got2 = bfd_get_section_by_name (input_bfd, ".got2"); 5675 5676 /* Initialize howto table if not already done. */ 5677 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 5678 ppc_elf_howto_init (); 5679 5680 htab = ppc_elf_hash_table (info); 5681 local_got_offsets = elf_local_got_offsets (input_bfd); 5682 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 5683 sym_hashes = elf_sym_hashes (input_bfd); 5684 rel = relocs; 5685 relend = relocs + input_section->reloc_count; 5686 for (; rel < relend; rel++) 5687 { 5688 enum elf_ppc_reloc_type r_type; 5689 bfd_vma addend; 5690 bfd_reloc_status_type r; 5691 Elf_Internal_Sym *sym; 5692 asection *sec; 5693 struct elf_link_hash_entry *h; 5694 const char *sym_name; 5695 reloc_howto_type *howto; 5696 unsigned long r_symndx; 5697 bfd_vma relocation; 5698 bfd_vma branch_bit, insn, from; 5699 bfd_boolean unresolved_reloc; 5700 bfd_boolean warned; 5701 unsigned int tls_type, tls_mask, tls_gd; 5702 5703 r_type = ELF32_R_TYPE (rel->r_info); 5704 sym = NULL; 5705 sec = NULL; 5706 h = NULL; 5707 unresolved_reloc = FALSE; 5708 warned = FALSE; 5709 r_symndx = ELF32_R_SYM (rel->r_info); 5710 5711 if (r_symndx < symtab_hdr->sh_info) 5712 { 5713 sym = local_syms + r_symndx; 5714 sec = local_sections[r_symndx]; 5715 sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); 5716 5717 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 5718 } 5719 else 5720 { 5721 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 5722 r_symndx, symtab_hdr, sym_hashes, 5723 h, sec, relocation, 5724 unresolved_reloc, warned); 5725 5726 sym_name = h->root.root.string; 5727 } 5728 5729 if (sec != NULL && elf_discarded_section (sec)) 5730 { 5731 /* For relocs against symbols from removed linkonce sections, 5732 or sections discarded by a linker script, we just want the 5733 section contents zeroed. Avoid any special processing. */ 5734 howto = NULL; 5735 if (r_type < R_PPC_max) 5736 howto = ppc_elf_howto_table[r_type]; 5737 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset); 5738 rel->r_info = 0; 5739 rel->r_addend = 0; 5740 continue; 5741 } 5742 5743 if (info->relocatable) 5744 { 5745 if (got2 != NULL 5746 && r_type == R_PPC_PLTREL24 5747 && rel->r_addend >= 32768) 5748 { 5749 /* R_PPC_PLTREL24 is rather special. If non-zero, the 5750 addend specifies the GOT pointer offset within .got2. */ 5751 rel->r_addend += got2->output_offset; 5752 } 5753 continue; 5754 } 5755 5756 /* TLS optimizations. Replace instruction sequences and relocs 5757 based on information we collected in tls_optimize. We edit 5758 RELOCS so that --emit-relocs will output something sensible 5759 for the final instruction stream. */ 5760 tls_mask = 0; 5761 tls_gd = 0; 5762 if (IS_PPC_TLS_RELOC (r_type)) 5763 { 5764 if (h != NULL) 5765 tls_mask = ((struct ppc_elf_link_hash_entry *) h)->tls_mask; 5766 else if (local_got_offsets != NULL) 5767 { 5768 char *lgot_masks; 5769 lgot_masks = (char *) (local_got_offsets + symtab_hdr->sh_info); 5770 tls_mask = lgot_masks[r_symndx]; 5771 } 5772 } 5773 5774 /* Ensure reloc mapping code below stays sane. */ 5775 if ((R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TLSGD16 & 3) 5776 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TLSGD16_LO & 3) 5777 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TLSGD16_HI & 3) 5778 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TLSGD16_HA & 3) 5779 || (R_PPC_GOT_TLSLD16 & 3) != (R_PPC_GOT_TPREL16 & 3) 5780 || (R_PPC_GOT_TLSLD16_LO & 3) != (R_PPC_GOT_TPREL16_LO & 3) 5781 || (R_PPC_GOT_TLSLD16_HI & 3) != (R_PPC_GOT_TPREL16_HI & 3) 5782 || (R_PPC_GOT_TLSLD16_HA & 3) != (R_PPC_GOT_TPREL16_HA & 3)) 5783 abort (); 5784 switch (r_type) 5785 { 5786 default: 5787 break; 5788 5789 case R_PPC_GOT_TPREL16: 5790 case R_PPC_GOT_TPREL16_LO: 5791 if (tls_mask != 0 5792 && (tls_mask & TLS_TPREL) == 0) 5793 { 5794 bfd_vma insn; 5795 insn = bfd_get_32 (output_bfd, contents + rel->r_offset - d_offset); 5796 insn &= 31 << 21; 5797 insn |= 0x3c020000; /* addis 0,2,0 */ 5798 bfd_put_32 (output_bfd, insn, contents + rel->r_offset - d_offset); 5799 r_type = R_PPC_TPREL16_HA; 5800 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 5801 } 5802 break; 5803 5804 case R_PPC_TLS: 5805 if (tls_mask != 0 5806 && (tls_mask & TLS_TPREL) == 0) 5807 { 5808 bfd_vma insn, rtra; 5809 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 5810 if ((insn & ((31 << 26) | (31 << 11))) 5811 == ((31 << 26) | (2 << 11))) 5812 rtra = insn & ((1 << 26) - (1 << 16)); 5813 else if ((insn & ((31 << 26) | (31 << 16))) 5814 == ((31 << 26) | (2 << 16))) 5815 rtra = (insn & (31 << 21)) | ((insn & (31 << 11)) << 5); 5816 else 5817 abort (); 5818 if ((insn & ((1 << 11) - (1 << 1))) == 266 << 1) 5819 /* add -> addi. */ 5820 insn = 14 << 26; 5821 else if ((insn & (31 << 1)) == 23 << 1 5822 && ((insn & (31 << 6)) < 14 << 6 5823 || ((insn & (31 << 6)) >= 16 << 6 5824 && (insn & (31 << 6)) < 24 << 6))) 5825 /* load and store indexed -> dform. */ 5826 insn = (32 | ((insn >> 6) & 31)) << 26; 5827 else if ((insn & (31 << 1)) == 21 << 1 5828 && (insn & (0x1a << 6)) == 0) 5829 /* ldx, ldux, stdx, stdux -> ld, ldu, std, stdu. */ 5830 insn = (((58 | ((insn >> 6) & 4)) << 26) 5831 | ((insn >> 6) & 1)); 5832 else if ((insn & (31 << 1)) == 21 << 1 5833 && (insn & ((1 << 11) - (1 << 1))) == 341 << 1) 5834 /* lwax -> lwa. */ 5835 insn = (58 << 26) | 2; 5836 else 5837 abort (); 5838 insn |= rtra; 5839 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 5840 r_type = R_PPC_TPREL16_LO; 5841 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 5842 5843 /* Was PPC_TLS which sits on insn boundary, now 5844 PPC_TPREL16_LO which is at low-order half-word. */ 5845 rel->r_offset += d_offset; 5846 } 5847 break; 5848 5849 case R_PPC_GOT_TLSGD16_HI: 5850 case R_PPC_GOT_TLSGD16_HA: 5851 tls_gd = TLS_TPRELGD; 5852 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 5853 goto tls_gdld_hi; 5854 break; 5855 5856 case R_PPC_GOT_TLSLD16_HI: 5857 case R_PPC_GOT_TLSLD16_HA: 5858 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 5859 { 5860 tls_gdld_hi: 5861 if ((tls_mask & tls_gd) != 0) 5862 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3) 5863 + R_PPC_GOT_TPREL16); 5864 else 5865 { 5866 bfd_put_32 (output_bfd, NOP, contents + rel->r_offset); 5867 rel->r_offset -= d_offset; 5868 r_type = R_PPC_NONE; 5869 } 5870 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 5871 } 5872 break; 5873 5874 case R_PPC_GOT_TLSGD16: 5875 case R_PPC_GOT_TLSGD16_LO: 5876 tls_gd = TLS_TPRELGD; 5877 if (tls_mask != 0 && (tls_mask & TLS_GD) == 0) 5878 goto tls_get_addr_check; 5879 break; 5880 5881 case R_PPC_GOT_TLSLD16: 5882 case R_PPC_GOT_TLSLD16_LO: 5883 if (tls_mask != 0 && (tls_mask & TLS_LD) == 0) 5884 { 5885 tls_get_addr_check: 5886 if (rel + 1 < relend) 5887 { 5888 enum elf_ppc_reloc_type r_type2; 5889 unsigned long r_symndx2; 5890 struct elf_link_hash_entry *h2; 5891 bfd_vma insn1, insn2; 5892 bfd_vma offset; 5893 5894 /* The next instruction should be a call to 5895 __tls_get_addr. Peek at the reloc to be sure. */ 5896 r_type2 = ELF32_R_TYPE (rel[1].r_info); 5897 r_symndx2 = ELF32_R_SYM (rel[1].r_info); 5898 if (r_symndx2 < symtab_hdr->sh_info 5899 || (r_type2 != R_PPC_REL14 5900 && r_type2 != R_PPC_REL14_BRTAKEN 5901 && r_type2 != R_PPC_REL14_BRNTAKEN 5902 && r_type2 != R_PPC_REL24 5903 && r_type2 != R_PPC_PLTREL24)) 5904 break; 5905 5906 h2 = sym_hashes[r_symndx2 - symtab_hdr->sh_info]; 5907 while (h2->root.type == bfd_link_hash_indirect 5908 || h2->root.type == bfd_link_hash_warning) 5909 h2 = (struct elf_link_hash_entry *) h2->root.u.i.link; 5910 if (h2 == NULL || h2 != htab->tls_get_addr) 5911 break; 5912 5913 /* OK, it checks out. Replace the call. */ 5914 offset = rel[1].r_offset; 5915 insn1 = bfd_get_32 (output_bfd, 5916 contents + rel->r_offset - d_offset); 5917 if ((tls_mask & tls_gd) != 0) 5918 { 5919 /* IE */ 5920 insn1 &= (1 << 26) - 1; 5921 insn1 |= 32 << 26; /* lwz */ 5922 insn2 = 0x7c631214; /* add 3,3,2 */ 5923 rel[1].r_info = ELF32_R_INFO (r_symndx2, R_PPC_NONE); 5924 rel[1].r_addend = 0; 5925 r_type = (((r_type - (R_PPC_GOT_TLSGD16 & 3)) & 3) 5926 + R_PPC_GOT_TPREL16); 5927 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 5928 } 5929 else 5930 { 5931 /* LE */ 5932 insn1 = 0x3c620000; /* addis 3,2,0 */ 5933 insn2 = 0x38630000; /* addi 3,3,0 */ 5934 if (tls_gd == 0) 5935 { 5936 /* Was an LD reloc. */ 5937 r_symndx = 0; 5938 rel->r_addend = htab->elf.tls_sec->vma + DTP_OFFSET; 5939 } 5940 r_type = R_PPC_TPREL16_HA; 5941 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 5942 rel[1].r_info = ELF32_R_INFO (r_symndx, 5943 R_PPC_TPREL16_LO); 5944 rel[1].r_offset += d_offset; 5945 rel[1].r_addend = rel->r_addend; 5946 } 5947 bfd_put_32 (output_bfd, insn1, contents + rel->r_offset - d_offset); 5948 bfd_put_32 (output_bfd, insn2, contents + offset); 5949 if (tls_gd == 0) 5950 { 5951 /* We changed the symbol on an LD reloc. Start over 5952 in order to get h, sym, sec etc. right. */ 5953 rel--; 5954 continue; 5955 } 5956 } 5957 } 5958 break; 5959 } 5960 5961 /* Handle other relocations that tweak non-addend part of insn. */ 5962 branch_bit = 0; 5963 switch (r_type) 5964 { 5965 default: 5966 break; 5967 5968 /* Branch taken prediction relocations. */ 5969 case R_PPC_ADDR14_BRTAKEN: 5970 case R_PPC_REL14_BRTAKEN: 5971 branch_bit = BRANCH_PREDICT_BIT; 5972 /* Fall thru */ 5973 5974 /* Branch not taken prediction relocations. */ 5975 case R_PPC_ADDR14_BRNTAKEN: 5976 case R_PPC_REL14_BRNTAKEN: 5977 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 5978 insn &= ~BRANCH_PREDICT_BIT; 5979 insn |= branch_bit; 5980 5981 from = (rel->r_offset 5982 + input_section->output_offset 5983 + input_section->output_section->vma); 5984 5985 /* Invert 'y' bit if not the default. */ 5986 if ((bfd_signed_vma) (relocation + rel->r_addend - from) < 0) 5987 insn ^= BRANCH_PREDICT_BIT; 5988 5989 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 5990 break; 5991 } 5992 5993 addend = rel->r_addend; 5994 tls_type = 0; 5995 howto = NULL; 5996 if (r_type < R_PPC_max) 5997 howto = ppc_elf_howto_table[r_type]; 5998 switch (r_type) 5999 { 6000 default: 6001 (*_bfd_error_handler) 6002 (_("%B: unknown relocation type %d for symbol %s"), 6003 input_bfd, (int) r_type, sym_name); 6004 6005 bfd_set_error (bfd_error_bad_value); 6006 ret = FALSE; 6007 continue; 6008 6009 case R_PPC_NONE: 6010 case R_PPC_TLS: 6011 case R_PPC_EMB_MRKREF: 6012 case R_PPC_GNU_VTINHERIT: 6013 case R_PPC_GNU_VTENTRY: 6014 continue; 6015 6016 /* GOT16 relocations. Like an ADDR16 using the symbol's 6017 address in the GOT as relocation value instead of the 6018 symbol's value itself. Also, create a GOT entry for the 6019 symbol and put the symbol value there. */ 6020 case R_PPC_GOT_TLSGD16: 6021 case R_PPC_GOT_TLSGD16_LO: 6022 case R_PPC_GOT_TLSGD16_HI: 6023 case R_PPC_GOT_TLSGD16_HA: 6024 tls_type = TLS_TLS | TLS_GD; 6025 goto dogot; 6026 6027 case R_PPC_GOT_TLSLD16: 6028 case R_PPC_GOT_TLSLD16_LO: 6029 case R_PPC_GOT_TLSLD16_HI: 6030 case R_PPC_GOT_TLSLD16_HA: 6031 tls_type = TLS_TLS | TLS_LD; 6032 goto dogot; 6033 6034 case R_PPC_GOT_TPREL16: 6035 case R_PPC_GOT_TPREL16_LO: 6036 case R_PPC_GOT_TPREL16_HI: 6037 case R_PPC_GOT_TPREL16_HA: 6038 tls_type = TLS_TLS | TLS_TPREL; 6039 goto dogot; 6040 6041 case R_PPC_GOT_DTPREL16: 6042 case R_PPC_GOT_DTPREL16_LO: 6043 case R_PPC_GOT_DTPREL16_HI: 6044 case R_PPC_GOT_DTPREL16_HA: 6045 tls_type = TLS_TLS | TLS_DTPREL; 6046 goto dogot; 6047 6048 case R_PPC_GOT16: 6049 case R_PPC_GOT16_LO: 6050 case R_PPC_GOT16_HI: 6051 case R_PPC_GOT16_HA: 6052 dogot: 6053 { 6054 /* Relocation is to the entry for this symbol in the global 6055 offset table. */ 6056 bfd_vma off; 6057 bfd_vma *offp; 6058 unsigned long indx; 6059 6060 if (htab->got == NULL) 6061 abort (); 6062 6063 indx = 0; 6064 if (tls_type == (TLS_TLS | TLS_LD) 6065 && (h == NULL 6066 || !h->def_dynamic)) 6067 offp = &htab->tlsld_got.offset; 6068 else if (h != NULL) 6069 { 6070 bfd_boolean dyn; 6071 dyn = htab->elf.dynamic_sections_created; 6072 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 6073 || (info->shared 6074 && SYMBOL_REFERENCES_LOCAL (info, h))) 6075 /* This is actually a static link, or it is a 6076 -Bsymbolic link and the symbol is defined 6077 locally, or the symbol was forced to be local 6078 because of a version file. */ 6079 ; 6080 else 6081 { 6082 indx = h->dynindx; 6083 unresolved_reloc = FALSE; 6084 } 6085 offp = &h->got.offset; 6086 } 6087 else 6088 { 6089 if (local_got_offsets == NULL) 6090 abort (); 6091 offp = &local_got_offsets[r_symndx]; 6092 } 6093 6094 /* The offset must always be a multiple of 4. We use the 6095 least significant bit to record whether we have already 6096 processed this entry. */ 6097 off = *offp; 6098 if ((off & 1) != 0) 6099 off &= ~1; 6100 else 6101 { 6102 unsigned int tls_m = (tls_mask 6103 & (TLS_LD | TLS_GD | TLS_DTPREL 6104 | TLS_TPREL | TLS_TPRELGD)); 6105 6106 if (offp == &htab->tlsld_got.offset) 6107 tls_m = TLS_LD; 6108 else if (h == NULL 6109 || !h->def_dynamic) 6110 tls_m &= ~TLS_LD; 6111 6112 /* We might have multiple got entries for this sym. 6113 Initialize them all. */ 6114 do 6115 { 6116 int tls_ty = 0; 6117 6118 if ((tls_m & TLS_LD) != 0) 6119 { 6120 tls_ty = TLS_TLS | TLS_LD; 6121 tls_m &= ~TLS_LD; 6122 } 6123 else if ((tls_m & TLS_GD) != 0) 6124 { 6125 tls_ty = TLS_TLS | TLS_GD; 6126 tls_m &= ~TLS_GD; 6127 } 6128 else if ((tls_m & TLS_DTPREL) != 0) 6129 { 6130 tls_ty = TLS_TLS | TLS_DTPREL; 6131 tls_m &= ~TLS_DTPREL; 6132 } 6133 else if ((tls_m & (TLS_TPREL | TLS_TPRELGD)) != 0) 6134 { 6135 tls_ty = TLS_TLS | TLS_TPREL; 6136 tls_m = 0; 6137 } 6138 6139 /* Generate relocs for the dynamic linker. */ 6140 if ((info->shared || indx != 0) 6141 && (h == NULL 6142 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 6143 || h->root.type != bfd_link_hash_undefweak)) 6144 { 6145 outrel.r_offset = (htab->got->output_section->vma 6146 + htab->got->output_offset 6147 + off); 6148 outrel.r_addend = 0; 6149 if (tls_ty & (TLS_LD | TLS_GD)) 6150 { 6151 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPMOD32); 6152 if (tls_ty == (TLS_TLS | TLS_GD)) 6153 { 6154 loc = htab->relgot->contents; 6155 loc += (htab->relgot->reloc_count++ 6156 * sizeof (Elf32_External_Rela)); 6157 bfd_elf32_swap_reloca_out (output_bfd, 6158 &outrel, loc); 6159 outrel.r_offset += 4; 6160 outrel.r_info 6161 = ELF32_R_INFO (indx, R_PPC_DTPREL32); 6162 } 6163 } 6164 else if (tls_ty == (TLS_TLS | TLS_DTPREL)) 6165 outrel.r_info = ELF32_R_INFO (indx, R_PPC_DTPREL32); 6166 else if (tls_ty == (TLS_TLS | TLS_TPREL)) 6167 outrel.r_info = ELF32_R_INFO (indx, R_PPC_TPREL32); 6168 else if (indx == 0) 6169 outrel.r_info = ELF32_R_INFO (indx, R_PPC_RELATIVE); 6170 else 6171 outrel.r_info = ELF32_R_INFO (indx, R_PPC_GLOB_DAT); 6172 if (indx == 0) 6173 { 6174 outrel.r_addend += relocation; 6175 if (tls_ty & (TLS_GD | TLS_DTPREL | TLS_TPREL)) 6176 outrel.r_addend -= htab->elf.tls_sec->vma; 6177 } 6178 loc = htab->relgot->contents; 6179 loc += (htab->relgot->reloc_count++ 6180 * sizeof (Elf32_External_Rela)); 6181 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 6182 } 6183 6184 /* Init the .got section contents if we're not 6185 emitting a reloc. */ 6186 else 6187 { 6188 bfd_vma value = relocation; 6189 6190 if (tls_ty == (TLS_TLS | TLS_LD)) 6191 value = 1; 6192 else if (tls_ty != 0) 6193 { 6194 value -= htab->elf.tls_sec->vma + DTP_OFFSET; 6195 if (tls_ty == (TLS_TLS | TLS_TPREL)) 6196 value += DTP_OFFSET - TP_OFFSET; 6197 6198 if (tls_ty == (TLS_TLS | TLS_GD)) 6199 { 6200 bfd_put_32 (output_bfd, value, 6201 htab->got->contents + off + 4); 6202 value = 1; 6203 } 6204 } 6205 bfd_put_32 (output_bfd, value, 6206 htab->got->contents + off); 6207 } 6208 6209 off += 4; 6210 if (tls_ty & (TLS_LD | TLS_GD)) 6211 off += 4; 6212 } 6213 while (tls_m != 0); 6214 6215 off = *offp; 6216 *offp = off | 1; 6217 } 6218 6219 if (off >= (bfd_vma) -2) 6220 abort (); 6221 6222 if ((tls_type & TLS_TLS) != 0) 6223 { 6224 if (tls_type != (TLS_TLS | TLS_LD)) 6225 { 6226 if ((tls_mask & TLS_LD) != 0 6227 && !(h == NULL 6228 || !h->def_dynamic)) 6229 off += 8; 6230 if (tls_type != (TLS_TLS | TLS_GD)) 6231 { 6232 if ((tls_mask & TLS_GD) != 0) 6233 off += 8; 6234 if (tls_type != (TLS_TLS | TLS_DTPREL)) 6235 { 6236 if ((tls_mask & TLS_DTPREL) != 0) 6237 off += 4; 6238 } 6239 } 6240 } 6241 } 6242 6243 relocation = htab->got->output_offset + off; 6244 relocation -= htab->elf.hgot->root.u.def.value; 6245 6246 /* Addends on got relocations don't make much sense. 6247 x+off@got is actually x@got+off, and since the got is 6248 generated by a hash table traversal, the value in the 6249 got at entry m+n bears little relation to the entry m. */ 6250 if (addend != 0) 6251 (*_bfd_error_handler) 6252 (_("%B(%A+0x%lx): non-zero addend on %s reloc against `%s'"), 6253 input_bfd, 6254 input_section, 6255 (long) rel->r_offset, 6256 howto->name, 6257 sym_name); 6258 } 6259 break; 6260 6261 /* Relocations that need no special processing. */ 6262 case R_PPC_LOCAL24PC: 6263 /* It makes no sense to point a local relocation 6264 at a symbol not in this object. */ 6265 if (unresolved_reloc) 6266 { 6267 if (! (*info->callbacks->undefined_symbol) (info, 6268 h->root.root.string, 6269 input_bfd, 6270 input_section, 6271 rel->r_offset, 6272 TRUE)) 6273 return FALSE; 6274 continue; 6275 } 6276 break; 6277 6278 case R_PPC_DTPREL16: 6279 case R_PPC_DTPREL16_LO: 6280 case R_PPC_DTPREL16_HI: 6281 case R_PPC_DTPREL16_HA: 6282 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 6283 break; 6284 6285 /* Relocations that may need to be propagated if this is a shared 6286 object. */ 6287 case R_PPC_TPREL16: 6288 case R_PPC_TPREL16_LO: 6289 case R_PPC_TPREL16_HI: 6290 case R_PPC_TPREL16_HA: 6291 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 6292 /* The TPREL16 relocs shouldn't really be used in shared 6293 libs as they will result in DT_TEXTREL being set, but 6294 support them anyway. */ 6295 goto dodyn; 6296 6297 case R_PPC_TPREL32: 6298 addend -= htab->elf.tls_sec->vma + TP_OFFSET; 6299 goto dodyn; 6300 6301 case R_PPC_DTPREL32: 6302 addend -= htab->elf.tls_sec->vma + DTP_OFFSET; 6303 goto dodyn; 6304 6305 case R_PPC_DTPMOD32: 6306 relocation = 1; 6307 addend = 0; 6308 goto dodyn; 6309 6310 case R_PPC_REL16: 6311 case R_PPC_REL16_LO: 6312 case R_PPC_REL16_HI: 6313 case R_PPC_REL16_HA: 6314 break; 6315 6316 case R_PPC_REL24: 6317 case R_PPC_REL32: 6318 case R_PPC_REL14: 6319 case R_PPC_REL14_BRTAKEN: 6320 case R_PPC_REL14_BRNTAKEN: 6321 /* If these relocations are not to a named symbol, they can be 6322 handled right here, no need to bother the dynamic linker. */ 6323 if (SYMBOL_REFERENCES_LOCAL (info, h) 6324 || h == htab->elf.hgot) 6325 break; 6326 /* fall through */ 6327 6328 /* Relocations that always need to be propagated if this is a shared 6329 object. */ 6330 case R_PPC_ADDR32: 6331 case R_PPC_ADDR24: 6332 case R_PPC_ADDR16: 6333 case R_PPC_ADDR16_LO: 6334 case R_PPC_ADDR16_HI: 6335 case R_PPC_ADDR16_HA: 6336 case R_PPC_ADDR14: 6337 case R_PPC_ADDR14_BRTAKEN: 6338 case R_PPC_ADDR14_BRNTAKEN: 6339 case R_PPC_UADDR32: 6340 case R_PPC_UADDR16: 6341 dodyn: 6342 if ((input_section->flags & SEC_ALLOC) == 0) 6343 break; 6344 /* Fall thru. */ 6345 6346 if ((info->shared 6347 && (h == NULL 6348 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 6349 || h->root.type != bfd_link_hash_undefweak) 6350 && (MUST_BE_DYN_RELOC (r_type) 6351 || !SYMBOL_CALLS_LOCAL (info, h))) 6352 || (ELIMINATE_COPY_RELOCS 6353 && !info->shared 6354 && h != NULL 6355 && h->dynindx != -1 6356 && !h->non_got_ref 6357 && h->def_dynamic 6358 && !h->def_regular)) 6359 { 6360 int skip; 6361 6362#ifdef DEBUG 6363 fprintf (stderr, "ppc_elf_relocate_section needs to " 6364 "create relocation for %s\n", 6365 (h && h->root.root.string 6366 ? h->root.root.string : "<unknown>")); 6367#endif 6368 6369 /* When generating a shared object, these relocations 6370 are copied into the output file to be resolved at run 6371 time. */ 6372 if (sreloc == NULL) 6373 { 6374 const char *name; 6375 6376 name = (bfd_elf_string_from_elf_section 6377 (input_bfd, 6378 elf_elfheader (input_bfd)->e_shstrndx, 6379 elf_section_data (input_section)->rel_hdr.sh_name)); 6380 if (name == NULL) 6381 return FALSE; 6382 6383 BFD_ASSERT (CONST_STRNEQ (name, ".rela") 6384 && strcmp (bfd_get_section_name (input_bfd, 6385 input_section), 6386 name + 5) == 0); 6387 6388 sreloc = bfd_get_section_by_name (htab->elf.dynobj, name); 6389 BFD_ASSERT (sreloc != NULL); 6390 } 6391 6392 skip = 0; 6393 6394 outrel.r_offset = 6395 _bfd_elf_section_offset (output_bfd, info, input_section, 6396 rel->r_offset); 6397 if (outrel.r_offset == (bfd_vma) -1 6398 || outrel.r_offset == (bfd_vma) -2) 6399 skip = (int) outrel.r_offset; 6400 outrel.r_offset += (input_section->output_section->vma 6401 + input_section->output_offset); 6402 6403 if (skip) 6404 memset (&outrel, 0, sizeof outrel); 6405 else if (!SYMBOL_REFERENCES_LOCAL (info, h)) 6406 { 6407 unresolved_reloc = FALSE; 6408 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 6409 outrel.r_addend = rel->r_addend; 6410 } 6411 else 6412 { 6413 outrel.r_addend = relocation + rel->r_addend; 6414 6415 if (r_type == R_PPC_ADDR32) 6416 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 6417 else 6418 { 6419 long indx; 6420 6421 if (bfd_is_abs_section (sec)) 6422 indx = 0; 6423 else if (sec == NULL || sec->owner == NULL) 6424 { 6425 bfd_set_error (bfd_error_bad_value); 6426 return FALSE; 6427 } 6428 else 6429 { 6430 asection *osec; 6431 6432 /* We are turning this relocation into one 6433 against a section symbol. It would be 6434 proper to subtract the symbol's value, 6435 osec->vma, from the emitted reloc addend, 6436 but ld.so expects buggy relocs. */ 6437 osec = sec->output_section; 6438 indx = elf_section_data (osec)->dynindx; 6439 if (indx == 0) 6440 { 6441 osec = htab->elf.text_index_section; 6442 indx = elf_section_data (osec)->dynindx; 6443 } 6444 BFD_ASSERT (indx != 0); 6445#ifdef DEBUG 6446 if (indx == 0) 6447 printf ("indx=%ld section=%s flags=%08x name=%s\n", 6448 indx, osec->name, osec->flags, 6449 h->root.root.string); 6450#endif 6451 } 6452 6453 outrel.r_info = ELF32_R_INFO (indx, r_type); 6454 } 6455 } 6456 6457 loc = sreloc->contents; 6458 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 6459 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 6460 6461 if (skip == -1) 6462 continue; 6463 6464 /* This reloc will be computed at runtime. We clear the memory 6465 so that it contains predictable value. */ 6466 if (! skip 6467 && ((input_section->flags & SEC_ALLOC) != 0 6468 || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE)) 6469 { 6470 relocation = howto->pc_relative ? outrel.r_offset : 0; 6471 addend = 0; 6472 break; 6473 } 6474 } 6475 break; 6476 6477 case R_PPC_RELAX32PC_PLT: 6478 case R_PPC_RELAX32_PLT: 6479 { 6480 struct plt_entry *ent = find_plt_ent (h, got2, addend); 6481 6482 if (htab->plt_type == PLT_NEW) 6483 relocation = (htab->glink->output_section->vma 6484 + htab->glink->output_offset 6485 + ent->glink_offset); 6486 else 6487 relocation = (htab->plt->output_section->vma 6488 + htab->plt->output_offset 6489 + ent->plt.offset); 6490 addend = 0; 6491 } 6492 if (r_type == R_PPC_RELAX32_PLT) 6493 goto relax32; 6494 /* Fall thru */ 6495 6496 case R_PPC_RELAX32PC: 6497 relocation -= (input_section->output_section->vma 6498 + input_section->output_offset 6499 + rel->r_offset - 4); 6500 /* Fall thru */ 6501 6502 case R_PPC_RELAX32: 6503 relax32: 6504 { 6505 unsigned long t0; 6506 unsigned long t1; 6507 6508 t0 = bfd_get_32 (output_bfd, contents + rel->r_offset); 6509 t1 = bfd_get_32 (output_bfd, contents + rel->r_offset + 4); 6510 6511 /* We're clearing the bits for R_PPC_ADDR16_HA 6512 and R_PPC_ADDR16_LO here. */ 6513 t0 &= ~0xffff; 6514 t1 &= ~0xffff; 6515 6516 /* t0 is HA, t1 is LO */ 6517 relocation += addend; 6518 t0 |= ((relocation + 0x8000) >> 16) & 0xffff; 6519 t1 |= relocation & 0xffff; 6520 6521 bfd_put_32 (output_bfd, t0, contents + rel->r_offset); 6522 bfd_put_32 (output_bfd, t1, contents + rel->r_offset + 4); 6523 } 6524 continue; 6525 6526 /* Indirect .sdata relocation. */ 6527 case R_PPC_EMB_SDAI16: 6528 BFD_ASSERT (htab->sdata[0].section != NULL); 6529 relocation 6530 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[0], 6531 h, relocation, rel); 6532 break; 6533 6534 /* Indirect .sdata2 relocation. */ 6535 case R_PPC_EMB_SDA2I16: 6536 BFD_ASSERT (htab->sdata[1].section != NULL); 6537 relocation 6538 = elf_finish_pointer_linker_section (input_bfd, &htab->sdata[1], 6539 h, relocation, rel); 6540 break; 6541 6542 /* Handle the TOC16 reloc. We want to use the offset within the .got 6543 section, not the actual VMA. This is appropriate when generating 6544 an embedded ELF object, for which the .got section acts like the 6545 AIX .toc section. */ 6546 case R_PPC_TOC16: /* phony GOT16 relocations */ 6547 BFD_ASSERT (sec != NULL); 6548 BFD_ASSERT (bfd_is_und_section (sec) 6549 || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0 6550 || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0); 6551 6552 addend -= sec->output_section->vma + sec->output_offset + 0x8000; 6553 break; 6554 6555 case R_PPC_PLTREL24: 6556 /* Relocation is to the entry for this symbol in the 6557 procedure linkage table. */ 6558 { 6559 struct plt_entry *ent = find_plt_ent (h, got2, addend); 6560 6561 addend = 0; 6562 if (ent == NULL 6563 || htab->plt == NULL) 6564 { 6565 /* We didn't make a PLT entry for this symbol. This 6566 happens when statically linking PIC code, or when 6567 using -Bsymbolic. */ 6568 break; 6569 } 6570 6571 unresolved_reloc = FALSE; 6572 if (htab->plt_type == PLT_NEW) 6573 relocation = (htab->glink->output_section->vma 6574 + htab->glink->output_offset 6575 + ent->glink_offset); 6576 else 6577 relocation = (htab->plt->output_section->vma 6578 + htab->plt->output_offset 6579 + ent->plt.offset); 6580 } 6581 break; 6582 6583 /* Relocate against _SDA_BASE_. */ 6584 case R_PPC_SDAREL16: 6585 { 6586 const char *name; 6587 struct elf_link_hash_entry *sh; 6588 6589 BFD_ASSERT (sec != NULL); 6590 name = bfd_get_section_name (abfd, sec->output_section); 6591 if (! ((CONST_STRNEQ (name, ".sdata") 6592 && (name[6] == 0 || name[6] == '.')) 6593 || (CONST_STRNEQ (name, ".sbss") 6594 && (name[5] == 0 || name[5] == '.')))) 6595 { 6596 (*_bfd_error_handler) 6597 (_("%B: the target (%s) of a %s relocation is " 6598 "in the wrong output section (%s)"), 6599 input_bfd, 6600 sym_name, 6601 howto->name, 6602 name); 6603 } 6604 sh = htab->sdata[0].sym; 6605 addend -= (sh->root.u.def.value 6606 + sh->root.u.def.section->output_offset 6607 + sh->root.u.def.section->output_section->vma); 6608 } 6609 break; 6610 6611 /* Relocate against _SDA2_BASE_. */ 6612 case R_PPC_EMB_SDA2REL: 6613 { 6614 const char *name; 6615 struct elf_link_hash_entry *sh; 6616 6617 BFD_ASSERT (sec != NULL); 6618 name = bfd_get_section_name (abfd, sec->output_section); 6619 if (! (CONST_STRNEQ (name, ".sdata2") 6620 || CONST_STRNEQ (name, ".sbss2"))) 6621 { 6622 (*_bfd_error_handler) 6623 (_("%B: the target (%s) of a %s relocation is " 6624 "in the wrong output section (%s)"), 6625 input_bfd, 6626 sym_name, 6627 howto->name, 6628 name); 6629 6630 bfd_set_error (bfd_error_bad_value); 6631 ret = FALSE; 6632 continue; 6633 } 6634 sh = htab->sdata[1].sym; 6635 addend -= (sh->root.u.def.value 6636 + sh->root.u.def.section->output_offset 6637 + sh->root.u.def.section->output_section->vma); 6638 } 6639 break; 6640 6641 /* Relocate against either _SDA_BASE_, _SDA2_BASE_, or 0. */ 6642 case R_PPC_EMB_SDA21: 6643 case R_PPC_EMB_RELSDA: 6644 { 6645 const char *name; 6646 int reg; 6647 struct elf_link_hash_entry *sh; 6648 6649 BFD_ASSERT (sec != NULL); 6650 name = bfd_get_section_name (abfd, sec->output_section); 6651 if (((CONST_STRNEQ (name, ".sdata") 6652 && (name[6] == 0 || name[6] == '.')) 6653 || (CONST_STRNEQ (name, ".sbss") 6654 && (name[5] == 0 || name[5] == '.')))) 6655 { 6656 reg = 13; 6657 sh = htab->sdata[0].sym; 6658 addend -= (sh->root.u.def.value 6659 + sh->root.u.def.section->output_offset 6660 + sh->root.u.def.section->output_section->vma); 6661 } 6662 6663 else if (CONST_STRNEQ (name, ".sdata2") 6664 || CONST_STRNEQ (name, ".sbss2")) 6665 { 6666 reg = 2; 6667 sh = htab->sdata[1].sym; 6668 addend -= (sh->root.u.def.value 6669 + sh->root.u.def.section->output_offset 6670 + sh->root.u.def.section->output_section->vma); 6671 } 6672 6673 else if (strcmp (name, ".PPC.EMB.sdata0") == 0 6674 || strcmp (name, ".PPC.EMB.sbss0") == 0) 6675 { 6676 reg = 0; 6677 } 6678 6679 else 6680 { 6681 (*_bfd_error_handler) 6682 (_("%B: the target (%s) of a %s relocation is " 6683 "in the wrong output section (%s)"), 6684 input_bfd, 6685 sym_name, 6686 howto->name, 6687 name); 6688 6689 bfd_set_error (bfd_error_bad_value); 6690 ret = FALSE; 6691 continue; 6692 } 6693 6694 if (r_type == R_PPC_EMB_SDA21) 6695 { /* fill in register field */ 6696 insn = bfd_get_32 (output_bfd, contents + rel->r_offset); 6697 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT); 6698 bfd_put_32 (output_bfd, insn, contents + rel->r_offset); 6699 } 6700 } 6701 break; 6702 6703 /* Relocate against the beginning of the section. */ 6704 case R_PPC_SECTOFF: 6705 case R_PPC_SECTOFF_LO: 6706 case R_PPC_SECTOFF_HI: 6707 case R_PPC_SECTOFF_HA: 6708 BFD_ASSERT (sec != NULL); 6709 addend -= sec->output_section->vma; 6710 break; 6711 6712 /* Negative relocations. */ 6713 case R_PPC_EMB_NADDR32: 6714 case R_PPC_EMB_NADDR16: 6715 case R_PPC_EMB_NADDR16_LO: 6716 case R_PPC_EMB_NADDR16_HI: 6717 case R_PPC_EMB_NADDR16_HA: 6718 addend -= 2 * relocation; 6719 break; 6720 6721 case R_PPC_COPY: 6722 case R_PPC_GLOB_DAT: 6723 case R_PPC_JMP_SLOT: 6724 case R_PPC_RELATIVE: 6725 case R_PPC_PLT32: 6726 case R_PPC_PLTREL32: 6727 case R_PPC_PLT16_LO: 6728 case R_PPC_PLT16_HI: 6729 case R_PPC_PLT16_HA: 6730 case R_PPC_ADDR30: 6731 case R_PPC_EMB_RELSEC16: 6732 case R_PPC_EMB_RELST_LO: 6733 case R_PPC_EMB_RELST_HI: 6734 case R_PPC_EMB_RELST_HA: 6735 case R_PPC_EMB_BIT_FLD: 6736 (*_bfd_error_handler) 6737 (_("%B: relocation %s is not yet supported for symbol %s."), 6738 input_bfd, 6739 howto->name, 6740 sym_name); 6741 6742 bfd_set_error (bfd_error_invalid_operation); 6743 ret = FALSE; 6744 continue; 6745 } 6746 6747 /* Do any further special processing. */ 6748 switch (r_type) 6749 { 6750 default: 6751 break; 6752 6753 case R_PPC_ADDR16_HA: 6754 case R_PPC_REL16_HA: 6755 case R_PPC_SECTOFF_HA: 6756 case R_PPC_TPREL16_HA: 6757 case R_PPC_DTPREL16_HA: 6758 case R_PPC_EMB_NADDR16_HA: 6759 case R_PPC_EMB_RELST_HA: 6760 /* It's just possible that this symbol is a weak symbol 6761 that's not actually defined anywhere. In that case, 6762 'sec' would be NULL, and we should leave the symbol 6763 alone (it will be set to zero elsewhere in the link). */ 6764 if (sec == NULL) 6765 break; 6766 /* Fall thru */ 6767 6768 case R_PPC_PLT16_HA: 6769 case R_PPC_GOT16_HA: 6770 case R_PPC_GOT_TLSGD16_HA: 6771 case R_PPC_GOT_TLSLD16_HA: 6772 case R_PPC_GOT_TPREL16_HA: 6773 case R_PPC_GOT_DTPREL16_HA: 6774 /* Add 0x10000 if sign bit in 0:15 is set. 6775 Bits 0:15 are not used. */ 6776 addend += 0x8000; 6777 break; 6778 } 6779 6780#ifdef DEBUG 6781 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, " 6782 "offset = %ld, addend = %ld\n", 6783 howto->name, 6784 (int) r_type, 6785 sym_name, 6786 r_symndx, 6787 (long) rel->r_offset, 6788 (long) addend); 6789#endif 6790 6791 if (unresolved_reloc 6792 && !((input_section->flags & SEC_DEBUGGING) != 0 6793 && h->def_dynamic)) 6794 { 6795 (*_bfd_error_handler) 6796 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 6797 input_bfd, 6798 input_section, 6799 (long) rel->r_offset, 6800 howto->name, 6801 sym_name); 6802 ret = FALSE; 6803 } 6804 6805 r = _bfd_final_link_relocate (howto, 6806 input_bfd, 6807 input_section, 6808 contents, 6809 rel->r_offset, 6810 relocation, 6811 addend); 6812 6813 if (r != bfd_reloc_ok) 6814 { 6815 if (r == bfd_reloc_overflow) 6816 { 6817 if (warned) 6818 continue; 6819 if (h != NULL 6820 && h->root.type == bfd_link_hash_undefweak 6821 && howto->pc_relative) 6822 { 6823 /* Assume this is a call protected by other code that 6824 detect the symbol is undefined. If this is the case, 6825 we can safely ignore the overflow. If not, the 6826 program is hosed anyway, and a little warning isn't 6827 going to help. */ 6828 6829 continue; 6830 } 6831 6832 if (! (*info->callbacks->reloc_overflow) (info, 6833 (h ? &h->root : NULL), 6834 sym_name, 6835 howto->name, 6836 rel->r_addend, 6837 input_bfd, 6838 input_section, 6839 rel->r_offset)) 6840 return FALSE; 6841 } 6842 else 6843 { 6844 (*_bfd_error_handler) 6845 (_("%B(%A+0x%lx): %s reloc against `%s': error %d"), 6846 input_bfd, input_section, 6847 (long) rel->r_offset, howto->name, sym_name, (int) r); 6848 ret = FALSE; 6849 } 6850 } 6851 } 6852 6853#ifdef DEBUG 6854 fprintf (stderr, "\n"); 6855#endif 6856 6857 return ret; 6858} 6859 6860#define PPC_LO(v) ((v) & 0xffff) 6861#define PPC_HI(v) (((v) >> 16) & 0xffff) 6862#define PPC_HA(v) PPC_HI ((v) + 0x8000) 6863 6864/* Finish up dynamic symbol handling. We set the contents of various 6865 dynamic sections here. */ 6866 6867static bfd_boolean 6868ppc_elf_finish_dynamic_symbol (bfd *output_bfd, 6869 struct bfd_link_info *info, 6870 struct elf_link_hash_entry *h, 6871 Elf_Internal_Sym *sym) 6872{ 6873 struct ppc_elf_link_hash_table *htab; 6874 struct plt_entry *ent; 6875 bfd_boolean doneone; 6876 6877#ifdef DEBUG 6878 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", 6879 h->root.root.string); 6880#endif 6881 6882 htab = ppc_elf_hash_table (info); 6883 BFD_ASSERT (htab->elf.dynobj != NULL); 6884 6885 doneone = FALSE; 6886 for (ent = h->plt.plist; ent != NULL; ent = ent->next) 6887 if (ent->plt.offset != (bfd_vma) -1) 6888 { 6889 if (!doneone) 6890 { 6891 Elf_Internal_Rela rela; 6892 bfd_byte *loc; 6893 bfd_vma reloc_index; 6894 6895 if (htab->plt_type == PLT_NEW) 6896 reloc_index = ent->plt.offset / 4; 6897 else 6898 { 6899 reloc_index = ((ent->plt.offset - htab->plt_initial_entry_size) 6900 / htab->plt_slot_size); 6901 if (reloc_index > PLT_NUM_SINGLE_ENTRIES 6902 && htab->plt_type == PLT_OLD) 6903 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2; 6904 } 6905 6906 /* This symbol has an entry in the procedure linkage table. 6907 Set it up. */ 6908 if (htab->plt_type == PLT_VXWORKS) 6909 { 6910 bfd_vma got_offset; 6911 const bfd_vma *plt_entry; 6912 6913 /* The first three entries in .got.plt are reserved. */ 6914 got_offset = (reloc_index + 3) * 4; 6915 6916 /* Use the right PLT. */ 6917 plt_entry = info->shared ? ppc_elf_vxworks_pic_plt_entry 6918 : ppc_elf_vxworks_plt_entry; 6919 6920 /* Fill in the .plt on VxWorks. */ 6921 if (info->shared) 6922 { 6923 bfd_vma got_offset_hi = (got_offset >> 16) 6924 + ((got_offset & 0x8000) >> 15); 6925 6926 bfd_put_32 (output_bfd, 6927 plt_entry[0] | (got_offset_hi & 0xffff), 6928 htab->plt->contents + ent->plt.offset + 0); 6929 bfd_put_32 (output_bfd, 6930 plt_entry[1] | (got_offset & 0xffff), 6931 htab->plt->contents + ent->plt.offset + 4); 6932 } 6933 else 6934 { 6935 bfd_vma got_loc 6936 = (got_offset 6937 + htab->elf.hgot->root.u.def.value 6938 + htab->elf.hgot->root.u.def.section->output_offset 6939 + htab->elf.hgot->root.u.def.section->output_section->vma); 6940 bfd_vma got_loc_hi = (got_loc >> 16) 6941 + ((got_loc & 0x8000) >> 15); 6942 6943 bfd_put_32 (output_bfd, 6944 plt_entry[0] | (got_loc_hi & 0xffff), 6945 htab->plt->contents + ent->plt.offset + 0); 6946 bfd_put_32 (output_bfd, 6947 plt_entry[1] | (got_loc & 0xffff), 6948 htab->plt->contents + ent->plt.offset + 4); 6949 } 6950 6951 bfd_put_32 (output_bfd, plt_entry[2], 6952 htab->plt->contents + ent->plt.offset + 8); 6953 bfd_put_32 (output_bfd, plt_entry[3], 6954 htab->plt->contents + ent->plt.offset + 12); 6955 6956 /* This instruction is an immediate load. The value loaded is 6957 the byte offset of the R_PPC_JMP_SLOT relocation from the 6958 start of the .rela.plt section. The value is stored in the 6959 low-order 16 bits of the load instruction. */ 6960 /* NOTE: It appears that this is now an index rather than a 6961 prescaled offset. */ 6962 bfd_put_32 (output_bfd, 6963 plt_entry[4] | reloc_index, 6964 htab->plt->contents + ent->plt.offset + 16); 6965 /* This instruction is a PC-relative branch whose target is 6966 the start of the PLT section. The address of this branch 6967 instruction is 20 bytes beyond the start of this PLT entry. 6968 The address is encoded in bits 6-29, inclusive. The value 6969 stored is right-shifted by two bits, permitting a 26-bit 6970 offset. */ 6971 bfd_put_32 (output_bfd, 6972 (plt_entry[5] 6973 | (-(ent->plt.offset + 20) & 0x03fffffc)), 6974 htab->plt->contents + ent->plt.offset + 20); 6975 bfd_put_32 (output_bfd, plt_entry[6], 6976 htab->plt->contents + ent->plt.offset + 24); 6977 bfd_put_32 (output_bfd, plt_entry[7], 6978 htab->plt->contents + ent->plt.offset + 28); 6979 6980 /* Fill in the GOT entry corresponding to this PLT slot with 6981 the address immediately after the the "bctr" instruction 6982 in this PLT entry. */ 6983 bfd_put_32 (output_bfd, (htab->plt->output_section->vma 6984 + htab->plt->output_offset 6985 + ent->plt.offset + 16), 6986 htab->sgotplt->contents + got_offset); 6987 6988 if (!info->shared) 6989 { 6990 /* Fill in a couple of entries in .rela.plt.unloaded. */ 6991 loc = htab->srelplt2->contents 6992 + ((VXWORKS_PLTRESOLVE_RELOCS + reloc_index 6993 * VXWORKS_PLT_NON_JMP_SLOT_RELOCS) 6994 * sizeof (Elf32_External_Rela)); 6995 6996 /* Provide the @ha relocation for the first instruction. */ 6997 rela.r_offset = (htab->plt->output_section->vma 6998 + htab->plt->output_offset 6999 + ent->plt.offset + 2); 7000 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, 7001 R_PPC_ADDR16_HA); 7002 rela.r_addend = got_offset; 7003 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7004 loc += sizeof (Elf32_External_Rela); 7005 7006 /* Provide the @l relocation for the second instruction. */ 7007 rela.r_offset = (htab->plt->output_section->vma 7008 + htab->plt->output_offset 7009 + ent->plt.offset + 6); 7010 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, 7011 R_PPC_ADDR16_LO); 7012 rela.r_addend = got_offset; 7013 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7014 loc += sizeof (Elf32_External_Rela); 7015 7016 /* Provide a relocation for the GOT entry corresponding to this 7017 PLT slot. Point it at the middle of the .plt entry. */ 7018 rela.r_offset = (htab->sgotplt->output_section->vma 7019 + htab->sgotplt->output_offset 7020 + got_offset); 7021 rela.r_info = ELF32_R_INFO (htab->elf.hplt->indx, 7022 R_PPC_ADDR32); 7023 rela.r_addend = ent->plt.offset + 16; 7024 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7025 } 7026 7027 /* VxWorks uses non-standard semantics for R_PPC_JMP_SLOT. 7028 In particular, the offset for the relocation is not the 7029 address of the PLT entry for this function, as specified 7030 by the ABI. Instead, the offset is set to the address of 7031 the GOT slot for this function. See EABI 4.4.4.1. */ 7032 rela.r_offset = (htab->sgotplt->output_section->vma 7033 + htab->sgotplt->output_offset 7034 + got_offset); 7035 7036 } 7037 else 7038 { 7039 rela.r_offset = (htab->plt->output_section->vma 7040 + htab->plt->output_offset 7041 + ent->plt.offset); 7042 if (htab->plt_type == PLT_OLD) 7043 { 7044 /* We don't need to fill in the .plt. The ppc dynamic 7045 linker will fill it in. */ 7046 } 7047 else 7048 { 7049 bfd_vma val = (htab->glink_pltresolve + ent->plt.offset 7050 + htab->glink->output_section->vma 7051 + htab->glink->output_offset); 7052 bfd_put_32 (output_bfd, val, 7053 htab->plt->contents + ent->plt.offset); 7054 } 7055 } 7056 7057 /* Fill in the entry in the .rela.plt section. */ 7058 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT); 7059 rela.r_addend = 0; 7060 7061 loc = (htab->relplt->contents 7062 + reloc_index * sizeof (Elf32_External_Rela)); 7063 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7064 7065 if (!h->def_regular) 7066 { 7067 /* Mark the symbol as undefined, rather than as defined in 7068 the .plt section. Leave the value alone. */ 7069 sym->st_shndx = SHN_UNDEF; 7070 /* If the symbol is weak, we do need to clear the value. 7071 Otherwise, the PLT entry would provide a definition for 7072 the symbol even if the symbol wasn't defined anywhere, 7073 and so the symbol would never be NULL. */ 7074 if (!h->ref_regular_nonweak) 7075 sym->st_value = 0; 7076 } 7077 doneone = TRUE; 7078 } 7079 7080 if (htab->plt_type == PLT_NEW) 7081 { 7082 bfd_vma plt; 7083 unsigned char *p; 7084 7085 plt = (ent->plt.offset 7086 + htab->plt->output_section->vma 7087 + htab->plt->output_offset); 7088 p = (unsigned char *) htab->glink->contents + ent->glink_offset; 7089 7090 if (info->shared || info->pie) 7091 { 7092 bfd_vma got = 0; 7093 7094 if (ent->addend >= 32768) 7095 got = (ent->addend 7096 + ent->sec->output_section->vma 7097 + ent->sec->output_offset); 7098 else if (htab->elf.hgot != NULL) 7099 got = (htab->elf.hgot->root.u.def.value 7100 + htab->elf.hgot->root.u.def.section->output_section->vma 7101 + htab->elf.hgot->root.u.def.section->output_offset); 7102 7103 plt -= got; 7104 7105 if (plt + 0x8000 < 0x10000) 7106 { 7107 bfd_put_32 (output_bfd, LWZ_11_30 + PPC_LO (plt), p); 7108 p += 4; 7109 bfd_put_32 (output_bfd, MTCTR_11, p); 7110 p += 4; 7111 bfd_put_32 (output_bfd, BCTR, p); 7112 p += 4; 7113 bfd_put_32 (output_bfd, NOP, p); 7114 p += 4; 7115 } 7116 else 7117 { 7118 bfd_put_32 (output_bfd, ADDIS_11_30 + PPC_HA (plt), p); 7119 p += 4; 7120 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); 7121 p += 4; 7122 bfd_put_32 (output_bfd, MTCTR_11, p); 7123 p += 4; 7124 bfd_put_32 (output_bfd, BCTR, p); 7125 p += 4; 7126 } 7127 } 7128 else 7129 { 7130 bfd_put_32 (output_bfd, LIS_11 + PPC_HA (plt), p); 7131 p += 4; 7132 bfd_put_32 (output_bfd, LWZ_11_11 + PPC_LO (plt), p); 7133 p += 4; 7134 bfd_put_32 (output_bfd, MTCTR_11, p); 7135 p += 4; 7136 bfd_put_32 (output_bfd, BCTR, p); 7137 p += 4; 7138 7139 /* We only need one non-PIC glink stub. */ 7140 break; 7141 } 7142 } 7143 else 7144 break; 7145 } 7146 7147 if (h->needs_copy) 7148 { 7149 asection *s; 7150 Elf_Internal_Rela rela; 7151 bfd_byte *loc; 7152 7153 /* This symbols needs a copy reloc. Set it up. */ 7154 7155#ifdef DEBUG 7156 fprintf (stderr, ", copy"); 7157#endif 7158 7159 BFD_ASSERT (h->dynindx != -1); 7160 7161 if (ppc_elf_hash_entry (h)->has_sda_refs) 7162 s = htab->relsbss; 7163 else 7164 s = htab->relbss; 7165 BFD_ASSERT (s != NULL); 7166 7167 rela.r_offset = (h->root.u.def.value 7168 + h->root.u.def.section->output_section->vma 7169 + h->root.u.def.section->output_offset); 7170 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY); 7171 rela.r_addend = 0; 7172 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 7173 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7174 } 7175 7176#ifdef DEBUG 7177 fprintf (stderr, "\n"); 7178#endif 7179 7180 /* Mark some specially defined symbols as absolute. */ 7181 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 7182 || (!htab->is_vxworks 7183 && (h == htab->elf.hgot 7184 || strcmp (h->root.root.string, 7185 "_PROCEDURE_LINKAGE_TABLE_") == 0))) 7186 sym->st_shndx = SHN_ABS; 7187 7188 return TRUE; 7189} 7190 7191static enum elf_reloc_type_class 7192ppc_elf_reloc_type_class (const Elf_Internal_Rela *rela) 7193{ 7194 switch (ELF32_R_TYPE (rela->r_info)) 7195 { 7196 case R_PPC_RELATIVE: 7197 return reloc_class_relative; 7198 case R_PPC_REL24: 7199 case R_PPC_ADDR24: 7200 case R_PPC_JMP_SLOT: 7201 return reloc_class_plt; 7202 case R_PPC_COPY: 7203 return reloc_class_copy; 7204 default: 7205 return reloc_class_normal; 7206 } 7207} 7208 7209/* Finish up the dynamic sections. */ 7210 7211static bfd_boolean 7212ppc_elf_finish_dynamic_sections (bfd *output_bfd, 7213 struct bfd_link_info *info) 7214{ 7215 asection *sdyn; 7216 asection *splt; 7217 struct ppc_elf_link_hash_table *htab; 7218 bfd_vma got; 7219 bfd * dynobj; 7220 7221#ifdef DEBUG 7222 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n"); 7223#endif 7224 7225 htab = ppc_elf_hash_table (info); 7226 dynobj = elf_hash_table (info)->dynobj; 7227 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 7228 if (htab->is_vxworks) 7229 splt = bfd_get_section_by_name (dynobj, ".plt"); 7230 else 7231 splt = NULL; 7232 7233 got = 0; 7234 if (htab->elf.hgot != NULL) 7235 got = (htab->elf.hgot->root.u.def.value 7236 + htab->elf.hgot->root.u.def.section->output_section->vma 7237 + htab->elf.hgot->root.u.def.section->output_offset); 7238 7239 if (htab->elf.dynamic_sections_created) 7240 { 7241 Elf32_External_Dyn *dyncon, *dynconend; 7242 7243 BFD_ASSERT (htab->plt != NULL && sdyn != NULL); 7244 7245 dyncon = (Elf32_External_Dyn *) sdyn->contents; 7246 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 7247 for (; dyncon < dynconend; dyncon++) 7248 { 7249 Elf_Internal_Dyn dyn; 7250 asection *s; 7251 7252 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 7253 7254 switch (dyn.d_tag) 7255 { 7256 case DT_PLTGOT: 7257 if (htab->is_vxworks) 7258 s = htab->sgotplt; 7259 else 7260 s = htab->plt; 7261 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 7262 break; 7263 7264 case DT_PLTRELSZ: 7265 dyn.d_un.d_val = htab->relplt->size; 7266 break; 7267 7268 case DT_JMPREL: 7269 s = htab->relplt; 7270 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 7271 break; 7272 7273 case DT_PPC_GOT: 7274 dyn.d_un.d_ptr = got; 7275 break; 7276 7277 case DT_RELASZ: 7278 if (htab->is_vxworks) 7279 { 7280 if (htab->relplt) 7281 dyn.d_un.d_ptr -= htab->relplt->size; 7282 break; 7283 } 7284 continue; 7285 7286 default: 7287 continue; 7288 } 7289 7290 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7291 } 7292 } 7293 7294 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can 7295 easily find the address of the _GLOBAL_OFFSET_TABLE_. */ 7296 if (htab->got != NULL) 7297 { 7298 unsigned char *p = htab->got->contents; 7299 bfd_vma val; 7300 7301 p += htab->elf.hgot->root.u.def.value; 7302 if (htab->plt_type == PLT_OLD) 7303 bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, p - 4); 7304 7305 val = 0; 7306 if (sdyn != NULL) 7307 val = sdyn->output_section->vma + sdyn->output_offset; 7308 bfd_put_32 (output_bfd, val, p); 7309 7310 elf_section_data (htab->got->output_section)->this_hdr.sh_entsize = 4; 7311 } 7312 7313 /* Fill in the first entry in the VxWorks procedure linkage table. */ 7314 if (splt && splt->size > 0) 7315 { 7316 /* Use the right PLT. */ 7317 static const bfd_vma *plt_entry = NULL; 7318 plt_entry = info->shared ? 7319 ppc_elf_vxworks_pic_plt0_entry : ppc_elf_vxworks_plt0_entry; 7320 7321 if (!info->shared) 7322 { 7323 bfd_vma got_value = 7324 (htab->elf.hgot->root.u.def.section->output_section->vma 7325 + htab->elf.hgot->root.u.def.section->output_offset 7326 + htab->elf.hgot->root.u.def.value); 7327 bfd_vma got_hi = (got_value >> 16) + ((got_value & 0x8000) >> 15); 7328 7329 bfd_put_32 (output_bfd, plt_entry[0] | (got_hi & 0xffff), 7330 splt->contents + 0); 7331 bfd_put_32 (output_bfd, plt_entry[1] | (got_value & 0xffff), 7332 splt->contents + 4); 7333 } 7334 else 7335 { 7336 bfd_put_32 (output_bfd, plt_entry[0], splt->contents + 0); 7337 bfd_put_32 (output_bfd, plt_entry[1], splt->contents + 4); 7338 } 7339 bfd_put_32 (output_bfd, plt_entry[2], splt->contents + 8); 7340 bfd_put_32 (output_bfd, plt_entry[3], splt->contents + 12); 7341 bfd_put_32 (output_bfd, plt_entry[4], splt->contents + 16); 7342 bfd_put_32 (output_bfd, plt_entry[5], splt->contents + 20); 7343 bfd_put_32 (output_bfd, plt_entry[6], splt->contents + 24); 7344 bfd_put_32 (output_bfd, plt_entry[7], splt->contents + 28); 7345 7346 if (! info->shared) 7347 { 7348 Elf_Internal_Rela rela; 7349 bfd_byte *loc; 7350 7351 loc = htab->srelplt2->contents; 7352 7353 /* Output the @ha relocation for the first instruction. */ 7354 rela.r_offset = (htab->plt->output_section->vma 7355 + htab->plt->output_offset 7356 + 2); 7357 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); 7358 rela.r_addend = 0; 7359 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7360 loc += sizeof (Elf32_External_Rela); 7361 7362 /* Output the @l relocation for the second instruction. */ 7363 rela.r_offset = (htab->plt->output_section->vma 7364 + htab->plt->output_offset 7365 + 6); 7366 rela.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); 7367 rela.r_addend = 0; 7368 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc); 7369 loc += sizeof (Elf32_External_Rela); 7370 7371 /* Fix up the remaining relocations. They may have the wrong 7372 symbol index for _G_O_T_ or _P_L_T_ depending on the order 7373 in which symbols were output. */ 7374 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 7375 { 7376 Elf_Internal_Rela rel; 7377 7378 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 7379 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_HA); 7380 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 7381 loc += sizeof (Elf32_External_Rela); 7382 7383 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 7384 rel.r_info = ELF32_R_INFO (htab->elf.hgot->indx, R_PPC_ADDR16_LO); 7385 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 7386 loc += sizeof (Elf32_External_Rela); 7387 7388 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 7389 rel.r_info = ELF32_R_INFO (htab->elf.hplt->indx, R_PPC_ADDR32); 7390 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 7391 loc += sizeof (Elf32_External_Rela); 7392 } 7393 } 7394 } 7395 7396 if (htab->glink != NULL && htab->glink->contents != NULL) 7397 { 7398 unsigned char *p; 7399 unsigned char *endp; 7400 bfd_vma res0; 7401 unsigned int i; 7402 7403 /* 7404 * PIC glink code is the following: 7405 * 7406 * # ith PLT code stub. 7407 * addis 11,30,(plt+(i-1)*4-got)@ha 7408 * lwz 11,(plt+(i-1)*4-got)@l(11) 7409 * mtctr 11 7410 * bctr 7411 * 7412 * # A table of branches, one for each plt entry. 7413 * # The idea is that the plt call stub loads ctr (and r11) with these 7414 * # addresses, so (r11 - res_0) gives the plt index * 4. 7415 * res_0: b PLTresolve 7416 * res_1: b PLTresolve 7417 * . 7418 * # Some number of entries towards the end can be nops 7419 * res_n_m3: nop 7420 * res_n_m2: nop 7421 * res_n_m1: 7422 * 7423 * PLTresolve: 7424 * addis 11,11,(1f-res_0)@ha 7425 * mflr 0 7426 * bcl 20,31,1f 7427 * 1: addi 11,11,(1b-res_0)@l 7428 * mflr 12 7429 * mtlr 0 7430 * sub 11,11,12 # r11 = index * 4 7431 * addis 12,12,(got+4-1b)@ha 7432 * lwz 0,(got+4-1b)@l(12) # got[1] address of dl_runtime_resolve 7433 * lwz 12,(got+8-1b)@l(12) # got[2] contains the map address 7434 * mtctr 0 7435 * add 0,11,11 7436 * add 11,0,11 # r11 = index * 12 = reloc offset. 7437 * bctr 7438 */ 7439 static const unsigned int pic_plt_resolve[] = 7440 { 7441 ADDIS_11_11, 7442 MFLR_0, 7443 BCL_20_31, 7444 ADDI_11_11, 7445 MFLR_12, 7446 MTLR_0, 7447 SUB_11_11_12, 7448 ADDIS_12_12, 7449 LWZ_0_12, 7450 LWZ_12_12, 7451 MTCTR_0, 7452 ADD_0_11_11, 7453 ADD_11_0_11, 7454 BCTR, 7455 NOP, 7456 NOP 7457 }; 7458 7459 static const unsigned int plt_resolve[] = 7460 { 7461 LIS_12, 7462 ADDIS_11_11, 7463 LWZ_0_12, 7464 ADDI_11_11, 7465 MTCTR_0, 7466 ADD_0_11_11, 7467 LWZ_12_12, 7468 ADD_11_0_11, 7469 BCTR, 7470 NOP, 7471 NOP, 7472 NOP, 7473 NOP, 7474 NOP, 7475 NOP, 7476 NOP 7477 }; 7478 7479 if (ARRAY_SIZE (pic_plt_resolve) != GLINK_PLTRESOLVE / 4) 7480 abort (); 7481 if (ARRAY_SIZE (plt_resolve) != GLINK_PLTRESOLVE / 4) 7482 abort (); 7483 7484 /* Build the branch table, one for each plt entry (less one), 7485 and perhaps some padding. */ 7486 p = htab->glink->contents; 7487 p += htab->glink_pltresolve; 7488 endp = htab->glink->contents; 7489 endp += htab->glink->size - GLINK_PLTRESOLVE; 7490 while (p < endp - 8 * 4) 7491 { 7492 bfd_put_32 (output_bfd, B + endp - p, p); 7493 p += 4; 7494 } 7495 while (p < endp) 7496 { 7497 bfd_put_32 (output_bfd, NOP, p); 7498 p += 4; 7499 } 7500 7501 res0 = (htab->glink_pltresolve 7502 + htab->glink->output_section->vma 7503 + htab->glink->output_offset); 7504 7505 /* Last comes the PLTresolve stub. */ 7506 if (info->shared || info->pie) 7507 { 7508 bfd_vma bcl; 7509 7510 for (i = 0; i < ARRAY_SIZE (pic_plt_resolve); i++) 7511 { 7512 bfd_put_32 (output_bfd, pic_plt_resolve[i], p); 7513 p += 4; 7514 } 7515 p -= 4 * ARRAY_SIZE (pic_plt_resolve); 7516 7517 bcl = (htab->glink->size - GLINK_PLTRESOLVE + 3*4 7518 + htab->glink->output_section->vma 7519 + htab->glink->output_offset); 7520 7521 bfd_put_32 (output_bfd, 7522 ADDIS_11_11 + PPC_HA (bcl - res0), p + 0*4); 7523 bfd_put_32 (output_bfd, 7524 ADDI_11_11 + PPC_LO (bcl - res0), p + 3*4); 7525 bfd_put_32 (output_bfd, 7526 ADDIS_12_12 + PPC_HA (got + 4 - bcl), p + 7*4); 7527 if (PPC_HA (got + 4 - bcl) == PPC_HA (got + 8 - bcl)) 7528 { 7529 bfd_put_32 (output_bfd, 7530 LWZ_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); 7531 bfd_put_32 (output_bfd, 7532 LWZ_12_12 + PPC_LO (got + 8 - bcl), p + 9*4); 7533 } 7534 else 7535 { 7536 bfd_put_32 (output_bfd, 7537 LWZU_0_12 + PPC_LO (got + 4 - bcl), p + 8*4); 7538 bfd_put_32 (output_bfd, 7539 LWZ_12_12 + 4, p + 9*4); 7540 } 7541 } 7542 else 7543 { 7544 for (i = 0; i < ARRAY_SIZE (plt_resolve); i++) 7545 { 7546 bfd_put_32 (output_bfd, plt_resolve[i], p); 7547 p += 4; 7548 } 7549 p -= 4 * ARRAY_SIZE (plt_resolve); 7550 7551 bfd_put_32 (output_bfd, 7552 LIS_12 + PPC_HA (got + 4), p + 0*4); 7553 bfd_put_32 (output_bfd, 7554 ADDIS_11_11 + PPC_HA (-res0), p + 1*4); 7555 bfd_put_32 (output_bfd, 7556 ADDI_11_11 + PPC_LO (-res0), p + 3*4); 7557 if (PPC_HA (got + 4) == PPC_HA (got + 8)) 7558 { 7559 bfd_put_32 (output_bfd, 7560 LWZ_0_12 + PPC_LO (got + 4), p + 2*4); 7561 bfd_put_32 (output_bfd, 7562 LWZ_12_12 + PPC_LO (got + 8), p + 6*4); 7563 } 7564 else 7565 { 7566 bfd_put_32 (output_bfd, 7567 LWZU_0_12 + PPC_LO (got + 4), p + 2*4); 7568 bfd_put_32 (output_bfd, 7569 LWZ_12_12 + 4, p + 6*4); 7570 } 7571 } 7572 } 7573 7574 return TRUE; 7575} 7576 7577#define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec 7578#define TARGET_LITTLE_NAME "elf32-powerpcle" 7579#define TARGET_BIG_SYM bfd_elf32_powerpc_vec 7580#define TARGET_BIG_NAME "elf32-powerpc" 7581#define ELF_ARCH bfd_arch_powerpc 7582#define ELF_MACHINE_CODE EM_PPC 7583#ifdef __QNXTARGET__ 7584#define ELF_MAXPAGESIZE 0x1000 7585#else 7586#define ELF_MAXPAGESIZE 0x10000 7587#endif 7588#define ELF_MINPAGESIZE 0x1000 7589#define ELF_COMMONPAGESIZE 0x1000 7590#define elf_info_to_howto ppc_elf_info_to_howto 7591 7592#ifdef EM_CYGNUS_POWERPC 7593#define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC 7594#endif 7595 7596#ifdef EM_PPC_OLD 7597#define ELF_MACHINE_ALT2 EM_PPC_OLD 7598#endif 7599 7600#define elf_backend_plt_not_loaded 1 7601#define elf_backend_can_gc_sections 1 7602#define elf_backend_can_refcount 1 7603#define elf_backend_rela_normal 1 7604 7605#define bfd_elf32_mkobject ppc_elf_mkobject 7606#define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data 7607#define bfd_elf32_bfd_relax_section ppc_elf_relax_section 7608#define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup 7609#define bfd_elf32_bfd_reloc_name_lookup ppc_elf_reloc_name_lookup 7610#define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags 7611#define bfd_elf32_bfd_link_hash_table_create ppc_elf_link_hash_table_create 7612 7613#define elf_backend_object_p ppc_elf_object_p 7614#define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook 7615#define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook 7616#define elf_backend_section_from_shdr ppc_elf_section_from_shdr 7617#define elf_backend_relocate_section ppc_elf_relocate_section 7618#define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections 7619#define elf_backend_check_relocs ppc_elf_check_relocs 7620#define elf_backend_copy_indirect_symbol ppc_elf_copy_indirect_symbol 7621#define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol 7622#define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook 7623#define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections 7624#define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol 7625#define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections 7626#define elf_backend_fake_sections ppc_elf_fake_sections 7627#define elf_backend_additional_program_headers ppc_elf_additional_program_headers 7628#define elf_backend_grok_prstatus ppc_elf_grok_prstatus 7629#define elf_backend_grok_psinfo ppc_elf_grok_psinfo 7630#define elf_backend_write_core_note ppc_elf_write_core_note 7631#define elf_backend_reloc_type_class ppc_elf_reloc_type_class 7632#define elf_backend_begin_write_processing ppc_elf_begin_write_processing 7633#define elf_backend_final_write_processing ppc_elf_final_write_processing 7634#define elf_backend_write_section ppc_elf_write_section 7635#define elf_backend_get_sec_type_attr ppc_elf_get_sec_type_attr 7636#define elf_backend_plt_sym_val ppc_elf_plt_sym_val 7637#define elf_backend_action_discarded ppc_elf_action_discarded 7638#define elf_backend_init_index_section _bfd_elf_init_1_index_section 7639 7640#include "elf32-target.h" 7641 7642/* VxWorks Target */ 7643 7644#undef TARGET_LITTLE_SYM 7645#undef TARGET_LITTLE_NAME 7646 7647#undef TARGET_BIG_SYM 7648#define TARGET_BIG_SYM bfd_elf32_powerpc_vxworks_vec 7649#undef TARGET_BIG_NAME 7650#define TARGET_BIG_NAME "elf32-powerpc-vxworks" 7651 7652/* VxWorks uses the elf default section flags for .plt. */ 7653static const struct bfd_elf_special_section * 7654ppc_elf_vxworks_get_sec_type_attr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) 7655{ 7656 if (sec->name == NULL) 7657 return NULL; 7658 7659 if (strcmp (sec->name, ".plt") == 0) 7660 return _bfd_elf_get_sec_type_attr (abfd, sec); 7661 7662 return ppc_elf_get_sec_type_attr (abfd, sec); 7663} 7664 7665/* Like ppc_elf_link_hash_table_create, but overrides 7666 appropriately for VxWorks. */ 7667static struct bfd_link_hash_table * 7668ppc_elf_vxworks_link_hash_table_create (bfd *abfd) 7669{ 7670 struct bfd_link_hash_table *ret; 7671 7672 ret = ppc_elf_link_hash_table_create (abfd); 7673 if (ret) 7674 { 7675 struct ppc_elf_link_hash_table *htab 7676 = (struct ppc_elf_link_hash_table *)ret; 7677 htab->is_vxworks = 1; 7678 htab->plt_type = PLT_VXWORKS; 7679 htab->plt_entry_size = VXWORKS_PLT_ENTRY_SIZE; 7680 htab->plt_slot_size = VXWORKS_PLT_ENTRY_SIZE; 7681 htab->plt_initial_entry_size = VXWORKS_PLT_INITIAL_ENTRY_SIZE; 7682 } 7683 return ret; 7684} 7685 7686/* Tweak magic VxWorks symbols as they are loaded. */ 7687static bfd_boolean 7688ppc_elf_vxworks_add_symbol_hook (bfd *abfd, 7689 struct bfd_link_info *info, 7690 Elf_Internal_Sym *sym, 7691 const char **namep ATTRIBUTE_UNUSED, 7692 flagword *flagsp ATTRIBUTE_UNUSED, 7693 asection **secp, 7694 bfd_vma *valp) 7695{ 7696 if (!elf_vxworks_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, 7697 valp)) 7698 return FALSE; 7699 7700 return ppc_elf_add_symbol_hook(abfd, info, sym,namep, flagsp, secp, valp); 7701} 7702 7703static void 7704ppc_elf_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker) 7705{ 7706 ppc_elf_final_write_processing(abfd, linker); 7707 elf_vxworks_final_write_processing(abfd, linker); 7708} 7709 7710/* On VxWorks, we emit relocations against _PROCEDURE_LINKAGE_TABLE_, so 7711 define it. */ 7712#undef elf_backend_want_plt_sym 7713#define elf_backend_want_plt_sym 1 7714#undef elf_backend_want_got_plt 7715#define elf_backend_want_got_plt 1 7716#undef elf_backend_got_symbol_offset 7717#define elf_backend_got_symbol_offset 0 7718#undef elf_backend_plt_not_loaded 7719#define elf_backend_plt_not_loaded 0 7720#undef elf_backend_plt_readonly 7721#define elf_backend_plt_readonly 1 7722#undef elf_backend_got_header_size 7723#define elf_backend_got_header_size 12 7724 7725#undef bfd_elf32_bfd_link_hash_table_create 7726#define bfd_elf32_bfd_link_hash_table_create \ 7727 ppc_elf_vxworks_link_hash_table_create 7728#undef elf_backend_add_symbol_hook 7729#define elf_backend_add_symbol_hook \ 7730 ppc_elf_vxworks_add_symbol_hook 7731#undef elf_backend_link_output_symbol_hook 7732#define elf_backend_link_output_symbol_hook \ 7733 elf_vxworks_link_output_symbol_hook 7734#undef elf_backend_final_write_processing 7735#define elf_backend_final_write_processing \ 7736 ppc_elf_vxworks_final_write_processing 7737#undef elf_backend_get_sec_type_attr 7738#define elf_backend_get_sec_type_attr \ 7739 ppc_elf_vxworks_get_sec_type_attr 7740#undef elf_backend_emit_relocs 7741#define elf_backend_emit_relocs \ 7742 elf_vxworks_emit_relocs 7743 7744#undef elf32_bed 7745#define elf32_bed ppc_elf_vxworks_bed 7746 7747#include "elf32-target.h" 7748