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