elf32-ppc.c revision 78828
1/* PowerPC-specific support for 32-bit ELF 2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 3 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support. 5 6This file is part of BFD, the Binary File Descriptor library. 7 8This program is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2 of the License, or 11(at your option) any later version. 12 13This program is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with this program; if not, write to the Free Software 20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 21 22/* This file is based on a preliminary PowerPC ELF ABI. The 23 information may not match the final PowerPC ELF ABI. It includes 24 suggestions from the in-progress Embedded PowerPC ABI, and that 25 information may also not match. */ 26 27#include "bfd.h" 28#include "sysdep.h" 29#include "bfdlink.h" 30#include "libbfd.h" 31#include "elf-bfd.h" 32#include "elf/ppc.h" 33 34#define USE_RELA /* we want RELA relocations, not REL */ 35 36static reloc_howto_type *ppc_elf_reloc_type_lookup 37 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); 38static void ppc_elf_info_to_howto 39 PARAMS ((bfd *abfd, arelent *cache_ptr, Elf32_Internal_Rela *dst)); 40static void ppc_elf_howto_init PARAMS ((void)); 41static bfd_reloc_status_type ppc_elf_addr16_ha_reloc 42 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); 43static boolean ppc_elf_set_private_flags PARAMS ((bfd *, flagword)); 44static boolean ppc_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *)); 45static boolean ppc_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *)); 46 47static int ppc_elf_additional_program_headers PARAMS ((bfd *)); 48static boolean ppc_elf_modify_segment_map PARAMS ((bfd *)); 49 50static boolean ppc_elf_create_dynamic_sections 51 PARAMS ((bfd *, struct bfd_link_info *)); 52 53static boolean ppc_elf_section_from_shdr PARAMS ((bfd *, 54 Elf32_Internal_Shdr *, 55 char *)); 56static boolean ppc_elf_fake_sections 57 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *)); 58 59static elf_linker_section_t *ppc_elf_create_linker_section 60 PARAMS ((bfd *abfd, 61 struct bfd_link_info *info, 62 enum elf_linker_section_enum)); 63 64static boolean ppc_elf_check_relocs PARAMS ((bfd *, 65 struct bfd_link_info *, 66 asection *, 67 const Elf_Internal_Rela *)); 68 69static asection * ppc_elf_gc_mark_hook PARAMS ((bfd *abfd, 70 struct bfd_link_info *info, 71 Elf_Internal_Rela *rel, 72 struct elf_link_hash_entry *h, 73 Elf_Internal_Sym *sym)); 74 75static boolean ppc_elf_gc_sweep_hook PARAMS ((bfd *abfd, 76 struct bfd_link_info *info, 77 asection *sec, 78 const Elf_Internal_Rela *relocs)); 79 80static boolean ppc_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *, 81 struct elf_link_hash_entry *)); 82 83static boolean ppc_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *)); 84 85static boolean ppc_elf_relocate_section PARAMS ((bfd *, 86 struct bfd_link_info *info, 87 bfd *, 88 asection *, 89 bfd_byte *, 90 Elf_Internal_Rela *relocs, 91 Elf_Internal_Sym *local_syms, 92 asection **)); 93 94static boolean ppc_elf_add_symbol_hook PARAMS ((bfd *, 95 struct bfd_link_info *, 96 const Elf_Internal_Sym *, 97 const char **, 98 flagword *, 99 asection **, 100 bfd_vma *)); 101 102static boolean ppc_elf_finish_dynamic_symbol PARAMS ((bfd *, 103 struct bfd_link_info *, 104 struct elf_link_hash_entry *, 105 Elf_Internal_Sym *)); 106 107static boolean ppc_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *)); 108 109#define BRANCH_PREDICT_BIT 0x200000 /* branch prediction bit for branch taken relocs */ 110#define RA_REGISTER_MASK 0x001f0000 /* mask to set RA in memory instructions */ 111#define RA_REGISTER_SHIFT 16 /* value to shift register by to insert RA */ 112 113/* The name of the dynamic interpreter. This is put in the .interp 114 section. */ 115 116#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 117 118/* The size in bytes of an entry in the procedure linkage table. */ 119#define PLT_ENTRY_SIZE 12 120/* The initial size of the plt reserved for the dynamic linker. */ 121#define PLT_INITIAL_ENTRY_SIZE 72 122/* The size of the gap between entries in the PLT. */ 123#define PLT_SLOT_SIZE 8 124/* The number of single-slot PLT entries (the rest use two slots). */ 125#define PLT_NUM_SINGLE_ENTRIES 8192 126 127/* Will references to this symbol always reference the symbol 128 in this object? */ 129#define SYMBOL_REFERENCES_LOCAL(INFO, H) \ 130 ((! INFO->shared \ 131 || INFO->symbolic \ 132 || H->dynindx == -1 \ 133 || ELF_ST_VISIBILITY (H->other) == STV_INTERNAL \ 134 || ELF_ST_VISIBILITY (H->other) == STV_HIDDEN) \ 135 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0) 136 137/* Will _calls_ to this symbol always call the version in this object? */ 138#define SYMBOL_CALLS_LOCAL(INFO, H) \ 139 ((! INFO->shared \ 140 || INFO->symbolic \ 141 || H->dynindx == -1 \ 142 || ELF_ST_VISIBILITY (H->other) != STV_DEFAULT) \ 143 && (H->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0) 144 145static reloc_howto_type *ppc_elf_howto_table[(int) R_PPC_max]; 146 147static reloc_howto_type ppc_elf_howto_raw[] = { 148 /* This reloc does nothing. */ 149 HOWTO (R_PPC_NONE, /* type */ 150 0, /* rightshift */ 151 2, /* size (0 = byte, 1 = short, 2 = long) */ 152 32, /* bitsize */ 153 false, /* pc_relative */ 154 0, /* bitpos */ 155 complain_overflow_bitfield, /* complain_on_overflow */ 156 bfd_elf_generic_reloc, /* special_function */ 157 "R_PPC_NONE", /* name */ 158 false, /* partial_inplace */ 159 0, /* src_mask */ 160 0, /* dst_mask */ 161 false), /* pcrel_offset */ 162 163 /* A standard 32 bit relocation. */ 164 HOWTO (R_PPC_ADDR32, /* 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_ADDR32", /* name */ 173 false, /* partial_inplace */ 174 0, /* src_mask */ 175 0xffffffff, /* dst_mask */ 176 false), /* pcrel_offset */ 177 178 /* An absolute 26 bit branch; the lower two bits must be zero. 179 FIXME: we don't check that, we just clear them. */ 180 HOWTO (R_PPC_ADDR24, /* type */ 181 0, /* rightshift */ 182 2, /* size (0 = byte, 1 = short, 2 = long) */ 183 26, /* bitsize */ 184 false, /* pc_relative */ 185 0, /* bitpos */ 186 complain_overflow_bitfield, /* complain_on_overflow */ 187 bfd_elf_generic_reloc, /* special_function */ 188 "R_PPC_ADDR24", /* name */ 189 false, /* partial_inplace */ 190 0, /* src_mask */ 191 0x3fffffc, /* dst_mask */ 192 false), /* pcrel_offset */ 193 194 /* A standard 16 bit relocation. */ 195 HOWTO (R_PPC_ADDR16, /* type */ 196 0, /* rightshift */ 197 1, /* size (0 = byte, 1 = short, 2 = long) */ 198 16, /* 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_ADDR16", /* name */ 204 false, /* partial_inplace */ 205 0, /* src_mask */ 206 0xffff, /* dst_mask */ 207 false), /* pcrel_offset */ 208 209 /* A 16 bit relocation without overflow. */ 210 HOWTO (R_PPC_ADDR16_LO, /* 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_dont,/* complain_on_overflow */ 217 bfd_elf_generic_reloc, /* special_function */ 218 "R_PPC_ADDR16_LO", /* name */ 219 false, /* partial_inplace */ 220 0, /* src_mask */ 221 0xffff, /* dst_mask */ 222 false), /* pcrel_offset */ 223 224 /* The high order 16 bits of an address. */ 225 HOWTO (R_PPC_ADDR16_HI, /* type */ 226 16, /* 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_HI", /* 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, plus 1 if the contents of 240 the low 16 bits, treated as a signed number, is negative. */ 241 HOWTO (R_PPC_ADDR16_HA, /* type */ 242 16, /* rightshift */ 243 1, /* size (0 = byte, 1 = short, 2 = long) */ 244 16, /* bitsize */ 245 false, /* pc_relative */ 246 0, /* bitpos */ 247 complain_overflow_dont, /* complain_on_overflow */ 248 ppc_elf_addr16_ha_reloc, /* special_function */ 249 "R_PPC_ADDR16_HA", /* name */ 250 false, /* partial_inplace */ 251 0, /* src_mask */ 252 0xffff, /* dst_mask */ 253 false), /* pcrel_offset */ 254 255 /* An absolute 16 bit branch; the lower two bits must be zero. 256 FIXME: we don't check that, we just clear them. */ 257 HOWTO (R_PPC_ADDR14, /* type */ 258 0, /* rightshift */ 259 2, /* size (0 = byte, 1 = short, 2 = long) */ 260 16, /* bitsize */ 261 false, /* pc_relative */ 262 0, /* bitpos */ 263 complain_overflow_bitfield, /* complain_on_overflow */ 264 bfd_elf_generic_reloc, /* special_function */ 265 "R_PPC_ADDR14", /* name */ 266 false, /* partial_inplace */ 267 0, /* src_mask */ 268 0xfffc, /* dst_mask */ 269 false), /* pcrel_offset */ 270 271 /* An absolute 16 bit branch, for which bit 10 should be set to 272 indicate that the branch is expected to be taken. The lower two 273 bits must be zero. */ 274 HOWTO (R_PPC_ADDR14_BRTAKEN, /* type */ 275 0, /* rightshift */ 276 2, /* size (0 = byte, 1 = short, 2 = long) */ 277 16, /* bitsize */ 278 false, /* pc_relative */ 279 0, /* bitpos */ 280 complain_overflow_bitfield, /* complain_on_overflow */ 281 bfd_elf_generic_reloc, /* special_function */ 282 "R_PPC_ADDR14_BRTAKEN",/* name */ 283 false, /* partial_inplace */ 284 0, /* src_mask */ 285 0xfffc, /* dst_mask */ 286 false), /* pcrel_offset */ 287 288 /* An absolute 16 bit branch, for which bit 10 should be set to 289 indicate that the branch is not expected to be taken. The lower 290 two bits must be zero. */ 291 HOWTO (R_PPC_ADDR14_BRNTAKEN, /* type */ 292 0, /* rightshift */ 293 2, /* size (0 = byte, 1 = short, 2 = long) */ 294 16, /* bitsize */ 295 false, /* pc_relative */ 296 0, /* bitpos */ 297 complain_overflow_bitfield, /* complain_on_overflow */ 298 bfd_elf_generic_reloc, /* special_function */ 299 "R_PPC_ADDR14_BRNTAKEN",/* name */ 300 false, /* partial_inplace */ 301 0, /* src_mask */ 302 0xfffc, /* dst_mask */ 303 false), /* pcrel_offset */ 304 305 /* A relative 26 bit branch; the lower two bits must be zero. */ 306 HOWTO (R_PPC_REL24, /* type */ 307 0, /* rightshift */ 308 2, /* size (0 = byte, 1 = short, 2 = long) */ 309 26, /* bitsize */ 310 true, /* pc_relative */ 311 0, /* bitpos */ 312 complain_overflow_signed, /* complain_on_overflow */ 313 bfd_elf_generic_reloc, /* special_function */ 314 "R_PPC_REL24", /* name */ 315 false, /* partial_inplace */ 316 0, /* src_mask */ 317 0x3fffffc, /* dst_mask */ 318 true), /* pcrel_offset */ 319 320 /* A relative 16 bit branch; the lower two bits must be zero. */ 321 HOWTO (R_PPC_REL14, /* type */ 322 0, /* rightshift */ 323 2, /* size (0 = byte, 1 = short, 2 = long) */ 324 16, /* 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_REL14", /* name */ 330 false, /* partial_inplace */ 331 0, /* src_mask */ 332 0xfffc, /* dst_mask */ 333 true), /* pcrel_offset */ 334 335 /* A relative 16 bit branch. Bit 10 should be set to indicate that 336 the branch is expected to be taken. The lower two bits must be 337 zero. */ 338 HOWTO (R_PPC_REL14_BRTAKEN, /* type */ 339 0, /* rightshift */ 340 2, /* size (0 = byte, 1 = short, 2 = long) */ 341 16, /* bitsize */ 342 true, /* pc_relative */ 343 0, /* bitpos */ 344 complain_overflow_signed, /* complain_on_overflow */ 345 bfd_elf_generic_reloc, /* special_function */ 346 "R_PPC_REL14_BRTAKEN", /* name */ 347 false, /* partial_inplace */ 348 0, /* src_mask */ 349 0xfffc, /* dst_mask */ 350 true), /* pcrel_offset */ 351 352 /* A relative 16 bit branch. Bit 10 should be set to indicate that 353 the branch is not expected to be taken. The lower two bits must 354 be zero. */ 355 HOWTO (R_PPC_REL14_BRNTAKEN, /* type */ 356 0, /* rightshift */ 357 2, /* size (0 = byte, 1 = short, 2 = long) */ 358 16, /* bitsize */ 359 true, /* pc_relative */ 360 0, /* bitpos */ 361 complain_overflow_signed, /* complain_on_overflow */ 362 bfd_elf_generic_reloc, /* special_function */ 363 "R_PPC_REL14_BRNTAKEN",/* name */ 364 false, /* partial_inplace */ 365 0, /* src_mask */ 366 0xfffc, /* dst_mask */ 367 true), /* pcrel_offset */ 368 369 /* Like R_PPC_ADDR16, but referring to the GOT table entry for the 370 symbol. */ 371 HOWTO (R_PPC_GOT16, /* type */ 372 0, /* rightshift */ 373 1, /* size (0 = byte, 1 = short, 2 = long) */ 374 16, /* bitsize */ 375 false, /* pc_relative */ 376 0, /* bitpos */ 377 complain_overflow_signed, /* complain_on_overflow */ 378 bfd_elf_generic_reloc, /* special_function */ 379 "R_PPC_GOT16", /* name */ 380 false, /* partial_inplace */ 381 0, /* src_mask */ 382 0xffff, /* dst_mask */ 383 false), /* pcrel_offset */ 384 385 /* Like R_PPC_ADDR16_LO, but referring to the GOT table entry for 386 the symbol. */ 387 HOWTO (R_PPC_GOT16_LO, /* type */ 388 0, /* rightshift */ 389 1, /* size (0 = byte, 1 = short, 2 = long) */ 390 16, /* bitsize */ 391 false, /* pc_relative */ 392 0, /* bitpos */ 393 complain_overflow_dont, /* complain_on_overflow */ 394 bfd_elf_generic_reloc, /* special_function */ 395 "R_PPC_GOT16_LO", /* name */ 396 false, /* partial_inplace */ 397 0, /* src_mask */ 398 0xffff, /* dst_mask */ 399 false), /* pcrel_offset */ 400 401 /* Like R_PPC_ADDR16_HI, but referring to the GOT table entry for 402 the symbol. */ 403 HOWTO (R_PPC_GOT16_HI, /* type */ 404 16, /* rightshift */ 405 1, /* size (0 = byte, 1 = short, 2 = long) */ 406 16, /* bitsize */ 407 false, /* pc_relative */ 408 0, /* bitpos */ 409 complain_overflow_bitfield, /* complain_on_overflow */ 410 bfd_elf_generic_reloc, /* special_function */ 411 "R_PPC_GOT16_HI", /* name */ 412 false, /* partial_inplace */ 413 0, /* src_mask */ 414 0xffff, /* dst_mask */ 415 false), /* pcrel_offset */ 416 417 /* Like R_PPC_ADDR16_HA, but referring to the GOT table entry for 418 the symbol. */ 419 HOWTO (R_PPC_GOT16_HA, /* type */ 420 16, /* rightshift */ 421 1, /* size (0 = byte, 1 = short, 2 = long) */ 422 16, /* bitsize */ 423 false, /* pc_relative */ 424 0, /* bitpos */ 425 complain_overflow_bitfield, /* complain_on_overflow */ 426 ppc_elf_addr16_ha_reloc, /* special_function */ 427 "R_PPC_GOT16_HA", /* name */ 428 false, /* partial_inplace */ 429 0, /* src_mask */ 430 0xffff, /* dst_mask */ 431 false), /* pcrel_offset */ 432 433 /* Like R_PPC_REL24, but referring to the procedure linkage table 434 entry for the symbol. */ 435 HOWTO (R_PPC_PLTREL24, /* type */ 436 0, /* rightshift */ 437 2, /* size (0 = byte, 1 = short, 2 = long) */ 438 26, /* bitsize */ 439 true, /* pc_relative */ 440 0, /* bitpos */ 441 complain_overflow_signed, /* complain_on_overflow */ 442 bfd_elf_generic_reloc, /* special_function */ 443 "R_PPC_PLTREL24", /* name */ 444 false, /* partial_inplace */ 445 0, /* src_mask */ 446 0x3fffffc, /* dst_mask */ 447 true), /* pcrel_offset */ 448 449 /* This is used only by the dynamic linker. The symbol should exist 450 both in the object being run and in some shared library. The 451 dynamic linker copies the data addressed by the symbol from the 452 shared library into the object, because the object being 453 run has to have the data at some particular address. */ 454 HOWTO (R_PPC_COPY, /* type */ 455 0, /* rightshift */ 456 2, /* size (0 = byte, 1 = short, 2 = long) */ 457 32, /* bitsize */ 458 false, /* pc_relative */ 459 0, /* bitpos */ 460 complain_overflow_bitfield, /* complain_on_overflow */ 461 bfd_elf_generic_reloc, /* special_function */ 462 "R_PPC_COPY", /* name */ 463 false, /* partial_inplace */ 464 0, /* src_mask */ 465 0, /* dst_mask */ 466 false), /* pcrel_offset */ 467 468 /* Like R_PPC_ADDR32, but used when setting global offset table 469 entries. */ 470 HOWTO (R_PPC_GLOB_DAT, /* type */ 471 0, /* rightshift */ 472 2, /* size (0 = byte, 1 = short, 2 = long) */ 473 32, /* bitsize */ 474 false, /* pc_relative */ 475 0, /* bitpos */ 476 complain_overflow_bitfield, /* complain_on_overflow */ 477 bfd_elf_generic_reloc, /* special_function */ 478 "R_PPC_GLOB_DAT", /* name */ 479 false, /* partial_inplace */ 480 0, /* src_mask */ 481 0xffffffff, /* dst_mask */ 482 false), /* pcrel_offset */ 483 484 /* Marks a procedure linkage table entry for a symbol. */ 485 HOWTO (R_PPC_JMP_SLOT, /* 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_JMP_SLOT", /* name */ 494 false, /* partial_inplace */ 495 0, /* src_mask */ 496 0, /* dst_mask */ 497 false), /* pcrel_offset */ 498 499 /* Used only by the dynamic linker. When the object is run, this 500 longword is set to the load address of the object, plus the 501 addend. */ 502 HOWTO (R_PPC_RELATIVE, /* type */ 503 0, /* rightshift */ 504 2, /* size (0 = byte, 1 = short, 2 = long) */ 505 32, /* bitsize */ 506 false, /* pc_relative */ 507 0, /* bitpos */ 508 complain_overflow_bitfield, /* complain_on_overflow */ 509 bfd_elf_generic_reloc, /* special_function */ 510 "R_PPC_RELATIVE", /* name */ 511 false, /* partial_inplace */ 512 0, /* src_mask */ 513 0xffffffff, /* dst_mask */ 514 false), /* pcrel_offset */ 515 516 /* Like R_PPC_REL24, but uses the value of the symbol within the 517 object rather than the final value. Normally used for 518 _GLOBAL_OFFSET_TABLE_. */ 519 HOWTO (R_PPC_LOCAL24PC, /* type */ 520 0, /* rightshift */ 521 2, /* size (0 = byte, 1 = short, 2 = long) */ 522 26, /* bitsize */ 523 true, /* pc_relative */ 524 0, /* bitpos */ 525 complain_overflow_signed, /* complain_on_overflow */ 526 bfd_elf_generic_reloc, /* special_function */ 527 "R_PPC_LOCAL24PC", /* name */ 528 false, /* partial_inplace */ 529 0, /* src_mask */ 530 0x3fffffc, /* dst_mask */ 531 true), /* pcrel_offset */ 532 533 /* Like R_PPC_ADDR32, but may be unaligned. */ 534 HOWTO (R_PPC_UADDR32, /* type */ 535 0, /* rightshift */ 536 2, /* size (0 = byte, 1 = short, 2 = long) */ 537 32, /* bitsize */ 538 false, /* pc_relative */ 539 0, /* bitpos */ 540 complain_overflow_bitfield, /* complain_on_overflow */ 541 bfd_elf_generic_reloc, /* special_function */ 542 "R_PPC_UADDR32", /* name */ 543 false, /* partial_inplace */ 544 0, /* src_mask */ 545 0xffffffff, /* dst_mask */ 546 false), /* pcrel_offset */ 547 548 /* Like R_PPC_ADDR16, but may be unaligned. */ 549 HOWTO (R_PPC_UADDR16, /* type */ 550 0, /* rightshift */ 551 1, /* size (0 = byte, 1 = short, 2 = long) */ 552 16, /* 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_UADDR16", /* name */ 558 false, /* partial_inplace */ 559 0, /* src_mask */ 560 0xffff, /* dst_mask */ 561 false), /* pcrel_offset */ 562 563 /* 32-bit PC relative */ 564 HOWTO (R_PPC_REL32, /* type */ 565 0, /* rightshift */ 566 2, /* size (0 = byte, 1 = short, 2 = long) */ 567 32, /* bitsize */ 568 true, /* pc_relative */ 569 0, /* bitpos */ 570 complain_overflow_bitfield, /* complain_on_overflow */ 571 bfd_elf_generic_reloc, /* special_function */ 572 "R_PPC_REL32", /* name */ 573 false, /* partial_inplace */ 574 0, /* src_mask */ 575 0xffffffff, /* dst_mask */ 576 true), /* pcrel_offset */ 577 578 /* 32-bit relocation to the symbol's procedure linkage table. 579 FIXME: not supported. */ 580 HOWTO (R_PPC_PLT32, /* type */ 581 0, /* rightshift */ 582 2, /* size (0 = byte, 1 = short, 2 = long) */ 583 32, /* bitsize */ 584 false, /* pc_relative */ 585 0, /* bitpos */ 586 complain_overflow_bitfield, /* complain_on_overflow */ 587 bfd_elf_generic_reloc, /* special_function */ 588 "R_PPC_PLT32", /* name */ 589 false, /* partial_inplace */ 590 0, /* src_mask */ 591 0, /* dst_mask */ 592 false), /* pcrel_offset */ 593 594 /* 32-bit PC relative relocation to the symbol's procedure linkage table. 595 FIXME: not supported. */ 596 HOWTO (R_PPC_PLTREL32, /* type */ 597 0, /* rightshift */ 598 2, /* size (0 = byte, 1 = short, 2 = long) */ 599 32, /* bitsize */ 600 true, /* pc_relative */ 601 0, /* bitpos */ 602 complain_overflow_bitfield, /* complain_on_overflow */ 603 bfd_elf_generic_reloc, /* special_function */ 604 "R_PPC_PLTREL32", /* name */ 605 false, /* partial_inplace */ 606 0, /* src_mask */ 607 0, /* dst_mask */ 608 true), /* pcrel_offset */ 609 610 /* Like R_PPC_ADDR16_LO, but referring to the PLT table entry for 611 the symbol. */ 612 HOWTO (R_PPC_PLT16_LO, /* type */ 613 0, /* rightshift */ 614 1, /* size (0 = byte, 1 = short, 2 = long) */ 615 16, /* bitsize */ 616 false, /* pc_relative */ 617 0, /* bitpos */ 618 complain_overflow_dont, /* complain_on_overflow */ 619 bfd_elf_generic_reloc, /* special_function */ 620 "R_PPC_PLT16_LO", /* name */ 621 false, /* partial_inplace */ 622 0, /* src_mask */ 623 0xffff, /* dst_mask */ 624 false), /* pcrel_offset */ 625 626 /* Like R_PPC_ADDR16_HI, but referring to the PLT table entry for 627 the symbol. */ 628 HOWTO (R_PPC_PLT16_HI, /* type */ 629 16, /* rightshift */ 630 1, /* size (0 = byte, 1 = short, 2 = long) */ 631 16, /* bitsize */ 632 false, /* pc_relative */ 633 0, /* bitpos */ 634 complain_overflow_bitfield, /* complain_on_overflow */ 635 bfd_elf_generic_reloc, /* special_function */ 636 "R_PPC_PLT16_HI", /* name */ 637 false, /* partial_inplace */ 638 0, /* src_mask */ 639 0xffff, /* dst_mask */ 640 false), /* pcrel_offset */ 641 642 /* Like R_PPC_ADDR16_HA, but referring to the PLT table entry for 643 the symbol. */ 644 HOWTO (R_PPC_PLT16_HA, /* type */ 645 16, /* rightshift */ 646 1, /* size (0 = byte, 1 = short, 2 = long) */ 647 16, /* bitsize */ 648 false, /* pc_relative */ 649 0, /* bitpos */ 650 complain_overflow_bitfield, /* complain_on_overflow */ 651 ppc_elf_addr16_ha_reloc, /* special_function */ 652 "R_PPC_PLT16_HA", /* name */ 653 false, /* partial_inplace */ 654 0, /* src_mask */ 655 0xffff, /* dst_mask */ 656 false), /* pcrel_offset */ 657 658 /* A sign-extended 16 bit value relative to _SDA_BASE_, for use with 659 small data items. */ 660 HOWTO (R_PPC_SDAREL16, /* type */ 661 0, /* rightshift */ 662 1, /* size (0 = byte, 1 = short, 2 = long) */ 663 16, /* bitsize */ 664 false, /* pc_relative */ 665 0, /* bitpos */ 666 complain_overflow_signed, /* complain_on_overflow */ 667 bfd_elf_generic_reloc, /* special_function */ 668 "R_PPC_SDAREL16", /* name */ 669 false, /* partial_inplace */ 670 0, /* src_mask */ 671 0xffff, /* dst_mask */ 672 false), /* pcrel_offset */ 673 674 /* 32-bit section relative relocation. */ 675 HOWTO (R_PPC_SECTOFF, /* type */ 676 0, /* rightshift */ 677 2, /* size (0 = byte, 1 = short, 2 = long) */ 678 32, /* bitsize */ 679 true, /* pc_relative */ 680 0, /* bitpos */ 681 complain_overflow_bitfield, /* complain_on_overflow */ 682 bfd_elf_generic_reloc, /* special_function */ 683 "R_PPC_SECTOFF", /* name */ 684 false, /* partial_inplace */ 685 0, /* src_mask */ 686 0, /* dst_mask */ 687 true), /* pcrel_offset */ 688 689 /* 16-bit lower half section relative relocation. */ 690 HOWTO (R_PPC_SECTOFF_LO, /* 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_dont, /* complain_on_overflow */ 697 bfd_elf_generic_reloc, /* special_function */ 698 "R_PPC_SECTOFF_LO", /* name */ 699 false, /* partial_inplace */ 700 0, /* src_mask */ 701 0xffff, /* dst_mask */ 702 false), /* pcrel_offset */ 703 704 /* 16-bit upper half section relative relocation. */ 705 HOWTO (R_PPC_SECTOFF_HI, /* type */ 706 16, /* rightshift */ 707 1, /* size (0 = byte, 1 = short, 2 = long) */ 708 16, /* bitsize */ 709 false, /* pc_relative */ 710 0, /* bitpos */ 711 complain_overflow_bitfield, /* complain_on_overflow */ 712 bfd_elf_generic_reloc, /* special_function */ 713 "R_PPC_SECTOFF_HI", /* name */ 714 false, /* partial_inplace */ 715 0, /* src_mask */ 716 0xffff, /* dst_mask */ 717 false), /* pcrel_offset */ 718 719 /* 16-bit upper half adjusted section relative relocation. */ 720 HOWTO (R_PPC_SECTOFF_HA, /* 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 ppc_elf_addr16_ha_reloc, /* special_function */ 728 "R_PPC_SECTOFF_HA", /* name */ 729 false, /* partial_inplace */ 730 0, /* src_mask */ 731 0xffff, /* dst_mask */ 732 false), /* pcrel_offset */ 733 734 /* The remaining relocs are from the Embedded ELF ABI, and are not 735 in the SVR4 ELF ABI. */ 736 737 /* 32 bit value resulting from the addend minus the symbol */ 738 HOWTO (R_PPC_EMB_NADDR32, /* type */ 739 0, /* rightshift */ 740 2, /* size (0 = byte, 1 = short, 2 = long) */ 741 32, /* bitsize */ 742 false, /* pc_relative */ 743 0, /* bitpos */ 744 complain_overflow_bitfield, /* complain_on_overflow */ 745 bfd_elf_generic_reloc, /* special_function */ 746 "R_PPC_EMB_NADDR32", /* name */ 747 false, /* partial_inplace */ 748 0, /* src_mask */ 749 0xffffffff, /* dst_mask */ 750 false), /* pcrel_offset */ 751 752 /* 16 bit value resulting from the addend minus the symbol */ 753 HOWTO (R_PPC_EMB_NADDR16, /* type */ 754 0, /* rightshift */ 755 1, /* size (0 = byte, 1 = short, 2 = long) */ 756 16, /* bitsize */ 757 false, /* pc_relative */ 758 0, /* bitpos */ 759 complain_overflow_bitfield, /* complain_on_overflow */ 760 bfd_elf_generic_reloc, /* special_function */ 761 "R_PPC_EMB_NADDR16", /* name */ 762 false, /* partial_inplace */ 763 0, /* src_mask */ 764 0xffff, /* dst_mask */ 765 false), /* pcrel_offset */ 766 767 /* 16 bit value resulting from the addend minus the symbol */ 768 HOWTO (R_PPC_EMB_NADDR16_LO, /* type */ 769 0, /* rightshift */ 770 1, /* size (0 = byte, 1 = short, 2 = long) */ 771 16, /* bitsize */ 772 false, /* pc_relative */ 773 0, /* bitpos */ 774 complain_overflow_dont,/* complain_on_overflow */ 775 bfd_elf_generic_reloc, /* special_function */ 776 "R_PPC_EMB_ADDR16_LO", /* name */ 777 false, /* partial_inplace */ 778 0, /* src_mask */ 779 0xffff, /* dst_mask */ 780 false), /* pcrel_offset */ 781 782 /* The high order 16 bits of the addend minus the symbol */ 783 HOWTO (R_PPC_EMB_NADDR16_HI, /* type */ 784 16, /* rightshift */ 785 1, /* size (0 = byte, 1 = short, 2 = long) */ 786 16, /* bitsize */ 787 false, /* pc_relative */ 788 0, /* bitpos */ 789 complain_overflow_dont, /* complain_on_overflow */ 790 bfd_elf_generic_reloc, /* special_function */ 791 "R_PPC_EMB_NADDR16_HI", /* name */ 792 false, /* partial_inplace */ 793 0, /* src_mask */ 794 0xffff, /* dst_mask */ 795 false), /* pcrel_offset */ 796 797 /* The high order 16 bits of the result of the addend minus the address, 798 plus 1 if the contents of the low 16 bits, treated as a signed number, 799 is negative. */ 800 HOWTO (R_PPC_EMB_NADDR16_HA, /* type */ 801 16, /* rightshift */ 802 1, /* size (0 = byte, 1 = short, 2 = long) */ 803 16, /* bitsize */ 804 false, /* pc_relative */ 805 0, /* bitpos */ 806 complain_overflow_dont, /* complain_on_overflow */ 807 ppc_elf_addr16_ha_reloc, /* special_function */ 808 "R_PPC_EMB_NADDR16_HA", /* name */ 809 false, /* partial_inplace */ 810 0, /* src_mask */ 811 0xffff, /* dst_mask */ 812 false), /* pcrel_offset */ 813 814 /* 16 bit value resulting from allocating a 4 byte word to hold an 815 address in the .sdata section, and returning the offset from 816 _SDA_BASE_ for that relocation */ 817 HOWTO (R_PPC_EMB_SDAI16, /* type */ 818 0, /* rightshift */ 819 1, /* size (0 = byte, 1 = short, 2 = long) */ 820 16, /* bitsize */ 821 false, /* pc_relative */ 822 0, /* bitpos */ 823 complain_overflow_bitfield, /* complain_on_overflow */ 824 bfd_elf_generic_reloc, /* special_function */ 825 "R_PPC_EMB_SDAI16", /* name */ 826 false, /* partial_inplace */ 827 0, /* src_mask */ 828 0xffff, /* dst_mask */ 829 false), /* pcrel_offset */ 830 831 /* 16 bit value resulting from allocating a 4 byte word to hold an 832 address in the .sdata2 section, and returning the offset from 833 _SDA2_BASE_ for that relocation */ 834 HOWTO (R_PPC_EMB_SDA2I16, /* type */ 835 0, /* rightshift */ 836 1, /* size (0 = byte, 1 = short, 2 = long) */ 837 16, /* bitsize */ 838 false, /* pc_relative */ 839 0, /* bitpos */ 840 complain_overflow_bitfield, /* complain_on_overflow */ 841 bfd_elf_generic_reloc, /* special_function */ 842 "R_PPC_EMB_SDA2I16", /* name */ 843 false, /* partial_inplace */ 844 0, /* src_mask */ 845 0xffff, /* dst_mask */ 846 false), /* pcrel_offset */ 847 848 /* A sign-extended 16 bit value relative to _SDA2_BASE_, for use with 849 small data items. */ 850 HOWTO (R_PPC_EMB_SDA2REL, /* type */ 851 0, /* rightshift */ 852 1, /* size (0 = byte, 1 = short, 2 = long) */ 853 16, /* bitsize */ 854 false, /* pc_relative */ 855 0, /* bitpos */ 856 complain_overflow_signed, /* complain_on_overflow */ 857 bfd_elf_generic_reloc, /* special_function */ 858 "R_PPC_EMB_SDA2REL", /* name */ 859 false, /* partial_inplace */ 860 0, /* src_mask */ 861 0xffff, /* dst_mask */ 862 false), /* pcrel_offset */ 863 864 /* Relocate against either _SDA_BASE_ or _SDA2_BASE_, filling in the 16 bit 865 signed offset from the appropriate base, and filling in the register 866 field with the appropriate register (0, 2, or 13). */ 867 HOWTO (R_PPC_EMB_SDA21, /* type */ 868 0, /* rightshift */ 869 2, /* size (0 = byte, 1 = short, 2 = long) */ 870 16, /* bitsize */ 871 false, /* pc_relative */ 872 0, /* bitpos */ 873 complain_overflow_signed, /* complain_on_overflow */ 874 bfd_elf_generic_reloc, /* special_function */ 875 "R_PPC_EMB_SDA21", /* name */ 876 false, /* partial_inplace */ 877 0, /* src_mask */ 878 0xffff, /* dst_mask */ 879 false), /* pcrel_offset */ 880 881 /* Relocation not handled: R_PPC_EMB_MRKREF */ 882 /* Relocation not handled: R_PPC_EMB_RELSEC16 */ 883 /* Relocation not handled: R_PPC_EMB_RELST_LO */ 884 /* Relocation not handled: R_PPC_EMB_RELST_HI */ 885 /* Relocation not handled: R_PPC_EMB_RELST_HA */ 886 /* Relocation not handled: R_PPC_EMB_BIT_FLD */ 887 888 /* PC relative relocation against either _SDA_BASE_ or _SDA2_BASE_, filling 889 in the 16 bit signed offset from the appropriate base, and filling in the 890 register field with the appropriate register (0, 2, or 13). */ 891 HOWTO (R_PPC_EMB_RELSDA, /* type */ 892 0, /* rightshift */ 893 1, /* size (0 = byte, 1 = short, 2 = long) */ 894 16, /* bitsize */ 895 true, /* pc_relative */ 896 0, /* bitpos */ 897 complain_overflow_signed, /* complain_on_overflow */ 898 bfd_elf_generic_reloc, /* special_function */ 899 "R_PPC_EMB_RELSDA", /* name */ 900 false, /* partial_inplace */ 901 0, /* src_mask */ 902 0xffff, /* dst_mask */ 903 false), /* pcrel_offset */ 904 905 /* GNU extension to record C++ vtable hierarchy */ 906 HOWTO (R_PPC_GNU_VTINHERIT, /* type */ 907 0, /* rightshift */ 908 0, /* size (0 = byte, 1 = short, 2 = long) */ 909 0, /* bitsize */ 910 false, /* pc_relative */ 911 0, /* bitpos */ 912 complain_overflow_dont, /* complain_on_overflow */ 913 NULL, /* special_function */ 914 "R_PPC_GNU_VTINHERIT", /* name */ 915 false, /* partial_inplace */ 916 0, /* src_mask */ 917 0, /* dst_mask */ 918 false), /* pcrel_offset */ 919 920 /* GNU extension to record C++ vtable member usage */ 921 HOWTO (R_PPC_GNU_VTENTRY, /* type */ 922 0, /* rightshift */ 923 0, /* size (0 = byte, 1 = short, 2 = long) */ 924 0, /* bitsize */ 925 false, /* pc_relative */ 926 0, /* bitpos */ 927 complain_overflow_dont, /* complain_on_overflow */ 928 NULL, /* special_function */ 929 "R_PPC_GNU_VTENTRY", /* name */ 930 false, /* partial_inplace */ 931 0, /* src_mask */ 932 0, /* dst_mask */ 933 false), /* pcrel_offset */ 934 935 /* Phony reloc to handle AIX style TOC entries */ 936 HOWTO (R_PPC_TOC16, /* type */ 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 bfd_elf_generic_reloc, /* special_function */ 944 "R_PPC_TOC16", /* name */ 945 false, /* partial_inplace */ 946 0, /* src_mask */ 947 0xffff, /* dst_mask */ 948 false), /* pcrel_offset */ 949}; 950 951/* Initialize the ppc_elf_howto_table, so that linear accesses can be done. */ 952 953static void 954ppc_elf_howto_init () 955{ 956 unsigned int i, type; 957 958 for (i = 0; i < sizeof (ppc_elf_howto_raw) / sizeof (ppc_elf_howto_raw[0]); i++) 959 { 960 type = ppc_elf_howto_raw[i].type; 961 BFD_ASSERT (type < sizeof (ppc_elf_howto_table) / sizeof (ppc_elf_howto_table[0])); 962 ppc_elf_howto_table[type] = &ppc_elf_howto_raw[i]; 963 } 964} 965 966/* This function handles relaxing for the PPC with option --mpc860c0[=<n>]. 967 968 The MPC860, revision C0 or earlier contains a bug in the die. 969 If all of the following conditions are true, the next instruction 970 to be executed *may* be treated as a no-op. 971 1/ A forward branch is executed. 972 2/ The branch is predicted as not taken. 973 3/ The branch is taken. 974 4/ The branch is located in the last 5 words of a page. 975 (The EOP limit is 5 by default but may be specified as any value from 1-10.) 976 977 Our software solution is to detect these problematic branches in a 978 linker pass and modify them as follows: 979 1/ Unconditional branches - Since these are always predicted taken, 980 there is no problem and no action is required. 981 2/ Conditional backward branches - No problem, no action required. 982 3/ Conditional forward branches - Ensure that the "inverse prediction 983 bit" is set (ensure it is predicted taken). 984 4/ Conditional register branches - Ensure that the "y bit" is set 985 (ensure it is predicted taken). 986*/ 987 988/* Sort sections by address. */ 989 990static int 991ppc_elf_sort_rela (arg1, arg2) 992 const void *arg1; 993 const void *arg2; 994{ 995 const Elf_Internal_Rela **rela1 = (const Elf_Internal_Rela**) arg1; 996 const Elf_Internal_Rela **rela2 = (const Elf_Internal_Rela**) arg2; 997 998 /* Sort by offset. */ 999 return ((*rela1)->r_offset - (*rela2)->r_offset); 1000} 1001 1002static boolean 1003ppc_elf_relax_section (abfd, isec, link_info, again) 1004 bfd *abfd; 1005 asection *isec; 1006 struct bfd_link_info *link_info; 1007 boolean *again; 1008{ 1009#define PAGESIZE 0x1000 1010 1011 bfd_byte *contents = NULL; 1012 bfd_byte *free_contents = NULL; 1013 Elf_Internal_Rela *internal_relocs = NULL; 1014 Elf_Internal_Rela *free_relocs = NULL; 1015 Elf_Internal_Rela **rela_comb = NULL; 1016 int comb_curr, comb_count; 1017 1018 /* We never have to do this more than once per input section. */ 1019 *again = false; 1020 1021 /* If needed, initialize this section's cooked size. */ 1022 if (isec->_cooked_size == 0) 1023 isec->_cooked_size = isec->_raw_size; 1024 1025 /* We're only interested in text sections which overlap the 1026 troublesome area at the end of a page. */ 1027 if (link_info->mpc860c0 && (isec->flags & SEC_CODE) && isec->_cooked_size) 1028 { 1029 bfd_vma dot, end_page, end_section; 1030 boolean section_modified; 1031 1032 /* Get the section contents. */ 1033 /* Get cached copy if it exists. */ 1034 if (elf_section_data (isec)->this_hdr.contents != NULL) 1035 contents = elf_section_data (isec)->this_hdr.contents; 1036 else 1037 { 1038 /* Go get them off disk. */ 1039 contents = (bfd_byte *) bfd_malloc (isec->_raw_size); 1040 if (contents == NULL) 1041 goto error_return; 1042 free_contents = contents; 1043 1044 if (! bfd_get_section_contents (abfd, isec, contents, 1045 (file_ptr) 0, isec->_raw_size)) 1046 goto error_return; 1047 } 1048 1049 comb_curr = 0; 1050 comb_count = 0; 1051 if (isec->reloc_count) 1052 { 1053 unsigned n; 1054 1055 /* Get a copy of the native relocations. */ 1056 internal_relocs = _bfd_elf32_link_read_relocs ( 1057 abfd, isec, (PTR) NULL, (Elf_Internal_Rela *) NULL, 1058 link_info->keep_memory); 1059 if (internal_relocs == NULL) 1060 goto error_return; 1061 if (! link_info->keep_memory) 1062 free_relocs = internal_relocs; 1063 1064 /* Setup a faster access method for the reloc info we need. */ 1065 rela_comb = (Elf_Internal_Rela**) 1066 bfd_malloc (isec->reloc_count*sizeof (Elf_Internal_Rela*)); 1067 if (rela_comb == NULL) 1068 goto error_return; 1069 for (n = 0; n < isec->reloc_count; ++n) 1070 { 1071 long r_type; 1072 1073 r_type = ELF32_R_TYPE (internal_relocs[n].r_info); 1074 if (r_type < 0 || r_type >= (int) R_PPC_max) 1075 goto error_return; 1076 1077 /* Prologue constants are sometimes present in the ".text" 1078 sections and they can be identified by their associated relocation. 1079 We don't want to process those words and some others which 1080 can also be identified by their relocations. However, not all 1081 conditional branches will have a relocation so we will 1082 only ignore words that 1) have a reloc, and 2) the reloc 1083 is not applicable to a conditional branch. 1084 The array rela_comb is built here for use in the EOP scan loop. */ 1085 switch (r_type) 1086 { 1087 case R_PPC_ADDR14_BRNTAKEN: /* absolute, predicted not taken */ 1088 case R_PPC_REL14: /* relative cond. br. */ 1089 case R_PPC_REL14_BRNTAKEN: /* rel. cond. br., predicted not taken */ 1090 /* We should check the instruction. */ 1091 break; 1092 default: 1093 /* The word is not a conditional branch - ignore it. */ 1094 rela_comb[comb_count++] = &internal_relocs[n]; 1095 break; 1096 } 1097 } 1098 if (comb_count > 1) 1099 qsort (rela_comb, (size_t) comb_count, sizeof (int), ppc_elf_sort_rela); 1100 } 1101 1102 /* Enumerate each EOP region that overlaps this section. */ 1103 end_section = isec->vma + isec->_cooked_size; 1104 dot = end_page = (isec->vma | (PAGESIZE - 1)) + 1; 1105 dot -= link_info->mpc860c0; 1106 section_modified = false; 1107 if (dot < isec->vma) /* Increment the start position if this section */ 1108 dot = isec->vma; /* begins in the middle of its first EOP region. */ 1109 for (; 1110 dot < end_section; 1111 dot += PAGESIZE, end_page += PAGESIZE) 1112 { 1113 1114 /* Check each word in this EOP region. */ 1115 for (; dot < end_page; dot += 4) 1116 { 1117 bfd_vma isec_offset; 1118 unsigned long insn; 1119 boolean skip, modified; 1120 1121 /* Don't process this word if there is a relocation for it and 1122 the relocation indicates the word is not a conditional branch. */ 1123 skip = false; 1124 isec_offset = dot - isec->vma; 1125 for (; comb_curr<comb_count; ++comb_curr) 1126 { 1127 bfd_vma r_offset; 1128 1129 r_offset = rela_comb[comb_curr]->r_offset; 1130 if (r_offset >= isec_offset) 1131 { 1132 if (r_offset == isec_offset) skip = true; 1133 break; 1134 } 1135 } 1136 if (skip) continue; 1137 1138 /* Check the current word for a problematic conditional branch. */ 1139#define BO0(insn) ((insn) & 0x02000000) 1140#define BO2(insn) ((insn) & 0x00800000) 1141#define BO4(insn) ((insn) & 0x00200000) 1142 insn = (unsigned long) bfd_get_32 (abfd, contents + isec_offset); 1143 modified = false; 1144 if ((insn & 0xFc000000) == 0x40000000) 1145 { 1146 /* Instruction is BCx */ 1147 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn)) 1148 { 1149 bfd_vma target; 1150 /* This branch is predicted as "normal". 1151 If this is a forward branch, it is problematic. */ 1152 1153 target = insn & 0x0000Fffc; /*extract*/ 1154 target = (target ^ 0x8000) - 0x8000; /*sign extend*/ 1155 if ((insn & 0x00000002) == 0) 1156 target += dot; /*convert to abs*/ 1157 if (target > dot) 1158 { 1159 insn |= 0x00200000; /* set the prediction bit */ 1160 modified = true; 1161 } 1162 } 1163 } 1164 else if ((insn & 0xFc00Fffe) == 0x4c000420) 1165 { 1166 /* Instruction is BCCTRx */ 1167 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn)) 1168 { 1169 /* This branch is predicted as not-taken. 1170 If this is a forward branch, it is problematic. 1171 Since we can't tell statically if it will branch forward, 1172 always set the prediction bit. */ 1173 insn |= 0x00200000; /* set the prediction bit */ 1174 modified = true; 1175 } 1176 } 1177 else if ((insn & 0xFc00Fffe) == 0x4c000020) 1178 { 1179 /* Instruction is BCLRx */ 1180 if ((!BO0(insn) || !BO2(insn)) && !BO4(insn)) 1181 { 1182 /* This branch is predicted as not-taken. 1183 If this is a forward branch, it is problematic. 1184 Since we can't tell statically if it will branch forward, 1185 always set the prediction bit. */ 1186 insn |= 0x00200000; /* set the prediction bit */ 1187 modified = true; 1188 } 1189 } 1190#undef BO0 1191#undef BO2 1192#undef BO4 1193 if (modified) 1194 { 1195 bfd_put_32 (abfd, insn, contents + isec_offset); 1196 section_modified = true; 1197 } 1198 } 1199 } 1200 if (section_modified) 1201 { 1202 elf_section_data (isec)->this_hdr.contents = contents; 1203 free_contents = NULL; 1204 } 1205 } 1206 1207 if (rela_comb != NULL) 1208 { 1209 free (rela_comb); 1210 rela_comb = NULL; 1211 } 1212 1213 if (free_relocs != NULL) 1214 { 1215 free (free_relocs); 1216 free_relocs = NULL; 1217 } 1218 1219 if (free_contents != NULL) 1220 { 1221 if (! link_info->keep_memory) 1222 free (free_contents); 1223 else 1224 { 1225 /* Cache the section contents for elf_link_input_bfd. */ 1226 elf_section_data (isec)->this_hdr.contents = contents; 1227 } 1228 free_contents = NULL; 1229 } 1230 1231 return true; 1232 1233error_return: 1234 if (rela_comb != NULL) 1235 free (rela_comb); 1236 if (free_relocs != NULL) 1237 free (free_relocs); 1238 if (free_contents != NULL) 1239 free (free_contents); 1240 return false; 1241} 1242 1243static reloc_howto_type * 1244ppc_elf_reloc_type_lookup (abfd, code) 1245 bfd *abfd ATTRIBUTE_UNUSED; 1246 bfd_reloc_code_real_type code; 1247{ 1248 enum elf_ppc_reloc_type ppc_reloc = R_PPC_NONE; 1249 1250 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 1251 /* Initialize howto table if needed. */ 1252 ppc_elf_howto_init (); 1253 1254 switch ((int) code) 1255 { 1256 default: 1257 return (reloc_howto_type *) NULL; 1258 1259 case BFD_RELOC_NONE: ppc_reloc = R_PPC_NONE; break; 1260 case BFD_RELOC_32: ppc_reloc = R_PPC_ADDR32; break; 1261 case BFD_RELOC_PPC_BA26: ppc_reloc = R_PPC_ADDR24; break; 1262 case BFD_RELOC_16: ppc_reloc = R_PPC_ADDR16; break; 1263 case BFD_RELOC_LO16: ppc_reloc = R_PPC_ADDR16_LO; break; 1264 case BFD_RELOC_HI16: ppc_reloc = R_PPC_ADDR16_HI; break; 1265 case BFD_RELOC_HI16_S: ppc_reloc = R_PPC_ADDR16_HA; break; 1266 case BFD_RELOC_PPC_BA16: ppc_reloc = R_PPC_ADDR14; break; 1267 case BFD_RELOC_PPC_BA16_BRTAKEN: ppc_reloc = R_PPC_ADDR14_BRTAKEN; break; 1268 case BFD_RELOC_PPC_BA16_BRNTAKEN: ppc_reloc = R_PPC_ADDR14_BRNTAKEN; break; 1269 case BFD_RELOC_PPC_B26: ppc_reloc = R_PPC_REL24; break; 1270 case BFD_RELOC_PPC_B16: ppc_reloc = R_PPC_REL14; break; 1271 case BFD_RELOC_PPC_B16_BRTAKEN: ppc_reloc = R_PPC_REL14_BRTAKEN; break; 1272 case BFD_RELOC_PPC_B16_BRNTAKEN: ppc_reloc = R_PPC_REL14_BRNTAKEN; break; 1273 case BFD_RELOC_16_GOTOFF: ppc_reloc = R_PPC_GOT16; break; 1274 case BFD_RELOC_LO16_GOTOFF: ppc_reloc = R_PPC_GOT16_LO; break; 1275 case BFD_RELOC_HI16_GOTOFF: ppc_reloc = R_PPC_GOT16_HI; break; 1276 case BFD_RELOC_HI16_S_GOTOFF: ppc_reloc = R_PPC_GOT16_HA; break; 1277 case BFD_RELOC_24_PLT_PCREL: ppc_reloc = R_PPC_PLTREL24; break; 1278 case BFD_RELOC_PPC_COPY: ppc_reloc = R_PPC_COPY; break; 1279 case BFD_RELOC_PPC_GLOB_DAT: ppc_reloc = R_PPC_GLOB_DAT; break; 1280 case BFD_RELOC_PPC_LOCAL24PC: ppc_reloc = R_PPC_LOCAL24PC; break; 1281 case BFD_RELOC_32_PCREL: ppc_reloc = R_PPC_REL32; break; 1282 case BFD_RELOC_32_PLTOFF: ppc_reloc = R_PPC_PLT32; break; 1283 case BFD_RELOC_32_PLT_PCREL: ppc_reloc = R_PPC_PLTREL32; break; 1284 case BFD_RELOC_LO16_PLTOFF: ppc_reloc = R_PPC_PLT16_LO; break; 1285 case BFD_RELOC_HI16_PLTOFF: ppc_reloc = R_PPC_PLT16_HI; break; 1286 case BFD_RELOC_HI16_S_PLTOFF: ppc_reloc = R_PPC_PLT16_HA; break; 1287 case BFD_RELOC_GPREL16: ppc_reloc = R_PPC_SDAREL16; break; 1288 case BFD_RELOC_32_BASEREL: ppc_reloc = R_PPC_SECTOFF; break; 1289 case BFD_RELOC_LO16_BASEREL: ppc_reloc = R_PPC_SECTOFF_LO; break; 1290 case BFD_RELOC_HI16_BASEREL: ppc_reloc = R_PPC_SECTOFF_HI; break; 1291 case BFD_RELOC_HI16_S_BASEREL: ppc_reloc = R_PPC_SECTOFF_HA; break; 1292 case BFD_RELOC_CTOR: ppc_reloc = R_PPC_ADDR32; break; 1293 case BFD_RELOC_PPC_TOC16: ppc_reloc = R_PPC_TOC16; break; 1294 case BFD_RELOC_PPC_EMB_NADDR32: ppc_reloc = R_PPC_EMB_NADDR32; break; 1295 case BFD_RELOC_PPC_EMB_NADDR16: ppc_reloc = R_PPC_EMB_NADDR16; break; 1296 case BFD_RELOC_PPC_EMB_NADDR16_LO: ppc_reloc = R_PPC_EMB_NADDR16_LO; break; 1297 case BFD_RELOC_PPC_EMB_NADDR16_HI: ppc_reloc = R_PPC_EMB_NADDR16_HI; break; 1298 case BFD_RELOC_PPC_EMB_NADDR16_HA: ppc_reloc = R_PPC_EMB_NADDR16_HA; break; 1299 case BFD_RELOC_PPC_EMB_SDAI16: ppc_reloc = R_PPC_EMB_SDAI16; break; 1300 case BFD_RELOC_PPC_EMB_SDA2I16: ppc_reloc = R_PPC_EMB_SDA2I16; break; 1301 case BFD_RELOC_PPC_EMB_SDA2REL: ppc_reloc = R_PPC_EMB_SDA2REL; break; 1302 case BFD_RELOC_PPC_EMB_SDA21: ppc_reloc = R_PPC_EMB_SDA21; break; 1303 case BFD_RELOC_PPC_EMB_MRKREF: ppc_reloc = R_PPC_EMB_MRKREF; break; 1304 case BFD_RELOC_PPC_EMB_RELSEC16: ppc_reloc = R_PPC_EMB_RELSEC16; break; 1305 case BFD_RELOC_PPC_EMB_RELST_LO: ppc_reloc = R_PPC_EMB_RELST_LO; break; 1306 case BFD_RELOC_PPC_EMB_RELST_HI: ppc_reloc = R_PPC_EMB_RELST_HI; break; 1307 case BFD_RELOC_PPC_EMB_RELST_HA: ppc_reloc = R_PPC_EMB_RELST_HA; break; 1308 case BFD_RELOC_PPC_EMB_BIT_FLD: ppc_reloc = R_PPC_EMB_BIT_FLD; break; 1309 case BFD_RELOC_PPC_EMB_RELSDA: ppc_reloc = R_PPC_EMB_RELSDA; break; 1310 case BFD_RELOC_VTABLE_INHERIT: ppc_reloc = R_PPC_GNU_VTINHERIT; break; 1311 case BFD_RELOC_VTABLE_ENTRY: ppc_reloc = R_PPC_GNU_VTENTRY; break; 1312 } 1313 1314 return ppc_elf_howto_table[(int) ppc_reloc]; 1315}; 1316 1317/* Set the howto pointer for a PowerPC ELF reloc. */ 1318 1319static void 1320ppc_elf_info_to_howto (abfd, cache_ptr, dst) 1321 bfd *abfd ATTRIBUTE_UNUSED; 1322 arelent *cache_ptr; 1323 Elf32_Internal_Rela *dst; 1324{ 1325 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 1326 /* Initialize howto table if needed. */ 1327 ppc_elf_howto_init (); 1328 1329 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_PPC_max); 1330 cache_ptr->howto = ppc_elf_howto_table[ELF32_R_TYPE (dst->r_info)]; 1331} 1332 1333/* Handle the R_PPC_ADDR16_HA reloc. */ 1334 1335static bfd_reloc_status_type 1336ppc_elf_addr16_ha_reloc (abfd, reloc_entry, symbol, data, input_section, 1337 output_bfd, error_message) 1338 bfd *abfd ATTRIBUTE_UNUSED; 1339 arelent *reloc_entry; 1340 asymbol *symbol; 1341 PTR data ATTRIBUTE_UNUSED; 1342 asection *input_section; 1343 bfd *output_bfd; 1344 char **error_message ATTRIBUTE_UNUSED; 1345{ 1346 bfd_vma relocation; 1347 1348 if (output_bfd != NULL) 1349 { 1350 reloc_entry->address += input_section->output_offset; 1351 return bfd_reloc_ok; 1352 } 1353 1354 if (reloc_entry->address > input_section->_cooked_size) 1355 return bfd_reloc_outofrange; 1356 1357 if (bfd_is_com_section (symbol->section)) 1358 relocation = 0; 1359 else 1360 relocation = symbol->value; 1361 1362 relocation += symbol->section->output_section->vma; 1363 relocation += symbol->section->output_offset; 1364 relocation += reloc_entry->addend; 1365 1366 reloc_entry->addend += (relocation & 0x8000) << 1; 1367 1368 return bfd_reloc_continue; 1369} 1370 1371/* Function to set whether a module needs the -mrelocatable bit set. */ 1372 1373static boolean 1374ppc_elf_set_private_flags (abfd, flags) 1375 bfd *abfd; 1376 flagword flags; 1377{ 1378 BFD_ASSERT (!elf_flags_init (abfd) 1379 || elf_elfheader (abfd)->e_flags == flags); 1380 1381 elf_elfheader (abfd)->e_flags = flags; 1382 elf_flags_init (abfd) = true; 1383 return true; 1384} 1385 1386/* Copy backend specific data from one object module to another */ 1387static boolean 1388ppc_elf_copy_private_bfd_data (ibfd, obfd) 1389 bfd *ibfd; 1390 bfd *obfd; 1391{ 1392 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1393 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1394 return true; 1395 1396 BFD_ASSERT (!elf_flags_init (obfd) 1397 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags); 1398 1399 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 1400 elf_flags_init (obfd) = true; 1401 return true; 1402} 1403 1404/* Merge backend specific data from an object file to the output 1405 object file when linking */ 1406static boolean 1407ppc_elf_merge_private_bfd_data (ibfd, obfd) 1408 bfd *ibfd; 1409 bfd *obfd; 1410{ 1411 flagword old_flags; 1412 flagword new_flags; 1413 boolean error; 1414 1415 /* Check if we have the same endianess */ 1416 if (_bfd_generic_verify_endian_match (ibfd, obfd) == false) 1417 return false; 1418 1419 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 1420 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 1421 return true; 1422 1423 new_flags = elf_elfheader (ibfd)->e_flags; 1424 old_flags = elf_elfheader (obfd)->e_flags; 1425 if (!elf_flags_init (obfd)) /* First call, no flags set */ 1426 { 1427 elf_flags_init (obfd) = true; 1428 elf_elfheader (obfd)->e_flags = new_flags; 1429 } 1430 1431 else if (new_flags == old_flags) /* Compatible flags are ok */ 1432 ; 1433 1434 else /* Incompatible flags */ 1435 { 1436 /* Warn about -mrelocatable mismatch. Allow -mrelocatable-lib to be linked 1437 with either. */ 1438 error = false; 1439 if ((new_flags & EF_PPC_RELOCATABLE) != 0 1440 && (old_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0) 1441 { 1442 error = true; 1443 (*_bfd_error_handler) 1444 (_("%s: compiled with -mrelocatable and linked with modules compiled normally"), 1445 bfd_get_filename (ibfd)); 1446 } 1447 else if ((new_flags & (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB)) == 0 1448 && (old_flags & EF_PPC_RELOCATABLE) != 0) 1449 { 1450 error = true; 1451 (*_bfd_error_handler) 1452 (_("%s: compiled normally and linked with modules compiled with -mrelocatable"), 1453 bfd_get_filename (ibfd)); 1454 } 1455 1456 /* The output is -mrelocatable-lib iff both the input files are. */ 1457 if (! (new_flags & EF_PPC_RELOCATABLE_LIB)) 1458 elf_elfheader (obfd)->e_flags &= ~EF_PPC_RELOCATABLE_LIB; 1459 1460 /* The output is -mrelocatable iff it can't be -mrelocatable-lib, 1461 but each input file is either -mrelocatable or -mrelocatable-lib. */ 1462 if (! (elf_elfheader (obfd)->e_flags & EF_PPC_RELOCATABLE_LIB) 1463 && (new_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE)) 1464 && (old_flags & (EF_PPC_RELOCATABLE_LIB | EF_PPC_RELOCATABLE))) 1465 elf_elfheader (obfd)->e_flags |= EF_PPC_RELOCATABLE; 1466 1467 /* Do not warn about eabi vs. V.4 mismatch, just or in the bit if any module uses it */ 1468 elf_elfheader (obfd)->e_flags |= (new_flags & EF_PPC_EMB); 1469 1470 new_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 1471 old_flags &= ~ (EF_PPC_RELOCATABLE | EF_PPC_RELOCATABLE_LIB | EF_PPC_EMB); 1472 1473 /* Warn about any other mismatches */ 1474 if (new_flags != old_flags) 1475 { 1476 error = true; 1477 (*_bfd_error_handler) 1478 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"), 1479 bfd_get_filename (ibfd), (long) new_flags, (long) old_flags); 1480 } 1481 1482 if (error) 1483 { 1484 bfd_set_error (bfd_error_bad_value); 1485 return false; 1486 } 1487 } 1488 1489 return true; 1490} 1491 1492/* Handle a PowerPC specific section when reading an object file. This 1493 is called when elfcode.h finds a section with an unknown type. */ 1494 1495static boolean 1496ppc_elf_section_from_shdr (abfd, hdr, name) 1497 bfd *abfd; 1498 Elf32_Internal_Shdr *hdr; 1499 char *name; 1500{ 1501 asection *newsect; 1502 flagword flags; 1503 1504 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 1505 return false; 1506 1507 newsect = hdr->bfd_section; 1508 flags = bfd_get_section_flags (abfd, newsect); 1509 if (hdr->sh_flags & SHF_EXCLUDE) 1510 flags |= SEC_EXCLUDE; 1511 1512 if (hdr->sh_type == SHT_ORDERED) 1513 flags |= SEC_SORT_ENTRIES; 1514 1515 bfd_set_section_flags (abfd, newsect, flags); 1516 return true; 1517} 1518 1519/* Set up any other section flags and such that may be necessary. */ 1520 1521static boolean 1522ppc_elf_fake_sections (abfd, shdr, asect) 1523 bfd *abfd ATTRIBUTE_UNUSED; 1524 Elf32_Internal_Shdr *shdr; 1525 asection *asect; 1526{ 1527 if ((asect->flags & SEC_EXCLUDE) != 0) 1528 shdr->sh_flags |= SHF_EXCLUDE; 1529 1530 if ((asect->flags & SEC_SORT_ENTRIES) != 0) 1531 shdr->sh_type = SHT_ORDERED; 1532 1533 return true; 1534} 1535 1536/* Create a special linker section */ 1537static elf_linker_section_t * 1538ppc_elf_create_linker_section (abfd, info, which) 1539 bfd *abfd; 1540 struct bfd_link_info *info; 1541 enum elf_linker_section_enum which; 1542{ 1543 bfd *dynobj = elf_hash_table (info)->dynobj; 1544 elf_linker_section_t *lsect; 1545 1546 /* Record the first bfd section that needs the special section */ 1547 if (!dynobj) 1548 dynobj = elf_hash_table (info)->dynobj = abfd; 1549 1550 /* If this is the first time, create the section */ 1551 lsect = elf_linker_section (dynobj, which); 1552 if (!lsect) 1553 { 1554 elf_linker_section_t defaults; 1555 static elf_linker_section_t zero_section; 1556 1557 defaults = zero_section; 1558 defaults.which = which; 1559 defaults.hole_written_p = false; 1560 defaults.alignment = 2; 1561 1562 /* Both of these sections are (technically) created by the user 1563 putting data in them, so they shouldn't be marked 1564 SEC_LINKER_CREATED. 1565 1566 The linker creates them so it has somewhere to attach their 1567 respective symbols. In fact, if they were empty it would 1568 be OK to leave the symbol set to 0 (or any random number), because 1569 the appropriate register should never be used. */ 1570 defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 1571 | SEC_IN_MEMORY); 1572 1573 switch (which) 1574 { 1575 default: 1576 (*_bfd_error_handler) (_("%s: Unknown special linker type %d"), 1577 bfd_get_filename (abfd), 1578 (int) which); 1579 1580 bfd_set_error (bfd_error_bad_value); 1581 return (elf_linker_section_t *) 0; 1582 1583 case LINKER_SECTION_SDATA: /* .sdata/.sbss section */ 1584 defaults.name = ".sdata"; 1585 defaults.rel_name = ".rela.sdata"; 1586 defaults.bss_name = ".sbss"; 1587 defaults.sym_name = "_SDA_BASE_"; 1588 defaults.sym_offset = 32768; 1589 break; 1590 1591 case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */ 1592 defaults.name = ".sdata2"; 1593 defaults.rel_name = ".rela.sdata2"; 1594 defaults.bss_name = ".sbss2"; 1595 defaults.sym_name = "_SDA2_BASE_"; 1596 defaults.sym_offset = 32768; 1597 defaults.flags |= SEC_READONLY; 1598 break; 1599 } 1600 1601 lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults); 1602 } 1603 1604 return lsect; 1605} 1606 1607/* If we have a non-zero sized .sbss2 or .PPC.EMB.sbss0 sections, we 1608 need to bump up the number of section headers. */ 1609 1610static int 1611ppc_elf_additional_program_headers (abfd) 1612 bfd *abfd; 1613{ 1614 asection *s; 1615 int ret; 1616 1617 ret = 0; 1618 1619 s = bfd_get_section_by_name (abfd, ".interp"); 1620 if (s != NULL) 1621 ++ret; 1622 1623 s = bfd_get_section_by_name (abfd, ".sbss2"); 1624 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0) 1625 ++ret; 1626 1627 s = bfd_get_section_by_name (abfd, ".PPC.EMB.sbss0"); 1628 if (s != NULL && (s->flags & SEC_LOAD) != 0 && s->_raw_size > 0) 1629 ++ret; 1630 1631 return ret; 1632} 1633 1634/* Modify the segment map if needed. */ 1635 1636static boolean 1637ppc_elf_modify_segment_map (abfd) 1638 bfd *abfd ATTRIBUTE_UNUSED; 1639{ 1640 return true; 1641} 1642 1643/* We have to create .dynsbss and .rela.sbss here so that they get mapped 1644 to output sections (just like _bfd_elf_create_dynamic_sections has 1645 to create .dynbss and .rela.bss). */ 1646 1647static boolean 1648ppc_elf_create_dynamic_sections (abfd, info) 1649 bfd *abfd; 1650 struct bfd_link_info *info; 1651{ 1652 register asection *s; 1653 flagword flags; 1654 1655 if (!_bfd_elf_create_dynamic_sections (abfd, info)) 1656 return false; 1657 1658 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 1659 | SEC_LINKER_CREATED); 1660 1661 s = bfd_make_section (abfd, ".dynsbss"); 1662 if (s == NULL 1663 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC)) 1664 return false; 1665 1666 if (! info->shared) 1667 { 1668 s = bfd_make_section (abfd, ".rela.sbss"); 1669 if (s == NULL 1670 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY) 1671 || ! bfd_set_section_alignment (abfd, s, 2)) 1672 return false; 1673 } 1674 return true; 1675} 1676 1677/* Adjust a symbol defined by a dynamic object and referenced by a 1678 regular object. The current definition is in some section of the 1679 dynamic object, but we're not including those sections. We have to 1680 change the definition to something the rest of the link can 1681 understand. */ 1682 1683static boolean 1684ppc_elf_adjust_dynamic_symbol (info, h) 1685 struct bfd_link_info *info; 1686 struct elf_link_hash_entry *h; 1687{ 1688 bfd *dynobj = elf_hash_table (info)->dynobj; 1689 asection *s; 1690 unsigned int power_of_two; 1691 bfd_vma plt_offset; 1692 1693#ifdef DEBUG 1694 fprintf (stderr, "ppc_elf_adjust_dynamic_symbol called for %s\n", h->root.root.string); 1695#endif 1696 1697 /* Make sure we know what is going on here. */ 1698 BFD_ASSERT (dynobj != NULL 1699 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) 1700 || h->weakdef != NULL 1701 || ((h->elf_link_hash_flags 1702 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1703 && (h->elf_link_hash_flags 1704 & ELF_LINK_HASH_REF_REGULAR) != 0 1705 && (h->elf_link_hash_flags 1706 & ELF_LINK_HASH_DEF_REGULAR) == 0))); 1707 1708 /* If this is a function, put it in the procedure linkage table. We 1709 will fill in the contents of the procedure linkage table later, 1710 when we know the address of the .got section. */ 1711 if (h->type == STT_FUNC 1712 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 1713 { 1714 if (! elf_hash_table (info)->dynamic_sections_created 1715 || SYMBOL_CALLS_LOCAL (info, h) 1716 || (info->shared && h->plt.refcount <= 0)) 1717 { 1718 /* A PLT entry is not required/allowed when: 1719 1720 1. We are not using ld.so; because then the PLT entry 1721 can't be set up, so we can't use one. 1722 1723 2. We know for certain that a call to this symbol 1724 will go to this object. 1725 1726 3. GC has rendered the entry unused. 1727 Note, however, that in an executable all references to the 1728 symbol go to the PLT, so we can't turn it off in that case. 1729 ??? The correct thing to do here is to reference count 1730 all uses of the symbol, not just those to the GOT or PLT. */ 1731 h->plt.offset = (bfd_vma) -1; 1732 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1733 return true; 1734 } 1735 1736 /* Make sure this symbol is output as a dynamic symbol. */ 1737 if (h->dynindx == -1) 1738 { 1739 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1740 return false; 1741 } 1742 BFD_ASSERT (h->dynindx != -1); 1743 1744 s = bfd_get_section_by_name (dynobj, ".plt"); 1745 BFD_ASSERT (s != NULL); 1746 1747 /* If this is the first .plt entry, make room for the special 1748 first entry. */ 1749 if (s->_raw_size == 0) 1750 s->_raw_size += PLT_INITIAL_ENTRY_SIZE; 1751 1752 /* The PowerPC PLT is actually composed of two parts, the first part 1753 is 2 words (for a load and a jump), and then there is a remaining 1754 word available at the end. */ 1755 plt_offset = (PLT_INITIAL_ENTRY_SIZE 1756 + (PLT_SLOT_SIZE 1757 * ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) 1758 / PLT_ENTRY_SIZE))); 1759 1760 /* If this symbol is not defined in a regular file, and we are 1761 not generating a shared library, then set the symbol to this 1762 location in the .plt. This is required to make function 1763 pointers compare as equal between the normal executable and 1764 the shared library. */ 1765 if (! info->shared 1766 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1767 { 1768 h->root.u.def.section = s; 1769 h->root.u.def.value = plt_offset; 1770 } 1771 1772 h->plt.offset = plt_offset; 1773 1774 /* Make room for this entry. After the 8192nd entry, room 1775 for two entries is allocated. */ 1776 if ((s->_raw_size - PLT_INITIAL_ENTRY_SIZE) / PLT_ENTRY_SIZE 1777 >= PLT_NUM_SINGLE_ENTRIES) 1778 s->_raw_size += 2 * PLT_ENTRY_SIZE; 1779 else 1780 s->_raw_size += PLT_ENTRY_SIZE; 1781 1782 /* We also need to make an entry in the .rela.plt section. */ 1783 s = bfd_get_section_by_name (dynobj, ".rela.plt"); 1784 BFD_ASSERT (s != NULL); 1785 s->_raw_size += sizeof (Elf32_External_Rela); 1786 1787 return true; 1788 } 1789 1790 /* If this is a weak symbol, and there is a real definition, the 1791 processor independent code will have arranged for us to see the 1792 real definition first, and we can just use the same value. */ 1793 if (h->weakdef != NULL) 1794 { 1795 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 1796 || h->weakdef->root.type == bfd_link_hash_defweak); 1797 h->root.u.def.section = h->weakdef->root.u.def.section; 1798 h->root.u.def.value = h->weakdef->root.u.def.value; 1799 return true; 1800 } 1801 1802 /* This is a reference to a symbol defined by a dynamic object which 1803 is not a function. */ 1804 1805 /* If we are creating a shared library, we must presume that the 1806 only references to the symbol are via the global offset table. 1807 For such cases we need not do anything here; the relocations will 1808 be handled correctly by relocate_section. */ 1809 if (info->shared) 1810 return true; 1811 1812 /* We must allocate the symbol in our .dynbss section, which will 1813 become part of the .bss section of the executable. There will be 1814 an entry for this symbol in the .dynsym section. The dynamic 1815 object will contain position independent code, so all references 1816 from the dynamic object to this symbol will go through the global 1817 offset table. The dynamic linker will use the .dynsym entry to 1818 determine the address it must put in the global offset table, so 1819 both the dynamic object and the regular object will refer to the 1820 same memory location for the variable. 1821 1822 Of course, if the symbol is sufficiently small, we must instead 1823 allocate it in .sbss. FIXME: It would be better to do this if and 1824 only if there were actually SDAREL relocs for that symbol. */ 1825 1826 if (h->size <= elf_gp_size (dynobj)) 1827 s = bfd_get_section_by_name (dynobj, ".dynsbss"); 1828 else 1829 s = bfd_get_section_by_name (dynobj, ".dynbss"); 1830 BFD_ASSERT (s != NULL); 1831 1832 /* We must generate a R_PPC_COPY reloc to tell the dynamic linker to 1833 copy the initial value out of the dynamic object and into the 1834 runtime process image. We need to remember the offset into the 1835 .rela.bss section we are going to use. */ 1836 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1837 { 1838 asection *srel; 1839 1840 if (h->size <= elf_gp_size (dynobj)) 1841 srel = bfd_get_section_by_name (dynobj, ".rela.sbss"); 1842 else 1843 srel = bfd_get_section_by_name (dynobj, ".rela.bss"); 1844 BFD_ASSERT (srel != NULL); 1845 srel->_raw_size += sizeof (Elf32_External_Rela); 1846 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 1847 } 1848 1849 /* We need to figure out the alignment required for this symbol. I 1850 have no idea how ELF linkers handle this. */ 1851 power_of_two = bfd_log2 (h->size); 1852 if (power_of_two > 4) 1853 power_of_two = 4; 1854 1855 /* Apply the required alignment. */ 1856 s->_raw_size = BFD_ALIGN (s->_raw_size, 1857 (bfd_size_type) (1 << power_of_two)); 1858 if (power_of_two > bfd_get_section_alignment (dynobj, s)) 1859 { 1860 if (! bfd_set_section_alignment (dynobj, s, power_of_two)) 1861 return false; 1862 } 1863 1864 /* Define the symbol as being at this point in the section. */ 1865 h->root.u.def.section = s; 1866 h->root.u.def.value = s->_raw_size; 1867 1868 /* Increment the section size to make room for the symbol. */ 1869 s->_raw_size += h->size; 1870 1871 return true; 1872} 1873 1874/* Set the sizes of the dynamic sections. */ 1875 1876static boolean 1877ppc_elf_size_dynamic_sections (output_bfd, info) 1878 bfd *output_bfd; 1879 struct bfd_link_info *info; 1880{ 1881 bfd *dynobj; 1882 asection *s; 1883 boolean plt; 1884 boolean relocs; 1885 boolean reltext; 1886 1887#ifdef DEBUG 1888 fprintf (stderr, "ppc_elf_size_dynamic_sections called\n"); 1889#endif 1890 1891 dynobj = elf_hash_table (info)->dynobj; 1892 BFD_ASSERT (dynobj != NULL); 1893 1894 if (elf_hash_table (info)->dynamic_sections_created) 1895 { 1896 /* Set the contents of the .interp section to the interpreter. */ 1897 if (! info->shared) 1898 { 1899 s = bfd_get_section_by_name (dynobj, ".interp"); 1900 BFD_ASSERT (s != NULL); 1901 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1902 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1903 } 1904 } 1905 else 1906 { 1907 /* We may have created entries in the .rela.got, .rela.sdata, and 1908 .rela.sdata2 sections. However, if we are not creating the 1909 dynamic sections, we will not actually use these entries. Reset 1910 the size of .rela.got, et al, which will cause it to get 1911 stripped from the output file below. */ 1912 static char *rela_sections[] = { ".rela.got", ".rela.sdata", 1913 ".rela.sdata2", ".rela.sbss", 1914 (char *) 0 }; 1915 char **p; 1916 1917 for (p = rela_sections; *p != (char *) 0; p++) 1918 { 1919 s = bfd_get_section_by_name (dynobj, *p); 1920 if (s != NULL) 1921 s->_raw_size = 0; 1922 } 1923 } 1924 1925 /* The check_relocs and adjust_dynamic_symbol entry points have 1926 determined the sizes of the various dynamic sections. Allocate 1927 memory for them. */ 1928 plt = false; 1929 relocs = false; 1930 reltext = false; 1931 for (s = dynobj->sections; s != NULL; s = s->next) 1932 { 1933 const char *name; 1934 boolean strip; 1935 1936 if ((s->flags & SEC_LINKER_CREATED) == 0) 1937 continue; 1938 1939 /* It's OK to base decisions on the section name, because none 1940 of the dynobj section names depend upon the input files. */ 1941 name = bfd_get_section_name (dynobj, s); 1942 1943 strip = false; 1944 1945 if (strcmp (name, ".plt") == 0) 1946 { 1947 if (s->_raw_size == 0) 1948 { 1949 /* Strip this section if we don't need it; see the 1950 comment below. */ 1951 strip = true; 1952 } 1953 else 1954 { 1955 /* Remember whether there is a PLT. */ 1956 plt = true; 1957 } 1958 } 1959 else if (strncmp (name, ".rela", 5) == 0) 1960 { 1961 if (s->_raw_size == 0) 1962 { 1963 /* If we don't need this section, strip it from the 1964 output file. This is mostly to handle .rela.bss and 1965 .rela.plt. We must create both sections in 1966 create_dynamic_sections, because they must be created 1967 before the linker maps input sections to output 1968 sections. The linker does that before 1969 adjust_dynamic_symbol is called, and it is that 1970 function which decides whether anything needs to go 1971 into these sections. */ 1972 strip = true; 1973 } 1974 else 1975 { 1976 asection *target; 1977 const char *outname; 1978 1979 /* Remember whether there are any relocation sections. */ 1980 relocs = true; 1981 1982 /* If this relocation section applies to a read only 1983 section, then we probably need a DT_TEXTREL entry. */ 1984 outname = bfd_get_section_name (output_bfd, 1985 s->output_section); 1986 target = bfd_get_section_by_name (output_bfd, outname + 5); 1987 if (target != NULL 1988 && (target->flags & SEC_READONLY) != 0 1989 && (target->flags & SEC_ALLOC) != 0) 1990 reltext = true; 1991 1992 /* We use the reloc_count field as a counter if we need 1993 to copy relocs into the output file. */ 1994 s->reloc_count = 0; 1995 } 1996 } 1997 else if (strcmp (name, ".got") != 0 1998 && strcmp (name, ".sdata") != 0 1999 && strcmp (name, ".sdata2") != 0) 2000 { 2001 /* It's not one of our sections, so don't allocate space. */ 2002 continue; 2003 } 2004 2005 if (strip) 2006 { 2007 _bfd_strip_section_from_output (info, s); 2008 continue; 2009 } 2010 2011 /* Allocate memory for the section contents. */ 2012 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 2013 if (s->contents == NULL && s->_raw_size != 0) 2014 return false; 2015 } 2016 2017 if (elf_hash_table (info)->dynamic_sections_created) 2018 { 2019 /* Add some entries to the .dynamic section. We fill in the 2020 values later, in ppc_elf_finish_dynamic_sections, but we 2021 must add the entries now so that we get the correct size for 2022 the .dynamic section. The DT_DEBUG entry is filled in by the 2023 dynamic linker and used by the debugger. */ 2024 if (! info->shared) 2025 { 2026 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0)) 2027 return false; 2028 } 2029 2030 if (plt) 2031 { 2032 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0) 2033 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0) 2034 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA) 2035 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)) 2036 return false; 2037 } 2038 2039 if (relocs) 2040 { 2041 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0) 2042 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0) 2043 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT, 2044 sizeof (Elf32_External_Rela))) 2045 return false; 2046 } 2047 2048 if (reltext) 2049 { 2050 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0)) 2051 return false; 2052 info->flags |= DF_TEXTREL; 2053 } 2054 } 2055 2056 return true; 2057} 2058 2059/* Look through the relocs for a section during the first phase, and 2060 allocate space in the global offset table or procedure linkage 2061 table. */ 2062 2063static boolean 2064ppc_elf_check_relocs (abfd, info, sec, relocs) 2065 bfd *abfd; 2066 struct bfd_link_info *info; 2067 asection *sec; 2068 const Elf_Internal_Rela *relocs; 2069{ 2070 bfd *dynobj; 2071 Elf_Internal_Shdr *symtab_hdr; 2072 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 2073 const Elf_Internal_Rela *rel; 2074 const Elf_Internal_Rela *rel_end; 2075 bfd_signed_vma *local_got_refcounts; 2076 elf_linker_section_t *sdata; 2077 elf_linker_section_t *sdata2; 2078 asection *sreloc; 2079 asection *sgot = NULL; 2080 asection *srelgot = NULL; 2081 2082 if (info->relocateable) 2083 return true; 2084 2085#ifdef DEBUG 2086 fprintf (stderr, "ppc_elf_check_relocs called for section %s in %s\n", 2087 bfd_get_section_name (abfd, sec), 2088 bfd_get_filename (abfd)); 2089#endif 2090 2091 /* Create the linker generated sections all the time so that the 2092 special symbols are created. */ 2093 2094 if ((sdata = elf_linker_section (abfd, LINKER_SECTION_SDATA)) == NULL) 2095 { 2096 sdata = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA); 2097 if (!sdata) 2098 return false; 2099 } 2100 2101 if ((sdata2 = elf_linker_section (abfd, LINKER_SECTION_SDATA2)) == NULL) 2102 { 2103 sdata2 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA2); 2104 if (!sdata2) 2105 return false; 2106 } 2107 2108 dynobj = elf_hash_table (info)->dynobj; 2109 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2110 local_got_refcounts = elf_local_got_refcounts (abfd); 2111 2112 sym_hashes = elf_sym_hashes (abfd); 2113 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym); 2114 if (!elf_bad_symtab (abfd)) 2115 sym_hashes_end -= symtab_hdr->sh_info; 2116 2117 sreloc = NULL; 2118 2119 rel_end = relocs + sec->reloc_count; 2120 for (rel = relocs; rel < rel_end; rel++) 2121 { 2122 unsigned long r_symndx; 2123 struct elf_link_hash_entry *h; 2124 2125 r_symndx = ELF32_R_SYM (rel->r_info); 2126 if (r_symndx < symtab_hdr->sh_info) 2127 h = NULL; 2128 else 2129 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2130 2131 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got. 2132 This shows up in particular in an R_PPC_ADDR32 in the eabi 2133 startup code. */ 2134 if (h && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2135 { 2136 if (sgot == NULL) 2137 { 2138 if (dynobj == NULL) 2139 elf_hash_table (info)->dynobj = dynobj = abfd; 2140 if (! _bfd_elf_create_got_section (dynobj, info)) 2141 return false; 2142 sgot = bfd_get_section_by_name (dynobj, ".got"); 2143 BFD_ASSERT (sgot != NULL); 2144 } 2145 } 2146 2147 switch (ELF32_R_TYPE (rel->r_info)) 2148 { 2149 /* GOT16 relocations */ 2150 case R_PPC_GOT16: 2151 case R_PPC_GOT16_LO: 2152 case R_PPC_GOT16_HI: 2153 case R_PPC_GOT16_HA: 2154 /* This symbol requires a global offset table entry. */ 2155 2156 if (sgot == NULL) 2157 { 2158 if (dynobj == NULL) 2159 elf_hash_table (info)->dynobj = dynobj = abfd; 2160 if (! _bfd_elf_create_got_section (dynobj, info)) 2161 return false; 2162 sgot = bfd_get_section_by_name (dynobj, ".got"); 2163 BFD_ASSERT (sgot != NULL); 2164 } 2165 2166 if (srelgot == NULL 2167 && (h != NULL || info->shared)) 2168 { 2169 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 2170 if (srelgot == NULL) 2171 { 2172 srelgot = bfd_make_section (dynobj, ".rela.got"); 2173 if (srelgot == NULL 2174 || ! bfd_set_section_flags (dynobj, srelgot, 2175 (SEC_ALLOC 2176 | SEC_LOAD 2177 | SEC_HAS_CONTENTS 2178 | SEC_IN_MEMORY 2179 | SEC_LINKER_CREATED 2180 | SEC_READONLY)) 2181 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 2182 return false; 2183 } 2184 } 2185 2186 if (h != NULL) 2187 { 2188 if (h->got.refcount == -1) 2189 { 2190 /* Make sure this symbol is output as a dynamic symbol. */ 2191 if (h->dynindx == -1) 2192 if (!bfd_elf32_link_record_dynamic_symbol (info, h)) 2193 return false; 2194 2195 /* Allocate space in the .got. */ 2196 sgot->_raw_size += 4; 2197 /* Allocate relocation space. */ 2198 srelgot->_raw_size += sizeof (Elf32_External_Rela); 2199 2200 h->got.refcount = 1; 2201 } 2202 else 2203 h->got.refcount++; 2204 } 2205 else 2206 { 2207 /* This is a global offset table entry for a local symbol. */ 2208 if (local_got_refcounts == NULL) 2209 { 2210 size_t size; 2211 2212 size = symtab_hdr->sh_info * sizeof (bfd_signed_vma); 2213 local_got_refcounts = (bfd_signed_vma *) 2214 bfd_alloc (abfd, size); 2215 if (local_got_refcounts == NULL) 2216 return false; 2217 elf_local_got_refcounts (abfd) = local_got_refcounts; 2218 memset (local_got_refcounts, -1, size); 2219 } 2220 if (local_got_refcounts[r_symndx] == -1) 2221 { 2222 sgot->_raw_size += 4; 2223 2224 /* If we are generating a shared object, we need to 2225 output a R_PPC_RELATIVE reloc so that the 2226 dynamic linker can adjust this GOT entry. */ 2227 if (info->shared) 2228 srelgot->_raw_size += sizeof (Elf32_External_Rela); 2229 2230 local_got_refcounts[r_symndx] = 1; 2231 } 2232 else 2233 local_got_refcounts[r_symndx]++; 2234 } 2235 break; 2236 2237 /* Indirect .sdata relocation */ 2238 case R_PPC_EMB_SDAI16: 2239 if (info->shared) 2240 { 2241 ((*_bfd_error_handler) 2242 (_("%s: relocation %s cannot be used when making a shared object"), 2243 bfd_get_filename (abfd), "R_PPC_EMB_SDAI16")); 2244 return false; 2245 } 2246 2247 if (srelgot == NULL && (h != NULL || info->shared)) 2248 { 2249 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 2250 if (srelgot == NULL) 2251 { 2252 srelgot = bfd_make_section (dynobj, ".rela.got"); 2253 if (srelgot == NULL 2254 || ! bfd_set_section_flags (dynobj, srelgot, 2255 (SEC_ALLOC 2256 | SEC_LOAD 2257 | SEC_HAS_CONTENTS 2258 | SEC_IN_MEMORY 2259 | SEC_LINKER_CREATED 2260 | SEC_READONLY)) 2261 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 2262 return false; 2263 } 2264 } 2265 2266 if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata, h, rel)) 2267 return false; 2268 2269 break; 2270 2271 /* Indirect .sdata2 relocation */ 2272 case R_PPC_EMB_SDA2I16: 2273 if (info->shared) 2274 { 2275 ((*_bfd_error_handler) 2276 (_("%s: relocation %s cannot be used when making a shared object"), 2277 bfd_get_filename (abfd), "R_PPC_EMB_SDA2I16")); 2278 return false; 2279 } 2280 2281 if (srelgot == NULL && (h != NULL || info->shared)) 2282 { 2283 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 2284 if (srelgot == NULL) 2285 { 2286 srelgot = bfd_make_section (dynobj, ".rela.got"); 2287 if (srelgot == NULL 2288 || ! bfd_set_section_flags (dynobj, srelgot, 2289 (SEC_ALLOC 2290 | SEC_LOAD 2291 | SEC_HAS_CONTENTS 2292 | SEC_IN_MEMORY 2293 | SEC_LINKER_CREATED 2294 | SEC_READONLY)) 2295 || ! bfd_set_section_alignment (dynobj, srelgot, 2)) 2296 return false; 2297 } 2298 } 2299 2300 if (!bfd_elf32_create_pointer_linker_section (abfd, info, sdata2, h, rel)) 2301 return false; 2302 2303 break; 2304 2305 case R_PPC_SDAREL16: 2306 case R_PPC_EMB_SDA2REL: 2307 case R_PPC_EMB_SDA21: 2308 if (info->shared) 2309 { 2310 ((*_bfd_error_handler) 2311 (_("%s: relocation %s cannot be used when making a shared object"), 2312 bfd_get_filename (abfd), 2313 ppc_elf_howto_table[(int) ELF32_R_TYPE (rel->r_info)]->name)); 2314 return false; 2315 } 2316 break; 2317 2318 case R_PPC_PLT32: 2319 case R_PPC_PLTREL24: 2320 case R_PPC_PLT16_LO: 2321 case R_PPC_PLT16_HI: 2322 case R_PPC_PLT16_HA: 2323#ifdef DEBUG 2324 fprintf (stderr, "Reloc requires a PLT entry\n"); 2325#endif 2326 /* This symbol requires a procedure linkage table entry. We 2327 actually build the entry in adjust_dynamic_symbol, 2328 because this might be a case of linking PIC code without 2329 linking in any dynamic objects, in which case we don't 2330 need to generate a procedure linkage table after all. */ 2331 2332 if (h == NULL) 2333 { 2334 /* It does not make sense to have a procedure linkage 2335 table entry for a local symbol. */ 2336 bfd_set_error (bfd_error_bad_value); 2337 return false; 2338 } 2339 2340 /* Make sure this symbol is output as a dynamic symbol. */ 2341 if (h->dynindx == -1) 2342 { 2343 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 2344 return false; 2345 } 2346 if (h->plt.refcount == -1) 2347 { 2348 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 2349 h->plt.refcount = 1; 2350 } 2351 else 2352 h->plt.refcount++; 2353 break; 2354 2355 /* The following relocations don't need to propagate the 2356 relocation if linking a shared object since they are 2357 section relative. */ 2358 case R_PPC_SECTOFF: 2359 case R_PPC_SECTOFF_LO: 2360 case R_PPC_SECTOFF_HI: 2361 case R_PPC_SECTOFF_HA: 2362 break; 2363 2364 /* This refers only to functions defined in the shared library */ 2365 case R_PPC_LOCAL24PC: 2366 break; 2367 2368 /* This relocation describes the C++ object vtable hierarchy. 2369 Reconstruct it for later use during GC. */ 2370 case R_PPC_GNU_VTINHERIT: 2371 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2372 return false; 2373 break; 2374 2375 /* This relocation describes which C++ vtable entries are actually 2376 used. Record for later use during GC. */ 2377 case R_PPC_GNU_VTENTRY: 2378 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 2379 return false; 2380 break; 2381 2382 /* When creating a shared object, we must copy these 2383 relocs into the output file. We create a reloc 2384 section in dynobj and make room for the reloc. */ 2385 case R_PPC_REL24: 2386 case R_PPC_REL14: 2387 case R_PPC_REL14_BRTAKEN: 2388 case R_PPC_REL14_BRNTAKEN: 2389 case R_PPC_REL32: 2390 if (h == NULL 2391 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 2392 || SYMBOL_REFERENCES_LOCAL (info, h)) 2393 break; 2394 /* fall through */ 2395 2396 default: 2397 if (info->shared) 2398 { 2399#ifdef DEBUG 2400 fprintf (stderr, "ppc_elf_check_relocs need to create relocation for %s\n", 2401 (h && h->root.root.string) ? h->root.root.string : "<unknown>"); 2402#endif 2403 if (sreloc == NULL) 2404 { 2405 const char *name; 2406 2407 name = (bfd_elf_string_from_elf_section 2408 (abfd, 2409 elf_elfheader (abfd)->e_shstrndx, 2410 elf_section_data (sec)->rel_hdr.sh_name)); 2411 if (name == NULL) 2412 return false; 2413 2414 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 2415 && strcmp (bfd_get_section_name (abfd, sec), 2416 name + 5) == 0); 2417 2418 sreloc = bfd_get_section_by_name (dynobj, name); 2419 if (sreloc == NULL) 2420 { 2421 flagword flags; 2422 2423 sreloc = bfd_make_section (dynobj, name); 2424 flags = (SEC_HAS_CONTENTS | SEC_READONLY 2425 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 2426 if ((sec->flags & SEC_ALLOC) != 0) 2427 flags |= SEC_ALLOC | SEC_LOAD; 2428 if (sreloc == NULL 2429 || ! bfd_set_section_flags (dynobj, sreloc, flags) 2430 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 2431 return false; 2432 } 2433 } 2434 2435 sreloc->_raw_size += sizeof (Elf32_External_Rela); 2436 2437 /* FIXME: We should here do what the m68k and i386 2438 backends do: if the reloc is pc-relative, record it 2439 in case it turns out that the reloc is unnecessary 2440 because the symbol is forced local by versioning or 2441 we are linking with -Bdynamic. Fortunately this 2442 case is not frequent. */ 2443 } 2444 2445 break; 2446 } 2447 } 2448 2449 return true; 2450} 2451 2452/* Return the section that should be marked against GC for a given 2453 relocation. */ 2454 2455static asection * 2456ppc_elf_gc_mark_hook (abfd, info, rel, h, sym) 2457 bfd *abfd; 2458 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2459 Elf_Internal_Rela *rel; 2460 struct elf_link_hash_entry *h; 2461 Elf_Internal_Sym *sym; 2462{ 2463 if (h != NULL) 2464 { 2465 switch (ELF32_R_TYPE (rel->r_info)) 2466 { 2467 case R_PPC_GNU_VTINHERIT: 2468 case R_PPC_GNU_VTENTRY: 2469 break; 2470 2471 default: 2472 switch (h->root.type) 2473 { 2474 case bfd_link_hash_defined: 2475 case bfd_link_hash_defweak: 2476 return h->root.u.def.section; 2477 2478 case bfd_link_hash_common: 2479 return h->root.u.c.p->section; 2480 2481 default: 2482 break; 2483 } 2484 } 2485 } 2486 else 2487 { 2488 if (!(elf_bad_symtab (abfd) 2489 && ELF_ST_BIND (sym->st_info) != STB_LOCAL) 2490 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE) 2491 && sym->st_shndx != SHN_COMMON)) 2492 { 2493 return bfd_section_from_elf_index (abfd, sym->st_shndx); 2494 } 2495 } 2496 2497 return NULL; 2498} 2499 2500/* Update the got entry reference counts for the section being removed. */ 2501 2502static boolean 2503ppc_elf_gc_sweep_hook (abfd, info, sec, relocs) 2504 bfd *abfd; 2505 struct bfd_link_info *info ATTRIBUTE_UNUSED; 2506 asection *sec; 2507 const Elf_Internal_Rela *relocs; 2508{ 2509 Elf_Internal_Shdr *symtab_hdr; 2510 struct elf_link_hash_entry **sym_hashes; 2511 bfd_signed_vma *local_got_refcounts; 2512 const Elf_Internal_Rela *rel, *relend; 2513 unsigned long r_symndx; 2514 struct elf_link_hash_entry *h; 2515 2516 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2517 sym_hashes = elf_sym_hashes (abfd); 2518 local_got_refcounts = elf_local_got_refcounts (abfd); 2519 2520 relend = relocs + sec->reloc_count; 2521 for (rel = relocs; rel < relend; rel++) 2522 switch (ELF32_R_TYPE (rel->r_info)) 2523 { 2524 case R_PPC_GOT16: 2525 case R_PPC_GOT16_LO: 2526 case R_PPC_GOT16_HI: 2527 case R_PPC_GOT16_HA: 2528 r_symndx = ELF32_R_SYM (rel->r_info); 2529 if (r_symndx >= symtab_hdr->sh_info) 2530 { 2531 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2532 if (h->got.refcount > 0) 2533 h->got.refcount--; 2534 } 2535 else if (local_got_refcounts != NULL) 2536 { 2537 if (local_got_refcounts[r_symndx] > 0) 2538 local_got_refcounts[r_symndx]--; 2539 } 2540 break; 2541 2542 case R_PPC_PLT32: 2543 case R_PPC_PLTREL24: 2544 case R_PPC_PLT16_LO: 2545 case R_PPC_PLT16_HI: 2546 case R_PPC_PLT16_HA: 2547 r_symndx = ELF32_R_SYM (rel->r_info); 2548 if (r_symndx >= symtab_hdr->sh_info) 2549 { 2550 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 2551 if (h->plt.refcount > 0) 2552 h->plt.refcount--; 2553 } 2554 break; 2555 2556 default: 2557 break; 2558 } 2559 2560 return true; 2561} 2562 2563/* Hook called by the linker routine which adds symbols from an object 2564 file. We use it to put .comm items in .sbss, and not .bss. */ 2565 2566static boolean 2567ppc_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 2568 bfd *abfd; 2569 struct bfd_link_info *info; 2570 const Elf_Internal_Sym *sym; 2571 const char **namep ATTRIBUTE_UNUSED; 2572 flagword *flagsp ATTRIBUTE_UNUSED; 2573 asection **secp; 2574 bfd_vma *valp; 2575{ 2576 if (sym->st_shndx == SHN_COMMON 2577 && !info->relocateable 2578 && sym->st_size <= (bfd_vma) bfd_get_gp_size (abfd)) 2579 { 2580 /* Common symbols less than or equal to -G nn bytes are automatically 2581 put into .sdata. */ 2582 elf_linker_section_t *sdata 2583 = ppc_elf_create_linker_section (abfd, info, LINKER_SECTION_SDATA); 2584 2585 if (!sdata->bss_section) 2586 { 2587 /* We don't go through bfd_make_section, because we don't 2588 want to attach this common section to DYNOBJ. The linker 2589 will move the symbols to the appropriate output section 2590 when it defines common symbols. */ 2591 sdata->bss_section = ((asection *) 2592 bfd_zalloc (abfd, sizeof (asection))); 2593 if (sdata->bss_section == NULL) 2594 return false; 2595 sdata->bss_section->name = sdata->bss_name; 2596 sdata->bss_section->flags = SEC_IS_COMMON; 2597 sdata->bss_section->output_section = sdata->bss_section; 2598 sdata->bss_section->symbol = 2599 (asymbol *) bfd_zalloc (abfd, sizeof (asymbol)); 2600 sdata->bss_section->symbol_ptr_ptr = 2601 (asymbol **) bfd_zalloc (abfd, sizeof (asymbol *)); 2602 if (sdata->bss_section->symbol == NULL 2603 || sdata->bss_section->symbol_ptr_ptr == NULL) 2604 return false; 2605 sdata->bss_section->symbol->name = sdata->bss_name; 2606 sdata->bss_section->symbol->flags = BSF_SECTION_SYM; 2607 sdata->bss_section->symbol->section = sdata->bss_section; 2608 *sdata->bss_section->symbol_ptr_ptr = sdata->bss_section->symbol; 2609 } 2610 2611 *secp = sdata->bss_section; 2612 *valp = sym->st_size; 2613 } 2614 2615 return true; 2616} 2617 2618/* Finish up dynamic symbol handling. We set the contents of various 2619 dynamic sections here. */ 2620 2621static boolean 2622ppc_elf_finish_dynamic_symbol (output_bfd, info, h, sym) 2623 bfd *output_bfd; 2624 struct bfd_link_info *info; 2625 struct elf_link_hash_entry *h; 2626 Elf_Internal_Sym *sym; 2627{ 2628 bfd *dynobj; 2629 2630#ifdef DEBUG 2631 fprintf (stderr, "ppc_elf_finish_dynamic_symbol called for %s", 2632 h->root.root.string); 2633#endif 2634 2635 dynobj = elf_hash_table (info)->dynobj; 2636 BFD_ASSERT (dynobj != NULL); 2637 2638 if (h->plt.offset != (bfd_vma) -1) 2639 { 2640 asection *splt; 2641 asection *srela; 2642 Elf_Internal_Rela rela; 2643 bfd_vma reloc_index; 2644 2645#ifdef DEBUG 2646 fprintf (stderr, ", plt_offset = %d", h->plt.offset); 2647#endif 2648 2649 /* This symbol has an entry in the procedure linkage table. Set 2650 it up. */ 2651 2652 BFD_ASSERT (h->dynindx != -1); 2653 2654 splt = bfd_get_section_by_name (dynobj, ".plt"); 2655 srela = bfd_get_section_by_name (dynobj, ".rela.plt"); 2656 BFD_ASSERT (splt != NULL && srela != NULL); 2657 2658 /* We don't need to fill in the .plt. The ppc dynamic linker 2659 will fill it in. */ 2660 2661 /* Fill in the entry in the .rela.plt section. */ 2662 rela.r_offset = (splt->output_section->vma 2663 + splt->output_offset 2664 + h->plt.offset); 2665 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_JMP_SLOT); 2666 rela.r_addend = 0; 2667 2668 reloc_index = (h->plt.offset - PLT_INITIAL_ENTRY_SIZE) / PLT_SLOT_SIZE; 2669 if (reloc_index > PLT_NUM_SINGLE_ENTRIES) 2670 reloc_index -= (reloc_index - PLT_NUM_SINGLE_ENTRIES) / 2; 2671 bfd_elf32_swap_reloca_out (output_bfd, &rela, 2672 ((Elf32_External_Rela *) srela->contents 2673 + reloc_index)); 2674 2675 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 2676 { 2677 /* Mark the symbol as undefined, rather than as defined in 2678 the .plt section. Leave the value alone. */ 2679 sym->st_shndx = SHN_UNDEF; 2680 /* If the symbol is weak, we do need to clear the value. 2681 Otherwise, the PLT entry would provide a definition for 2682 the symbol even if the symbol wasn't defined anywhere, 2683 and so the symbol would never be NULL. */ 2684 if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK) 2685 == 0) 2686 sym->st_value = 0; 2687 } 2688 } 2689 2690 if (h->got.offset != (bfd_vma) -1) 2691 { 2692 asection *sgot; 2693 asection *srela; 2694 Elf_Internal_Rela rela; 2695 2696 /* This symbol has an entry in the global offset table. Set it 2697 up. */ 2698 2699 sgot = bfd_get_section_by_name (dynobj, ".got"); 2700 srela = bfd_get_section_by_name (dynobj, ".rela.got"); 2701 BFD_ASSERT (sgot != NULL && srela != NULL); 2702 2703 rela.r_offset = (sgot->output_section->vma 2704 + sgot->output_offset 2705 + (h->got.offset &~ 1)); 2706 2707 /* If this is a -Bsymbolic link, and the symbol is defined 2708 locally, we just want to emit a RELATIVE reloc. The entry in 2709 the global offset table will already have been initialized in 2710 the relocate_section function. */ 2711 if (info->shared 2712 && SYMBOL_REFERENCES_LOCAL (info, h)) 2713 { 2714 rela.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 2715 rela.r_addend = (h->root.u.def.value 2716 + h->root.u.def.section->output_section->vma 2717 + h->root.u.def.section->output_offset); 2718 } 2719 else 2720 { 2721 BFD_ASSERT ((h->got.offset & 1) == 0); 2722 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 2723 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_GLOB_DAT); 2724 rela.r_addend = 0; 2725 } 2726 2727 bfd_elf32_swap_reloca_out (output_bfd, &rela, 2728 ((Elf32_External_Rela *) srela->contents 2729 + srela->reloc_count)); 2730 ++srela->reloc_count; 2731 } 2732 2733 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 2734 { 2735 asection *s; 2736 Elf_Internal_Rela rela; 2737 2738 /* This symbols needs a copy reloc. Set it up. */ 2739 2740#ifdef DEBUG 2741 fprintf (stderr, ", copy"); 2742#endif 2743 2744 BFD_ASSERT (h->dynindx != -1); 2745 2746 if (h->size <= elf_gp_size (dynobj)) 2747 s = bfd_get_section_by_name (h->root.u.def.section->owner, 2748 ".rela.sbss"); 2749 else 2750 s = bfd_get_section_by_name (h->root.u.def.section->owner, 2751 ".rela.bss"); 2752 BFD_ASSERT (s != NULL); 2753 2754 rela.r_offset = (h->root.u.def.value 2755 + h->root.u.def.section->output_section->vma 2756 + h->root.u.def.section->output_offset); 2757 rela.r_info = ELF32_R_INFO (h->dynindx, R_PPC_COPY); 2758 rela.r_addend = 0; 2759 bfd_elf32_swap_reloca_out (output_bfd, &rela, 2760 ((Elf32_External_Rela *) s->contents 2761 + s->reloc_count)); 2762 ++s->reloc_count; 2763 } 2764 2765#ifdef DEBUG 2766 fprintf (stderr, "\n"); 2767#endif 2768 2769 /* Mark some specially defined symbols as absolute. */ 2770 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2771 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 2772 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0) 2773 sym->st_shndx = SHN_ABS; 2774 2775 return true; 2776} 2777 2778/* Finish up the dynamic sections. */ 2779 2780static boolean 2781ppc_elf_finish_dynamic_sections (output_bfd, info) 2782 bfd *output_bfd; 2783 struct bfd_link_info *info; 2784{ 2785 asection *sdyn; 2786 bfd *dynobj = elf_hash_table (info)->dynobj; 2787 asection *sgot = bfd_get_section_by_name (dynobj, ".got"); 2788 2789#ifdef DEBUG 2790 fprintf (stderr, "ppc_elf_finish_dynamic_sections called\n"); 2791#endif 2792 2793 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2794 2795 if (elf_hash_table (info)->dynamic_sections_created) 2796 { 2797 asection *splt; 2798 Elf32_External_Dyn *dyncon, *dynconend; 2799 2800 splt = bfd_get_section_by_name (dynobj, ".plt"); 2801 BFD_ASSERT (splt != NULL && sdyn != NULL); 2802 2803 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2804 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 2805 for (; dyncon < dynconend; dyncon++) 2806 { 2807 Elf_Internal_Dyn dyn; 2808 const char *name; 2809 boolean size; 2810 2811 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2812 2813 switch (dyn.d_tag) 2814 { 2815 case DT_PLTGOT: name = ".plt"; size = false; break; 2816 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break; 2817 case DT_JMPREL: name = ".rela.plt"; size = false; break; 2818 default: name = NULL; size = false; break; 2819 } 2820 2821 if (name != NULL) 2822 { 2823 asection *s; 2824 2825 s = bfd_get_section_by_name (output_bfd, name); 2826 if (s == NULL) 2827 dyn.d_un.d_val = 0; 2828 else 2829 { 2830 if (! size) 2831 dyn.d_un.d_ptr = s->vma; 2832 else 2833 { 2834 if (s->_cooked_size != 0) 2835 dyn.d_un.d_val = s->_cooked_size; 2836 else 2837 dyn.d_un.d_val = s->_raw_size; 2838 } 2839 } 2840 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2841 } 2842 } 2843 } 2844 2845 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can 2846 easily find the address of the _GLOBAL_OFFSET_TABLE_. */ 2847 if (sgot) 2848 { 2849 unsigned char *contents = sgot->contents; 2850 bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents); 2851 2852 if (sdyn == NULL) 2853 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4); 2854 else 2855 bfd_put_32 (output_bfd, 2856 sdyn->output_section->vma + sdyn->output_offset, 2857 contents+4); 2858 2859 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4; 2860 } 2861 2862 return true; 2863} 2864 2865/* The RELOCATE_SECTION function is called by the ELF backend linker 2866 to handle the relocations for a section. 2867 2868 The relocs are always passed as Rela structures; if the section 2869 actually uses Rel structures, the r_addend field will always be 2870 zero. 2871 2872 This function is responsible for adjust the section contents as 2873 necessary, and (if using Rela relocs and generating a 2874 relocateable output file) adjusting the reloc addend as 2875 necessary. 2876 2877 This function does not have to worry about setting the reloc 2878 address or the reloc symbol index. 2879 2880 LOCAL_SYMS is a pointer to the swapped in local symbols. 2881 2882 LOCAL_SECTIONS is an array giving the section in the input file 2883 corresponding to the st_shndx field of each local symbol. 2884 2885 The global hash table entry for the global symbols can be found 2886 via elf_sym_hashes (input_bfd). 2887 2888 When generating relocateable output, this function must handle 2889 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 2890 going to be the section symbol corresponding to the output 2891 section, which means that the addend must be adjusted 2892 accordingly. */ 2893 2894static boolean 2895ppc_elf_relocate_section (output_bfd, info, input_bfd, input_section, 2896 contents, relocs, local_syms, local_sections) 2897 bfd *output_bfd; 2898 struct bfd_link_info *info; 2899 bfd *input_bfd; 2900 asection *input_section; 2901 bfd_byte *contents; 2902 Elf_Internal_Rela *relocs; 2903 Elf_Internal_Sym *local_syms; 2904 asection **local_sections; 2905{ 2906 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2907 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); 2908 bfd *dynobj = elf_hash_table (info)->dynobj; 2909 elf_linker_section_t *sdata = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA) : NULL; 2910 elf_linker_section_t *sdata2 = (dynobj) ? elf_linker_section (dynobj, LINKER_SECTION_SDATA2) : NULL; 2911 Elf_Internal_Rela *rel = relocs; 2912 Elf_Internal_Rela *relend = relocs + input_section->reloc_count; 2913 asection *sreloc = NULL; 2914 asection *splt; 2915 asection *sgot; 2916 bfd_vma *local_got_offsets; 2917 boolean ret = true; 2918 long insn; 2919 2920#ifdef DEBUG 2921 fprintf (stderr, "ppc_elf_relocate_section called for %s section %s, %ld relocations%s\n", 2922 bfd_get_filename (input_bfd), 2923 bfd_section_name(input_bfd, input_section), 2924 (long) input_section->reloc_count, 2925 (info->relocateable) ? " (relocatable)" : ""); 2926#endif 2927 2928 if (!ppc_elf_howto_table[R_PPC_ADDR32]) 2929 /* Initialize howto table if needed. */ 2930 ppc_elf_howto_init (); 2931 2932 local_got_offsets = elf_local_got_offsets (input_bfd); 2933 2934 splt = sgot = NULL; 2935 if (dynobj != NULL) 2936 { 2937 splt = bfd_get_section_by_name (dynobj, ".plt"); 2938 sgot = bfd_get_section_by_name (dynobj, ".got"); 2939 } 2940 2941 for (; rel < relend; rel++) 2942 { 2943 enum elf_ppc_reloc_type r_type = (enum elf_ppc_reloc_type)ELF32_R_TYPE (rel->r_info); 2944 bfd_vma offset = rel->r_offset; 2945 bfd_vma addend = rel->r_addend; 2946 bfd_reloc_status_type r = bfd_reloc_other; 2947 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) 0; 2948 asection *sec = (asection *) 0; 2949 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) 0; 2950 const char *sym_name = (const char *) 0; 2951 reloc_howto_type *howto; 2952 unsigned long r_symndx; 2953 bfd_vma relocation; 2954 int will_become_local; 2955 2956 /* Unknown relocation handling */ 2957 if ((unsigned) r_type >= (unsigned) R_PPC_max 2958 || !ppc_elf_howto_table[(int) r_type]) 2959 { 2960 (*_bfd_error_handler) (_("%s: unknown relocation type %d"), 2961 bfd_get_filename (input_bfd), 2962 (int) r_type); 2963 2964 bfd_set_error (bfd_error_bad_value); 2965 ret = false; 2966 continue; 2967 } 2968 2969 howto = ppc_elf_howto_table[(int) r_type]; 2970 r_symndx = ELF32_R_SYM (rel->r_info); 2971 2972 if (info->relocateable) 2973 { 2974 /* This is a relocateable link. We don't have to change 2975 anything, unless the reloc is against a section symbol, 2976 in which case we have to adjust according to where the 2977 section symbol winds up in the output section. */ 2978 if (r_symndx < symtab_hdr->sh_info) 2979 { 2980 sym = local_syms + r_symndx; 2981 if ((unsigned) ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2982 { 2983 sec = local_sections[r_symndx]; 2984 addend = rel->r_addend += sec->output_offset + sym->st_value; 2985 } 2986 } 2987 2988#ifdef DEBUG 2989 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n", 2990 howto->name, 2991 (int) r_type, 2992 r_symndx, 2993 (long) offset, 2994 (long) addend); 2995#endif 2996 continue; 2997 } 2998 2999 /* This is a final link. */ 3000 if (r_symndx < symtab_hdr->sh_info) 3001 { 3002 sym = local_syms + r_symndx; 3003 sec = local_sections[r_symndx]; 3004 sym_name = "<local symbol>"; 3005 3006 relocation = (sec->output_section->vma 3007 + sec->output_offset 3008 + sym->st_value); 3009 /* Relocs to local symbols are always resolved. */ 3010 will_become_local = 1; 3011 } 3012 else 3013 { 3014 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3015 while (h->root.type == bfd_link_hash_indirect 3016 || h->root.type == bfd_link_hash_warning) 3017 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3018 sym_name = h->root.root.string; 3019 3020 /* Can this relocation be resolved immediately? */ 3021 will_become_local = SYMBOL_REFERENCES_LOCAL (info, h); 3022 3023 if (h->root.type == bfd_link_hash_defined 3024 || h->root.type == bfd_link_hash_defweak) 3025 { 3026 sec = h->root.u.def.section; 3027 if (((r_type == R_PPC_PLT32 3028 || r_type == R_PPC_PLTREL24) 3029 && splt != NULL 3030 && h->plt.offset != (bfd_vma) -1) 3031 || (r_type == R_PPC_LOCAL24PC 3032 && sec->output_section == NULL) 3033 || ((r_type == R_PPC_GOT16 3034 || r_type == R_PPC_GOT16_LO 3035 || r_type == R_PPC_GOT16_HI 3036 || r_type == R_PPC_GOT16_HA) 3037 && elf_hash_table (info)->dynamic_sections_created 3038 && (! info->shared || ! will_become_local)) 3039 || (info->shared 3040 && ! will_become_local 3041 && ((input_section->flags & SEC_ALLOC) != 0 3042 /* Testing SEC_DEBUGGING here may be wrong. 3043 It's here to avoid a crash when 3044 generating a shared library with DWARF 3045 debugging information. */ 3046 || ((input_section->flags & SEC_DEBUGGING) != 0 3047 && (h->elf_link_hash_flags 3048 & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 3049 && (r_type == R_PPC_ADDR32 3050 || r_type == R_PPC_ADDR24 3051 || r_type == R_PPC_ADDR16 3052 || r_type == R_PPC_ADDR16_LO 3053 || r_type == R_PPC_ADDR16_HI 3054 || r_type == R_PPC_ADDR16_HA 3055 || r_type == R_PPC_ADDR14 3056 || r_type == R_PPC_ADDR14_BRTAKEN 3057 || r_type == R_PPC_ADDR14_BRNTAKEN 3058 || r_type == R_PPC_COPY 3059 || r_type == R_PPC_GLOB_DAT 3060 || r_type == R_PPC_JMP_SLOT 3061 || r_type == R_PPC_UADDR32 3062 || r_type == R_PPC_UADDR16 3063 || r_type == R_PPC_SDAREL16 3064 || r_type == R_PPC_EMB_NADDR32 3065 || r_type == R_PPC_EMB_NADDR16 3066 || r_type == R_PPC_EMB_NADDR16_LO 3067 || r_type == R_PPC_EMB_NADDR16_HI 3068 || r_type == R_PPC_EMB_NADDR16_HA 3069 || r_type == R_PPC_EMB_SDAI16 3070 || r_type == R_PPC_EMB_SDA2I16 3071 || r_type == R_PPC_EMB_SDA2REL 3072 || r_type == R_PPC_EMB_SDA21 3073 || r_type == R_PPC_EMB_MRKREF 3074 || r_type == R_PPC_EMB_BIT_FLD 3075 || r_type == R_PPC_EMB_RELSDA 3076 || ((r_type == R_PPC_REL24 3077 || r_type == R_PPC_REL32 3078 || r_type == R_PPC_REL14 3079 || r_type == R_PPC_REL14_BRTAKEN 3080 || r_type == R_PPC_REL14_BRNTAKEN 3081 || r_type == R_PPC_RELATIVE) 3082 && strcmp (h->root.root.string, 3083 "_GLOBAL_OFFSET_TABLE_") != 0)))) 3084 { 3085 /* In these cases, we don't need the relocation 3086 value. We check specially because in some 3087 obscure cases sec->output_section will be NULL. */ 3088 relocation = 0; 3089 } 3090 else if (sec->output_section == NULL) 3091 { 3092 (*_bfd_error_handler) 3093 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"), 3094 bfd_get_filename (input_bfd), h->root.root.string, 3095 bfd_get_section_name (input_bfd, input_section)); 3096 relocation = 0; 3097 } 3098 else 3099 relocation = (h->root.u.def.value 3100 + sec->output_section->vma 3101 + sec->output_offset); 3102 } 3103 else if (h->root.type == bfd_link_hash_undefweak) 3104 relocation = 0; 3105 else if (info->shared && !info->symbolic && !info->no_undefined 3106 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3107 relocation = 0; 3108 else 3109 { 3110 if (! (*info->callbacks->undefined_symbol) (info, 3111 h->root.root.string, 3112 input_bfd, 3113 input_section, 3114 rel->r_offset, 3115 (!info->shared 3116 || info->no_undefined 3117 || ELF_ST_VISIBILITY (h->other)))) 3118 return false; 3119 relocation = 0; 3120 } 3121 } 3122 3123 switch ((int) r_type) 3124 { 3125 default: 3126 (*_bfd_error_handler) (_("%s: unknown relocation type %d for symbol %s"), 3127 bfd_get_filename (input_bfd), 3128 (int) r_type, sym_name); 3129 3130 bfd_set_error (bfd_error_bad_value); 3131 ret = false; 3132 continue; 3133 3134 /* Relocations that need no special processing. */ 3135 case (int) R_PPC_LOCAL24PC: 3136 /* It makes no sense to point a local relocation 3137 at a symbol not in this object. */ 3138 if (h != NULL 3139 && (h->root.type == bfd_link_hash_defined 3140 || h->root.type == bfd_link_hash_defweak) 3141 && sec->output_section == NULL) 3142 { 3143 if (! (*info->callbacks->undefined_symbol) (info, 3144 h->root.root.string, 3145 input_bfd, 3146 input_section, 3147 rel->r_offset, 3148 true)) 3149 return false; 3150 continue; 3151 } 3152 break; 3153 3154 /* Relocations that may need to be propagated if this is a shared 3155 object. */ 3156 case (int) R_PPC_REL24: 3157 case (int) R_PPC_REL32: 3158 case (int) R_PPC_REL14: 3159 /* If these relocations are not to a named symbol, they can be 3160 handled right here, no need to bother the dynamic linker. */ 3161 if (h == NULL 3162 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0 3163 || SYMBOL_REFERENCES_LOCAL (info, h)) 3164 break; 3165 /* fall through */ 3166 3167 /* Relocations that always need to be propagated if this is a shared 3168 object. */ 3169 case (int) R_PPC_NONE: 3170 case (int) R_PPC_ADDR32: 3171 case (int) R_PPC_ADDR24: 3172 case (int) R_PPC_ADDR16: 3173 case (int) R_PPC_ADDR16_LO: 3174 case (int) R_PPC_ADDR16_HI: 3175 case (int) R_PPC_ADDR16_HA: 3176 case (int) R_PPC_ADDR14: 3177 case (int) R_PPC_UADDR32: 3178 case (int) R_PPC_UADDR16: 3179 if (info->shared) 3180 { 3181 Elf_Internal_Rela outrel; 3182 boolean skip; 3183 3184#ifdef DEBUG 3185 fprintf (stderr, "ppc_elf_relocate_section need to create relocation for %s\n", 3186 (h && h->root.root.string) ? h->root.root.string : "<unknown>"); 3187#endif 3188 3189 /* When generating a shared object, these relocations 3190 are copied into the output file to be resolved at run 3191 time. */ 3192 3193 if (sreloc == NULL) 3194 { 3195 const char *name; 3196 3197 name = (bfd_elf_string_from_elf_section 3198 (input_bfd, 3199 elf_elfheader (input_bfd)->e_shstrndx, 3200 elf_section_data (input_section)->rel_hdr.sh_name)); 3201 if (name == NULL) 3202 return false; 3203 3204 BFD_ASSERT (strncmp (name, ".rela", 5) == 0 3205 && strcmp (bfd_get_section_name (input_bfd, 3206 input_section), 3207 name + 5) == 0); 3208 3209 sreloc = bfd_get_section_by_name (dynobj, name); 3210 BFD_ASSERT (sreloc != NULL); 3211 } 3212 3213 skip = false; 3214 3215 if (elf_section_data (input_section)->stab_info == NULL) 3216 outrel.r_offset = rel->r_offset; 3217 else 3218 { 3219 bfd_vma off; 3220 3221 off = (_bfd_stab_section_offset 3222 (output_bfd, &elf_hash_table (info)->stab_info, 3223 input_section, 3224 &elf_section_data (input_section)->stab_info, 3225 rel->r_offset)); 3226 if (off == (bfd_vma) -1) 3227 skip = true; 3228 outrel.r_offset = off; 3229 } 3230 3231 outrel.r_offset += (input_section->output_section->vma 3232 + input_section->output_offset); 3233 3234 if (skip) 3235 memset (&outrel, 0, sizeof outrel); 3236 /* h->dynindx may be -1 if this symbol was marked to 3237 become local. */ 3238 else if (! will_become_local) 3239 { 3240 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 3241 outrel.r_addend = rel->r_addend; 3242 } 3243 else 3244 { 3245 if (r_type == R_PPC_ADDR32) 3246 { 3247 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 3248 outrel.r_addend = relocation + rel->r_addend; 3249 } 3250 else 3251 { 3252 long indx; 3253 3254 if (h == NULL) 3255 sec = local_sections[r_symndx]; 3256 else 3257 { 3258 BFD_ASSERT (h->root.type == bfd_link_hash_defined 3259 || (h->root.type 3260 == bfd_link_hash_defweak)); 3261 sec = h->root.u.def.section; 3262 } 3263 if (sec != NULL && bfd_is_abs_section (sec)) 3264 indx = 0; 3265 else if (sec == NULL || sec->owner == NULL) 3266 { 3267 bfd_set_error (bfd_error_bad_value); 3268 return false; 3269 } 3270 else 3271 { 3272 asection *osec; 3273 3274 osec = sec->output_section; 3275 indx = elf_section_data (osec)->dynindx; 3276 BFD_ASSERT (indx > 0); 3277#ifdef DEBUG 3278 if (indx <= 0) 3279 { 3280 printf ("indx=%d section=%s flags=%08x name=%s\n", 3281 indx, osec->name, osec->flags, 3282 h->root.root.string); 3283 } 3284#endif 3285 } 3286 3287 outrel.r_info = ELF32_R_INFO (indx, r_type); 3288 outrel.r_addend = relocation + rel->r_addend; 3289 } 3290 } 3291 3292 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 3293 (((Elf32_External_Rela *) 3294 sreloc->contents) 3295 + sreloc->reloc_count)); 3296 ++sreloc->reloc_count; 3297 3298 /* This reloc will be computed at runtime, so there's no 3299 need to do anything now, unless this is a RELATIVE 3300 reloc in an unallocated section. */ 3301 if (skip 3302 || (input_section->flags & SEC_ALLOC) != 0 3303 || ELF32_R_TYPE (outrel.r_info) != R_PPC_RELATIVE) 3304 continue; 3305 } 3306 3307 /* Arithmetic adjust relocations that aren't going into a 3308 shared object. */ 3309 if (r_type == R_PPC_ADDR16_HA 3310 /* It's just possible that this symbol is a weak symbol 3311 that's not actually defined anywhere. In that case, 3312 'sec' would be NULL, and we should leave the symbol 3313 alone (it will be set to zero elsewhere in the link). */ 3314 && sec != NULL) 3315 { 3316 addend += ((relocation + addend) & 0x8000) << 1; 3317 } 3318 break; 3319 3320 /* branch taken prediction relocations */ 3321 case (int) R_PPC_ADDR14_BRTAKEN: 3322 case (int) R_PPC_REL14_BRTAKEN: 3323 insn = bfd_get_32 (output_bfd, contents + offset); 3324 if ((relocation - offset) & 0x8000) 3325 insn &= ~BRANCH_PREDICT_BIT; 3326 else 3327 insn |= BRANCH_PREDICT_BIT; 3328 bfd_put_32 (output_bfd, insn, contents + offset); 3329 break; 3330 3331 /* branch not taken predicition relocations */ 3332 case (int) R_PPC_ADDR14_BRNTAKEN: 3333 case (int) R_PPC_REL14_BRNTAKEN: 3334 insn = bfd_get_32 (output_bfd, contents + offset); 3335 if ((relocation - offset) & 0x8000) 3336 insn |= BRANCH_PREDICT_BIT; 3337 else 3338 insn &= ~BRANCH_PREDICT_BIT; 3339 bfd_put_32 (output_bfd, insn, contents + offset); 3340 break; 3341 3342 /* GOT16 relocations */ 3343 case (int) R_PPC_GOT16: 3344 case (int) R_PPC_GOT16_LO: 3345 case (int) R_PPC_GOT16_HI: 3346 case (int) R_PPC_GOT16_HA: 3347 /* Relocation is to the entry for this symbol in the global 3348 offset table. */ 3349 BFD_ASSERT (sgot != NULL); 3350 3351 if (h != NULL) 3352 { 3353 bfd_vma off; 3354 3355 off = h->got.offset; 3356 BFD_ASSERT (off != (bfd_vma) -1); 3357 3358 if (! elf_hash_table (info)->dynamic_sections_created 3359 || (info->shared 3360 && SYMBOL_REFERENCES_LOCAL (info, h))) 3361 { 3362 /* This is actually a static link, or it is a 3363 -Bsymbolic link and the symbol is defined 3364 locally. We must initialize this entry in the 3365 global offset table. Since the offset must 3366 always be a multiple of 4, we use the least 3367 significant bit to record whether we have 3368 initialized it already. 3369 3370 When doing a dynamic link, we create a .rela.got 3371 relocation entry to initialize the value. This 3372 is done in the finish_dynamic_symbol routine. */ 3373 if ((off & 1) != 0) 3374 off &= ~1; 3375 else 3376 { 3377 bfd_put_32 (output_bfd, relocation, 3378 sgot->contents + off); 3379 h->got.offset |= 1; 3380 } 3381 } 3382 3383 relocation = sgot->output_offset + off - 4; 3384 } 3385 else 3386 { 3387 bfd_vma off; 3388 3389 BFD_ASSERT (local_got_offsets != NULL 3390 && local_got_offsets[r_symndx] != (bfd_vma) -1); 3391 3392 off = local_got_offsets[r_symndx]; 3393 3394 /* The offset must always be a multiple of 4. We use 3395 the least significant bit to record whether we have 3396 already processed this entry. */ 3397 if ((off & 1) != 0) 3398 off &= ~1; 3399 else 3400 { 3401 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 3402 3403 if (info->shared) 3404 { 3405 asection *srelgot; 3406 Elf_Internal_Rela outrel; 3407 3408 /* We need to generate a R_PPC_RELATIVE reloc 3409 for the dynamic linker. */ 3410 srelgot = bfd_get_section_by_name (dynobj, ".rela.got"); 3411 BFD_ASSERT (srelgot != NULL); 3412 3413 outrel.r_offset = (sgot->output_section->vma 3414 + sgot->output_offset 3415 + off); 3416 outrel.r_info = ELF32_R_INFO (0, R_PPC_RELATIVE); 3417 outrel.r_addend = relocation; 3418 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 3419 (((Elf32_External_Rela *) 3420 srelgot->contents) 3421 + srelgot->reloc_count)); 3422 ++srelgot->reloc_count; 3423 } 3424 3425 local_got_offsets[r_symndx] |= 1; 3426 } 3427 3428 relocation = sgot->output_offset + off - 4; 3429 } 3430 break; 3431 3432 /* Indirect .sdata relocation */ 3433 case (int) R_PPC_EMB_SDAI16: 3434 BFD_ASSERT (sdata != NULL); 3435 relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info, 3436 sdata, h, relocation, rel, 3437 R_PPC_RELATIVE); 3438 break; 3439 3440 /* Indirect .sdata2 relocation */ 3441 case (int) R_PPC_EMB_SDA2I16: 3442 BFD_ASSERT (sdata2 != NULL); 3443 relocation = bfd_elf32_finish_pointer_linker_section (output_bfd, input_bfd, info, 3444 sdata2, h, relocation, rel, 3445 R_PPC_RELATIVE); 3446 break; 3447 3448 /* Handle the TOC16 reloc. We want to use the offset within the .got 3449 section, not the actual VMA. This is appropriate when generating 3450 an embedded ELF object, for which the .got section acts like the 3451 AIX .toc section. */ 3452 case (int) R_PPC_TOC16: /* phony GOT16 relocations */ 3453 BFD_ASSERT (sec != (asection *) 0); 3454 BFD_ASSERT (bfd_is_und_section (sec) 3455 || strcmp (bfd_get_section_name (abfd, sec), ".got") == 0 3456 || strcmp (bfd_get_section_name (abfd, sec), ".cgot") == 0) 3457 3458 addend -= sec->output_section->vma + sec->output_offset + 0x8000; 3459 break; 3460 3461 case (int) R_PPC_PLTREL24: 3462 /* Relocation is to the entry for this symbol in the 3463 procedure linkage table. */ 3464 BFD_ASSERT (h != NULL); 3465 3466 if (h->plt.offset == (bfd_vma) -1 3467 || splt == NULL) 3468 { 3469 /* We didn't make a PLT entry for this symbol. This 3470 happens when statically linking PIC code, or when 3471 using -Bsymbolic. */ 3472 break; 3473 } 3474 3475 relocation = (splt->output_section->vma 3476 + splt->output_offset 3477 + h->plt.offset); 3478 break; 3479 3480 /* relocate against _SDA_BASE_ */ 3481 case (int) R_PPC_SDAREL16: 3482 { 3483 const char *name; 3484 3485 BFD_ASSERT (sec != (asection *) 0); 3486 name = bfd_get_section_name (abfd, sec->output_section); 3487 if (strcmp (name, ".sdata") != 0 3488 && strcmp (name, ".sbss") != 0) 3489 { 3490 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"), 3491 bfd_get_filename (input_bfd), 3492 sym_name, 3493 ppc_elf_howto_table[(int) r_type]->name, 3494 name); 3495 } 3496 addend -= (sdata->sym_hash->root.u.def.value 3497 + sdata->sym_hash->root.u.def.section->output_section->vma 3498 + sdata->sym_hash->root.u.def.section->output_offset); 3499 } 3500 break; 3501 3502 /* relocate against _SDA2_BASE_ */ 3503 case (int) R_PPC_EMB_SDA2REL: 3504 { 3505 const char *name; 3506 3507 BFD_ASSERT (sec != (asection *) 0); 3508 name = bfd_get_section_name (abfd, sec->output_section); 3509 if (strcmp (name, ".sdata2") != 0 && strcmp (name, ".sbss2") != 0) 3510 { 3511 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"), 3512 bfd_get_filename (input_bfd), 3513 sym_name, 3514 ppc_elf_howto_table[(int) r_type]->name, 3515 name); 3516 3517 bfd_set_error (bfd_error_bad_value); 3518 ret = false; 3519 continue; 3520 } 3521 addend -= (sdata2->sym_hash->root.u.def.value 3522 + sdata2->sym_hash->root.u.def.section->output_section->vma 3523 + sdata2->sym_hash->root.u.def.section->output_offset); 3524 } 3525 break; 3526 3527 /* relocate against either _SDA_BASE_, _SDA2_BASE_, or 0 */ 3528 case (int) R_PPC_EMB_SDA21: 3529 case (int) R_PPC_EMB_RELSDA: 3530 { 3531 const char *name; 3532 int reg; 3533 3534 BFD_ASSERT (sec != (asection *) 0); 3535 name = bfd_get_section_name (abfd, sec->output_section); 3536 if (strcmp (name, ".sdata") == 0 || strcmp (name, ".sbss") == 0) 3537 { 3538 reg = 13; 3539 addend -= (sdata->sym_hash->root.u.def.value 3540 + sdata->sym_hash->root.u.def.section->output_section->vma 3541 + sdata->sym_hash->root.u.def.section->output_offset); 3542 } 3543 3544 else if (strcmp (name, ".sdata2") == 0 3545 || strcmp (name, ".sbss2") == 0) 3546 { 3547 reg = 2; 3548 addend -= (sdata2->sym_hash->root.u.def.value 3549 + sdata2->sym_hash->root.u.def.section->output_section->vma 3550 + sdata2->sym_hash->root.u.def.section->output_offset); 3551 } 3552 3553 else if (strcmp (name, ".PPC.EMB.sdata0") == 0 3554 || strcmp (name, ".PPC.EMB.sbss0") == 0) 3555 { 3556 reg = 0; 3557 } 3558 3559 else 3560 { 3561 (*_bfd_error_handler) (_("%s: The target (%s) of a %s relocation is in the wrong output section (%s)"), 3562 bfd_get_filename (input_bfd), 3563 sym_name, 3564 ppc_elf_howto_table[(int) r_type]->name, 3565 name); 3566 3567 bfd_set_error (bfd_error_bad_value); 3568 ret = false; 3569 continue; 3570 } 3571 3572 if (r_type == R_PPC_EMB_SDA21) 3573 { /* fill in register field */ 3574 insn = bfd_get_32 (output_bfd, contents + offset); 3575 insn = (insn & ~RA_REGISTER_MASK) | (reg << RA_REGISTER_SHIFT); 3576 bfd_put_32 (output_bfd, insn, contents + offset); 3577 } 3578 } 3579 break; 3580 3581 /* Relocate against the beginning of the section */ 3582 case (int) R_PPC_SECTOFF: 3583 case (int) R_PPC_SECTOFF_LO: 3584 case (int) R_PPC_SECTOFF_HI: 3585 BFD_ASSERT (sec != (asection *) 0); 3586 addend -= sec->output_section->vma; 3587 break; 3588 3589 case (int) R_PPC_SECTOFF_HA: 3590 BFD_ASSERT (sec != (asection *) 0); 3591 addend -= sec->output_section->vma; 3592 addend += ((relocation + addend) & 0x8000) << 1; 3593 break; 3594 3595 /* Negative relocations */ 3596 case (int) R_PPC_EMB_NADDR32: 3597 case (int) R_PPC_EMB_NADDR16: 3598 case (int) R_PPC_EMB_NADDR16_LO: 3599 case (int) R_PPC_EMB_NADDR16_HI: 3600 addend -= 2 * relocation; 3601 break; 3602 3603 case (int) R_PPC_EMB_NADDR16_HA: 3604 addend -= 2 * relocation; 3605 addend += ((relocation + addend) & 0x8000) << 1; 3606 break; 3607 3608 /* NOP relocation that prevents garbage collecting linkers from omitting a 3609 reference. */ 3610 case (int) R_PPC_EMB_MRKREF: 3611 continue; 3612 3613 case (int) R_PPC_COPY: 3614 case (int) R_PPC_GLOB_DAT: 3615 case (int) R_PPC_JMP_SLOT: 3616 case (int) R_PPC_RELATIVE: 3617 case (int) R_PPC_PLT32: 3618 case (int) R_PPC_PLTREL32: 3619 case (int) R_PPC_PLT16_LO: 3620 case (int) R_PPC_PLT16_HI: 3621 case (int) R_PPC_PLT16_HA: 3622 case (int) R_PPC_EMB_RELSEC16: 3623 case (int) R_PPC_EMB_RELST_LO: 3624 case (int) R_PPC_EMB_RELST_HI: 3625 case (int) R_PPC_EMB_RELST_HA: 3626 case (int) R_PPC_EMB_BIT_FLD: 3627 (*_bfd_error_handler) (_("%s: Relocation %s is not yet supported for symbol %s."), 3628 bfd_get_filename (input_bfd), 3629 ppc_elf_howto_table[(int) r_type]->name, 3630 sym_name); 3631 3632 bfd_set_error (bfd_error_invalid_operation); 3633 ret = false; 3634 continue; 3635 3636 case (int) R_PPC_GNU_VTINHERIT: 3637 case (int) R_PPC_GNU_VTENTRY: 3638 /* These are no-ops in the end. */ 3639 continue; 3640 } 3641 3642#ifdef DEBUG 3643 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n", 3644 howto->name, 3645 (int) r_type, 3646 sym_name, 3647 r_symndx, 3648 (long) offset, 3649 (long) addend); 3650#endif 3651 3652 r = _bfd_final_link_relocate (howto, 3653 input_bfd, 3654 input_section, 3655 contents, 3656 offset, 3657 relocation, 3658 addend); 3659 3660 if (r == bfd_reloc_ok) 3661 ; 3662 else if (r == bfd_reloc_overflow) 3663 { 3664 const char *name; 3665 3666 if (h != NULL) 3667 { 3668 if (h->root.type == bfd_link_hash_undefweak 3669 && howto->pc_relative) 3670 { 3671 /* Assume this is a call protected by other code that 3672 detect the symbol is undefined. If this is the case, 3673 we can safely ignore the overflow. If not, the 3674 program is hosed anyway, and a little warning isn't 3675 going to help. */ 3676 3677 continue; 3678 } 3679 3680 name = h->root.root.string; 3681 } 3682 else 3683 { 3684 name = bfd_elf_string_from_elf_section (input_bfd, 3685 symtab_hdr->sh_link, 3686 sym->st_name); 3687 if (name == NULL) 3688 continue; 3689 if (*name == '\0') 3690 name = bfd_section_name (input_bfd, sec); 3691 } 3692 3693 if (! (*info->callbacks->reloc_overflow) (info, 3694 name, 3695 howto->name, 3696 (bfd_vma) 0, 3697 input_bfd, 3698 input_section, 3699 offset)) 3700 return false; 3701 } 3702 else 3703 ret = false; 3704 } 3705 3706#ifdef DEBUG 3707 fprintf (stderr, "\n"); 3708#endif 3709 3710 return ret; 3711} 3712 3713#define TARGET_LITTLE_SYM bfd_elf32_powerpcle_vec 3714#define TARGET_LITTLE_NAME "elf32-powerpcle" 3715#define TARGET_BIG_SYM bfd_elf32_powerpc_vec 3716#define TARGET_BIG_NAME "elf32-powerpc" 3717#define ELF_ARCH bfd_arch_powerpc 3718#define ELF_MACHINE_CODE EM_PPC 3719#define ELF_MAXPAGESIZE 0x10000 3720#define elf_info_to_howto ppc_elf_info_to_howto 3721 3722#ifdef EM_CYGNUS_POWERPC 3723#define ELF_MACHINE_ALT1 EM_CYGNUS_POWERPC 3724#endif 3725 3726#ifdef EM_PPC_OLD 3727#define ELF_MACHINE_ALT2 EM_PPC_OLD 3728#endif 3729 3730#define elf_backend_plt_not_loaded 1 3731#define elf_backend_got_symbol_offset 4 3732#define elf_backend_can_gc_sections 1 3733#define elf_backend_got_header_size 12 3734#define elf_backend_plt_header_size PLT_INITIAL_ENTRY_SIZE 3735 3736#define bfd_elf32_bfd_copy_private_bfd_data ppc_elf_copy_private_bfd_data 3737#define bfd_elf32_bfd_merge_private_bfd_data ppc_elf_merge_private_bfd_data 3738#define bfd_elf32_bfd_relax_section ppc_elf_relax_section 3739#define bfd_elf32_bfd_reloc_type_lookup ppc_elf_reloc_type_lookup 3740#define bfd_elf32_bfd_set_private_flags ppc_elf_set_private_flags 3741#define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link 3742 3743#define elf_backend_gc_mark_hook ppc_elf_gc_mark_hook 3744#define elf_backend_gc_sweep_hook ppc_elf_gc_sweep_hook 3745#define elf_backend_section_from_shdr ppc_elf_section_from_shdr 3746#define elf_backend_relocate_section ppc_elf_relocate_section 3747#define elf_backend_create_dynamic_sections ppc_elf_create_dynamic_sections 3748#define elf_backend_check_relocs ppc_elf_check_relocs 3749#define elf_backend_adjust_dynamic_symbol ppc_elf_adjust_dynamic_symbol 3750#define elf_backend_add_symbol_hook ppc_elf_add_symbol_hook 3751#define elf_backend_size_dynamic_sections ppc_elf_size_dynamic_sections 3752#define elf_backend_finish_dynamic_symbol ppc_elf_finish_dynamic_symbol 3753#define elf_backend_finish_dynamic_sections ppc_elf_finish_dynamic_sections 3754#define elf_backend_fake_sections ppc_elf_fake_sections 3755#define elf_backend_additional_program_headers ppc_elf_additional_program_headers 3756#define elf_backend_modify_segment_map ppc_elf_modify_segment_map 3757 3758#include "elf32-target.h" 3759