1/* BFD back-end for PowerPC Microsoft Portable Executable files. 2 Copyright (C) 1990-2020 Free Software Foundation, Inc. 3 4 Original version pieced together by Kim Knuttila (krk@cygnus.com) 5 6 There is nothing new under the sun. This file draws a lot on other 7 coff files, in particular, those for the rs/6000, alpha, mips, and 8 intel backends, and the PE work for the arm. 9 10 This file is part of BFD, the Binary File Descriptor library. 11 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; either version 3 of the License, or 15 (at your option) any later version. 16 17 This program is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program; if not, write to the Free Software 24 Foundation, 51 Franklin Street - Fifth Floor, 25 Boston, MA 02110-1301, USA. */ 26 27/* Current State: 28 - objdump works 29 - relocs generated by gas 30 - ld will link files, but they do not run. 31 - dlltool will not produce correct output in some .reloc cases, and will 32 not produce the right glue code for dll function calls. */ 33 34#include "sysdep.h" 35#include "bfd.h" 36#include "libbfd.h" 37 38#include "coff/powerpc.h" 39#include "coff/internal.h" 40 41#include "coff/pe.h" 42 43#ifdef BADMAG 44#undef BADMAG 45#endif 46 47#define BADMAG(x) PPCBADMAG(x) 48 49#include "libcoff.h" 50 51/* This file is compiled more than once, but we only compile the 52 final_link routine once. */ 53extern bfd_boolean ppc_bfd_coff_final_link (bfd *, struct bfd_link_info *); 54extern void dump_toc (void *); 55 56/* The toc is a set of bfd_vma fields. We use the fact that valid 57 addresses are even (i.e. the bit representing "1" is off) to allow 58 us to encode a little extra information in the field 59 - Unallocated addresses are initialized to 1. 60 - Allocated addresses are even numbers. 61 The first time we actually write a reference to the toc in the bfd, 62 we want to record that fact in a fixup file (if it is asked for), so 63 we keep track of whether or not an address has been written by marking 64 the low order bit with a "1" upon writing. */ 65 66#define SET_UNALLOCATED(x) ((x) = 1) 67#define IS_UNALLOCATED(x) ((x) == 1) 68 69#define IS_WRITTEN(x) ((x) & 1) 70#define MARK_AS_WRITTEN(x) ((x) |= 1) 71#define MAKE_ADDR_AGAIN(x) ((x) &= ~1) 72 73/* Turn on this check if you suspect something amiss in the hash tables. */ 74#ifdef DEBUG_HASH 75 76/* Need a 7 char string for an eye catcher. */ 77#define EYE "krkjunk" 78 79#define HASH_CHECK_DCL char eye_catcher[8]; 80#define HASH_CHECK_INIT(ret) strcpy(ret->eye_catcher, EYE) 81#define HASH_CHECK(addr) \ 82 if (strcmp (addr->eye_catcher, EYE) != 0) \ 83 { \ 84 fprintf (stderr,\ 85 /* xgettext: c-format */ \ 86 _("File %s, line %d, Hash check failure, bad eye %8s\n"), \ 87 __FILE__, __LINE__, addr->eye_catcher); \ 88 abort (); \ 89 } 90 91#else 92 93#define HASH_CHECK_DCL 94#define HASH_CHECK_INIT(ret) 95#define HASH_CHECK(addr) 96 97#endif 98 99/* In order not to add an int to every hash table item for every coff 100 linker, we define our own hash table, derived from the coff one. */ 101 102/* PE linker hash table entries. */ 103 104struct ppc_coff_link_hash_entry 105{ 106 struct coff_link_hash_entry root; /* First entry, as required. */ 107 108 /* As we wonder around the relocs, we'll keep the assigned toc_offset 109 here. */ 110 bfd_vma toc_offset; /* Our addition, as required. */ 111 int symbol_is_glue; 112 unsigned long int glue_insn; 113 114 HASH_CHECK_DCL 115}; 116 117/* PE linker hash table. */ 118 119struct ppc_coff_link_hash_table 120{ 121 struct coff_link_hash_table root; /* First entry, as required. */ 122}; 123 124/* Routine to create an entry in the link hash table. */ 125 126static struct bfd_hash_entry * 127ppc_coff_link_hash_newfunc (struct bfd_hash_entry * entry, 128 struct bfd_hash_table * table, 129 const char * string) 130{ 131 struct ppc_coff_link_hash_entry *ret = 132 (struct ppc_coff_link_hash_entry *) entry; 133 134 /* Allocate the structure if it has not already been allocated by a 135 subclass. */ 136 if (ret == (struct ppc_coff_link_hash_entry *) NULL) 137 ret = (struct ppc_coff_link_hash_entry *) 138 bfd_hash_allocate (table, 139 sizeof (struct ppc_coff_link_hash_entry)); 140 141 if (ret == (struct ppc_coff_link_hash_entry *) NULL) 142 return NULL; 143 144 /* Call the allocation method of the superclass. */ 145 ret = ((struct ppc_coff_link_hash_entry *) 146 _bfd_coff_link_hash_newfunc ((struct bfd_hash_entry *) ret, 147 table, string)); 148 149 if (ret) 150 { 151 /* Initialize the local fields. */ 152 SET_UNALLOCATED (ret->toc_offset); 153 ret->symbol_is_glue = 0; 154 ret->glue_insn = 0; 155 156 HASH_CHECK_INIT (ret); 157 } 158 159 return (struct bfd_hash_entry *) ret; 160} 161 162/* Initialize a PE linker hash table. */ 163 164static bfd_boolean 165ppc_coff_link_hash_table_init (struct ppc_coff_link_hash_table *table, 166 bfd *abfd, 167 struct bfd_hash_entry *(*newfunc) 168 (struct bfd_hash_entry *, 169 struct bfd_hash_table *, 170 const char *), 171 unsigned int entsize) 172{ 173 return _bfd_coff_link_hash_table_init (&table->root, abfd, newfunc, entsize); 174} 175 176/* Create a PE linker hash table. */ 177 178static struct bfd_link_hash_table * 179ppc_coff_link_hash_table_create (bfd *abfd) 180{ 181 struct ppc_coff_link_hash_table *ret; 182 bfd_size_type amt = sizeof (struct ppc_coff_link_hash_table); 183 184 ret = (struct ppc_coff_link_hash_table *) bfd_malloc (amt); 185 if (ret == NULL) 186 return NULL; 187 if (!ppc_coff_link_hash_table_init (ret, abfd, 188 ppc_coff_link_hash_newfunc, 189 sizeof (struct ppc_coff_link_hash_entry))) 190 { 191 free (ret); 192 return (struct bfd_link_hash_table *) NULL; 193 } 194 return &ret->root.root; 195} 196 197/* Now, tailor coffcode.h to use our hash stuff. */ 198 199#define coff_bfd_link_hash_table_create ppc_coff_link_hash_table_create 200 201/* The nt loader points the toc register to &toc + 32768, in order to 202 use the complete range of a 16-bit displacement. We have to adjust 203 for this when we fix up loads displaced off the toc reg. */ 204#define TOC_LOAD_ADJUSTMENT (-32768) 205#define TOC_SECTION_NAME ".private.toc" 206 207/* The main body of code is in coffcode.h. */ 208 209#define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3) 210 211/* In case we're on a 32-bit machine, construct a 64-bit "-1" value 212 from smaller values. Start with zero, widen, *then* decrement. */ 213#define MINUS_ONE (((bfd_vma)0) - 1) 214 215/* These should definitely go in a header file somewhere... */ 216 217/* NOP */ 218#define IMAGE_REL_PPC_ABSOLUTE 0x0000 219 220/* 64-bit address */ 221#define IMAGE_REL_PPC_ADDR64 0x0001 222 223/* 32-bit address */ 224#define IMAGE_REL_PPC_ADDR32 0x0002 225 226/* 26-bit address, shifted left 2 (branch absolute) */ 227#define IMAGE_REL_PPC_ADDR24 0x0003 228 229/* 16-bit address */ 230#define IMAGE_REL_PPC_ADDR16 0x0004 231 232/* 16-bit address, shifted left 2 (load doubleword) */ 233#define IMAGE_REL_PPC_ADDR14 0x0005 234 235/* 26-bit PC-relative offset, shifted left 2 (branch relative) */ 236#define IMAGE_REL_PPC_REL24 0x0006 237 238/* 16-bit PC-relative offset, shifted left 2 (br cond relative) */ 239#define IMAGE_REL_PPC_REL14 0x0007 240 241/* 16-bit offset from TOC base */ 242#define IMAGE_REL_PPC_TOCREL16 0x0008 243 244/* 16-bit offset from TOC base, shifted left 2 (load doubleword) */ 245#define IMAGE_REL_PPC_TOCREL14 0x0009 246 247/* 32-bit addr w/o image base */ 248#define IMAGE_REL_PPC_ADDR32NB 0x000A 249 250/* va of containing section (as in an image sectionhdr) */ 251#define IMAGE_REL_PPC_SECREL 0x000B 252 253/* sectionheader number */ 254#define IMAGE_REL_PPC_SECTION 0x000C 255 256/* substitute TOC restore instruction iff symbol is glue code */ 257#define IMAGE_REL_PPC_IFGLUE 0x000D 258 259/* symbol is glue code; virtual address is TOC restore instruction */ 260#define IMAGE_REL_PPC_IMGLUE 0x000E 261 262/* va of containing section (limited to 16 bits) */ 263#define IMAGE_REL_PPC_SECREL16 0x000F 264 265/* Stuff to handle immediate data when the number of bits in the 266 data is greater than the number of bits in the immediate field 267 We need to do (usually) 32 bit arithmetic on 16 bit chunks. */ 268#define IMAGE_REL_PPC_REFHI 0x0010 269#define IMAGE_REL_PPC_REFLO 0x0011 270#define IMAGE_REL_PPC_PAIR 0x0012 271 272/* This is essentially the same as tocrel16, with TOCDEFN assumed. */ 273#define IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 274 275/* Flag bits in IMAGE_RELOCATION.TYPE. */ 276 277/* Subtract reloc value rather than adding it. */ 278#define IMAGE_REL_PPC_NEG 0x0100 279 280/* Fix branch prediction bit to predict branch taken. */ 281#define IMAGE_REL_PPC_BRTAKEN 0x0200 282 283/* Fix branch prediction bit to predict branch not taken. */ 284#define IMAGE_REL_PPC_BRNTAKEN 0x0400 285 286/* TOC slot defined in file (or, data in toc). */ 287#define IMAGE_REL_PPC_TOCDEFN 0x0800 288 289/* Masks to isolate above values in IMAGE_RELOCATION.Type. */ 290#define IMAGE_REL_PPC_TYPEMASK 0x00FF 291#define IMAGE_REL_PPC_FLAGMASK 0x0F00 292 293#define EXTRACT_TYPE(x) ((x) & IMAGE_REL_PPC_TYPEMASK) 294#define EXTRACT_FLAGS(x) ((x) & IMAGE_REL_PPC_FLAGMASK) 295#define EXTRACT_JUNK(x) \ 296 ((x) & ~(IMAGE_REL_PPC_TYPEMASK | IMAGE_REL_PPC_FLAGMASK)) 297 298/* Static helper functions to make relocation work. */ 299/* (Work In Progress) */ 300 301static bfd_reloc_status_type ppc_refhi_reloc 302 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 303static bfd_reloc_status_type ppc_pair_reloc 304 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 305static bfd_reloc_status_type ppc_toc16_reloc 306 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 307static bfd_reloc_status_type ppc_section_reloc 308 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 309static bfd_reloc_status_type ppc_secrel_reloc 310 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 311static bfd_reloc_status_type ppc_imglue_reloc 312 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 313 314/* FIXME: It'll take a while to get through all of these. I only need a few to 315 get us started, so those I'll make sure work. Those marked FIXME are either 316 completely unverified or have a specific unknown marked in the comment. */ 317 318/* Relocation entries for Windows/NT on PowerPC. 319 320 From the document "" we find the following listed as used relocs: 321 322 ABSOLUTE : The noop 323 ADDR[64|32|16] : fields that hold addresses in data fields or the 324 16 bit displacement field on a load/store. 325 ADDR[24|14] : fields that hold addresses in branch and cond 326 branches. These represent [26|16] bit addresses. 327 The low order 2 bits are preserved. 328 REL[24|14] : branches relative to the Instruction Address 329 register. These represent [26|16] bit addresses, 330 as before. The instruction field will be zero, and 331 the address of the SYM will be inserted at link time. 332 TOCREL16 : 16 bit displacement field referring to a slot in 333 toc. 334 TOCREL14 : 16 bit displacement field, similar to REL14 or ADDR14. 335 ADDR32NB : 32 bit address relative to the virtual origin. 336 (On the alpha, this is always a linker generated thunk) 337 (i.e. 32bit addr relative to the image base) 338 SECREL : The value is relative to the start of the section 339 containing the symbol. 340 SECTION : access to the header containing the item. Supports the 341 codeview debugger. 342 343 In particular, note that the document does not indicate that the 344 relocations listed in the header file are used. */ 345 346 347static reloc_howto_type ppc_coff_howto_table[] = 348{ 349 /* IMAGE_REL_PPC_ABSOLUTE 0x0000 NOP */ 350 /* Unused: */ 351 HOWTO (IMAGE_REL_PPC_ABSOLUTE, /* type */ 352 0, /* rightshift */ 353 0, /* size (0 = byte, 1 = short, 2 = long) */ 354 0, /* bitsize */ 355 FALSE, /* pc_relative */ 356 0, /* bitpos */ 357 complain_overflow_dont, /* dont complain_on_overflow */ 358 0, /* special_function */ 359 "ABSOLUTE", /* name */ 360 FALSE, /* partial_inplace */ 361 0x00, /* src_mask */ 362 0x00, /* dst_mask */ 363 FALSE), /* pcrel_offset */ 364 365 /* IMAGE_REL_PPC_ADDR64 0x0001 64-bit address */ 366 /* Unused: */ 367 HOWTO(IMAGE_REL_PPC_ADDR64, /* type */ 368 0, /* rightshift */ 369 3, /* size (0 = byte, 1 = short, 2 = long) */ 370 64, /* bitsize */ 371 FALSE, /* pc_relative */ 372 0, /* bitpos */ 373 complain_overflow_bitfield, /* complain_on_overflow */ 374 0, /* special_function */ 375 "ADDR64", /* name */ 376 TRUE, /* partial_inplace */ 377 MINUS_ONE, /* src_mask */ 378 MINUS_ONE, /* dst_mask */ 379 FALSE), /* pcrel_offset */ 380 381 /* IMAGE_REL_PPC_ADDR32 0x0002 32-bit address */ 382 /* Used: */ 383 HOWTO (IMAGE_REL_PPC_ADDR32, /* type */ 384 0, /* rightshift */ 385 2, /* size (0 = byte, 1 = short, 2 = long) */ 386 32, /* bitsize */ 387 FALSE, /* pc_relative */ 388 0, /* bitpos */ 389 complain_overflow_bitfield, /* complain_on_overflow */ 390 0, /* special_function */ 391 "ADDR32", /* name */ 392 TRUE, /* partial_inplace */ 393 0xffffffff, /* src_mask */ 394 0xffffffff, /* dst_mask */ 395 FALSE), /* pcrel_offset */ 396 397 /* IMAGE_REL_PPC_ADDR24 0x0003 26-bit address, shifted left 2 (branch absolute) */ 398 /* the LI field is in bit 6 through bit 29 is 24 bits, + 2 for the shift */ 399 /* Of course, That's the IBM approved bit numbering, which is not what */ 400 /* anyone else uses.... The li field is in bit 2 thru 25 */ 401 /* Used: */ 402 HOWTO (IMAGE_REL_PPC_ADDR24, /* type */ 403 0, /* rightshift */ 404 2, /* size (0 = byte, 1 = short, 2 = long) */ 405 26, /* bitsize */ 406 FALSE, /* pc_relative */ 407 0, /* bitpos */ 408 complain_overflow_bitfield, /* complain_on_overflow */ 409 0, /* special_function */ 410 "ADDR24", /* name */ 411 TRUE, /* partial_inplace */ 412 0x07fffffc, /* src_mask */ 413 0x07fffffc, /* dst_mask */ 414 FALSE), /* pcrel_offset */ 415 416 /* IMAGE_REL_PPC_ADDR16 0x0004 16-bit address */ 417 /* Used: */ 418 HOWTO (IMAGE_REL_PPC_ADDR16, /* type */ 419 0, /* rightshift */ 420 1, /* size (0 = byte, 1 = short, 2 = long) */ 421 16, /* bitsize */ 422 FALSE, /* pc_relative */ 423 0, /* bitpos */ 424 complain_overflow_signed, /* complain_on_overflow */ 425 0, /* special_function */ 426 "ADDR16", /* name */ 427 TRUE, /* partial_inplace */ 428 0xffff, /* src_mask */ 429 0xffff, /* dst_mask */ 430 FALSE), /* pcrel_offset */ 431 432 /* IMAGE_REL_PPC_ADDR14 0x0005 */ 433 /* 16-bit address, shifted left 2 (load doubleword) */ 434 /* FIXME: the mask is likely wrong, and the bit position may be as well */ 435 /* Unused: */ 436 HOWTO (IMAGE_REL_PPC_ADDR14, /* type */ 437 1, /* rightshift */ 438 1, /* size (0 = byte, 1 = short, 2 = long) */ 439 16, /* bitsize */ 440 FALSE, /* pc_relative */ 441 0, /* bitpos */ 442 complain_overflow_signed, /* complain_on_overflow */ 443 0, /* special_function */ 444 "ADDR16", /* name */ 445 TRUE, /* partial_inplace */ 446 0xffff, /* src_mask */ 447 0xffff, /* dst_mask */ 448 FALSE), /* pcrel_offset */ 449 450 /* IMAGE_REL_PPC_REL24 0x0006 */ 451 /* 26-bit PC-relative offset, shifted left 2 (branch relative) */ 452 /* Used: */ 453 HOWTO (IMAGE_REL_PPC_REL24, /* type */ 454 0, /* rightshift */ 455 2, /* size (0 = byte, 1 = short, 2 = long) */ 456 26, /* bitsize */ 457 TRUE, /* pc_relative */ 458 0, /* bitpos */ 459 complain_overflow_signed, /* complain_on_overflow */ 460 0, /* special_function */ 461 "REL24", /* name */ 462 TRUE, /* partial_inplace */ 463 0x3fffffc, /* src_mask */ 464 0x3fffffc, /* dst_mask */ 465 FALSE), /* pcrel_offset */ 466 467 /* IMAGE_REL_PPC_REL14 0x0007 */ 468 /* 16-bit PC-relative offset, shifted left 2 (br cond relative) */ 469 /* FIXME: the mask is likely wrong, and the bit position may be as well */ 470 /* FIXME: how does it know how far to shift? */ 471 /* Unused: */ 472 HOWTO (IMAGE_REL_PPC_ADDR14, /* type */ 473 1, /* rightshift */ 474 1, /* size (0 = byte, 1 = short, 2 = long) */ 475 16, /* bitsize */ 476 FALSE, /* pc_relative */ 477 0, /* bitpos */ 478 complain_overflow_signed, /* complain_on_overflow */ 479 0, /* special_function */ 480 "ADDR16", /* name */ 481 TRUE, /* partial_inplace */ 482 0xffff, /* src_mask */ 483 0xffff, /* dst_mask */ 484 TRUE), /* pcrel_offset */ 485 486 /* IMAGE_REL_PPC_TOCREL16 0x0008 */ 487 /* 16-bit offset from TOC base */ 488 /* Used: */ 489 HOWTO (IMAGE_REL_PPC_TOCREL16,/* type */ 490 0, /* rightshift */ 491 1, /* size (0 = byte, 1 = short, 2 = long) */ 492 16, /* bitsize */ 493 FALSE, /* pc_relative */ 494 0, /* bitpos */ 495 complain_overflow_dont, /* complain_on_overflow */ 496 ppc_toc16_reloc, /* special_function */ 497 "TOCREL16", /* name */ 498 FALSE, /* partial_inplace */ 499 0xffff, /* src_mask */ 500 0xffff, /* dst_mask */ 501 FALSE), /* pcrel_offset */ 502 503 /* IMAGE_REL_PPC_TOCREL14 0x0009 */ 504 /* 16-bit offset from TOC base, shifted left 2 (load doubleword) */ 505 /* Unused: */ 506 HOWTO (IMAGE_REL_PPC_TOCREL14,/* type */ 507 1, /* rightshift */ 508 1, /* size (0 = byte, 1 = short, 2 = long) */ 509 16, /* bitsize */ 510 FALSE, /* pc_relative */ 511 0, /* bitpos */ 512 complain_overflow_signed, /* complain_on_overflow */ 513 0, /* special_function */ 514 "TOCREL14", /* name */ 515 FALSE, /* partial_inplace */ 516 0xffff, /* src_mask */ 517 0xffff, /* dst_mask */ 518 FALSE), /* pcrel_offset */ 519 520 /* IMAGE_REL_PPC_ADDR32NB 0x000A */ 521 /* 32-bit addr w/ image base */ 522 /* Unused: */ 523 HOWTO (IMAGE_REL_PPC_ADDR32NB,/* type */ 524 0, /* rightshift */ 525 2, /* size (0 = byte, 1 = short, 2 = long) */ 526 32, /* bitsize */ 527 FALSE, /* pc_relative */ 528 0, /* bitpos */ 529 complain_overflow_signed, /* complain_on_overflow */ 530 0, /* special_function */ 531 "ADDR32NB", /* name */ 532 TRUE, /* partial_inplace */ 533 0xffffffff, /* src_mask */ 534 0xffffffff, /* dst_mask */ 535 FALSE), /* pcrel_offset */ 536 537 /* IMAGE_REL_PPC_SECREL 0x000B */ 538 /* va of containing section (as in an image sectionhdr) */ 539 /* Unused: */ 540 HOWTO (IMAGE_REL_PPC_SECREL,/* type */ 541 0, /* rightshift */ 542 2, /* size (0 = byte, 1 = short, 2 = long) */ 543 32, /* bitsize */ 544 FALSE, /* pc_relative */ 545 0, /* bitpos */ 546 complain_overflow_signed, /* complain_on_overflow */ 547 ppc_secrel_reloc, /* special_function */ 548 "SECREL", /* name */ 549 TRUE, /* partial_inplace */ 550 0xffffffff, /* src_mask */ 551 0xffffffff, /* dst_mask */ 552 TRUE), /* pcrel_offset */ 553 554 /* IMAGE_REL_PPC_SECTION 0x000C */ 555 /* sectionheader number */ 556 /* Unused: */ 557 HOWTO (IMAGE_REL_PPC_SECTION,/* type */ 558 0, /* rightshift */ 559 2, /* size (0 = byte, 1 = short, 2 = long) */ 560 32, /* bitsize */ 561 FALSE, /* pc_relative */ 562 0, /* bitpos */ 563 complain_overflow_signed, /* complain_on_overflow */ 564 ppc_section_reloc, /* special_function */ 565 "SECTION", /* name */ 566 TRUE, /* partial_inplace */ 567 0xffffffff, /* src_mask */ 568 0xffffffff, /* dst_mask */ 569 TRUE), /* pcrel_offset */ 570 571 /* IMAGE_REL_PPC_IFGLUE 0x000D */ 572 /* substitute TOC restore instruction iff symbol is glue code */ 573 /* Used: */ 574 HOWTO (IMAGE_REL_PPC_IFGLUE,/* type */ 575 0, /* rightshift */ 576 2, /* size (0 = byte, 1 = short, 2 = long) */ 577 32, /* bitsize */ 578 FALSE, /* pc_relative */ 579 0, /* bitpos */ 580 complain_overflow_signed, /* complain_on_overflow */ 581 0, /* special_function */ 582 "IFGLUE", /* name */ 583 TRUE, /* partial_inplace */ 584 0xffffffff, /* src_mask */ 585 0xffffffff, /* dst_mask */ 586 FALSE), /* pcrel_offset */ 587 588 /* IMAGE_REL_PPC_IMGLUE 0x000E */ 589 /* symbol is glue code; virtual address is TOC restore instruction */ 590 /* Unused: */ 591 HOWTO (IMAGE_REL_PPC_IMGLUE,/* type */ 592 0, /* rightshift */ 593 2, /* size (0 = byte, 1 = short, 2 = long) */ 594 32, /* bitsize */ 595 FALSE, /* pc_relative */ 596 0, /* bitpos */ 597 complain_overflow_dont, /* complain_on_overflow */ 598 ppc_imglue_reloc, /* special_function */ 599 "IMGLUE", /* name */ 600 FALSE, /* partial_inplace */ 601 0xffffffff, /* src_mask */ 602 0xffffffff, /* dst_mask */ 603 FALSE), /* pcrel_offset */ 604 605 /* IMAGE_REL_PPC_SECREL16 0x000F */ 606 /* va of containing section (limited to 16 bits) */ 607 /* Unused: */ 608 HOWTO (IMAGE_REL_PPC_SECREL16,/* type */ 609 0, /* rightshift */ 610 1, /* size (0 = byte, 1 = short, 2 = long) */ 611 16, /* bitsize */ 612 FALSE, /* pc_relative */ 613 0, /* bitpos */ 614 complain_overflow_signed, /* complain_on_overflow */ 615 0, /* special_function */ 616 "SECREL16", /* name */ 617 TRUE, /* partial_inplace */ 618 0xffff, /* src_mask */ 619 0xffff, /* dst_mask */ 620 TRUE), /* pcrel_offset */ 621 622 /* IMAGE_REL_PPC_REFHI 0x0010 */ 623 /* Unused: */ 624 HOWTO (IMAGE_REL_PPC_REFHI, /* type */ 625 0, /* rightshift */ 626 1, /* size (0 = byte, 1 = short, 2 = long) */ 627 16, /* bitsize */ 628 FALSE, /* pc_relative */ 629 0, /* bitpos */ 630 complain_overflow_signed, /* complain_on_overflow */ 631 ppc_refhi_reloc, /* special_function */ 632 "REFHI", /* name */ 633 TRUE, /* partial_inplace */ 634 0xffffffff, /* src_mask */ 635 0xffffffff, /* dst_mask */ 636 FALSE), /* pcrel_offset */ 637 638 /* IMAGE_REL_PPC_REFLO 0x0011 */ 639 /* Unused: */ 640 HOWTO (IMAGE_REL_PPC_REFLO, /* type */ 641 0, /* rightshift */ 642 1, /* size (0 = byte, 1 = short, 2 = long) */ 643 16, /* bitsize */ 644 FALSE, /* pc_relative */ 645 0, /* bitpos */ 646 complain_overflow_signed, /* complain_on_overflow */ 647 ppc_refhi_reloc, /* special_function */ 648 "REFLO", /* name */ 649 TRUE, /* partial_inplace */ 650 0xffffffff, /* src_mask */ 651 0xffffffff, /* dst_mask */ 652 FALSE), /* pcrel_offset */ 653 654 /* IMAGE_REL_PPC_PAIR 0x0012 */ 655 /* Unused: */ 656 HOWTO (IMAGE_REL_PPC_PAIR, /* type */ 657 0, /* rightshift */ 658 1, /* size (0 = byte, 1 = short, 2 = long) */ 659 16, /* bitsize */ 660 FALSE, /* pc_relative */ 661 0, /* bitpos */ 662 complain_overflow_signed, /* complain_on_overflow */ 663 ppc_pair_reloc, /* special_function */ 664 "PAIR", /* name */ 665 TRUE, /* partial_inplace */ 666 0xffffffff, /* src_mask */ 667 0xffffffff, /* dst_mask */ 668 FALSE), /* pcrel_offset */ 669 670 /* IMAGE_REL_PPC_TOCREL16_DEFN 0x0013 */ 671 /* 16-bit offset from TOC base, without causing a definition */ 672 /* Used: */ 673 HOWTO ( (IMAGE_REL_PPC_TOCREL16 | IMAGE_REL_PPC_TOCDEFN), /* type */ 674 0, /* rightshift */ 675 1, /* size (0 = byte, 1 = short, 2 = long) */ 676 16, /* bitsize */ 677 FALSE, /* pc_relative */ 678 0, /* bitpos */ 679 complain_overflow_dont, /* complain_on_overflow */ 680 0, /* special_function */ 681 "TOCREL16, TOCDEFN", /* name */ 682 FALSE, /* partial_inplace */ 683 0xffff, /* src_mask */ 684 0xffff, /* dst_mask */ 685 FALSE), /* pcrel_offset */ 686 687}; 688 689/* Some really cheezy macros that can be turned on to test stderr :-) */ 690 691#ifdef DEBUG_RELOC 692#define UN_IMPL(x) \ 693{ \ 694 static int i; \ 695 if (i == 0) \ 696 { \ 697 i = 1; \ 698 fprintf (stderr,_("Unimplemented Relocation -- %s\n"),x); \ 699 } \ 700} 701 702#define DUMP_RELOC(n,r) \ 703{ \ 704 fprintf (stderr,"%s sym %d, addr %d, addend %d\n", \ 705 n, (*(r->sym_ptr_ptr))->name, \ 706 r->address, r->addend); \ 707} 708 709/* Given a reloc name, n, and a pointer to an internal_reloc, 710 dump out interesting information on the contents 711 712#define n_name _n._n_name 713#define n_zeroes _n._n_n._n_zeroes 714#define n_offset _n._n_n._n_offset */ 715 716#define DUMP_RELOC2(n,r) \ 717{ \ 718 fprintf (stderr,"%s sym %d, r_vaddr %d %s\n", \ 719 n, r->r_symndx, r->r_vaddr, \ 720 (((r->r_type) & IMAGE_REL_PPC_TOCDEFN) == 0) \ 721 ?" ":" TOCDEFN" ); \ 722} 723 724#else 725#define UN_IMPL(x) 726#define DUMP_RELOC(n,r) 727#define DUMP_RELOC2(n,r) 728#endif 729 730/* TOC construction and management routines. */ 731 732/* This file is compiled twice, and these variables are defined in one 733 of the compilations. FIXME: This is confusing and weird. Also, 734 BFD should not use global variables. */ 735extern bfd * bfd_of_toc_owner; 736extern long int global_toc_size; 737extern long int import_table_size; 738extern long int first_thunk_address; 739extern long int thunk_size; 740 741enum toc_type 742{ 743 default_toc, 744 toc_32, 745 toc_64 746}; 747 748enum ref_category 749{ 750 priv, 751 pub, 752 tocdata 753}; 754 755struct list_ele 756{ 757 struct list_ele *next; 758 bfd_vma addr; 759 enum ref_category cat; 760 int offset; 761 const char *name; 762}; 763 764extern struct list_ele *head; 765extern struct list_ele *tail; 766 767static void 768record_toc (asection *toc_section, 769 bfd_signed_vma our_toc_offset, 770 enum ref_category cat, 771 const char *name) 772{ 773 /* Add this entry to our toc addr-offset-name list. */ 774 bfd_size_type amt = sizeof (struct list_ele); 775 struct list_ele *t = (struct list_ele *) bfd_malloc (amt); 776 777 if (t == NULL) 778 abort (); 779 t->next = 0; 780 t->offset = our_toc_offset; 781 t->name = name; 782 t->cat = cat; 783 t->addr = toc_section->output_offset + our_toc_offset; 784 785 if (head == 0) 786 { 787 head = t; 788 tail = t; 789 } 790 else 791 { 792 tail->next = t; 793 tail = t; 794 } 795} 796 797#ifdef COFF_IMAGE_WITH_PE 798 799/* Record a toc offset against a symbol. */ 800static bfd_boolean 801ppc_record_toc_entry (bfd *abfd, 802 struct bfd_link_info *info ATTRIBUTE_UNUSED, 803 asection *sec ATTRIBUTE_UNUSED, 804 int sym, 805 enum toc_type toc_kind ATTRIBUTE_UNUSED) 806{ 807 struct ppc_coff_link_hash_entry *h; 808 int *local_syms; 809 810 h = 0; 811 812 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]); 813 if (h != 0) 814 { 815 HASH_CHECK(h); 816 } 817 818 if (h == 0) 819 { 820 local_syms = obj_coff_local_toc_table(abfd); 821 822 if (local_syms == 0) 823 { 824 unsigned int i; 825 bfd_size_type amt; 826 827 /* allocate a table */ 828 amt = (bfd_size_type) obj_raw_syment_count (abfd) * sizeof (int); 829 local_syms = (int *) bfd_zalloc (abfd, amt); 830 if (local_syms == 0) 831 return FALSE; 832 obj_coff_local_toc_table (abfd) = local_syms; 833 834 for (i = 0; i < obj_raw_syment_count (abfd); ++i) 835 { 836 SET_UNALLOCATED (local_syms[i]); 837 } 838 } 839 840 if (IS_UNALLOCATED(local_syms[sym])) 841 { 842 local_syms[sym] = global_toc_size; 843 global_toc_size += 4; 844 845 /* The size must fit in a 16-bit displacement. */ 846 if (global_toc_size > 65535) 847 { 848 _bfd_error_handler (_("TOC overflow")); 849 bfd_set_error (bfd_error_file_too_big); 850 return FALSE; 851 } 852 } 853 } 854 else 855 { 856 /* Check to see if there's a toc slot allocated. If not, do it 857 here. It will be used in relocate_section. */ 858 if (IS_UNALLOCATED(h->toc_offset)) 859 { 860 h->toc_offset = global_toc_size; 861 global_toc_size += 4; 862 863 /* The size must fit in a 16-bit displacement. */ 864 if (global_toc_size >= 65535) 865 { 866 _bfd_error_handler (_("TOC overflow")); 867 bfd_set_error (bfd_error_file_too_big); 868 return FALSE; 869 } 870 } 871 } 872 873 return TRUE; 874} 875 876/* Record a toc offset against a symbol. */ 877static void 878ppc_mark_symbol_as_glue (bfd *abfd, 879 int sym, 880 struct internal_reloc *rel) 881{ 882 struct ppc_coff_link_hash_entry *h; 883 884 h = (struct ppc_coff_link_hash_entry *) (obj_coff_sym_hashes (abfd)[sym]); 885 886 HASH_CHECK(h); 887 888 h->symbol_is_glue = 1; 889 h->glue_insn = bfd_get_32 (abfd, (bfd_byte *) &rel->r_vaddr); 890 891 return; 892} 893 894#endif /* COFF_IMAGE_WITH_PE */ 895 896/* Return TRUE if this relocation should 897 appear in the output .reloc section. */ 898 899static bfd_boolean 900in_reloc_p (bfd * abfd ATTRIBUTE_UNUSED, 901 reloc_howto_type *howto) 902{ 903 return 904 (! howto->pc_relative) 905 && (howto->type != IMAGE_REL_PPC_ADDR32NB) 906 && (howto->type != IMAGE_REL_PPC_TOCREL16) 907 && (howto->type != IMAGE_REL_PPC_IMGLUE) 908 && (howto->type != IMAGE_REL_PPC_IFGLUE) 909 && (howto->type != IMAGE_REL_PPC_SECREL) 910 && (howto->type != IMAGE_REL_PPC_SECTION) 911 && (howto->type != IMAGE_REL_PPC_SECREL16) 912 && (howto->type != IMAGE_REL_PPC_REFHI) 913 && (howto->type != IMAGE_REL_PPC_REFLO) 914 && (howto->type != IMAGE_REL_PPC_PAIR) 915 && (howto->type != IMAGE_REL_PPC_TOCREL16_DEFN) ; 916} 917 918static bfd_boolean 919write_base_file_entry (bfd *obfd, struct bfd_link_info *info, bfd_vma addr) 920{ 921 if (coff_data (obfd)->pe) 922 addr -= pe_data (obfd)->pe_opthdr.ImageBase; 923 if (fwrite (&addr, sizeof (addr), 1, (FILE *) info->base_file) == 1) 924 return TRUE; 925 926 bfd_set_error (bfd_error_system_call); 927 return FALSE; 928} 929 930/* The reloc processing routine for the optimized COFF linker. */ 931 932static bfd_boolean 933coff_ppc_relocate_section (bfd *output_bfd, 934 struct bfd_link_info *info, 935 bfd *input_bfd, 936 asection *input_section, 937 bfd_byte *contents, 938 struct internal_reloc *relocs, 939 struct internal_syment *syms, 940 asection **sections) 941{ 942 struct internal_reloc *rel; 943 struct internal_reloc *relend; 944 asection *toc_section = 0; 945 bfd_vma relocation; 946 reloc_howto_type *howto = 0; 947 948 /* If we are performing a relocatable link, we don't need to do a 949 thing. The caller will take care of adjusting the reloc 950 addresses and symbol indices. */ 951 if (bfd_link_relocatable (info)) 952 return TRUE; 953 954 rel = relocs; 955 relend = rel + input_section->reloc_count; 956 for (; rel < relend; rel++) 957 { 958 long symndx; 959 struct ppc_coff_link_hash_entry *h; 960 struct internal_syment *sym; 961 bfd_vma val; 962 963 asection *sec; 964 bfd_reloc_status_type rstat; 965 bfd_byte *loc; 966 967 unsigned short r_type = EXTRACT_TYPE (rel->r_type); 968 unsigned short r_flags = EXTRACT_FLAGS(rel->r_type); 969 970 symndx = rel->r_symndx; 971 loc = contents + rel->r_vaddr - input_section->vma; 972 973 /* FIXME: check bounds on r_type */ 974 howto = ppc_coff_howto_table + r_type; 975 976 if (symndx == -1) 977 { 978 h = NULL; 979 sym = NULL; 980 } 981 else 982 { 983 h = (struct ppc_coff_link_hash_entry *) 984 (obj_coff_sym_hashes (input_bfd)[symndx]); 985 if (h != 0) 986 { 987 HASH_CHECK(h); 988 } 989 990 sym = syms + symndx; 991 } 992 993 if (r_type == IMAGE_REL_PPC_IMGLUE && h == 0) 994 { 995 /* An IMGLUE reloc must have a name. Something is very wrong. */ 996 abort (); 997 } 998 999 sec = NULL; 1000 val = 0; 1001 1002 /* FIXME: PAIR unsupported in the following code. */ 1003 if (h == NULL) 1004 { 1005 if (symndx == -1) 1006 sec = bfd_abs_section_ptr; 1007 else 1008 { 1009 sec = sections[symndx]; 1010 val = (sec->output_section->vma 1011 + sec->output_offset 1012 + sym->n_value); 1013 if (! obj_pe (output_bfd)) 1014 val -= sec->vma; 1015 } 1016 } 1017 else 1018 { 1019 HASH_CHECK(h); 1020 1021 if (h->root.root.type == bfd_link_hash_defined 1022 || h->root.root.type == bfd_link_hash_defweak) 1023 { 1024 sec = h->root.root.u.def.section; 1025 val = (h->root.root.u.def.value 1026 + sec->output_section->vma 1027 + sec->output_offset); 1028 } 1029 else 1030 (*info->callbacks->undefined_symbol) 1031 (info, h->root.root.root.string, input_bfd, input_section, 1032 rel->r_vaddr - input_section->vma, TRUE); 1033 } 1034 1035 rstat = bfd_reloc_ok; 1036 1037 /* Each case must do its own relocation, setting rstat appropriately. */ 1038 switch (r_type) 1039 { 1040 default: 1041 /* xgettext: c-format */ 1042 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 1043 input_bfd, r_type); 1044 bfd_set_error (bfd_error_bad_value); 1045 return FALSE; 1046 case IMAGE_REL_PPC_TOCREL16: 1047 { 1048 bfd_signed_vma our_toc_offset; 1049 int fixit; 1050 1051 DUMP_RELOC2(howto->name, rel); 1052 1053 if (toc_section == 0) 1054 { 1055 toc_section = bfd_get_section_by_name (bfd_of_toc_owner, 1056 TOC_SECTION_NAME); 1057 1058 if ( toc_section == NULL ) 1059 { 1060 /* There is no toc section. Something is very wrong. */ 1061 abort (); 1062 } 1063 } 1064 1065 /* Amazing bit tricks present. As we may have seen earlier, we 1066 use the 1 bit to tell us whether or not a toc offset has been 1067 allocated. Now that they've all been allocated, we will use 1068 the 1 bit to tell us if we've written this particular toc 1069 entry out. */ 1070 fixit = FALSE; 1071 if (h == 0) 1072 { 1073 /* It is a file local symbol. */ 1074 int *local_toc_table; 1075 char name[SYMNMLEN + 1]; 1076 1077 sym = syms + symndx; 1078 strncpy (name, sym->_n._n_name, SYMNMLEN); 1079 name[SYMNMLEN] = '\0'; 1080 1081 local_toc_table = obj_coff_local_toc_table(input_bfd); 1082 our_toc_offset = local_toc_table[symndx]; 1083 1084 if (IS_WRITTEN(our_toc_offset)) 1085 { 1086 /* If it has been written out, it is marked with the 1087 1 bit. Fix up our offset, but do not write it out 1088 again. */ 1089 MAKE_ADDR_AGAIN(our_toc_offset); 1090 } 1091 else 1092 { 1093 /* Write out the toc entry. */ 1094 record_toc (toc_section, our_toc_offset, priv, 1095 strdup (name)); 1096 1097 bfd_put_32 (output_bfd, val, 1098 toc_section->contents + our_toc_offset); 1099 1100 MARK_AS_WRITTEN(local_toc_table[symndx]); 1101 fixit = TRUE; 1102 } 1103 } 1104 else 1105 { 1106 const char *name = h->root.root.root.string; 1107 our_toc_offset = h->toc_offset; 1108 1109 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) 1110 == IMAGE_REL_PPC_TOCDEFN ) 1111 { 1112 /* This is unbelievable cheese. Some knowledgable asm 1113 hacker has decided to use r2 as a base for loading 1114 a value. He/She does this by setting the tocdefn bit, 1115 and not supplying a toc definition. The behaviour is 1116 then to use the difference between the value of the 1117 symbol and the actual location of the toc as the toc 1118 index. 1119 1120 In fact, what is usually happening is, because the 1121 Import Address Table is mapped immediately following 1122 the toc, some trippy library code trying for speed on 1123 dll linkage, takes advantage of that and considers 1124 the IAT to be part of the toc, thus saving a load. */ 1125 1126 our_toc_offset = val - (toc_section->output_section->vma 1127 + toc_section->output_offset); 1128 1129 /* The size must still fit in a 16-bit displacement. */ 1130 if ((bfd_vma) our_toc_offset >= 65535) 1131 { 1132 _bfd_error_handler 1133 /* xgettext: c-format */ 1134 (_("%pB: Relocation for %s of %#" PRIx64 " exceeds " 1135 "Toc size limit"), 1136 input_bfd, name, (uint64_t) our_toc_offset); 1137 bfd_set_error (bfd_error_bad_value); 1138 return FALSE; 1139 } 1140 1141 record_toc (toc_section, our_toc_offset, pub, 1142 strdup (name)); 1143 } 1144 else if (IS_WRITTEN (our_toc_offset)) 1145 { 1146 /* If it has been written out, it is marked with the 1147 1 bit. Fix up our offset, but do not write it out 1148 again. */ 1149 MAKE_ADDR_AGAIN(our_toc_offset); 1150 } 1151 else 1152 { 1153 record_toc(toc_section, our_toc_offset, pub, 1154 strdup (name)); 1155 1156 /* Write out the toc entry. */ 1157 bfd_put_32 (output_bfd, val, 1158 toc_section->contents + our_toc_offset); 1159 1160 MARK_AS_WRITTEN(h->toc_offset); 1161 /* The tricky part is that this is the address that 1162 needs a .reloc entry for it. */ 1163 fixit = TRUE; 1164 } 1165 } 1166 1167 if (fixit && info->base_file) 1168 { 1169 /* So if this is non pcrelative, and is referenced 1170 to a section or a common symbol, then it needs a reloc. */ 1171 1172 /* Relocation to a symbol in a section which 1173 isn't absolute - we output the address here 1174 to a file. */ 1175 bfd_vma addr = (toc_section->output_section->vma 1176 + toc_section->output_offset + our_toc_offset); 1177 1178 if (!write_base_file_entry (output_bfd, info, addr)) 1179 return FALSE; 1180 } 1181 1182 /* FIXME: this test is conservative. */ 1183 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN 1184 && (bfd_vma) our_toc_offset > toc_section->size) 1185 { 1186 _bfd_error_handler 1187 /* xgettext: c-format */ 1188 (_("%pB: Relocation exceeds allocated TOC (%#" PRIx64 ")"), 1189 input_bfd, (uint64_t) toc_section->size); 1190 bfd_set_error (bfd_error_bad_value); 1191 return FALSE; 1192 } 1193 1194 /* Now we know the relocation for this toc reference. */ 1195 relocation = our_toc_offset + TOC_LOAD_ADJUSTMENT; 1196 rstat = _bfd_relocate_contents (howto, input_bfd, relocation, loc); 1197 } 1198 break; 1199 case IMAGE_REL_PPC_IFGLUE: 1200 { 1201 /* To solve this, we need to know whether or not the symbol 1202 appearing on the call instruction is a glue function or not. 1203 A glue function must announce itself via a IMGLUE reloc, and 1204 the reloc contains the required toc restore instruction. */ 1205 DUMP_RELOC2 (howto->name, rel); 1206 1207 if (h != 0) 1208 { 1209 if (h->symbol_is_glue == 1) 1210 { 1211 bfd_put_32 (input_bfd, (bfd_vma) h->glue_insn, loc); 1212 } 1213 } 1214 } 1215 break; 1216 case IMAGE_REL_PPC_SECREL: 1217 /* Unimplemented: codeview debugging information. */ 1218 /* For fast access to the header of the section 1219 containing the item. */ 1220 break; 1221 case IMAGE_REL_PPC_SECTION: 1222 /* Unimplemented: codeview debugging information. */ 1223 /* Is used to indicate that the value should be relative 1224 to the beginning of the section that contains the 1225 symbol. */ 1226 break; 1227 case IMAGE_REL_PPC_ABSOLUTE: 1228 { 1229 const char *my_name; 1230 char buf[SYMNMLEN + 1]; 1231 1232 if (h == 0) 1233 { 1234 strncpy (buf, (syms+symndx)->_n._n_name, SYMNMLEN); 1235 buf[SYMNMLEN] = '\0'; 1236 my_name = buf; 1237 } 1238 else 1239 my_name = h->root.root.root.string; 1240 1241 _bfd_error_handler 1242 /* xgettext: c-format */ 1243 (_("warning: unsupported reloc %s <file %pB, section %pA>\n" 1244 "sym %ld (%s), r_vaddr %" PRId64 " (%#" PRIx64 ")"), 1245 howto->name, input_bfd, input_section, 1246 rel->r_symndx, my_name, 1247 (int64_t) rel->r_vaddr, (uint64_t) rel->r_vaddr); 1248 } 1249 break; 1250 case IMAGE_REL_PPC_IMGLUE: 1251 { 1252 /* There is nothing to do now. This reloc was noted in the first 1253 pass over the relocs, and the glue instruction extracted. */ 1254 const char *my_name; 1255 1256 if (h->symbol_is_glue == 1) 1257 break; 1258 my_name = h->root.root.root.string; 1259 1260 _bfd_error_handler 1261 /* xgettext: c-format */ 1262 (_("%pB: Out of order IMGLUE reloc for %s"), input_bfd, my_name); 1263 bfd_set_error (bfd_error_bad_value); 1264 return FALSE; 1265 } 1266 1267 case IMAGE_REL_PPC_ADDR32NB: 1268 { 1269 const char *name = 0; 1270 1271 DUMP_RELOC2 (howto->name, rel); 1272 1273 if (CONST_STRNEQ (input_section->name, ".idata$2") && first_thunk_address == 0) 1274 { 1275 /* Set magic values. */ 1276 int idata5offset; 1277 struct coff_link_hash_entry *myh; 1278 1279 myh = coff_link_hash_lookup (coff_hash_table (info), 1280 "__idata5_magic__", 1281 FALSE, FALSE, TRUE); 1282 first_thunk_address = myh->root.u.def.value + 1283 sec->output_section->vma + 1284 sec->output_offset - 1285 pe_data(output_bfd)->pe_opthdr.ImageBase; 1286 1287 idata5offset = myh->root.u.def.value; 1288 myh = coff_link_hash_lookup (coff_hash_table (info), 1289 "__idata6_magic__", 1290 FALSE, FALSE, TRUE); 1291 1292 thunk_size = myh->root.u.def.value - idata5offset; 1293 myh = coff_link_hash_lookup (coff_hash_table (info), 1294 "__idata4_magic__", 1295 FALSE, FALSE, TRUE); 1296 import_table_size = myh->root.u.def.value; 1297 } 1298 1299 if (h == 0) 1300 /* It is a file local symbol. */ 1301 sym = syms + symndx; 1302 else 1303 { 1304 char *target = 0; 1305 1306 name = h->root.root.root.string; 1307 if (strcmp (".idata$2", name) == 0) 1308 target = "__idata2_magic__"; 1309 else if (strcmp (".idata$4", name) == 0) 1310 target = "__idata4_magic__"; 1311 else if (strcmp (".idata$5", name) == 0) 1312 target = "__idata5_magic__"; 1313 1314 if (target != 0) 1315 { 1316 struct coff_link_hash_entry *myh; 1317 1318 myh = coff_link_hash_lookup (coff_hash_table (info), 1319 target, 1320 FALSE, FALSE, TRUE); 1321 if (myh == 0) 1322 { 1323 /* Missing magic cookies. Something is very wrong. */ 1324 abort (); 1325 } 1326 1327 val = myh->root.u.def.value + 1328 sec->output_section->vma + sec->output_offset; 1329 if (first_thunk_address == 0) 1330 { 1331 int idata5offset; 1332 myh = coff_link_hash_lookup (coff_hash_table (info), 1333 "__idata5_magic__", 1334 FALSE, FALSE, TRUE); 1335 first_thunk_address = myh->root.u.def.value + 1336 sec->output_section->vma + 1337 sec->output_offset - 1338 pe_data(output_bfd)->pe_opthdr.ImageBase; 1339 1340 idata5offset = myh->root.u.def.value; 1341 myh = coff_link_hash_lookup (coff_hash_table (info), 1342 "__idata6_magic__", 1343 FALSE, FALSE, TRUE); 1344 1345 thunk_size = myh->root.u.def.value - idata5offset; 1346 myh = coff_link_hash_lookup (coff_hash_table (info), 1347 "__idata4_magic__", 1348 FALSE, FALSE, TRUE); 1349 import_table_size = myh->root.u.def.value; 1350 } 1351 } 1352 } 1353 1354 rstat = _bfd_relocate_contents (howto, 1355 input_bfd, 1356 val - 1357 pe_data (output_bfd)->pe_opthdr.ImageBase, 1358 loc); 1359 } 1360 break; 1361 1362 case IMAGE_REL_PPC_REL24: 1363 DUMP_RELOC2(howto->name, rel); 1364 val -= (input_section->output_section->vma 1365 + input_section->output_offset); 1366 1367 rstat = _bfd_relocate_contents (howto, 1368 input_bfd, 1369 val, 1370 loc); 1371 break; 1372 case IMAGE_REL_PPC_ADDR16: 1373 case IMAGE_REL_PPC_ADDR24: 1374 case IMAGE_REL_PPC_ADDR32: 1375 DUMP_RELOC2(howto->name, rel); 1376 rstat = _bfd_relocate_contents (howto, 1377 input_bfd, 1378 val, 1379 loc); 1380 break; 1381 } 1382 1383 if (info->base_file) 1384 { 1385 /* So if this is non pcrelative, and is referenced 1386 to a section or a common symbol, then it needs a reloc. */ 1387 if (sym && pe_data(output_bfd)->in_reloc_p (output_bfd, howto)) 1388 { 1389 /* Relocation to a symbol in a section which 1390 isn't absolute - we output the address here 1391 to a file. */ 1392 bfd_vma addr = (rel->r_vaddr 1393 - input_section->vma 1394 + input_section->output_offset 1395 + input_section->output_section->vma); 1396 1397 if (!write_base_file_entry (output_bfd, info, addr)) 1398 return FALSE; 1399 } 1400 } 1401 1402 switch (rstat) 1403 { 1404 default: 1405 abort (); 1406 case bfd_reloc_ok: 1407 break; 1408 case bfd_reloc_overflow: 1409 { 1410 const char *name; 1411 char buf[SYMNMLEN + 1]; 1412 1413 if (symndx == -1) 1414 name = "*ABS*"; 1415 else if (h != NULL) 1416 name = NULL; 1417 else if (sym == NULL) 1418 name = "*unknown*"; 1419 else if (sym->_n._n_n._n_zeroes == 0 1420 && sym->_n._n_n._n_offset != 0) 1421 name = obj_coff_strings (input_bfd) + sym->_n._n_n._n_offset; 1422 else 1423 { 1424 strncpy (buf, sym->_n._n_name, SYMNMLEN); 1425 buf[SYMNMLEN] = '\0'; 1426 name = buf; 1427 } 1428 1429 (*info->callbacks->reloc_overflow) 1430 (info, (h ? &h->root.root : NULL), name, howto->name, 1431 (bfd_vma) 0, input_bfd, input_section, 1432 rel->r_vaddr - input_section->vma); 1433 } 1434 } 1435 } 1436 1437 return TRUE; 1438} 1439 1440#ifdef COFF_IMAGE_WITH_PE 1441 1442/* FIXME: BFD should not use global variables. This file is compiled 1443 twice, and these variables are shared. This is confusing and 1444 weird. */ 1445 1446long int global_toc_size = 4; 1447 1448bfd* bfd_of_toc_owner = 0; 1449 1450long int import_table_size; 1451long int first_thunk_address; 1452long int thunk_size; 1453 1454struct list_ele *head; 1455struct list_ele *tail; 1456 1457static char * 1458h1 = N_("\n\t\t\tTOC MAPPING\n\n"); 1459static char * 1460h2 = N_(" TOC disassembly Comments Name\n"); 1461static char * 1462h3 = N_(" Offset spelling (if present)\n"); 1463 1464void 1465dump_toc (void * vfile) 1466{ 1467 FILE *file = (FILE *) vfile; 1468 struct list_ele *t; 1469 1470 fputs (_(h1), file); 1471 fputs (_(h2), file); 1472 fputs (_(h3), file); 1473 1474 for (t = head; t != 0; t=t->next) 1475 { 1476 const char *cat = ""; 1477 1478 if (t->cat == priv) 1479 cat = _("private "); 1480 else if (t->cat == pub) 1481 cat = _("public "); 1482 else if (t->cat == tocdata) 1483 cat = _("data-in-toc "); 1484 1485 if (t->offset > global_toc_size) 1486 { 1487 if (t->offset <= global_toc_size + thunk_size) 1488 cat = _("IAT reference "); 1489 else 1490 { 1491 fprintf (file, 1492 /* xgettext: c-format */ 1493 _("**** global_toc_size %ld(%lx), thunk_size %ld(%lx)\n"), 1494 global_toc_size, (unsigned long) global_toc_size, 1495 thunk_size, (unsigned long) thunk_size); 1496 cat = _("Out of bounds!"); 1497 } 1498 } 1499 1500 fprintf (file, 1501 " %04lx (%d)", (unsigned long) t->offset, t->offset - 32768); 1502 fprintf (file, 1503 " %s %s\n", 1504 cat, t->name); 1505 1506 } 1507 1508 fprintf (file, "\n"); 1509} 1510 1511bfd_boolean 1512ppc_allocate_toc_section (struct bfd_link_info *info ATTRIBUTE_UNUSED) 1513{ 1514 asection *s; 1515 bfd_byte *foo; 1516 bfd_size_type amt; 1517 static char test_char = '1'; 1518 1519 if ( global_toc_size == 0 ) /* FIXME: does this get me in trouble? */ 1520 return TRUE; 1521 1522 if (bfd_of_toc_owner == 0) 1523 /* No toc owner? Something is very wrong. */ 1524 abort (); 1525 1526 s = bfd_get_section_by_name ( bfd_of_toc_owner , TOC_SECTION_NAME); 1527 if (s == NULL) 1528 /* No toc section? Something is very wrong. */ 1529 abort (); 1530 1531 amt = global_toc_size; 1532 foo = (bfd_byte *) bfd_alloc (bfd_of_toc_owner, amt); 1533 memset(foo, test_char, (size_t) global_toc_size); 1534 1535 s->size = global_toc_size; 1536 s->contents = foo; 1537 1538 return TRUE; 1539} 1540 1541bfd_boolean 1542ppc_process_before_allocation (bfd *abfd, 1543 struct bfd_link_info *info) 1544{ 1545 asection *sec; 1546 struct internal_reloc *i, *rel; 1547 1548 /* Here we have a bfd that is to be included on the link. We have a hook 1549 to do reloc rummaging, before section sizes are nailed down. */ 1550 _bfd_coff_get_external_symbols (abfd); 1551 1552 /* Rummage around all the relocs and map the toc. */ 1553 sec = abfd->sections; 1554 1555 if (sec == 0) 1556 return TRUE; 1557 1558 for (; sec != 0; sec = sec->next) 1559 { 1560 if (sec->reloc_count == 0) 1561 continue; 1562 1563 /* load the relocs */ 1564 /* FIXME: there may be a storage leak here */ 1565 i=_bfd_coff_read_internal_relocs(abfd,sec,1,0,0,0); 1566 1567 if (i == 0) 1568 abort (); 1569 1570 for (rel = i; rel < i + sec->reloc_count; ++rel) 1571 { 1572 unsigned short r_type = EXTRACT_TYPE (rel->r_type); 1573 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type); 1574 bfd_boolean ok = TRUE; 1575 1576 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, rel); 1577 1578 switch(r_type) 1579 { 1580 case IMAGE_REL_PPC_TOCREL16: 1581 /* If TOCDEFN is on, ignore as someone else has allocated the 1582 toc entry. */ 1583 if ((r_flags & IMAGE_REL_PPC_TOCDEFN) != IMAGE_REL_PPC_TOCDEFN) 1584 ok = ppc_record_toc_entry(abfd, info, sec, 1585 rel->r_symndx, default_toc); 1586 if (!ok) 1587 return FALSE; 1588 break; 1589 case IMAGE_REL_PPC_IMGLUE: 1590 ppc_mark_symbol_as_glue (abfd, rel->r_symndx, rel); 1591 break; 1592 default: 1593 break; 1594 } 1595 } 1596 } 1597 1598 return TRUE; 1599} 1600 1601#endif 1602 1603static bfd_reloc_status_type 1604ppc_refhi_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1605 arelent *reloc_entry ATTRIBUTE_UNUSED, 1606 asymbol *symbol ATTRIBUTE_UNUSED, 1607 void * data ATTRIBUTE_UNUSED, 1608 asection *input_section ATTRIBUTE_UNUSED, 1609 bfd *output_bfd, 1610 char **error_message ATTRIBUTE_UNUSED) 1611{ 1612 UN_IMPL("REFHI"); 1613 DUMP_RELOC("REFHI",reloc_entry); 1614 1615 if (output_bfd == (bfd *) NULL) 1616 return bfd_reloc_continue; 1617 1618 return bfd_reloc_undefined; 1619} 1620 1621static bfd_reloc_status_type 1622ppc_pair_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1623 arelent *reloc_entry ATTRIBUTE_UNUSED, 1624 asymbol *symbol ATTRIBUTE_UNUSED, 1625 void * data ATTRIBUTE_UNUSED, 1626 asection *input_section ATTRIBUTE_UNUSED, 1627 bfd *output_bfd, 1628 char **error_message ATTRIBUTE_UNUSED) 1629{ 1630 UN_IMPL("PAIR"); 1631 DUMP_RELOC("PAIR",reloc_entry); 1632 1633 if (output_bfd == (bfd *) NULL) 1634 return bfd_reloc_continue; 1635 1636 return bfd_reloc_undefined; 1637} 1638 1639static bfd_reloc_status_type 1640ppc_toc16_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1641 arelent *reloc_entry ATTRIBUTE_UNUSED, 1642 asymbol *symbol ATTRIBUTE_UNUSED, 1643 void * data ATTRIBUTE_UNUSED, 1644 asection *input_section ATTRIBUTE_UNUSED, 1645 bfd *output_bfd, 1646 char **error_message ATTRIBUTE_UNUSED) 1647{ 1648 UN_IMPL ("TOCREL16"); 1649 DUMP_RELOC ("TOCREL16",reloc_entry); 1650 1651 if (output_bfd == (bfd *) NULL) 1652 return bfd_reloc_continue; 1653 1654 return bfd_reloc_ok; 1655} 1656 1657static bfd_reloc_status_type 1658ppc_secrel_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1659 arelent *reloc_entry ATTRIBUTE_UNUSED, 1660 asymbol *symbol ATTRIBUTE_UNUSED, 1661 void * data ATTRIBUTE_UNUSED, 1662 asection *input_section ATTRIBUTE_UNUSED, 1663 bfd *output_bfd, 1664 char **error_message ATTRIBUTE_UNUSED) 1665{ 1666 UN_IMPL("SECREL"); 1667 DUMP_RELOC("SECREL",reloc_entry); 1668 1669 if (output_bfd == (bfd *) NULL) 1670 return bfd_reloc_continue; 1671 1672 return bfd_reloc_ok; 1673} 1674 1675static bfd_reloc_status_type 1676ppc_section_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1677 arelent *reloc_entry ATTRIBUTE_UNUSED, 1678 asymbol *symbol ATTRIBUTE_UNUSED, 1679 void * data ATTRIBUTE_UNUSED, 1680 asection *input_section ATTRIBUTE_UNUSED, 1681 bfd *output_bfd, 1682 char **error_message ATTRIBUTE_UNUSED) 1683{ 1684 UN_IMPL("SECTION"); 1685 DUMP_RELOC("SECTION",reloc_entry); 1686 1687 if (output_bfd == (bfd *) NULL) 1688 return bfd_reloc_continue; 1689 1690 return bfd_reloc_ok; 1691} 1692 1693static bfd_reloc_status_type 1694ppc_imglue_reloc (bfd *abfd ATTRIBUTE_UNUSED, 1695 arelent *reloc_entry ATTRIBUTE_UNUSED, 1696 asymbol *symbol ATTRIBUTE_UNUSED, 1697 void * data ATTRIBUTE_UNUSED, 1698 asection *input_section ATTRIBUTE_UNUSED, 1699 bfd *output_bfd, 1700 char **error_message ATTRIBUTE_UNUSED) 1701 1702{ 1703 UN_IMPL("IMGLUE"); 1704 DUMP_RELOC("IMGLUE",reloc_entry); 1705 1706 if (output_bfd == (bfd *) NULL) 1707 return bfd_reloc_continue; 1708 1709 return bfd_reloc_ok; 1710} 1711 1712#define MAX_RELOC_INDEX \ 1713 (sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]) - 1) 1714 1715/* FIXME: There is a possibility that when we read in a reloc from a file, 1716 that there are some bits encoded in the upper portion of the 1717 type field. Not yet implemented. */ 1718 1719static void 1720ppc_coff_rtype2howto (arelent *relent, struct internal_reloc *internal) 1721{ 1722 /* We can encode one of three things in the type field, aside from the 1723 type: 1724 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction 1725 value, rather than an addition value 1726 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that 1727 the branch is expected to be taken or not. 1728 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file 1729 For now, we just strip this stuff to find the type, and ignore it other 1730 than that. */ 1731 reloc_howto_type *howto; 1732 unsigned short r_type = EXTRACT_TYPE (internal->r_type); 1733 unsigned short r_flags = EXTRACT_FLAGS(internal->r_type); 1734 unsigned short junk = EXTRACT_JUNK (internal->r_type); 1735 1736 /* The masking process only slices off the bottom byte for r_type. */ 1737 if ( r_type > MAX_RELOC_INDEX ) 1738 abort (); 1739 1740 /* Check for absolute crap. */ 1741 if (junk != 0) 1742 abort (); 1743 1744 switch(r_type) 1745 { 1746 case IMAGE_REL_PPC_ADDR16: 1747 case IMAGE_REL_PPC_REL24: 1748 case IMAGE_REL_PPC_ADDR24: 1749 case IMAGE_REL_PPC_ADDR32: 1750 case IMAGE_REL_PPC_IFGLUE: 1751 case IMAGE_REL_PPC_ADDR32NB: 1752 case IMAGE_REL_PPC_SECTION: 1753 case IMAGE_REL_PPC_SECREL: 1754 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal); 1755 howto = ppc_coff_howto_table + r_type; 1756 break; 1757 case IMAGE_REL_PPC_IMGLUE: 1758 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal); 1759 howto = ppc_coff_howto_table + r_type; 1760 break; 1761 case IMAGE_REL_PPC_TOCREL16: 1762 DUMP_RELOC2 (ppc_coff_howto_table[r_type].name, internal); 1763 if (r_flags & IMAGE_REL_PPC_TOCDEFN) 1764 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN; 1765 else 1766 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16; 1767 break; 1768 default: 1769 _bfd_error_handler 1770 /* xgettext: c-format */ 1771 (_("warning: unsupported reloc %s [%d] used -- it may not work"), 1772 ppc_coff_howto_table[r_type].name, r_type); 1773 howto = ppc_coff_howto_table + r_type; 1774 break; 1775 } 1776 1777 relent->howto = howto; 1778} 1779 1780static reloc_howto_type * 1781coff_ppc_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 1782 asection *sec, 1783 struct internal_reloc *rel, 1784 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED, 1785 struct internal_syment *sym ATTRIBUTE_UNUSED, 1786 bfd_vma *addendp) 1787{ 1788 reloc_howto_type *howto; 1789 1790 /* We can encode one of three things in the type field, aside from the 1791 type: 1792 1. IMAGE_REL_PPC_NEG - indicates the value field is a subtraction 1793 value, rather than an addition value 1794 2. IMAGE_REL_PPC_BRTAKEN, IMAGE_REL_PPC_BRNTAKEN - indicates that 1795 the branch is expected to be taken or not. 1796 3. IMAGE_REL_PPC_TOCDEFN - toc slot definition in the file 1797 For now, we just strip this stuff to find the type, and ignore it other 1798 than that. */ 1799 1800 unsigned short r_type = EXTRACT_TYPE (rel->r_type); 1801 unsigned short r_flags = EXTRACT_FLAGS (rel->r_type); 1802 unsigned short junk = EXTRACT_JUNK (rel->r_type); 1803 1804 /* The masking process only slices off the bottom byte for r_type. */ 1805 if (r_type > MAX_RELOC_INDEX) 1806 abort (); 1807 1808 /* Check for absolute crap. */ 1809 if (junk != 0) 1810 abort (); 1811 1812 switch(r_type) 1813 { 1814 case IMAGE_REL_PPC_ADDR32NB: 1815 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel); 1816 *addendp -= pe_data(sec->output_section->owner)->pe_opthdr.ImageBase; 1817 howto = ppc_coff_howto_table + r_type; 1818 break; 1819 case IMAGE_REL_PPC_TOCREL16: 1820 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel); 1821 if (r_flags & IMAGE_REL_PPC_TOCDEFN) 1822 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16_DEFN; 1823 else 1824 howto = ppc_coff_howto_table + IMAGE_REL_PPC_TOCREL16; 1825 break; 1826 case IMAGE_REL_PPC_ADDR16: 1827 case IMAGE_REL_PPC_REL24: 1828 case IMAGE_REL_PPC_ADDR24: 1829 case IMAGE_REL_PPC_ADDR32: 1830 case IMAGE_REL_PPC_IFGLUE: 1831 case IMAGE_REL_PPC_SECTION: 1832 case IMAGE_REL_PPC_SECREL: 1833 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel); 1834 howto = ppc_coff_howto_table + r_type; 1835 break; 1836 case IMAGE_REL_PPC_IMGLUE: 1837 DUMP_RELOC2(ppc_coff_howto_table[r_type].name, rel); 1838 howto = ppc_coff_howto_table + r_type; 1839 break; 1840 default: 1841 _bfd_error_handler 1842 /* xgettext: c-format */ 1843 (_("warning: unsupported reloc %s [%d] used -- it may not work"), 1844 ppc_coff_howto_table[r_type].name, r_type); 1845 howto = ppc_coff_howto_table + r_type; 1846 break; 1847 } 1848 1849 return howto; 1850} 1851 1852/* A cheesy little macro to make the code a little more readable. */ 1853#define HOW2MAP(bfd_rtype,ppc_rtype) \ 1854 case bfd_rtype: return &ppc_coff_howto_table[ppc_rtype] 1855 1856static reloc_howto_type * 1857ppc_coff_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1858 bfd_reloc_code_real_type code) 1859{ 1860 switch (code) 1861 { 1862 HOW2MAP(BFD_RELOC_32_GOTOFF, IMAGE_REL_PPC_IMGLUE); 1863 HOW2MAP(BFD_RELOC_16_GOT_PCREL, IMAGE_REL_PPC_IFGLUE); 1864 HOW2MAP(BFD_RELOC_16, IMAGE_REL_PPC_ADDR16); 1865 HOW2MAP(BFD_RELOC_PPC_B26, IMAGE_REL_PPC_REL24); 1866 HOW2MAP(BFD_RELOC_PPC_BA26, IMAGE_REL_PPC_ADDR24); 1867 HOW2MAP(BFD_RELOC_PPC_TOC16, IMAGE_REL_PPC_TOCREL16); 1868 HOW2MAP(BFD_RELOC_16_GOTOFF, IMAGE_REL_PPC_TOCREL16_DEFN); 1869 HOW2MAP(BFD_RELOC_32, IMAGE_REL_PPC_ADDR32); 1870 HOW2MAP(BFD_RELOC_RVA, IMAGE_REL_PPC_ADDR32NB); 1871 default: 1872 return NULL; 1873 } 1874} 1875#undef HOW2MAP 1876 1877static reloc_howto_type * 1878ppc_coff_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1879 const char *r_name) 1880{ 1881 unsigned int i; 1882 1883 for (i = 0; 1884 i < sizeof (ppc_coff_howto_table) / sizeof (ppc_coff_howto_table[0]); 1885 i++) 1886 if (ppc_coff_howto_table[i].name != NULL 1887 && strcasecmp (ppc_coff_howto_table[i].name, r_name) == 0) 1888 return &ppc_coff_howto_table[i]; 1889 1890 return NULL; 1891} 1892 1893/* Tailor coffcode.h -- macro heaven. */ 1894 1895#define RTYPE2HOWTO(cache_ptr, dst) ppc_coff_rtype2howto (cache_ptr, dst) 1896 1897/* We use the special COFF backend linker, with our own special touch. */ 1898 1899#define coff_bfd_reloc_type_lookup ppc_coff_reloc_type_lookup 1900#define coff_bfd_reloc_name_lookup ppc_coff_reloc_name_lookup 1901#define coff_rtype_to_howto coff_ppc_rtype_to_howto 1902#define coff_relocate_section coff_ppc_relocate_section 1903#define coff_bfd_final_link ppc_bfd_coff_final_link 1904 1905#ifndef COFF_IMAGE_WITH_PE 1906#endif 1907 1908#define SELECT_RELOC(internal, howto) {internal.r_type=howto->type;} 1909 1910#define COFF_PAGE_SIZE 0x1000 1911 1912/* FIXME: This controls some code that used to be in peicode.h and is 1913 now in peigen.c. It will not control the code in peigen.c. If 1914 anybody wants to get this working, you will need to fix that. */ 1915#define POWERPC_LE_PE 1916 1917#define COFF_SECTION_ALIGNMENT_ENTRIES \ 1918{ COFF_SECTION_NAME_EXACT_MATCH (".idata$2"), \ 1919 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \ 1920{ COFF_SECTION_NAME_EXACT_MATCH (".idata$3"), \ 1921 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \ 1922{ COFF_SECTION_NAME_EXACT_MATCH (".idata$4"), \ 1923 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \ 1924{ COFF_SECTION_NAME_EXACT_MATCH (".idata$5"), \ 1925 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \ 1926{ COFF_SECTION_NAME_EXACT_MATCH (".idata$6"), \ 1927 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 }, \ 1928{ COFF_SECTION_NAME_EXACT_MATCH (".reloc"), \ 1929 COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 1 } 1930 1931#include "coffcode.h" 1932 1933#ifndef COFF_IMAGE_WITH_PE 1934 1935static bfd_boolean 1936ppc_do_last (bfd *abfd) 1937{ 1938 if (abfd == bfd_of_toc_owner) 1939 return TRUE; 1940 else 1941 return FALSE; 1942} 1943 1944static bfd * 1945ppc_get_last (void) 1946{ 1947 return bfd_of_toc_owner; 1948} 1949 1950/* This piece of machinery exists only to guarantee that the bfd that holds 1951 the toc section is written last. 1952 1953 This does depend on bfd_make_section attaching a new section to the 1954 end of the section list for the bfd. 1955 1956 This is otherwise intended to be functionally the same as 1957 cofflink.c:_bfd_coff_final_link(). It is specifically different only 1958 where the POWERPC_LE_PE macro modifies the code. It is left in as a 1959 precise form of comment. krk@cygnus.com */ 1960 1961/* Do the final link step. */ 1962 1963bfd_boolean 1964ppc_bfd_coff_final_link (bfd *abfd, struct bfd_link_info *info) 1965{ 1966 bfd_size_type symesz; 1967 struct coff_final_link_info flaginfo; 1968 bfd_boolean debug_merge_allocated; 1969 asection *o; 1970 struct bfd_link_order *p; 1971 bfd_size_type max_sym_count; 1972 bfd_size_type max_lineno_count; 1973 bfd_size_type max_reloc_count; 1974 bfd_size_type max_output_reloc_count; 1975 bfd_size_type max_contents_size; 1976 file_ptr rel_filepos; 1977 unsigned int relsz; 1978 file_ptr line_filepos; 1979 unsigned int linesz; 1980 bfd *sub; 1981 bfd_byte *external_relocs = NULL; 1982 char strbuf[STRING_SIZE_SIZE]; 1983 bfd_size_type amt; 1984 1985 symesz = bfd_coff_symesz (abfd); 1986 1987 flaginfo.info = info; 1988 flaginfo.output_bfd = abfd; 1989 flaginfo.strtab = NULL; 1990 flaginfo.section_info = NULL; 1991 flaginfo.last_file_index = -1; 1992 flaginfo.last_bf_index = -1; 1993 flaginfo.internal_syms = NULL; 1994 flaginfo.sec_ptrs = NULL; 1995 flaginfo.sym_indices = NULL; 1996 flaginfo.outsyms = NULL; 1997 flaginfo.linenos = NULL; 1998 flaginfo.contents = NULL; 1999 flaginfo.external_relocs = NULL; 2000 flaginfo.internal_relocs = NULL; 2001 debug_merge_allocated = FALSE; 2002 2003 coff_data (abfd)->link_info = info; 2004 2005 flaginfo.strtab = _bfd_stringtab_init (); 2006 if (flaginfo.strtab == NULL) 2007 goto error_return; 2008 2009 if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge)) 2010 goto error_return; 2011 debug_merge_allocated = TRUE; 2012 2013 /* Compute the file positions for all the sections. */ 2014 if (! abfd->output_has_begun) 2015 { 2016 if (! bfd_coff_compute_section_file_positions (abfd)) 2017 return FALSE; 2018 } 2019 2020 /* Count the line numbers and relocation entries required for the 2021 output file. Set the file positions for the relocs. */ 2022 rel_filepos = obj_relocbase (abfd); 2023 relsz = bfd_coff_relsz (abfd); 2024 max_contents_size = 0; 2025 max_lineno_count = 0; 2026 max_reloc_count = 0; 2027 2028 for (o = abfd->sections; o != NULL; o = o->next) 2029 { 2030 o->reloc_count = 0; 2031 o->lineno_count = 0; 2032 2033 for (p = o->map_head.link_order; p != NULL; p = p->next) 2034 { 2035 if (p->type == bfd_indirect_link_order) 2036 { 2037 asection *sec; 2038 2039 sec = p->u.indirect.section; 2040 2041 /* Mark all sections which are to be included in the 2042 link. This will normally be every section. We need 2043 to do this so that we can identify any sections which 2044 the linker has decided to not include. */ 2045 sec->linker_mark = TRUE; 2046 2047 if (info->strip == strip_none 2048 || info->strip == strip_some) 2049 o->lineno_count += sec->lineno_count; 2050 2051 if (bfd_link_relocatable (info)) 2052 o->reloc_count += sec->reloc_count; 2053 2054 if (sec->rawsize > max_contents_size) 2055 max_contents_size = sec->rawsize; 2056 if (sec->size > max_contents_size) 2057 max_contents_size = sec->size; 2058 if (sec->lineno_count > max_lineno_count) 2059 max_lineno_count = sec->lineno_count; 2060 if (sec->reloc_count > max_reloc_count) 2061 max_reloc_count = sec->reloc_count; 2062 } 2063 else if (bfd_link_relocatable (info) 2064 && (p->type == bfd_section_reloc_link_order 2065 || p->type == bfd_symbol_reloc_link_order)) 2066 ++o->reloc_count; 2067 } 2068 if (o->reloc_count == 0) 2069 o->rel_filepos = 0; 2070 else 2071 { 2072 o->flags |= SEC_RELOC; 2073 o->rel_filepos = rel_filepos; 2074 rel_filepos += o->reloc_count * relsz; 2075 } 2076 } 2077 2078 /* If doing a relocatable link, allocate space for the pointers we 2079 need to keep. */ 2080 if (bfd_link_relocatable (info)) 2081 { 2082 unsigned int i; 2083 2084 /* We use section_count + 1, rather than section_count, because 2085 the target_index fields are 1 based. */ 2086 amt = abfd->section_count + 1; 2087 amt *= sizeof (struct coff_link_section_info); 2088 flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt); 2089 2090 if (flaginfo.section_info == NULL) 2091 goto error_return; 2092 2093 for (i = 0; i <= abfd->section_count; i++) 2094 { 2095 flaginfo.section_info[i].relocs = NULL; 2096 flaginfo.section_info[i].rel_hashes = NULL; 2097 } 2098 } 2099 2100 /* We now know the size of the relocs, so we can determine the file 2101 positions of the line numbers. */ 2102 line_filepos = rel_filepos; 2103 linesz = bfd_coff_linesz (abfd); 2104 max_output_reloc_count = 0; 2105 2106 for (o = abfd->sections; o != NULL; o = o->next) 2107 { 2108 if (o->lineno_count == 0) 2109 o->line_filepos = 0; 2110 else 2111 { 2112 o->line_filepos = line_filepos; 2113 line_filepos += o->lineno_count * linesz; 2114 } 2115 2116 if (o->reloc_count != 0) 2117 { 2118 /* We don't know the indices of global symbols until we have 2119 written out all the local symbols. For each section in 2120 the output file, we keep an array of pointers to hash 2121 table entries. Each entry in the array corresponds to a 2122 reloc. When we find a reloc against a global symbol, we 2123 set the corresponding entry in this array so that we can 2124 fix up the symbol index after we have written out all the 2125 local symbols. 2126 2127 Because of this problem, we also keep the relocs in 2128 memory until the end of the link. This wastes memory, 2129 but only when doing a relocatable link, which is not the 2130 common case. */ 2131 BFD_ASSERT (bfd_link_relocatable (info)); 2132 amt = o->reloc_count; 2133 amt *= sizeof (struct internal_reloc); 2134 flaginfo.section_info[o->target_index].relocs = 2135 (struct internal_reloc *) bfd_malloc (amt); 2136 amt = o->reloc_count; 2137 amt *= sizeof (struct coff_link_hash_entry *); 2138 flaginfo.section_info[o->target_index].rel_hashes = 2139 (struct coff_link_hash_entry **) bfd_malloc (amt); 2140 if (flaginfo.section_info[o->target_index].relocs == NULL 2141 || flaginfo.section_info[o->target_index].rel_hashes == NULL) 2142 goto error_return; 2143 2144 if (o->reloc_count > max_output_reloc_count) 2145 max_output_reloc_count = o->reloc_count; 2146 } 2147 2148 /* Reset the reloc and lineno counts, so that we can use them to 2149 count the number of entries we have output so far. */ 2150 o->reloc_count = 0; 2151 o->lineno_count = 0; 2152 } 2153 2154 obj_sym_filepos (abfd) = line_filepos; 2155 2156 /* Figure out the largest number of symbols in an input BFD. Take 2157 the opportunity to clear the output_has_begun fields of all the 2158 input BFD's. */ 2159 max_sym_count = 0; 2160 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next) 2161 { 2162 bfd_size_type sz; 2163 2164 sub->output_has_begun = FALSE; 2165 sz = obj_raw_syment_count (sub); 2166 if (sz > max_sym_count) 2167 max_sym_count = sz; 2168 } 2169 2170 /* Allocate some buffers used while linking. */ 2171 amt = max_sym_count * sizeof (struct internal_syment); 2172 flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt); 2173 amt = max_sym_count * sizeof (asection *); 2174 flaginfo.sec_ptrs = (asection **) bfd_malloc (amt); 2175 amt = max_sym_count * sizeof (long); 2176 flaginfo.sym_indices = (long *) bfd_malloc (amt); 2177 amt = (max_sym_count + 1) * symesz; 2178 flaginfo.outsyms = (bfd_byte *) bfd_malloc (amt); 2179 amt = max_lineno_count * bfd_coff_linesz (abfd); 2180 flaginfo.linenos = (bfd_byte *) bfd_malloc (amt); 2181 flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size); 2182 flaginfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz); 2183 if (! bfd_link_relocatable (info)) 2184 { 2185 amt = max_reloc_count * sizeof (struct internal_reloc); 2186 flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt); 2187 } 2188 if ((flaginfo.internal_syms == NULL && max_sym_count > 0) 2189 || (flaginfo.sec_ptrs == NULL && max_sym_count > 0) 2190 || (flaginfo.sym_indices == NULL && max_sym_count > 0) 2191 || flaginfo.outsyms == NULL 2192 || (flaginfo.linenos == NULL && max_lineno_count > 0) 2193 || (flaginfo.contents == NULL && max_contents_size > 0) 2194 || (flaginfo.external_relocs == NULL && max_reloc_count > 0) 2195 || (! bfd_link_relocatable (info) 2196 && flaginfo.internal_relocs == NULL 2197 && max_reloc_count > 0)) 2198 goto error_return; 2199 2200 /* We now know the position of everything in the file, except that 2201 we don't know the size of the symbol table and therefore we don't 2202 know where the string table starts. We just build the string 2203 table in memory as we go along. We process all the relocations 2204 for a single input file at once. */ 2205 obj_raw_syment_count (abfd) = 0; 2206 2207 if (coff_backend_info (abfd)->_bfd_coff_start_final_link) 2208 { 2209 if (! bfd_coff_start_final_link (abfd, info)) 2210 goto error_return; 2211 } 2212 2213 for (o = abfd->sections; o != NULL; o = o->next) 2214 { 2215 for (p = o->map_head.link_order; p != NULL; p = p->next) 2216 { 2217 if (p->type == bfd_indirect_link_order 2218 && (bfd_get_flavour (p->u.indirect.section->owner) 2219 == bfd_target_coff_flavour)) 2220 { 2221 sub = p->u.indirect.section->owner; 2222#ifdef POWERPC_LE_PE 2223 if (! sub->output_has_begun && !ppc_do_last(sub)) 2224#else 2225 if (! sub->output_has_begun) 2226#endif 2227 { 2228 if (! _bfd_coff_link_input_bfd (&flaginfo, sub)) 2229 goto error_return; 2230 sub->output_has_begun = TRUE; 2231 } 2232 } 2233 else if (p->type == bfd_section_reloc_link_order 2234 || p->type == bfd_symbol_reloc_link_order) 2235 { 2236 if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p)) 2237 goto error_return; 2238 } 2239 else 2240 { 2241 if (! _bfd_default_link_order (abfd, info, o, p)) 2242 goto error_return; 2243 } 2244 } 2245 } 2246 2247#ifdef POWERPC_LE_PE 2248 { 2249 bfd* last_one = ppc_get_last(); 2250 if (last_one) 2251 { 2252 if (! _bfd_coff_link_input_bfd (&flaginfo, last_one)) 2253 goto error_return; 2254 } 2255 last_one->output_has_begun = TRUE; 2256 } 2257#endif 2258 2259 /* Free up the buffers used by _bfd_coff_link_input_bfd. */ 2260 coff_debug_merge_hash_table_free (&flaginfo.debug_merge); 2261 debug_merge_allocated = FALSE; 2262 2263 if (flaginfo.internal_syms != NULL) 2264 { 2265 free (flaginfo.internal_syms); 2266 flaginfo.internal_syms = NULL; 2267 } 2268 if (flaginfo.sec_ptrs != NULL) 2269 { 2270 free (flaginfo.sec_ptrs); 2271 flaginfo.sec_ptrs = NULL; 2272 } 2273 if (flaginfo.sym_indices != NULL) 2274 { 2275 free (flaginfo.sym_indices); 2276 flaginfo.sym_indices = NULL; 2277 } 2278 if (flaginfo.linenos != NULL) 2279 { 2280 free (flaginfo.linenos); 2281 flaginfo.linenos = NULL; 2282 } 2283 if (flaginfo.contents != NULL) 2284 { 2285 free (flaginfo.contents); 2286 flaginfo.contents = NULL; 2287 } 2288 if (flaginfo.external_relocs != NULL) 2289 { 2290 free (flaginfo.external_relocs); 2291 flaginfo.external_relocs = NULL; 2292 } 2293 if (flaginfo.internal_relocs != NULL) 2294 { 2295 free (flaginfo.internal_relocs); 2296 flaginfo.internal_relocs = NULL; 2297 } 2298 2299 /* The value of the last C_FILE symbol is supposed to be the symbol 2300 index of the first external symbol. Write it out again if 2301 necessary. */ 2302 if (flaginfo.last_file_index != -1 2303 && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd)) 2304 { 2305 file_ptr pos; 2306 2307 flaginfo.last_file.n_value = obj_raw_syment_count (abfd); 2308 bfd_coff_swap_sym_out (abfd, &flaginfo.last_file, 2309 flaginfo.outsyms); 2310 pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz; 2311 if (bfd_seek (abfd, pos, SEEK_SET) != 0 2312 || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz) 2313 return FALSE; 2314 } 2315 2316 /* Write out the global symbols. */ 2317 flaginfo.failed = FALSE; 2318 bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo); 2319 if (flaginfo.failed) 2320 goto error_return; 2321 2322 /* The outsyms buffer is used by _bfd_coff_write_global_sym. */ 2323 if (flaginfo.outsyms != NULL) 2324 { 2325 free (flaginfo.outsyms); 2326 flaginfo.outsyms = NULL; 2327 } 2328 2329 if (bfd_link_relocatable (info)) 2330 { 2331 /* Now that we have written out all the global symbols, we know 2332 the symbol indices to use for relocs against them, and we can 2333 finally write out the relocs. */ 2334 amt = max_output_reloc_count * relsz; 2335 external_relocs = (bfd_byte *) bfd_malloc (amt); 2336 if (external_relocs == NULL) 2337 goto error_return; 2338 2339 for (o = abfd->sections; o != NULL; o = o->next) 2340 { 2341 struct internal_reloc *irel; 2342 struct internal_reloc *irelend; 2343 struct coff_link_hash_entry **rel_hash; 2344 bfd_byte *erel; 2345 2346 if (o->reloc_count == 0) 2347 continue; 2348 2349 irel = flaginfo.section_info[o->target_index].relocs; 2350 irelend = irel + o->reloc_count; 2351 rel_hash = flaginfo.section_info[o->target_index].rel_hashes; 2352 erel = external_relocs; 2353 for (; irel < irelend; irel++, rel_hash++, erel += relsz) 2354 { 2355 if (*rel_hash != NULL) 2356 { 2357 BFD_ASSERT ((*rel_hash)->indx >= 0); 2358 irel->r_symndx = (*rel_hash)->indx; 2359 } 2360 bfd_coff_swap_reloc_out (abfd, irel, erel); 2361 } 2362 2363 amt = relsz * o->reloc_count; 2364 if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0 2365 || bfd_bwrite (external_relocs, amt, abfd) != amt) 2366 goto error_return; 2367 } 2368 2369 free (external_relocs); 2370 external_relocs = NULL; 2371 } 2372 2373 /* Free up the section information. */ 2374 if (flaginfo.section_info != NULL) 2375 { 2376 unsigned int i; 2377 2378 for (i = 0; i < abfd->section_count; i++) 2379 { 2380 if (flaginfo.section_info[i].relocs != NULL) 2381 free (flaginfo.section_info[i].relocs); 2382 if (flaginfo.section_info[i].rel_hashes != NULL) 2383 free (flaginfo.section_info[i].rel_hashes); 2384 } 2385 free (flaginfo.section_info); 2386 flaginfo.section_info = NULL; 2387 } 2388 2389 /* If we have optimized stabs strings, output them. */ 2390 if (coff_hash_table (info)->stab_info.stabstr != NULL) 2391 { 2392 if (! _bfd_write_stab_strings (abfd, &coff_hash_table (info)->stab_info)) 2393 return FALSE; 2394 } 2395 2396 /* Write out the string table. */ 2397 if (obj_raw_syment_count (abfd) != 0) 2398 { 2399 file_ptr pos; 2400 2401 pos = obj_sym_filepos (abfd) + obj_raw_syment_count (abfd) * symesz; 2402 if (bfd_seek (abfd, pos, SEEK_SET) != 0) 2403 return FALSE; 2404 2405#if STRING_SIZE_SIZE == 4 2406 H_PUT_32 (abfd, 2407 _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE, 2408 strbuf); 2409#else 2410 #error Change H_PUT_32 above 2411#endif 2412 2413 if (bfd_bwrite (strbuf, (bfd_size_type) STRING_SIZE_SIZE, abfd) 2414 != STRING_SIZE_SIZE) 2415 return FALSE; 2416 2417 if (! _bfd_stringtab_emit (abfd, flaginfo.strtab)) 2418 return FALSE; 2419 } 2420 2421 _bfd_stringtab_free (flaginfo.strtab); 2422 2423 /* Setting symcount to 0 will cause write_object_contents to 2424 not try to write out the symbols. */ 2425 abfd->symcount = 0; 2426 2427 return TRUE; 2428 2429 error_return: 2430 if (debug_merge_allocated) 2431 coff_debug_merge_hash_table_free (&flaginfo.debug_merge); 2432 if (flaginfo.strtab != NULL) 2433 _bfd_stringtab_free (flaginfo.strtab); 2434 if (flaginfo.section_info != NULL) 2435 { 2436 unsigned int i; 2437 2438 for (i = 0; i < abfd->section_count; i++) 2439 { 2440 if (flaginfo.section_info[i].relocs != NULL) 2441 free (flaginfo.section_info[i].relocs); 2442 if (flaginfo.section_info[i].rel_hashes != NULL) 2443 free (flaginfo.section_info[i].rel_hashes); 2444 } 2445 free (flaginfo.section_info); 2446 } 2447 if (flaginfo.internal_syms != NULL) 2448 free (flaginfo.internal_syms); 2449 if (flaginfo.sec_ptrs != NULL) 2450 free (flaginfo.sec_ptrs); 2451 if (flaginfo.sym_indices != NULL) 2452 free (flaginfo.sym_indices); 2453 if (flaginfo.outsyms != NULL) 2454 free (flaginfo.outsyms); 2455 if (flaginfo.linenos != NULL) 2456 free (flaginfo.linenos); 2457 if (flaginfo.contents != NULL) 2458 free (flaginfo.contents); 2459 if (flaginfo.external_relocs != NULL) 2460 free (flaginfo.external_relocs); 2461 if (flaginfo.internal_relocs != NULL) 2462 free (flaginfo.internal_relocs); 2463 if (external_relocs != NULL) 2464 free (external_relocs); 2465 return FALSE; 2466} 2467#endif 2468 2469/* Forward declaration for use by alternative_target field. */ 2470#ifdef TARGET_BIG_SYM 2471extern const bfd_target TARGET_BIG_SYM; 2472#endif 2473 2474/* The transfer vectors that lead the outside world to all of the above. */ 2475 2476#ifdef TARGET_LITTLE_SYM 2477const bfd_target TARGET_LITTLE_SYM = 2478{ 2479 TARGET_LITTLE_NAME, /* name or coff-arm-little */ 2480 bfd_target_coff_flavour, 2481 BFD_ENDIAN_LITTLE, /* data byte order is little */ 2482 BFD_ENDIAN_LITTLE, /* header byte order is little */ 2483 2484 (HAS_RELOC | EXEC_P /* FIXME: object flags */ 2485 | HAS_LINENO | HAS_DEBUG 2486 | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 2487 2488#ifndef COFF_WITH_PE 2489 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 2490 | SEC_RELOC), /* section flags */ 2491#else 2492 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 2493 | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), 2494#endif 2495 2496 0, /* leading char */ 2497 '/', /* ar_pad_char */ 2498 15, /* ar_max_namelen??? FIXMEmgo */ 2499 0, /* match priority. */ 2500 2501 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 2502 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 2503 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ 2504 2505 bfd_getl64, bfd_getl_signed_64, bfd_putl64, 2506 bfd_getl32, bfd_getl_signed_32, bfd_putl32, 2507 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ 2508 2509 { /* bfd_check_format */ 2510 _bfd_dummy_target, 2511 coff_object_p, 2512 bfd_generic_archive_p, 2513 coff_object_p 2514 }, 2515 { /* bfd_set_format */ 2516 _bfd_bool_bfd_false_error, 2517 coff_mkobject, 2518 _bfd_generic_mkarchive, 2519 _bfd_bool_bfd_false_error 2520 }, 2521 { /* bfd_write_contents */ 2522 _bfd_bool_bfd_false_error, 2523 coff_write_object_contents, 2524 _bfd_write_archive_contents, 2525 _bfd_bool_bfd_false_error 2526 }, 2527 2528 BFD_JUMP_TABLE_GENERIC (coff), 2529 BFD_JUMP_TABLE_COPY (coff), 2530 BFD_JUMP_TABLE_CORE (_bfd_nocore), 2531 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 2532 BFD_JUMP_TABLE_SYMBOLS (coff), 2533 BFD_JUMP_TABLE_RELOCS (coff), 2534 BFD_JUMP_TABLE_WRITE (coff), 2535 BFD_JUMP_TABLE_LINK (coff), 2536 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 2537 2538 /* Alternative_target. */ 2539#ifdef TARGET_BIG_SYM 2540 &TARGET_BIG_SYM, 2541#else 2542 NULL, 2543#endif 2544 2545 COFF_SWAP_TABLE 2546}; 2547#endif 2548 2549#ifdef TARGET_BIG_SYM 2550const bfd_target TARGET_BIG_SYM = 2551{ 2552 TARGET_BIG_NAME, 2553 bfd_target_coff_flavour, 2554 BFD_ENDIAN_BIG, /* data byte order is big */ 2555 BFD_ENDIAN_BIG, /* header byte order is big */ 2556 2557 (HAS_RELOC | EXEC_P /* FIXME: object flags */ 2558 | HAS_LINENO | HAS_DEBUG 2559 | HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED), 2560 2561#ifndef COFF_WITH_PE 2562 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 2563 | SEC_RELOC), /* section flags */ 2564#else 2565 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_READONLY 2566 | SEC_RELOC | SEC_LINK_ONCE | SEC_LINK_DUPLICATES), 2567#endif 2568 2569 0, /* leading char */ 2570 '/', /* ar_pad_char */ 2571 15, /* ar_max_namelen??? FIXMEmgo */ 2572 0, /* match priority. */ 2573 2574 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 2575 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 2576 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ 2577 2578 bfd_getb64, bfd_getb_signed_64, bfd_putb64, 2579 bfd_getb32, bfd_getb_signed_32, bfd_putb32, 2580 bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* hdrs */ 2581 2582 { /* bfd_check_format */ 2583 _bfd_dummy_target, 2584 coff_object_p, 2585 bfd_generic_archive_p, 2586 coff_object_p 2587 }, 2588 { /* bfd_set_format */ 2589 _bfd_bool_bfd_false_error, 2590 coff_mkobject, 2591 _bfd_generic_mkarchive, 2592 _bfd_bool_bfd_false_error 2593 }, 2594 { /* bfd_write_contents */ 2595 _bfd_bool_bfd_false_error, 2596 coff_write_object_contents, 2597 _bfd_write_archive_contents, 2598 _bfd_bool_bfd_false_error 2599 }, 2600 2601 BFD_JUMP_TABLE_GENERIC (coff), 2602 BFD_JUMP_TABLE_COPY (coff), 2603 BFD_JUMP_TABLE_CORE (_bfd_nocore), 2604 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), 2605 BFD_JUMP_TABLE_SYMBOLS (coff), 2606 BFD_JUMP_TABLE_RELOCS (coff), 2607 BFD_JUMP_TABLE_WRITE (coff), 2608 BFD_JUMP_TABLE_LINK (coff), 2609 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), 2610 2611 /* Alternative_target. */ 2612#ifdef TARGET_LITTLE_SYM 2613 &TARGET_LITTLE_SYM, 2614#else 2615 NULL, 2616#endif 2617 2618 COFF_SWAP_TABLE 2619}; 2620 2621#endif 2622