1 /* Support for the generic parts of most COFF variants, for BFD. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24 /* Most of this hacked by Steve Chamberlain, 25 sac@cygnus.com. */ 26 /* 27 SECTION 28 coff backends 29 30 BFD supports a number of different flavours of coff format. 31 The major differences between formats are the sizes and 32 alignments of fields in structures on disk, and the occasional 33 extra field. 34 35 Coff in all its varieties is implemented with a few common 36 files and a number of implementation specific files. For 37 example, The 88k bcs coff format is implemented in the file 38 @file{coff-m88k.c}. This file @code{#include}s 39 @file{coff/m88k.h} which defines the external structure of the 40 coff format for the 88k, and @file{coff/internal.h} which 41 defines the internal structure. @file{coff-m88k.c} also 42 defines the relocations used by the 88k format 43 @xref{Relocations}. 44 45 The Intel i960 processor version of coff is implemented in 46 @file{coff-i960.c}. This file has the same structure as 47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h} 48 rather than @file{coff-m88k.h}. 49 50 SUBSECTION 51 Porting to a new version of coff 52 53 The recommended method is to select from the existing 54 implementations the version of coff which is most like the one 55 you want to use. For example, we'll say that i386 coff is 56 the one you select, and that your coff flavour is called foo. 57 Copy @file{i386coff.c} to @file{foocoff.c}, copy 58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h}, 59 and add the lines to @file{targets.c} and @file{Makefile.in} 60 so that your new back end is used. Alter the shapes of the 61 structures in @file{../include/coff/foo.h} so that they match 62 what you need. You will probably also have to add 63 @code{#ifdef}s to the code in @file{coff/internal.h} and 64 @file{coffcode.h} if your version of coff is too wild. 65 66 You can verify that your new BFD backend works quite simply by 67 building @file{objdump} from the @file{binutils} directory, 68 and making sure that its version of what's going on and your 69 host system's idea (assuming it has the pretty standard coff 70 dump utility, usually called @code{att-dump} or just 71 @code{dump}) are the same. Then clean up your code, and send 72 what you've done to Cygnus. Then your stuff will be in the 73 next release, and you won't have to keep integrating it. 74 75 SUBSECTION 76 How the coff backend works 77 78 SUBSUBSECTION 79 File layout 80 81 The Coff backend is split into generic routines that are 82 applicable to any Coff target and routines that are specific 83 to a particular target. The target-specific routines are 84 further split into ones which are basically the same for all 85 Coff targets except that they use the external symbol format 86 or use different values for certain constants. 87 88 The generic routines are in @file{coffgen.c}. These routines 89 work for any Coff target. They use some hooks into the target 90 specific code; the hooks are in a @code{bfd_coff_backend_data} 91 structure, one of which exists for each target. 92 93 The essentially similar target-specific routines are in 94 @file{coffcode.h}. This header file includes executable C code. 95 The various Coff targets first include the appropriate Coff 96 header file, make any special defines that are needed, and 97 then include @file{coffcode.h}. 98 99 Some of the Coff targets then also have additional routines in 100 the target source file itself. 101 102 For example, @file{coff-i960.c} includes 103 @file{coff/internal.h} and @file{coff/i960.h}. It then 104 defines a few constants, such as @code{I960}, and includes 105 @file{coffcode.h}. Since the i960 has complex relocation 106 types, @file{coff-i960.c} also includes some code to 107 manipulate the i960 relocs. This code is not in 108 @file{coffcode.h} because it would not be used by any other 109 target. 110 111 SUBSUBSECTION 112 Bit twiddling 113 114 Each flavour of coff supported in BFD has its own header file 115 describing the external layout of the structures. There is also 116 an internal description of the coff layout, in 117 @file{coff/internal.h}. A major function of the 118 coff backend is swapping the bytes and twiddling the bits to 119 translate the external form of the structures into the normal 120 internal form. This is all performed in the 121 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some 122 elements are different sizes between different versions of 123 coff; it is the duty of the coff version specific include file 124 to override the definitions of various packing routines in 125 @file{coffcode.h}. E.g., the size of line number entry in coff is 126 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing 127 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the 128 correct one. No doubt, some day someone will find a version of 129 coff which has a varying field size not catered to at the 130 moment. To port BFD, that person will have to add more @code{#defines}. 131 Three of the bit twiddling routines are exported to 132 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in} 133 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol 134 table on its own, but uses BFD to fix things up. More of the 135 bit twiddlers are exported for @code{gas}; 136 @code{coff_swap_aux_out}, @code{coff_swap_sym_out}, 137 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out}, 138 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out}, 139 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track 140 of all the symbol table and reloc drudgery itself, thereby 141 saving the internal BFD overhead, but uses BFD to swap things 142 on the way out, making cross ports much safer. Doing so also 143 allows BFD (and thus the linker) to use the same header files 144 as @code{gas}, which makes one avenue to disaster disappear. 145 146 SUBSUBSECTION 147 Symbol reading 148 149 The simple canonical form for symbols used by BFD is not rich 150 enough to keep all the information available in a coff symbol 151 table. The back end gets around this problem by keeping the original 152 symbol table around, "behind the scenes". 153 154 When a symbol table is requested (through a call to 155 @code{bfd_canonicalize_symtab}), a request gets through to 156 @code{coff_get_normalized_symtab}. This reads the symbol table from 157 the coff file and swaps all the structures inside into the 158 internal form. It also fixes up all the pointers in the table 159 (represented in the file by offsets from the first symbol in 160 the table) into physical pointers to elements in the new 161 internal table. This involves some work since the meanings of 162 fields change depending upon context: a field that is a 163 pointer to another structure in the symbol table at one moment 164 may be the size in bytes of a structure at the next. Another 165 pass is made over the table. All symbols which mark file names 166 (<<C_FILE>> symbols) are modified so that the internal 167 string points to the value in the auxent (the real filename) 168 rather than the normal text associated with the symbol 169 (@code{".file"}). 170 171 At this time the symbol names are moved around. Coff stores 172 all symbols less than nine characters long physically 173 within the symbol table; longer strings are kept at the end of 174 the file in the string table. This pass moves all strings 175 into memory and replaces them with pointers to the strings. 176 177 The symbol table is massaged once again, this time to create 178 the canonical table used by the BFD application. Each symbol 179 is inspected in turn, and a decision made (using the 180 @code{sclass} field) about the various flags to set in the 181 @code{asymbol}. @xref{Symbols}. The generated canonical table 182 shares strings with the hidden internal symbol table. 183 184 Any linenumbers are read from the coff file too, and attached 185 to the symbols which own the functions the linenumbers belong to. 186 187 SUBSUBSECTION 188 Symbol writing 189 190 Writing a symbol to a coff file which didn't come from a coff 191 file will lose any debugging information. The @code{asymbol} 192 structure remembers the BFD from which the symbol was taken, and on 193 output the back end makes sure that the same destination target as 194 source target is present. 195 196 When the symbols have come from a coff file then all the 197 debugging information is preserved. 198 199 Symbol tables are provided for writing to the back end in a 200 vector of pointers to pointers. This allows applications like 201 the linker to accumulate and output large symbol tables 202 without having to do too much byte copying. 203 204 This function runs through the provided symbol table and 205 patches each symbol marked as a file place holder 206 (@code{C_FILE}) to point to the next file place holder in the 207 list. It also marks each @code{offset} field in the list with 208 the offset from the first symbol of the current symbol. 209 210 Another function of this procedure is to turn the canonical 211 value form of BFD into the form used by coff. Internally, BFD 212 expects symbol values to be offsets from a section base; so a 213 symbol physically at 0x120, but in a section starting at 214 0x100, would have the value 0x20. Coff expects symbols to 215 contain their final value, so symbols have their values 216 changed at this point to reflect their sum with their owning 217 section. This transformation uses the 218 <<output_section>> field of the @code{asymbol}'s 219 @code{asection} @xref{Sections}. 220 221 o <<coff_mangle_symbols>> 222 223 This routine runs though the provided symbol table and uses 224 the offsets generated by the previous pass and the pointers 225 generated when the symbol table was read in to create the 226 structured hierarchy required by coff. It changes each pointer 227 to a symbol into the index into the symbol table of the asymbol. 228 229 o <<coff_write_symbols>> 230 231 This routine runs through the symbol table and patches up the 232 symbols from their internal form into the coff way, calls the 233 bit twiddlers, and writes out the table to the file. 234 235 */ 236 237 /* 238 INTERNAL_DEFINITION 239 coff_symbol_type 240 241 DESCRIPTION 242 The hidden information for an <<asymbol>> is described in a 243 <<combined_entry_type>>: 244 245 CODE_FRAGMENT 246 . 247 .typedef struct coff_ptr_struct 248 .{ 249 . {* Remembers the offset from the first symbol in the file for 250 . this symbol. Generated by coff_renumber_symbols. *} 251 . unsigned int offset; 252 . 253 . {* Should the value of this symbol be renumbered. Used for 254 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *} 255 . unsigned int fix_value : 1; 256 . 257 . {* Should the tag field of this symbol be renumbered. 258 . Created by coff_pointerize_aux. *} 259 . unsigned int fix_tag : 1; 260 . 261 . {* Should the endidx field of this symbol be renumbered. 262 . Created by coff_pointerize_aux. *} 263 . unsigned int fix_end : 1; 264 . 265 . {* Should the x_csect.x_scnlen field be renumbered. 266 . Created by coff_pointerize_aux. *} 267 . unsigned int fix_scnlen : 1; 268 . 269 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the 270 . index into the line number entries. Set by coff_slurp_symbol_table. *} 271 . unsigned int fix_line : 1; 272 . 273 . {* The container for the symbol structure as read and translated 274 . from the file. *} 275 . union 276 . { 277 . union internal_auxent auxent; 278 . struct internal_syment syment; 279 . } u; 280 .} combined_entry_type; 281 . 282 . 283 .{* Each canonical asymbol really looks like this: *} 284 . 285 .typedef struct coff_symbol_struct 286 .{ 287 . {* The actual symbol which the rest of BFD works with *} 288 . asymbol symbol; 289 . 290 . {* A pointer to the hidden information for this symbol *} 291 . combined_entry_type *native; 292 . 293 . {* A pointer to the linenumber information for this symbol *} 294 . struct lineno_cache_entry *lineno; 295 . 296 . {* Have the line numbers been relocated yet ? *} 297 . bfd_boolean done_lineno; 298 .} coff_symbol_type; 299 300 */ 301 302 #ifdef COFF_WITH_PE 303 #include "peicode.h" 304 #else 305 #include "coffswap.h" 306 #endif 307 308 #define STRING_SIZE_SIZE 4 309 310 #define DOT_DEBUG ".debug" 311 #define GNU_LINKONCE_WI ".gnu.linkonce.wi." 312 313 static long sec_to_styp_flags 314 (const char *, flagword); 315 static bfd_boolean styp_to_sec_flags 316 (bfd *, void *, const char *, asection *, flagword *); 317 static bfd_boolean coff_bad_format_hook 318 (bfd *, void *); 319 static void coff_set_custom_section_alignment 320 (bfd *, asection *, const struct coff_section_alignment_entry *, 321 const unsigned int); 322 static bfd_boolean coff_new_section_hook 323 (bfd *, asection *); 324 static bfd_boolean coff_set_arch_mach_hook 325 (bfd *, void *); 326 static bfd_boolean coff_write_relocs 327 (bfd *, int); 328 static bfd_boolean coff_set_flags 329 (bfd *, unsigned int *, unsigned short *); 330 static bfd_boolean coff_set_arch_mach 331 (bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED; 332 static bfd_boolean coff_compute_section_file_positions 333 (bfd *); 334 static bfd_boolean coff_write_object_contents 335 (bfd *) ATTRIBUTE_UNUSED; 336 static bfd_boolean coff_set_section_contents 337 (bfd *, asection *, const void *, file_ptr, bfd_size_type); 338 static void * buy_and_read 339 (bfd *, file_ptr, bfd_size_type); 340 static bfd_boolean coff_slurp_line_table 341 (bfd *, asection *); 342 static bfd_boolean coff_slurp_symbol_table 343 (bfd *); 344 static enum coff_symbol_classification coff_classify_symbol 345 (bfd *, struct internal_syment *); 346 static bfd_boolean coff_slurp_reloc_table 347 (bfd *, asection *, asymbol **); 348 static long coff_canonicalize_reloc 349 (bfd *, asection *, arelent **, asymbol **); 350 #ifndef coff_mkobject_hook 351 static void * coff_mkobject_hook 352 (bfd *, void *, void *); 353 #endif 354 #ifdef COFF_WITH_PE 355 static flagword handle_COMDAT 356 (bfd *, flagword, void *, const char *, asection *); 357 #endif 358 #ifdef COFF_IMAGE_WITH_PE 359 static bfd_boolean coff_read_word 360 (bfd *, unsigned int *); 361 static unsigned int coff_compute_checksum 362 (bfd *); 363 static bfd_boolean coff_apply_checksum 364 (bfd *); 365 #endif 366 #ifdef TICOFF 367 static bfd_boolean ticoff0_bad_format_hook 368 (bfd *, void * ); 369 static bfd_boolean ticoff1_bad_format_hook 370 (bfd *, void * ); 371 #endif 372 373 /* void warning(); */ 374 375 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent 376 the incoming SEC_* flags. The inverse of this function is 377 styp_to_sec_flags(). NOTE: If you add to/change this routine, you 378 should probably mirror the changes in styp_to_sec_flags(). */ 379 380 #ifndef COFF_WITH_PE 381 382 /* Macros for setting debugging flags. */ 383 384 #ifdef STYP_DEBUG 385 #define STYP_XCOFF_DEBUG STYP_DEBUG 386 #else 387 #define STYP_XCOFF_DEBUG STYP_INFO 388 #endif 389 390 #ifdef COFF_ALIGN_IN_S_FLAGS 391 #define STYP_DEBUG_INFO STYP_DSECT 392 #else 393 #define STYP_DEBUG_INFO STYP_INFO 394 #endif 395 396 static long 397 sec_to_styp_flags (const char *sec_name, flagword sec_flags) 398 { 399 long styp_flags = 0; 400 401 if (!strcmp (sec_name, _TEXT)) 402 { 403 styp_flags = STYP_TEXT; 404 } 405 else if (!strcmp (sec_name, _DATA)) 406 { 407 styp_flags = STYP_DATA; 408 } 409 else if (!strcmp (sec_name, _BSS)) 410 { 411 styp_flags = STYP_BSS; 412 #ifdef _COMMENT 413 } 414 else if (!strcmp (sec_name, _COMMENT)) 415 { 416 styp_flags = STYP_INFO; 417 #endif /* _COMMENT */ 418 #ifdef _LIB 419 } 420 else if (!strcmp (sec_name, _LIB)) 421 { 422 styp_flags = STYP_LIB; 423 #endif /* _LIB */ 424 #ifdef _LIT 425 } 426 else if (!strcmp (sec_name, _LIT)) 427 { 428 styp_flags = STYP_LIT; 429 #endif /* _LIT */ 430 } 431 else if (CONST_STRNEQ (sec_name, DOT_DEBUG)) 432 { 433 /* Handle the XCOFF debug section and DWARF2 debug sections. */ 434 if (!sec_name[6]) 435 styp_flags = STYP_XCOFF_DEBUG; 436 else 437 styp_flags = STYP_DEBUG_INFO; 438 } 439 else if (CONST_STRNEQ (sec_name, ".stab")) 440 { 441 styp_flags = STYP_DEBUG_INFO; 442 } 443 #ifdef COFF_LONG_SECTION_NAMES 444 else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)) 445 { 446 styp_flags = STYP_DEBUG_INFO; 447 } 448 #endif 449 #ifdef RS6000COFF_C 450 else if (!strcmp (sec_name, _PAD)) 451 { 452 styp_flags = STYP_PAD; 453 } 454 else if (!strcmp (sec_name, _LOADER)) 455 { 456 styp_flags = STYP_LOADER; 457 } 458 else if (!strcmp (sec_name, _EXCEPT)) 459 { 460 styp_flags = STYP_EXCEPT; 461 } 462 else if (!strcmp (sec_name, _TYPCHK)) 463 { 464 styp_flags = STYP_TYPCHK; 465 } 466 #endif 467 /* Try and figure out what it should be */ 468 else if (sec_flags & SEC_CODE) 469 { 470 styp_flags = STYP_TEXT; 471 } 472 else if (sec_flags & SEC_DATA) 473 { 474 styp_flags = STYP_DATA; 475 } 476 else if (sec_flags & SEC_READONLY) 477 { 478 #ifdef STYP_LIT /* 29k readonly text/data section */ 479 styp_flags = STYP_LIT; 480 #else 481 styp_flags = STYP_TEXT; 482 #endif /* STYP_LIT */ 483 } 484 else if (sec_flags & SEC_LOAD) 485 { 486 styp_flags = STYP_TEXT; 487 } 488 else if (sec_flags & SEC_ALLOC) 489 { 490 styp_flags = STYP_BSS; 491 } 492 493 #ifdef STYP_CLINK 494 if (sec_flags & SEC_TIC54X_CLINK) 495 styp_flags |= STYP_CLINK; 496 #endif 497 498 #ifdef STYP_BLOCK 499 if (sec_flags & SEC_TIC54X_BLOCK) 500 styp_flags |= STYP_BLOCK; 501 #endif 502 503 #ifdef STYP_NOLOAD 504 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0) 505 styp_flags |= STYP_NOLOAD; 506 #endif 507 508 return styp_flags; 509 } 510 511 #else /* COFF_WITH_PE */ 512 513 /* The PE version; see above for the general comments. The non-PE 514 case seems to be more guessing, and breaks PE format; specifically, 515 .rdata is readonly, but it sure ain't text. Really, all this 516 should be set up properly in gas (or whatever assembler is in use), 517 and honor whatever objcopy/strip, etc. sent us as input. */ 518 519 static long 520 sec_to_styp_flags (const char *sec_name, flagword sec_flags) 521 { 522 long styp_flags = 0; 523 524 /* caution: there are at least three groups of symbols that have 525 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*. 526 SEC_* are the BFD internal flags, used for generic BFD 527 information. STYP_* are the COFF section flags which appear in 528 COFF files. IMAGE_SCN_* are the PE section flags which appear in 529 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap, 530 but there are more IMAGE_SCN_* flags. */ 531 532 /* FIXME: There is no gas syntax to specify the debug section flag. */ 533 if (CONST_STRNEQ (sec_name, DOT_DEBUG) 534 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI)) 535 sec_flags = SEC_DEBUGGING; 536 537 /* skip LOAD */ 538 /* READONLY later */ 539 /* skip RELOC */ 540 if ((sec_flags & SEC_CODE) != 0) 541 styp_flags |= IMAGE_SCN_CNT_CODE; 542 if ((sec_flags & SEC_DATA) != 0) 543 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA; 544 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0) 545 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */ 546 /* skip ROM */ 547 /* skip constRUCTOR */ 548 /* skip CONTENTS */ 549 if ((sec_flags & SEC_IS_COMMON) != 0) 550 styp_flags |= IMAGE_SCN_LNK_COMDAT; 551 if ((sec_flags & SEC_DEBUGGING) != 0) 552 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE; 553 if ((sec_flags & SEC_EXCLUDE) != 0) 554 styp_flags |= IMAGE_SCN_LNK_REMOVE; 555 if ((sec_flags & SEC_NEVER_LOAD) != 0) 556 styp_flags |= IMAGE_SCN_LNK_REMOVE; 557 /* skip IN_MEMORY */ 558 /* skip SORT */ 559 if (sec_flags & SEC_LINK_ONCE) 560 styp_flags |= IMAGE_SCN_LNK_COMDAT; 561 /* skip LINK_DUPLICATES */ 562 /* skip LINKER_CREATED */ 563 564 if (sec_flags & (SEC_ALLOC | SEC_LOAD)) 565 { 566 /* For now, the read/write bits are mapped onto SEC_READONLY, even 567 though the semantics don't quite match. The bits from the input 568 are retained in pei_section_data(abfd, section)->pe_flags. */ 569 styp_flags |= IMAGE_SCN_MEM_READ; /* Always readable. */ 570 if ((sec_flags & SEC_READONLY) == 0) 571 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */ 572 if (sec_flags & SEC_CODE) 573 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */ 574 if (sec_flags & SEC_COFF_SHARED) 575 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */ 576 } 577 578 return styp_flags; 579 } 580 581 #endif /* COFF_WITH_PE */ 582 583 /* Return a word with SEC_* flags set to represent the incoming STYP_* 584 flags (from scnhdr.s_flags). The inverse of this function is 585 sec_to_styp_flags(). NOTE: If you add to/change this routine, you 586 should probably mirror the changes in sec_to_styp_flags(). */ 587 588 #ifndef COFF_WITH_PE 589 590 static bfd_boolean 591 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, 592 void * hdr, 593 const char *name, 594 asection *section ATTRIBUTE_UNUSED, 595 flagword *flags_ptr) 596 { 597 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 598 long styp_flags = internal_s->s_flags; 599 flagword sec_flags = 0; 600 601 #ifdef STYP_BLOCK 602 if (styp_flags & STYP_BLOCK) 603 sec_flags |= SEC_TIC54X_BLOCK; 604 #endif 605 606 #ifdef STYP_CLINK 607 if (styp_flags & STYP_CLINK) 608 sec_flags |= SEC_TIC54X_CLINK; 609 #endif 610 611 #ifdef STYP_NOLOAD 612 if (styp_flags & STYP_NOLOAD) 613 sec_flags |= SEC_NEVER_LOAD; 614 #endif /* STYP_NOLOAD */ 615 616 /* For 386 COFF, at least, an unloadable text or data section is 617 actually a shared library section. */ 618 if (styp_flags & STYP_TEXT) 619 { 620 if (sec_flags & SEC_NEVER_LOAD) 621 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 622 else 623 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 624 } 625 else if (styp_flags & STYP_DATA) 626 { 627 if (sec_flags & SEC_NEVER_LOAD) 628 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 629 else 630 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 631 } 632 else if (styp_flags & STYP_BSS) 633 { 634 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 635 if (sec_flags & SEC_NEVER_LOAD) 636 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 637 else 638 #endif 639 sec_flags |= SEC_ALLOC; 640 } 641 else if (styp_flags & STYP_INFO) 642 { 643 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is 644 defined. coff_compute_section_file_positions uses 645 COFF_PAGE_SIZE to ensure that the low order bits of the 646 section VMA and the file offset match. If we don't know 647 COFF_PAGE_SIZE, we can't ensure the correct correspondence, 648 and demand page loading of the file will fail. */ 649 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS) 650 sec_flags |= SEC_DEBUGGING; 651 #endif 652 } 653 else if (styp_flags & STYP_PAD) 654 sec_flags = 0; 655 else if (strcmp (name, _TEXT) == 0) 656 { 657 if (sec_flags & SEC_NEVER_LOAD) 658 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 659 else 660 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 661 } 662 else if (strcmp (name, _DATA) == 0) 663 { 664 if (sec_flags & SEC_NEVER_LOAD) 665 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 666 else 667 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 668 } 669 else if (strcmp (name, _BSS) == 0) 670 { 671 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 672 if (sec_flags & SEC_NEVER_LOAD) 673 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 674 else 675 #endif 676 sec_flags |= SEC_ALLOC; 677 } 678 else if (CONST_STRNEQ (name, DOT_DEBUG) 679 #ifdef _COMMENT 680 || strcmp (name, _COMMENT) == 0 681 #endif 682 #ifdef COFF_LONG_SECTION_NAMES 683 || CONST_STRNEQ (name, GNU_LINKONCE_WI) 684 #endif 685 || CONST_STRNEQ (name, ".stab")) 686 { 687 #ifdef COFF_PAGE_SIZE 688 sec_flags |= SEC_DEBUGGING; 689 #endif 690 } 691 #ifdef _LIB 692 else if (strcmp (name, _LIB) == 0) 693 ; 694 #endif 695 #ifdef _LIT 696 else if (strcmp (name, _LIT) == 0) 697 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY; 698 #endif 699 else 700 sec_flags |= SEC_ALLOC | SEC_LOAD; 701 702 #ifdef STYP_LIT /* A29k readonly text/data section type. */ 703 if ((styp_flags & STYP_LIT) == STYP_LIT) 704 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY); 705 #endif /* STYP_LIT */ 706 707 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */ 708 if (styp_flags & STYP_OTHER_LOAD) 709 sec_flags = (SEC_LOAD | SEC_ALLOC); 710 #endif /* STYP_SDATA */ 711 712 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) 713 /* As a GNU extension, if the name begins with .gnu.linkonce, we 714 only link a single copy of the section. This is used to support 715 g++. g++ will emit each template expansion in its own section. 716 The symbols will be defined as weak, so that multiple definitions 717 are permitted. The GNU linker extension is to actually discard 718 all but one of the sections. */ 719 if (CONST_STRNEQ (name, ".gnu.linkonce")) 720 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 721 #endif 722 723 if (flags_ptr == NULL) 724 return FALSE; 725 726 * flags_ptr = sec_flags; 727 return TRUE; 728 } 729 730 #else /* COFF_WITH_PE */ 731 732 static flagword 733 handle_COMDAT (bfd * abfd, 734 flagword sec_flags, 735 void * hdr, 736 const char *name, 737 asection *section) 738 { 739 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 740 bfd_byte *esymstart, *esym, *esymend; 741 int seen_state = 0; 742 char *target_name = NULL; 743 744 sec_flags |= SEC_LINK_ONCE; 745 746 /* Unfortunately, the PE format stores essential information in 747 the symbol table, of all places. We need to extract that 748 information now, so that objdump and the linker will know how 749 to handle the section without worrying about the symbols. We 750 can't call slurp_symtab, because the linker doesn't want the 751 swapped symbols. */ 752 753 /* COMDAT sections are special. The first symbol is the section 754 symbol, which tells what kind of COMDAT section it is. The 755 second symbol is the "comdat symbol" - the one with the 756 unique name. GNU uses the section symbol for the unique 757 name; MS uses ".text" for every comdat section. Sigh. - DJ */ 758 759 /* This is not mirrored in sec_to_styp_flags(), but there 760 doesn't seem to be a need to, either, and it would at best be 761 rather messy. */ 762 763 if (! _bfd_coff_get_external_symbols (abfd)) 764 return sec_flags; 765 766 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd); 767 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); 768 769 while (esym < esymend) 770 { 771 struct internal_syment isym; 772 char buf[SYMNMLEN + 1]; 773 const char *symname; 774 775 bfd_coff_swap_sym_in (abfd, esym, & isym); 776 777 if (sizeof (internal_s->s_name) > SYMNMLEN) 778 { 779 /* This case implies that the matching 780 symbol name will be in the string table. */ 781 abort (); 782 } 783 784 if (isym.n_scnum == section->target_index) 785 { 786 /* According to the MSVC documentation, the first 787 TWO entries with the section # are both of 788 interest to us. The first one is the "section 789 symbol" (section name). The second is the comdat 790 symbol name. Here, we've found the first 791 qualifying entry; we distinguish it from the 792 second with a state flag. 793 794 In the case of gas-generated (at least until that 795 is fixed) .o files, it isn't necessarily the 796 second one. It may be some other later symbol. 797 798 Since gas also doesn't follow MS conventions and 799 emits the section similar to .text$<name>, where 800 <something> is the name we're looking for, we 801 distinguish the two as follows: 802 803 If the section name is simply a section name (no 804 $) we presume it's MS-generated, and look at 805 precisely the second symbol for the comdat name. 806 If the section name has a $, we assume it's 807 gas-generated, and look for <something> (whatever 808 follows the $) as the comdat symbol. */ 809 810 /* All 3 branches use this. */ 811 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf); 812 813 if (symname == NULL) 814 abort (); 815 816 switch (seen_state) 817 { 818 case 0: 819 { 820 /* The first time we've seen the symbol. */ 821 union internal_auxent aux; 822 823 /* If it isn't the stuff we're expecting, die; 824 The MS documentation is vague, but it 825 appears that the second entry serves BOTH 826 as the comdat symbol and the defining 827 symbol record (either C_STAT or C_EXT, 828 possibly with an aux entry with debug 829 information if it's a function.) It 830 appears the only way to find the second one 831 is to count. (On Intel, they appear to be 832 adjacent, but on Alpha, they have been 833 found separated.) 834 835 Here, we think we've found the first one, 836 but there's some checking we can do to be 837 sure. */ 838 839 if (! (isym.n_sclass == C_STAT 840 && isym.n_type == T_NULL 841 && isym.n_value == 0)) 842 abort (); 843 844 /* FIXME LATER: MSVC generates section names 845 like .text for comdats. Gas generates 846 names like .text$foo__Fv (in the case of a 847 function). See comment above for more. */ 848 849 if (strcmp (name, symname) != 0) 850 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"), 851 abfd, symname, name); 852 853 seen_state = 1; 854 855 /* This is the section symbol. */ 856 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)), 857 isym.n_type, isym.n_sclass, 858 0, isym.n_numaux, & aux); 859 860 target_name = strchr (name, '$'); 861 if (target_name != NULL) 862 { 863 /* Gas mode. */ 864 seen_state = 2; 865 /* Skip the `$'. */ 866 target_name += 1; 867 } 868 869 /* FIXME: Microsoft uses NODUPLICATES and 870 ASSOCIATIVE, but gnu uses ANY and 871 SAME_SIZE. Unfortunately, gnu doesn't do 872 the comdat symbols right. So, until we can 873 fix it to do the right thing, we are 874 temporarily disabling comdats for the MS 875 types (they're used in DLLs and C++, but we 876 don't support *their* C++ libraries anyway 877 - DJ. */ 878 879 /* Cygwin does not follow the MS style, and 880 uses ANY and SAME_SIZE where NODUPLICATES 881 and ASSOCIATIVE should be used. For 882 Interix, we just do the right thing up 883 front. */ 884 885 switch (aux.x_scn.x_comdat) 886 { 887 case IMAGE_COMDAT_SELECT_NODUPLICATES: 888 #ifdef STRICT_PE_FORMAT 889 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY; 890 #else 891 sec_flags &= ~SEC_LINK_ONCE; 892 #endif 893 break; 894 895 case IMAGE_COMDAT_SELECT_ANY: 896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 897 break; 898 899 case IMAGE_COMDAT_SELECT_SAME_SIZE: 900 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE; 901 break; 902 903 case IMAGE_COMDAT_SELECT_EXACT_MATCH: 904 /* Not yet fully implemented ??? */ 905 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; 906 break; 907 908 /* debug$S gets this case; other 909 implications ??? */ 910 911 /* There may be no symbol... we'll search 912 the whole table... Is this the right 913 place to play this game? Or should we do 914 it when reading it in. */ 915 case IMAGE_COMDAT_SELECT_ASSOCIATIVE: 916 #ifdef STRICT_PE_FORMAT 917 /* FIXME: This is not currently implemented. */ 918 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 919 #else 920 sec_flags &= ~SEC_LINK_ONCE; 921 #endif 922 break; 923 924 default: /* 0 means "no symbol" */ 925 /* debug$F gets this case; other 926 implications ??? */ 927 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 928 break; 929 } 930 } 931 break; 932 933 case 2: 934 /* Gas mode: the first matching on partial name. */ 935 936 #ifndef TARGET_UNDERSCORE 937 #define TARGET_UNDERSCORE 0 938 #endif 939 /* Is this the name we're looking for ? */ 940 if (strcmp (target_name, 941 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0) 942 { 943 /* Not the name we're looking for */ 944 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); 945 continue; 946 } 947 /* Fall through. */ 948 case 1: 949 /* MSVC mode: the lexically second symbol (or 950 drop through from the above). */ 951 { 952 char *newname; 953 bfd_size_type amt; 954 955 /* This must the second symbol with the 956 section #. It is the actual symbol name. 957 Intel puts the two adjacent, but Alpha (at 958 least) spreads them out. */ 959 960 amt = sizeof (struct coff_comdat_info); 961 coff_section_data (abfd, section)->comdat 962 = bfd_alloc (abfd, amt); 963 if (coff_section_data (abfd, section)->comdat == NULL) 964 abort (); 965 966 coff_section_data (abfd, section)->comdat->symbol = 967 (esym - esymstart) / bfd_coff_symesz (abfd); 968 969 amt = strlen (symname) + 1; 970 newname = bfd_alloc (abfd, amt); 971 if (newname == NULL) 972 abort (); 973 974 strcpy (newname, symname); 975 coff_section_data (abfd, section)->comdat->name 976 = newname; 977 } 978 979 goto breakloop; 980 } 981 } 982 983 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); 984 } 985 986 breakloop: 987 return sec_flags; 988 } 989 990 991 /* The PE version; see above for the general comments. 992 993 Since to set the SEC_LINK_ONCE and associated flags, we have to 994 look at the symbol table anyway, we return the symbol table index 995 of the symbol being used as the COMDAT symbol. This is admittedly 996 ugly, but there's really nowhere else that we have access to the 997 required information. FIXME: Is the COMDAT symbol index used for 998 any purpose other than objdump? */ 999 1000 static bfd_boolean 1001 styp_to_sec_flags (bfd *abfd, 1002 void * hdr, 1003 const char *name, 1004 asection *section, 1005 flagword *flags_ptr) 1006 { 1007 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 1008 long styp_flags = internal_s->s_flags; 1009 flagword sec_flags; 1010 bfd_boolean result = TRUE; 1011 1012 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */ 1013 sec_flags = SEC_READONLY; 1014 1015 /* Process each flag bit in styp_flags in turn. */ 1016 while (styp_flags) 1017 { 1018 long flag = styp_flags & - styp_flags; 1019 char * unhandled = NULL; 1020 1021 styp_flags &= ~ flag; 1022 1023 /* We infer from the distinct read/write/execute bits the settings 1024 of some of the bfd flags; the actual values, should we need them, 1025 are also in pei_section_data (abfd, section)->pe_flags. */ 1026 1027 switch (flag) 1028 { 1029 case STYP_DSECT: 1030 unhandled = "STYP_DSECT"; 1031 break; 1032 case STYP_GROUP: 1033 unhandled = "STYP_GROUP"; 1034 break; 1035 case STYP_COPY: 1036 unhandled = "STYP_COPY"; 1037 break; 1038 case STYP_OVER: 1039 unhandled = "STYP_OVER"; 1040 break; 1041 #ifdef SEC_NEVER_LOAD 1042 case STYP_NOLOAD: 1043 sec_flags |= SEC_NEVER_LOAD; 1044 break; 1045 #endif 1046 case IMAGE_SCN_MEM_READ: 1047 /* Ignored, assume it always to be true. */ 1048 break; 1049 case IMAGE_SCN_TYPE_NO_PAD: 1050 /* Skip. */ 1051 break; 1052 case IMAGE_SCN_LNK_OTHER: 1053 unhandled = "IMAGE_SCN_LNK_OTHER"; 1054 break; 1055 case IMAGE_SCN_MEM_NOT_CACHED: 1056 unhandled = "IMAGE_SCN_MEM_NOT_CACHED"; 1057 break; 1058 case IMAGE_SCN_MEM_NOT_PAGED: 1059 /* Generate a warning message rather using the 'unhandled' 1060 variable as this will allow some .sys files generate by 1061 other toolchains to be processed. See bugzilla issue 196. */ 1062 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"), 1063 abfd, name); 1064 break; 1065 case IMAGE_SCN_MEM_EXECUTE: 1066 sec_flags |= SEC_CODE; 1067 break; 1068 case IMAGE_SCN_MEM_WRITE: 1069 sec_flags &= ~ SEC_READONLY; 1070 break; 1071 case IMAGE_SCN_MEM_DISCARDABLE: 1072 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections 1073 but we do not want them to be labelled as debug section, since 1074 then strip would remove them. */ 1075 if (! CONST_STRNEQ (name, ".reloc")) 1076 sec_flags |= SEC_DEBUGGING; 1077 break; 1078 case IMAGE_SCN_MEM_SHARED: 1079 sec_flags |= SEC_COFF_SHARED; 1080 break; 1081 case IMAGE_SCN_LNK_REMOVE: 1082 sec_flags |= SEC_EXCLUDE; 1083 break; 1084 case IMAGE_SCN_CNT_CODE: 1085 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD; 1086 break; 1087 case IMAGE_SCN_CNT_INITIALIZED_DATA: 1088 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD; 1089 break; 1090 case IMAGE_SCN_CNT_UNINITIALIZED_DATA: 1091 sec_flags |= SEC_ALLOC; 1092 break; 1093 case IMAGE_SCN_LNK_INFO: 1094 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is 1095 defined. coff_compute_section_file_positions uses 1096 COFF_PAGE_SIZE to ensure that the low order bits of the 1097 section VMA and the file offset match. If we don't know 1098 COFF_PAGE_SIZE, we can't ensure the correct correspondence, 1099 and demand page loading of the file will fail. */ 1100 #ifdef COFF_PAGE_SIZE 1101 sec_flags |= SEC_DEBUGGING; 1102 #endif 1103 break; 1104 case IMAGE_SCN_LNK_COMDAT: 1105 /* COMDAT gets very special treatment. */ 1106 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section); 1107 break; 1108 default: 1109 /* Silently ignore for now. */ 1110 break; 1111 } 1112 1113 /* If the section flag was not handled, report it here. */ 1114 if (unhandled != NULL) 1115 { 1116 (*_bfd_error_handler) 1117 (_("%B (%s): Section flag %s (0x%x) ignored"), 1118 abfd, name, unhandled, flag); 1119 result = FALSE; 1120 } 1121 } 1122 1123 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) 1124 /* As a GNU extension, if the name begins with .gnu.linkonce, we 1125 only link a single copy of the section. This is used to support 1126 g++. g++ will emit each template expansion in its own section. 1127 The symbols will be defined as weak, so that multiple definitions 1128 are permitted. The GNU linker extension is to actually discard 1129 all but one of the sections. */ 1130 if (CONST_STRNEQ (name, ".gnu.linkonce")) 1131 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 1132 #endif 1133 1134 if (flags_ptr) 1135 * flags_ptr = sec_flags; 1136 1137 return result; 1138 } 1139 1140 #endif /* COFF_WITH_PE */ 1141 1142 #define get_index(symbol) ((symbol)->udata.i) 1143 1144 /* 1145 INTERNAL_DEFINITION 1146 bfd_coff_backend_data 1147 1148 CODE_FRAGMENT 1149 1150 .{* COFF symbol classifications. *} 1151 . 1152 .enum coff_symbol_classification 1153 .{ 1154 . {* Global symbol. *} 1155 . COFF_SYMBOL_GLOBAL, 1156 . {* Common symbol. *} 1157 . COFF_SYMBOL_COMMON, 1158 . {* Undefined symbol. *} 1159 . COFF_SYMBOL_UNDEFINED, 1160 . {* Local symbol. *} 1161 . COFF_SYMBOL_LOCAL, 1162 . {* PE section symbol. *} 1163 . COFF_SYMBOL_PE_SECTION 1164 .}; 1165 . 1166 Special entry points for gdb to swap in coff symbol table parts: 1167 .typedef struct 1168 .{ 1169 . void (*_bfd_coff_swap_aux_in) 1170 . (bfd *, void *, int, int, int, int, void *); 1171 . 1172 . void (*_bfd_coff_swap_sym_in) 1173 . (bfd *, void *, void *); 1174 . 1175 . void (*_bfd_coff_swap_lineno_in) 1176 . (bfd *, void *, void *); 1177 . 1178 . unsigned int (*_bfd_coff_swap_aux_out) 1179 . (bfd *, void *, int, int, int, int, void *); 1180 . 1181 . unsigned int (*_bfd_coff_swap_sym_out) 1182 . (bfd *, void *, void *); 1183 . 1184 . unsigned int (*_bfd_coff_swap_lineno_out) 1185 . (bfd *, void *, void *); 1186 . 1187 . unsigned int (*_bfd_coff_swap_reloc_out) 1188 . (bfd *, void *, void *); 1189 . 1190 . unsigned int (*_bfd_coff_swap_filehdr_out) 1191 . (bfd *, void *, void *); 1192 . 1193 . unsigned int (*_bfd_coff_swap_aouthdr_out) 1194 . (bfd *, void *, void *); 1195 . 1196 . unsigned int (*_bfd_coff_swap_scnhdr_out) 1197 . (bfd *, void *, void *); 1198 . 1199 . unsigned int _bfd_filhsz; 1200 . unsigned int _bfd_aoutsz; 1201 . unsigned int _bfd_scnhsz; 1202 . unsigned int _bfd_symesz; 1203 . unsigned int _bfd_auxesz; 1204 . unsigned int _bfd_relsz; 1205 . unsigned int _bfd_linesz; 1206 . unsigned int _bfd_filnmlen; 1207 . bfd_boolean _bfd_coff_long_filenames; 1208 . bfd_boolean _bfd_coff_long_section_names; 1209 . unsigned int _bfd_coff_default_section_alignment_power; 1210 . bfd_boolean _bfd_coff_force_symnames_in_strings; 1211 . unsigned int _bfd_coff_debug_string_prefix_length; 1212 . 1213 . void (*_bfd_coff_swap_filehdr_in) 1214 . (bfd *, void *, void *); 1215 . 1216 . void (*_bfd_coff_swap_aouthdr_in) 1217 . (bfd *, void *, void *); 1218 . 1219 . void (*_bfd_coff_swap_scnhdr_in) 1220 . (bfd *, void *, void *); 1221 . 1222 . void (*_bfd_coff_swap_reloc_in) 1223 . (bfd *abfd, void *, void *); 1224 . 1225 . bfd_boolean (*_bfd_coff_bad_format_hook) 1226 . (bfd *, void *); 1227 . 1228 . bfd_boolean (*_bfd_coff_set_arch_mach_hook) 1229 . (bfd *, void *); 1230 . 1231 . void * (*_bfd_coff_mkobject_hook) 1232 . (bfd *, void *, void *); 1233 . 1234 . bfd_boolean (*_bfd_styp_to_sec_flags_hook) 1235 . (bfd *, void *, const char *, asection *, flagword *); 1236 . 1237 . void (*_bfd_set_alignment_hook) 1238 . (bfd *, asection *, void *); 1239 . 1240 . bfd_boolean (*_bfd_coff_slurp_symbol_table) 1241 . (bfd *); 1242 . 1243 . bfd_boolean (*_bfd_coff_symname_in_debug) 1244 . (bfd *, struct internal_syment *); 1245 . 1246 . bfd_boolean (*_bfd_coff_pointerize_aux_hook) 1247 . (bfd *, combined_entry_type *, combined_entry_type *, 1248 . unsigned int, combined_entry_type *); 1249 . 1250 . bfd_boolean (*_bfd_coff_print_aux) 1251 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *, 1252 . combined_entry_type *, unsigned int); 1253 . 1254 . void (*_bfd_coff_reloc16_extra_cases) 1255 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 1256 . bfd_byte *, unsigned int *, unsigned int *); 1257 . 1258 . int (*_bfd_coff_reloc16_estimate) 1259 . (bfd *, asection *, arelent *, unsigned int, 1260 . struct bfd_link_info *); 1261 . 1262 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) 1263 . (bfd *, struct internal_syment *); 1264 . 1265 . bfd_boolean (*_bfd_coff_compute_section_file_positions) 1266 . (bfd *); 1267 . 1268 . bfd_boolean (*_bfd_coff_start_final_link) 1269 . (bfd *, struct bfd_link_info *); 1270 . 1271 . bfd_boolean (*_bfd_coff_relocate_section) 1272 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 1273 . struct internal_reloc *, struct internal_syment *, asection **); 1274 . 1275 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) 1276 . (bfd *, asection *, struct internal_reloc *, 1277 . struct coff_link_hash_entry *, struct internal_syment *, 1278 . bfd_vma *); 1279 . 1280 . bfd_boolean (*_bfd_coff_adjust_symndx) 1281 . (bfd *, struct bfd_link_info *, bfd *, asection *, 1282 . struct internal_reloc *, bfd_boolean *); 1283 . 1284 . bfd_boolean (*_bfd_coff_link_add_one_symbol) 1285 . (struct bfd_link_info *, bfd *, const char *, flagword, 1286 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean, 1287 . struct bfd_link_hash_entry **); 1288 . 1289 . bfd_boolean (*_bfd_coff_link_output_has_begun) 1290 . (bfd *, struct coff_final_link_info *); 1291 . 1292 . bfd_boolean (*_bfd_coff_final_link_postscript) 1293 . (bfd *, struct coff_final_link_info *); 1294 . 1295 . bfd_boolean (*_bfd_coff_print_pdata) 1296 . (bfd *, void *); 1297 . 1298 .} bfd_coff_backend_data; 1299 . 1300 .#define coff_backend_info(abfd) \ 1301 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) 1302 . 1303 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ 1304 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) 1305 . 1306 .#define bfd_coff_swap_sym_in(a,e,i) \ 1307 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) 1308 . 1309 .#define bfd_coff_swap_lineno_in(a,e,i) \ 1310 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) 1311 . 1312 .#define bfd_coff_swap_reloc_out(abfd, i, o) \ 1313 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) 1314 . 1315 .#define bfd_coff_swap_lineno_out(abfd, i, o) \ 1316 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) 1317 . 1318 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ 1319 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) 1320 . 1321 .#define bfd_coff_swap_sym_out(abfd, i,o) \ 1322 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) 1323 . 1324 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ 1325 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) 1326 . 1327 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \ 1328 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) 1329 . 1330 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ 1331 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) 1332 . 1333 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) 1334 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) 1335 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) 1336 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) 1337 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) 1338 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) 1339 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) 1340 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) 1341 .#define bfd_coff_long_filenames(abfd) \ 1342 . (coff_backend_info (abfd)->_bfd_coff_long_filenames) 1343 .#define bfd_coff_long_section_names(abfd) \ 1344 . (coff_backend_info (abfd)->_bfd_coff_long_section_names) 1345 .#define bfd_coff_default_section_alignment_power(abfd) \ 1346 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) 1347 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \ 1348 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) 1349 . 1350 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ 1351 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) 1352 . 1353 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ 1354 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) 1355 . 1356 .#define bfd_coff_swap_reloc_in(abfd, i, o) \ 1357 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) 1358 . 1359 .#define bfd_coff_bad_format_hook(abfd, filehdr) \ 1360 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) 1361 . 1362 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ 1363 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) 1364 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ 1365 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\ 1366 . (abfd, filehdr, aouthdr)) 1367 . 1368 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\ 1369 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ 1370 . (abfd, scnhdr, name, section, flags_ptr)) 1371 . 1372 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ 1373 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) 1374 . 1375 .#define bfd_coff_slurp_symbol_table(abfd)\ 1376 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) 1377 . 1378 .#define bfd_coff_symname_in_debug(abfd, sym)\ 1379 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) 1380 . 1381 .#define bfd_coff_force_symnames_in_strings(abfd)\ 1382 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) 1383 . 1384 .#define bfd_coff_debug_string_prefix_length(abfd)\ 1385 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) 1386 . 1387 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ 1388 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ 1389 . (abfd, file, base, symbol, aux, indaux)) 1390 . 1391 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\ 1392 . reloc, data, src_ptr, dst_ptr)\ 1393 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ 1394 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) 1395 . 1396 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ 1397 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ 1398 . (abfd, section, reloc, shrink, link_info)) 1399 . 1400 .#define bfd_coff_classify_symbol(abfd, sym)\ 1401 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ 1402 . (abfd, sym)) 1403 . 1404 .#define bfd_coff_compute_section_file_positions(abfd)\ 1405 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ 1406 . (abfd)) 1407 . 1408 .#define bfd_coff_start_final_link(obfd, info)\ 1409 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ 1410 . (obfd, info)) 1411 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ 1412 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ 1413 . (obfd, info, ibfd, o, con, rel, isyms, secs)) 1414 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ 1415 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ 1416 . (abfd, sec, rel, h, sym, addendp)) 1417 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ 1418 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ 1419 . (obfd, info, ibfd, sec, rel, adjustedp)) 1420 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\ 1421 . value, string, cp, coll, hashp)\ 1422 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ 1423 . (info, abfd, name, flags, section, value, string, cp, coll, hashp)) 1424 . 1425 .#define bfd_coff_link_output_has_begun(a,p) \ 1426 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p)) 1427 .#define bfd_coff_final_link_postscript(a,p) \ 1428 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p)) 1429 . 1430 .#define bfd_coff_have_print_pdata(a) \ 1431 . (coff_backend_info (a)->_bfd_coff_print_pdata) 1432 .#define bfd_coff_print_pdata(a,p) \ 1433 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p)) 1434 . 1435 */ 1436 1437 /* See whether the magic number matches. */ 1438 1439 static bfd_boolean 1440 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr) 1441 { 1442 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1443 1444 if (BADMAG (*internal_f)) 1445 return FALSE; 1446 1447 /* If the optional header is NULL or not the correct size then 1448 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) 1449 and Intel 960 readwrite headers (I960WRMAGIC) is that the 1450 optional header is of a different size. 1451 1452 But the mips keeps extra stuff in it's opthdr, so dont check 1453 when doing that. */ 1454 1455 #if defined(M88) || defined(I960) 1456 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr) 1457 return FALSE; 1458 #endif 1459 1460 return TRUE; 1461 } 1462 1463 #ifdef TICOFF 1464 static bfd_boolean 1465 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr) 1466 { 1467 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1468 1469 if (COFF0_BADMAG (*internal_f)) 1470 return FALSE; 1471 1472 return TRUE; 1473 } 1474 #endif 1475 1476 #ifdef TICOFF 1477 static bfd_boolean 1478 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr) 1479 { 1480 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1481 1482 if (COFF1_BADMAG (*internal_f)) 1483 return FALSE; 1484 1485 return TRUE; 1486 } 1487 #endif 1488 1489 /* Check whether this section uses an alignment other than the 1490 default. */ 1491 1492 static void 1493 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED, 1494 asection *section, 1495 const struct coff_section_alignment_entry *alignment_table, 1496 const unsigned int table_size) 1497 { 1498 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; 1499 unsigned int i; 1500 1501 for (i = 0; i < table_size; ++i) 1502 { 1503 const char *secname = bfd_get_section_name (abfd, section); 1504 1505 if (alignment_table[i].comparison_length == (unsigned int) -1 1506 ? strcmp (alignment_table[i].name, secname) == 0 1507 : strncmp (alignment_table[i].name, secname, 1508 alignment_table[i].comparison_length) == 0) 1509 break; 1510 } 1511 if (i >= table_size) 1512 return; 1513 1514 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY 1515 && default_alignment < alignment_table[i].default_alignment_min) 1516 return; 1517 1518 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY 1519 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0 1520 && default_alignment > alignment_table[i].default_alignment_max 1521 #endif 1522 ) 1523 return; 1524 1525 section->alignment_power = alignment_table[i].alignment_power; 1526 } 1527 1528 /* Custom section alignment records. */ 1529 1530 static const struct coff_section_alignment_entry 1531 coff_section_alignment_table[] = 1532 { 1533 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES 1534 COFF_SECTION_ALIGNMENT_ENTRIES, 1535 #endif 1536 /* There must not be any gaps between .stabstr sections. */ 1537 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"), 1538 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, 1539 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */ 1540 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"), 1541 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, 1542 /* Similarly for the .ctors and .dtors sections. */ 1543 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"), 1544 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, 1545 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"), 1546 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 } 1547 }; 1548 1549 static const unsigned int coff_section_alignment_table_size = 1550 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0]; 1551 1552 /* Initialize a section structure with information peculiar to this 1553 particular implementation of COFF. */ 1554 1555 static bfd_boolean 1556 coff_new_section_hook (bfd * abfd, asection * section) 1557 { 1558 combined_entry_type *native; 1559 bfd_size_type amt; 1560 1561 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; 1562 1563 #ifdef RS6000COFF_C 1564 if (bfd_xcoff_text_align_power (abfd) != 0 1565 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0) 1566 section->alignment_power = bfd_xcoff_text_align_power (abfd); 1567 if (bfd_xcoff_data_align_power (abfd) != 0 1568 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0) 1569 section->alignment_power = bfd_xcoff_data_align_power (abfd); 1570 #endif 1571 1572 /* Set up the section symbol. */ 1573 if (!_bfd_generic_new_section_hook (abfd, section)) 1574 return FALSE; 1575 1576 /* Allocate aux records for section symbols, to store size and 1577 related info. 1578 1579 @@ The 10 is a guess at a plausible maximum number of aux entries 1580 (but shouldn't be a constant). */ 1581 amt = sizeof (combined_entry_type) * 10; 1582 native = bfd_zalloc (abfd, amt); 1583 if (native == NULL) 1584 return FALSE; 1585 1586 /* We don't need to set up n_name, n_value, or n_scnum in the native 1587 symbol information, since they'll be overridden by the BFD symbol 1588 anyhow. However, we do need to set the type and storage class, 1589 in case this symbol winds up getting written out. The value 0 1590 for n_numaux is already correct. */ 1591 1592 native->u.syment.n_type = T_NULL; 1593 native->u.syment.n_sclass = C_STAT; 1594 1595 coffsymbol (section->symbol)->native = native; 1596 1597 coff_set_custom_section_alignment (abfd, section, 1598 coff_section_alignment_table, 1599 coff_section_alignment_table_size); 1600 1601 return TRUE; 1602 } 1603 1604 #ifdef COFF_ALIGN_IN_SECTION_HEADER 1605 1606 /* Set the alignment of a BFD section. */ 1607 1608 static void 1609 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1610 asection * section, 1611 void * scnhdr) 1612 { 1613 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1614 unsigned int i; 1615 1616 #ifdef I960 1617 /* Extract ALIGN from 2**ALIGN stored in section header. */ 1618 for (i = 0; i < 32; i++) 1619 if ((1 << i) >= hdr->s_align) 1620 break; 1621 #endif 1622 #ifdef TIC80COFF 1623 /* TI tools puts the alignment power in bits 8-11. */ 1624 i = (hdr->s_flags >> 8) & 0xF ; 1625 #endif 1626 #ifdef COFF_DECODE_ALIGNMENT 1627 i = COFF_DECODE_ALIGNMENT(hdr->s_flags); 1628 #endif 1629 section->alignment_power = i; 1630 1631 #ifdef coff_set_section_load_page 1632 coff_set_section_load_page (section, hdr->s_page); 1633 #endif 1634 } 1635 1636 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1637 #ifdef COFF_WITH_PE 1638 1639 static void 1640 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1641 asection * section, 1642 void * scnhdr) 1643 { 1644 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1645 bfd_size_type amt; 1646 unsigned int alignment_power_const 1647 = hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK; 1648 1649 switch (alignment_power_const) 1650 { 1651 case IMAGE_SCN_ALIGN_8192BYTES: 1652 case IMAGE_SCN_ALIGN_4096BYTES: 1653 case IMAGE_SCN_ALIGN_2048BYTES: 1654 case IMAGE_SCN_ALIGN_1024BYTES: 1655 case IMAGE_SCN_ALIGN_512BYTES: 1656 case IMAGE_SCN_ALIGN_256BYTES: 1657 case IMAGE_SCN_ALIGN_128BYTES: 1658 case IMAGE_SCN_ALIGN_64BYTES: 1659 case IMAGE_SCN_ALIGN_32BYTES: 1660 case IMAGE_SCN_ALIGN_16BYTES: 1661 case IMAGE_SCN_ALIGN_8BYTES: 1662 case IMAGE_SCN_ALIGN_4BYTES: 1663 case IMAGE_SCN_ALIGN_2BYTES: 1664 case IMAGE_SCN_ALIGN_1BYTES: 1665 section->alignment_power 1666 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const); 1667 break; 1668 default: 1669 break; 1670 } 1671 1672 /* In a PE image file, the s_paddr field holds the virtual size of a 1673 section, while the s_size field holds the raw size. We also keep 1674 the original section flag value, since not every bit can be 1675 mapped onto a generic BFD section bit. */ 1676 if (coff_section_data (abfd, section) == NULL) 1677 { 1678 amt = sizeof (struct coff_section_tdata); 1679 section->used_by_bfd = bfd_zalloc (abfd, amt); 1680 if (section->used_by_bfd == NULL) 1681 /* FIXME: Return error. */ 1682 abort (); 1683 } 1684 1685 if (pei_section_data (abfd, section) == NULL) 1686 { 1687 amt = sizeof (struct pei_section_tdata); 1688 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt); 1689 if (coff_section_data (abfd, section)->tdata == NULL) 1690 /* FIXME: Return error. */ 1691 abort (); 1692 } 1693 pei_section_data (abfd, section)->virt_size = hdr->s_paddr; 1694 pei_section_data (abfd, section)->pe_flags = hdr->s_flags; 1695 1696 section->lma = hdr->s_vaddr; 1697 1698 /* Check for extended relocs. */ 1699 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL) 1700 { 1701 struct external_reloc dst; 1702 struct internal_reloc n; 1703 file_ptr oldpos = bfd_tell (abfd); 1704 bfd_size_type relsz = bfd_coff_relsz (abfd); 1705 1706 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0); 1707 if (bfd_bread (& dst, relsz, abfd) != relsz) 1708 return; 1709 1710 coff_swap_reloc_in (abfd, &dst, &n); 1711 bfd_seek (abfd, oldpos, 0); 1712 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1; 1713 section->rel_filepos += relsz; 1714 } 1715 else if (hdr->s_nreloc == 0xffff) 1716 (*_bfd_error_handler) 1717 ("%s: warning: claims to have 0xffff relocs, without overflow", 1718 bfd_get_filename (abfd)); 1719 } 1720 #undef ALIGN_SET 1721 #undef ELIFALIGN_SET 1722 1723 #else /* ! COFF_WITH_PE */ 1724 #ifdef RS6000COFF_C 1725 1726 /* We grossly abuse this function to handle XCOFF overflow headers. 1727 When we see one, we correct the reloc and line number counts in the 1728 real header, and remove the section we just created. */ 1729 1730 static void 1731 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr) 1732 { 1733 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1734 asection *real_sec; 1735 1736 if ((hdr->s_flags & STYP_OVRFLO) == 0) 1737 return; 1738 1739 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc); 1740 if (real_sec == NULL) 1741 return; 1742 1743 real_sec->reloc_count = hdr->s_paddr; 1744 real_sec->lineno_count = hdr->s_vaddr; 1745 1746 if (!bfd_section_removed_from_list (abfd, section)) 1747 { 1748 bfd_section_list_remove (abfd, section); 1749 --abfd->section_count; 1750 } 1751 } 1752 1753 #else /* ! RS6000COFF_C */ 1754 1755 #define coff_set_alignment_hook \ 1756 ((void (*) (bfd *, asection *, void *)) bfd_void) 1757 1758 #endif /* ! RS6000COFF_C */ 1759 #endif /* ! COFF_WITH_PE */ 1760 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1761 1762 #ifndef coff_mkobject 1763 1764 static bfd_boolean 1765 coff_mkobject (bfd * abfd) 1766 { 1767 coff_data_type *coff; 1768 bfd_size_type amt = sizeof (coff_data_type); 1769 1770 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt); 1771 if (abfd->tdata.coff_obj_data == NULL) 1772 return FALSE; 1773 coff = coff_data (abfd); 1774 coff->symbols = NULL; 1775 coff->conversion_table = NULL; 1776 coff->raw_syments = NULL; 1777 coff->relocbase = 0; 1778 coff->local_toc_sym_map = 0; 1779 1780 /* make_abs_section(abfd);*/ 1781 1782 return TRUE; 1783 } 1784 #endif 1785 1786 /* Create the COFF backend specific information. */ 1787 1788 #ifndef coff_mkobject_hook 1789 static void * 1790 coff_mkobject_hook (bfd * abfd, 1791 void * filehdr, 1792 void * aouthdr ATTRIBUTE_UNUSED) 1793 { 1794 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1795 coff_data_type *coff; 1796 1797 if (! coff_mkobject (abfd)) 1798 return NULL; 1799 1800 coff = coff_data (abfd); 1801 1802 coff->sym_filepos = internal_f->f_symptr; 1803 1804 /* These members communicate important constants about the symbol 1805 table to GDB's symbol-reading code. These `constants' 1806 unfortunately vary among coff implementations... */ 1807 coff->local_n_btmask = N_BTMASK; 1808 coff->local_n_btshft = N_BTSHFT; 1809 coff->local_n_tmask = N_TMASK; 1810 coff->local_n_tshift = N_TSHIFT; 1811 coff->local_symesz = bfd_coff_symesz (abfd); 1812 coff->local_auxesz = bfd_coff_auxesz (abfd); 1813 coff->local_linesz = bfd_coff_linesz (abfd); 1814 1815 coff->timestamp = internal_f->f_timdat; 1816 1817 obj_raw_syment_count (abfd) = 1818 obj_conv_table_size (abfd) = 1819 internal_f->f_nsyms; 1820 1821 #ifdef RS6000COFF_C 1822 if ((internal_f->f_flags & F_SHROBJ) != 0) 1823 abfd->flags |= DYNAMIC; 1824 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)) 1825 { 1826 struct internal_aouthdr *internal_a = 1827 (struct internal_aouthdr *) aouthdr; 1828 struct xcoff_tdata *xcoff; 1829 1830 xcoff = xcoff_data (abfd); 1831 # ifdef U803XTOCMAGIC 1832 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC; 1833 # else 1834 xcoff->xcoff64 = 0; 1835 # endif 1836 xcoff->full_aouthdr = TRUE; 1837 xcoff->toc = internal_a->o_toc; 1838 xcoff->sntoc = internal_a->o_sntoc; 1839 xcoff->snentry = internal_a->o_snentry; 1840 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext; 1841 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata; 1842 xcoff->modtype = internal_a->o_modtype; 1843 xcoff->cputype = internal_a->o_cputype; 1844 xcoff->maxdata = internal_a->o_maxdata; 1845 xcoff->maxstack = internal_a->o_maxstack; 1846 } 1847 #endif 1848 1849 #ifdef ARM 1850 /* Set the flags field from the COFF header read in. */ 1851 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 1852 coff->flags = 0; 1853 #endif 1854 1855 #ifdef COFF_WITH_PE 1856 /* FIXME: I'm not sure this is ever executed, since peicode.h 1857 defines coff_mkobject_hook. */ 1858 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 1859 abfd->flags |= HAS_DEBUG; 1860 #endif 1861 1862 return coff; 1863 } 1864 #endif 1865 1866 /* Determine the machine architecture and type. FIXME: This is target 1867 dependent because the magic numbers are defined in the target 1868 dependent header files. But there is no particular need for this. 1869 If the magic numbers were moved to a separate file, this function 1870 would be target independent and would also be much more successful 1871 at linking together COFF files for different architectures. */ 1872 1873 static bfd_boolean 1874 coff_set_arch_mach_hook (bfd *abfd, void * filehdr) 1875 { 1876 unsigned long machine; 1877 enum bfd_architecture arch; 1878 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1879 1880 /* Zero selects the default machine for an arch. */ 1881 machine = 0; 1882 switch (internal_f->f_magic) 1883 { 1884 #ifdef OR32_MAGIC_BIG 1885 case OR32_MAGIC_BIG: 1886 case OR32_MAGIC_LITTLE: 1887 arch = bfd_arch_or32; 1888 break; 1889 #endif 1890 #ifdef PPCMAGIC 1891 case PPCMAGIC: 1892 arch = bfd_arch_powerpc; 1893 break; 1894 #endif 1895 #ifdef I386MAGIC 1896 case I386MAGIC: 1897 case I386PTXMAGIC: 1898 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */ 1899 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */ 1900 arch = bfd_arch_i386; 1901 break; 1902 #endif 1903 #ifdef AMD64MAGIC 1904 case AMD64MAGIC: 1905 arch = bfd_arch_i386; 1906 machine = bfd_mach_x86_64; 1907 break; 1908 #endif 1909 #ifdef IA64MAGIC 1910 case IA64MAGIC: 1911 arch = bfd_arch_ia64; 1912 break; 1913 #endif 1914 #ifdef ARMMAGIC 1915 case ARMMAGIC: 1916 case ARMPEMAGIC: 1917 case THUMBPEMAGIC: 1918 arch = bfd_arch_arm; 1919 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 1920 if (machine == bfd_mach_arm_unknown) 1921 { 1922 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 1923 { 1924 case F_ARM_2: machine = bfd_mach_arm_2; break; 1925 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 1926 case F_ARM_3: machine = bfd_mach_arm_3; break; 1927 default: 1928 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 1929 case F_ARM_4: machine = bfd_mach_arm_4; break; 1930 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 1931 /* The COFF header does not have enough bits available 1932 to cover all the different ARM architectures. So 1933 we interpret F_ARM_5, the highest flag value to mean 1934 "the highest ARM architecture known to BFD" which is 1935 currently the XScale. */ 1936 case F_ARM_5: machine = bfd_mach_arm_XScale; break; 1937 } 1938 } 1939 break; 1940 #endif 1941 #ifdef MC68MAGIC 1942 case MC68MAGIC: 1943 case M68MAGIC: 1944 #ifdef MC68KBCSMAGIC 1945 case MC68KBCSMAGIC: 1946 #endif 1947 #ifdef APOLLOM68KMAGIC 1948 case APOLLOM68KMAGIC: 1949 #endif 1950 #ifdef LYNXCOFFMAGIC 1951 case LYNXCOFFMAGIC: 1952 #endif 1953 arch = bfd_arch_m68k; 1954 machine = bfd_mach_m68020; 1955 break; 1956 #endif 1957 #ifdef MAXQ20MAGIC 1958 case MAXQ20MAGIC: 1959 arch = bfd_arch_maxq; 1960 switch (internal_f->f_flags & F_MACHMASK) 1961 { 1962 case F_MAXQ10: 1963 machine = bfd_mach_maxq10; 1964 break; 1965 case F_MAXQ20: 1966 machine = bfd_mach_maxq20; 1967 break; 1968 default: 1969 return FALSE; 1970 } 1971 break; 1972 #endif 1973 #ifdef MC88MAGIC 1974 case MC88MAGIC: 1975 case MC88DMAGIC: 1976 case MC88OMAGIC: 1977 arch = bfd_arch_m88k; 1978 machine = 88100; 1979 break; 1980 #endif 1981 #ifdef Z80MAGIC 1982 case Z80MAGIC: 1983 arch = bfd_arch_z80; 1984 switch (internal_f->f_flags & F_MACHMASK) 1985 { 1986 case 0: 1987 case bfd_mach_z80strict << 12: 1988 case bfd_mach_z80 << 12: 1989 case bfd_mach_z80full << 12: 1990 case bfd_mach_r800 << 12: 1991 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12; 1992 break; 1993 default: 1994 return FALSE; 1995 } 1996 break; 1997 #endif 1998 #ifdef Z8KMAGIC 1999 case Z8KMAGIC: 2000 arch = bfd_arch_z8k; 2001 switch (internal_f->f_flags & F_MACHMASK) 2002 { 2003 case F_Z8001: 2004 machine = bfd_mach_z8001; 2005 break; 2006 case F_Z8002: 2007 machine = bfd_mach_z8002; 2008 break; 2009 default: 2010 return FALSE; 2011 } 2012 break; 2013 #endif 2014 #ifdef I860 2015 case I860MAGIC: 2016 arch = bfd_arch_i860; 2017 break; 2018 #endif 2019 #ifdef I960 2020 #ifdef I960ROMAGIC 2021 case I960ROMAGIC: 2022 case I960RWMAGIC: 2023 arch = bfd_arch_i960; 2024 switch (F_I960TYPE & internal_f->f_flags) 2025 { 2026 default: 2027 case F_I960CORE: 2028 machine = bfd_mach_i960_core; 2029 break; 2030 case F_I960KB: 2031 machine = bfd_mach_i960_kb_sb; 2032 break; 2033 case F_I960MC: 2034 machine = bfd_mach_i960_mc; 2035 break; 2036 case F_I960XA: 2037 machine = bfd_mach_i960_xa; 2038 break; 2039 case F_I960CA: 2040 machine = bfd_mach_i960_ca; 2041 break; 2042 case F_I960KA: 2043 machine = bfd_mach_i960_ka_sa; 2044 break; 2045 case F_I960JX: 2046 machine = bfd_mach_i960_jx; 2047 break; 2048 case F_I960HX: 2049 machine = bfd_mach_i960_hx; 2050 break; 2051 } 2052 break; 2053 #endif 2054 #endif 2055 2056 #ifdef RS6000COFF_C 2057 #ifdef XCOFF64 2058 case U64_TOCMAGIC: 2059 case U803XTOCMAGIC: 2060 #else 2061 case U802ROMAGIC: 2062 case U802WRMAGIC: 2063 case U802TOCMAGIC: 2064 #endif 2065 { 2066 int cputype; 2067 2068 if (xcoff_data (abfd)->cputype != -1) 2069 cputype = xcoff_data (abfd)->cputype & 0xff; 2070 else 2071 { 2072 /* We did not get a value from the a.out header. If the 2073 file has not been stripped, we may be able to get the 2074 architecture information from the first symbol, if it 2075 is a .file symbol. */ 2076 if (obj_raw_syment_count (abfd) == 0) 2077 cputype = 0; 2078 else 2079 { 2080 bfd_byte *buf; 2081 struct internal_syment sym; 2082 bfd_size_type amt = bfd_coff_symesz (abfd); 2083 2084 buf = bfd_malloc (amt); 2085 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 2086 || bfd_bread (buf, amt, abfd) != amt) 2087 { 2088 free (buf); 2089 return FALSE; 2090 } 2091 bfd_coff_swap_sym_in (abfd, buf, & sym); 2092 if (sym.n_sclass == C_FILE) 2093 cputype = sym.n_type & 0xff; 2094 else 2095 cputype = 0; 2096 free (buf); 2097 } 2098 } 2099 2100 /* FIXME: We don't handle all cases here. */ 2101 switch (cputype) 2102 { 2103 default: 2104 case 0: 2105 arch = bfd_xcoff_architecture (abfd); 2106 machine = bfd_xcoff_machine (abfd); 2107 break; 2108 2109 case 1: 2110 arch = bfd_arch_powerpc; 2111 machine = bfd_mach_ppc_601; 2112 break; 2113 case 2: /* 64 bit PowerPC */ 2114 arch = bfd_arch_powerpc; 2115 machine = bfd_mach_ppc_620; 2116 break; 2117 case 3: 2118 arch = bfd_arch_powerpc; 2119 machine = bfd_mach_ppc; 2120 break; 2121 case 4: 2122 arch = bfd_arch_rs6000; 2123 machine = bfd_mach_rs6k; 2124 break; 2125 } 2126 } 2127 break; 2128 #endif 2129 2130 #ifdef WE32KMAGIC 2131 case WE32KMAGIC: 2132 arch = bfd_arch_we32k; 2133 break; 2134 #endif 2135 2136 #ifdef H8300MAGIC 2137 case H8300MAGIC: 2138 arch = bfd_arch_h8300; 2139 machine = bfd_mach_h8300; 2140 /* !! FIXME this probably isn't the right place for this. */ 2141 abfd->flags |= BFD_IS_RELAXABLE; 2142 break; 2143 #endif 2144 2145 #ifdef H8300HMAGIC 2146 case H8300HMAGIC: 2147 arch = bfd_arch_h8300; 2148 machine = bfd_mach_h8300h; 2149 /* !! FIXME this probably isn't the right place for this. */ 2150 abfd->flags |= BFD_IS_RELAXABLE; 2151 break; 2152 #endif 2153 2154 #ifdef H8300SMAGIC 2155 case H8300SMAGIC: 2156 arch = bfd_arch_h8300; 2157 machine = bfd_mach_h8300s; 2158 /* !! FIXME this probably isn't the right place for this. */ 2159 abfd->flags |= BFD_IS_RELAXABLE; 2160 break; 2161 #endif 2162 2163 #ifdef H8300HNMAGIC 2164 case H8300HNMAGIC: 2165 arch = bfd_arch_h8300; 2166 machine = bfd_mach_h8300hn; 2167 /* !! FIXME this probably isn't the right place for this. */ 2168 abfd->flags |= BFD_IS_RELAXABLE; 2169 break; 2170 #endif 2171 2172 #ifdef H8300SNMAGIC 2173 case H8300SNMAGIC: 2174 arch = bfd_arch_h8300; 2175 machine = bfd_mach_h8300sn; 2176 /* !! FIXME this probably isn't the right place for this. */ 2177 abfd->flags |= BFD_IS_RELAXABLE; 2178 break; 2179 #endif 2180 2181 #ifdef SH_ARCH_MAGIC_BIG 2182 case SH_ARCH_MAGIC_BIG: 2183 case SH_ARCH_MAGIC_LITTLE: 2184 #ifdef COFF_WITH_PE 2185 case SH_ARCH_MAGIC_WINCE: 2186 #endif 2187 arch = bfd_arch_sh; 2188 break; 2189 #endif 2190 2191 #ifdef MIPS_ARCH_MAGIC_WINCE 2192 case MIPS_ARCH_MAGIC_WINCE: 2193 arch = bfd_arch_mips; 2194 break; 2195 #endif 2196 2197 #ifdef H8500MAGIC 2198 case H8500MAGIC: 2199 arch = bfd_arch_h8500; 2200 break; 2201 #endif 2202 2203 #ifdef SPARCMAGIC 2204 case SPARCMAGIC: 2205 #ifdef LYNXCOFFMAGIC 2206 case LYNXCOFFMAGIC: 2207 #endif 2208 arch = bfd_arch_sparc; 2209 break; 2210 #endif 2211 2212 #ifdef TIC30MAGIC 2213 case TIC30MAGIC: 2214 arch = bfd_arch_tic30; 2215 break; 2216 #endif 2217 2218 #ifdef TICOFF0MAGIC 2219 #ifdef TICOFF_TARGET_ARCH 2220 /* This TI COFF section should be used by all new TI COFF v0 targets. */ 2221 case TICOFF0MAGIC: 2222 arch = TICOFF_TARGET_ARCH; 2223 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2224 break; 2225 #endif 2226 #endif 2227 2228 #ifdef TICOFF1MAGIC 2229 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */ 2230 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */ 2231 case TICOFF1MAGIC: 2232 case TICOFF2MAGIC: 2233 switch (internal_f->f_target_id) 2234 { 2235 #ifdef TI_TARGET_ID 2236 case TI_TARGET_ID: 2237 arch = TICOFF_TARGET_ARCH; 2238 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2239 break; 2240 #endif 2241 default: 2242 arch = bfd_arch_obscure; 2243 (*_bfd_error_handler) 2244 (_("Unrecognized TI COFF target id '0x%x'"), 2245 internal_f->f_target_id); 2246 break; 2247 } 2248 break; 2249 #endif 2250 2251 #ifdef TIC80_ARCH_MAGIC 2252 case TIC80_ARCH_MAGIC: 2253 arch = bfd_arch_tic80; 2254 break; 2255 #endif 2256 2257 #ifdef MCOREMAGIC 2258 case MCOREMAGIC: 2259 arch = bfd_arch_mcore; 2260 break; 2261 #endif 2262 2263 #ifdef W65MAGIC 2264 case W65MAGIC: 2265 arch = bfd_arch_w65; 2266 break; 2267 #endif 2268 2269 default: /* Unreadable input file type. */ 2270 arch = bfd_arch_obscure; 2271 break; 2272 } 2273 2274 bfd_default_set_arch_mach (abfd, arch, machine); 2275 return TRUE; 2276 } 2277 2278 #ifdef SYMNAME_IN_DEBUG 2279 2280 static bfd_boolean 2281 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym) 2282 { 2283 return SYMNAME_IN_DEBUG (sym) != 0; 2284 } 2285 2286 #else 2287 2288 #define symname_in_debug_hook \ 2289 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false 2290 2291 #endif 2292 2293 #ifdef RS6000COFF_C 2294 2295 #ifdef XCOFF64 2296 #define FORCE_SYMNAMES_IN_STRINGS 2297 #endif 2298 2299 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */ 2300 2301 static bfd_boolean 2302 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2303 combined_entry_type *table_base, 2304 combined_entry_type *symbol, 2305 unsigned int indaux, 2306 combined_entry_type *aux) 2307 { 2308 int class = symbol->u.syment.n_sclass; 2309 2310 if ((class == C_EXT || class == C_HIDEXT) 2311 && indaux + 1 == symbol->u.syment.n_numaux) 2312 { 2313 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 2314 { 2315 aux->u.auxent.x_csect.x_scnlen.p = 2316 table_base + aux->u.auxent.x_csect.x_scnlen.l; 2317 aux->fix_scnlen = 1; 2318 } 2319 2320 /* Return TRUE to indicate that the caller should not do any 2321 further work on this auxent. */ 2322 return TRUE; 2323 } 2324 2325 /* Return FALSE to indicate that this auxent should be handled by 2326 the caller. */ 2327 return FALSE; 2328 } 2329 2330 #else 2331 #ifdef I960 2332 2333 /* We don't want to pointerize bal entries. */ 2334 2335 static bfd_boolean 2336 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2337 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2338 combined_entry_type *symbol, 2339 unsigned int indaux, 2340 combined_entry_type *aux ATTRIBUTE_UNUSED) 2341 { 2342 /* Return TRUE if we don't want to pointerize this aux entry, which 2343 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 2344 return (indaux == 1 2345 && (symbol->u.syment.n_sclass == C_LEAFPROC 2346 || symbol->u.syment.n_sclass == C_LEAFSTAT 2347 || symbol->u.syment.n_sclass == C_LEAFEXT)); 2348 } 2349 2350 #else /* ! I960 */ 2351 2352 #define coff_pointerize_aux_hook 0 2353 2354 #endif /* ! I960 */ 2355 #endif /* ! RS6000COFF_C */ 2356 2357 /* Print an aux entry. This returns TRUE if it has printed it. */ 2358 2359 static bfd_boolean 2360 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED, 2361 FILE *file ATTRIBUTE_UNUSED, 2362 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2363 combined_entry_type *symbol ATTRIBUTE_UNUSED, 2364 combined_entry_type *aux ATTRIBUTE_UNUSED, 2365 unsigned int indaux ATTRIBUTE_UNUSED) 2366 { 2367 #ifdef RS6000COFF_C 2368 if ((symbol->u.syment.n_sclass == C_EXT 2369 || symbol->u.syment.n_sclass == C_HIDEXT) 2370 && indaux + 1 == symbol->u.syment.n_numaux) 2371 { 2372 /* This is a csect entry. */ 2373 fprintf (file, "AUX "); 2374 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 2375 { 2376 BFD_ASSERT (! aux->fix_scnlen); 2377 #ifdef XCOFF64 2378 fprintf (file, "val %5lld", 2379 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2380 #else 2381 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2382 #endif 2383 } 2384 else 2385 { 2386 fprintf (file, "indx "); 2387 if (! aux->fix_scnlen) 2388 #ifdef XCOFF64 2389 fprintf (file, "%4lld", 2390 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2391 #else 2392 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2393 #endif 2394 else 2395 fprintf (file, "%4ld", 2396 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 2397 } 2398 fprintf (file, 2399 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 2400 aux->u.auxent.x_csect.x_parmhash, 2401 (unsigned int) aux->u.auxent.x_csect.x_snhash, 2402 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 2403 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 2404 (unsigned int) aux->u.auxent.x_csect.x_smclas, 2405 aux->u.auxent.x_csect.x_stab, 2406 (unsigned int) aux->u.auxent.x_csect.x_snstab); 2407 return TRUE; 2408 } 2409 #endif 2410 2411 /* Return FALSE to indicate that no special action was taken. */ 2412 return FALSE; 2413 } 2414 2415 /* 2416 SUBSUBSECTION 2417 Writing relocations 2418 2419 To write relocations, the back end steps though the 2420 canonical relocation table and create an 2421 @code{internal_reloc}. The symbol index to use is removed from 2422 the @code{offset} field in the symbol table supplied. The 2423 address comes directly from the sum of the section base 2424 address and the relocation offset; the type is dug directly 2425 from the howto field. Then the @code{internal_reloc} is 2426 swapped into the shape of an @code{external_reloc} and written 2427 out to disk. 2428 2429 */ 2430 2431 #ifdef TARG_AUX 2432 2433 2434 /* AUX's ld wants relocations to be sorted. */ 2435 static int 2436 compare_arelent_ptr (const void * x, const void * y) 2437 { 2438 const arelent **a = (const arelent **) x; 2439 const arelent **b = (const arelent **) y; 2440 bfd_size_type aadr = (*a)->address; 2441 bfd_size_type badr = (*b)->address; 2442 2443 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 2444 } 2445 2446 #endif /* TARG_AUX */ 2447 2448 static bfd_boolean 2449 coff_write_relocs (bfd * abfd, int first_undef) 2450 { 2451 asection *s; 2452 2453 for (s = abfd->sections; s != NULL; s = s->next) 2454 { 2455 unsigned int i; 2456 struct external_reloc dst; 2457 arelent **p; 2458 2459 #ifndef TARG_AUX 2460 p = s->orelocation; 2461 #else 2462 { 2463 /* Sort relocations before we write them out. */ 2464 bfd_size_type amt; 2465 2466 amt = s->reloc_count; 2467 amt *= sizeof (arelent *); 2468 p = bfd_malloc (amt); 2469 if (p == NULL && s->reloc_count > 0) 2470 return FALSE; 2471 memcpy (p, s->orelocation, (size_t) amt); 2472 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 2473 } 2474 #endif 2475 2476 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 2477 return FALSE; 2478 2479 #ifdef COFF_WITH_PE 2480 if (obj_pe (abfd) && s->reloc_count >= 0xffff) 2481 { 2482 /* Encode real count here as first reloc. */ 2483 struct internal_reloc n; 2484 2485 memset (& n, 0, sizeof (n)); 2486 /* Add one to count *this* reloc (grr). */ 2487 n.r_vaddr = s->reloc_count + 1; 2488 coff_swap_reloc_out (abfd, &n, &dst); 2489 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2490 abfd) != bfd_coff_relsz (abfd)) 2491 return FALSE; 2492 } 2493 #endif 2494 2495 for (i = 0; i < s->reloc_count; i++) 2496 { 2497 struct internal_reloc n; 2498 arelent *q = p[i]; 2499 2500 memset (& n, 0, sizeof (n)); 2501 2502 /* Now we've renumbered the symbols we know where the 2503 undefined symbols live in the table. Check the reloc 2504 entries for symbols who's output bfd isn't the right one. 2505 This is because the symbol was undefined (which means 2506 that all the pointers are never made to point to the same 2507 place). This is a bad thing,'cause the symbols attached 2508 to the output bfd are indexed, so that the relocation 2509 entries know which symbol index they point to. So we 2510 have to look up the output symbol here. */ 2511 2512 if (q->sym_ptr_ptr[0]->the_bfd != abfd) 2513 { 2514 int j; 2515 const char *sname = q->sym_ptr_ptr[0]->name; 2516 asymbol **outsyms = abfd->outsymbols; 2517 2518 for (j = first_undef; outsyms[j]; j++) 2519 { 2520 const char *intable = outsyms[j]->name; 2521 2522 if (strcmp (intable, sname) == 0) 2523 { 2524 /* Got a hit, so repoint the reloc. */ 2525 q->sym_ptr_ptr = outsyms + j; 2526 break; 2527 } 2528 } 2529 } 2530 2531 n.r_vaddr = q->address + s->vma; 2532 2533 #ifdef R_IHCONST 2534 /* The 29k const/consth reloc pair is a real kludge. The consth 2535 part doesn't have a symbol; it has an offset. So rebuilt 2536 that here. */ 2537 if (q->howto->type == R_IHCONST) 2538 n.r_symndx = q->addend; 2539 else 2540 #endif 2541 if (q->sym_ptr_ptr) 2542 { 2543 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P 2544 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s)) 2545 #else 2546 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr 2547 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0) 2548 #endif 2549 /* This is a relocation relative to the absolute symbol. */ 2550 n.r_symndx = -1; 2551 else 2552 { 2553 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 2554 /* Check to see if the symbol reloc points to a symbol 2555 we don't have in our symbol table. */ 2556 if (n.r_symndx > obj_conv_table_size (abfd)) 2557 { 2558 bfd_set_error (bfd_error_bad_value); 2559 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"), 2560 abfd, n.r_symndx); 2561 return FALSE; 2562 } 2563 } 2564 } 2565 2566 #ifdef SWAP_OUT_RELOC_OFFSET 2567 n.r_offset = q->addend; 2568 #endif 2569 2570 #ifdef SELECT_RELOC 2571 /* Work out reloc type from what is required. */ 2572 SELECT_RELOC (n, q->howto); 2573 #else 2574 n.r_type = q->howto->type; 2575 #endif 2576 coff_swap_reloc_out (abfd, &n, &dst); 2577 2578 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2579 abfd) != bfd_coff_relsz (abfd)) 2580 return FALSE; 2581 } 2582 2583 #ifdef TARG_AUX 2584 if (p != NULL) 2585 free (p); 2586 #endif 2587 } 2588 2589 return TRUE; 2590 } 2591 2592 /* Set flags and magic number of a coff file from architecture and machine 2593 type. Result is TRUE if we can represent the arch&type, FALSE if not. */ 2594 2595 static bfd_boolean 2596 coff_set_flags (bfd * abfd, 2597 unsigned int *magicp ATTRIBUTE_UNUSED, 2598 unsigned short *flagsp ATTRIBUTE_UNUSED) 2599 { 2600 switch (bfd_get_arch (abfd)) 2601 { 2602 #ifdef Z80MAGIC 2603 case bfd_arch_z80: 2604 *magicp = Z80MAGIC; 2605 switch (bfd_get_mach (abfd)) 2606 { 2607 case 0: 2608 case bfd_mach_z80strict: 2609 case bfd_mach_z80: 2610 case bfd_mach_z80full: 2611 case bfd_mach_r800: 2612 *flagsp = bfd_get_mach (abfd) << 12; 2613 break; 2614 default: 2615 return FALSE; 2616 } 2617 return TRUE; 2618 #endif 2619 2620 #ifdef Z8KMAGIC 2621 case bfd_arch_z8k: 2622 *magicp = Z8KMAGIC; 2623 2624 switch (bfd_get_mach (abfd)) 2625 { 2626 case bfd_mach_z8001: *flagsp = F_Z8001; break; 2627 case bfd_mach_z8002: *flagsp = F_Z8002; break; 2628 default: return FALSE; 2629 } 2630 return TRUE; 2631 #endif 2632 2633 #ifdef I960ROMAGIC 2634 case bfd_arch_i960: 2635 2636 { 2637 unsigned flags; 2638 2639 *magicp = I960ROMAGIC; 2640 2641 switch (bfd_get_mach (abfd)) 2642 { 2643 case bfd_mach_i960_core: flags = F_I960CORE; break; 2644 case bfd_mach_i960_kb_sb: flags = F_I960KB; break; 2645 case bfd_mach_i960_mc: flags = F_I960MC; break; 2646 case bfd_mach_i960_xa: flags = F_I960XA; break; 2647 case bfd_mach_i960_ca: flags = F_I960CA; break; 2648 case bfd_mach_i960_ka_sa: flags = F_I960KA; break; 2649 case bfd_mach_i960_jx: flags = F_I960JX; break; 2650 case bfd_mach_i960_hx: flags = F_I960HX; break; 2651 default: return FALSE; 2652 } 2653 *flagsp = flags; 2654 return TRUE; 2655 } 2656 break; 2657 #endif 2658 2659 #ifdef TIC30MAGIC 2660 case bfd_arch_tic30: 2661 *magicp = TIC30MAGIC; 2662 return TRUE; 2663 #endif 2664 2665 #ifdef TICOFF_DEFAULT_MAGIC 2666 case TICOFF_TARGET_ARCH: 2667 /* If there's no indication of which version we want, use the default. */ 2668 if (!abfd->xvec ) 2669 *magicp = TICOFF_DEFAULT_MAGIC; 2670 else 2671 { 2672 /* We may want to output in a different COFF version. */ 2673 switch (abfd->xvec->name[4]) 2674 { 2675 case '0': 2676 *magicp = TICOFF0MAGIC; 2677 break; 2678 case '1': 2679 *magicp = TICOFF1MAGIC; 2680 break; 2681 case '2': 2682 *magicp = TICOFF2MAGIC; 2683 break; 2684 default: 2685 return FALSE; 2686 } 2687 } 2688 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd)); 2689 return TRUE; 2690 #endif 2691 2692 #ifdef TIC80_ARCH_MAGIC 2693 case bfd_arch_tic80: 2694 *magicp = TIC80_ARCH_MAGIC; 2695 return TRUE; 2696 #endif 2697 2698 #ifdef ARMMAGIC 2699 case bfd_arch_arm: 2700 #ifdef ARM_WINCE 2701 * magicp = ARMPEMAGIC; 2702 #else 2703 * magicp = ARMMAGIC; 2704 #endif 2705 * flagsp = 0; 2706 if (APCS_SET (abfd)) 2707 { 2708 if (APCS_26_FLAG (abfd)) 2709 * flagsp |= F_APCS26; 2710 2711 if (APCS_FLOAT_FLAG (abfd)) 2712 * flagsp |= F_APCS_FLOAT; 2713 2714 if (PIC_FLAG (abfd)) 2715 * flagsp |= F_PIC; 2716 } 2717 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2718 * flagsp |= F_INTERWORK; 2719 switch (bfd_get_mach (abfd)) 2720 { 2721 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2722 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2723 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2724 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2725 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2726 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2727 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; 2728 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. 2729 See also the comment in coff_set_arch_mach_hook(). */ 2730 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; 2731 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; 2732 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; 2733 } 2734 return TRUE; 2735 #endif 2736 2737 #ifdef PPCMAGIC 2738 case bfd_arch_powerpc: 2739 *magicp = PPCMAGIC; 2740 return TRUE; 2741 #endif 2742 2743 #if defined(I386MAGIC) || defined(AMD64MAGIC) 2744 case bfd_arch_i386: 2745 #if defined(I386MAGIC) 2746 *magicp = I386MAGIC; 2747 #endif 2748 #if defined LYNXOS 2749 /* Just overwrite the usual value if we're doing Lynx. */ 2750 *magicp = LYNXCOFFMAGIC; 2751 #endif 2752 #if defined AMD64MAGIC 2753 *magicp = AMD64MAGIC; 2754 #endif 2755 return TRUE; 2756 #endif 2757 2758 #ifdef I860MAGIC 2759 case bfd_arch_i860: 2760 *magicp = I860MAGIC; 2761 return TRUE; 2762 #endif 2763 2764 #ifdef IA64MAGIC 2765 case bfd_arch_ia64: 2766 *magicp = IA64MAGIC; 2767 return TRUE; 2768 #endif 2769 2770 #ifdef MC68MAGIC 2771 case bfd_arch_m68k: 2772 #ifdef APOLLOM68KMAGIC 2773 *magicp = APOLLO_COFF_VERSION_NUMBER; 2774 #else 2775 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2776 #ifdef NAMES_HAVE_UNDERSCORE 2777 *magicp = MC68KBCSMAGIC; 2778 #else 2779 *magicp = MC68MAGIC; 2780 #endif 2781 #endif 2782 #ifdef LYNXOS 2783 /* Just overwrite the usual value if we're doing Lynx. */ 2784 *magicp = LYNXCOFFMAGIC; 2785 #endif 2786 return TRUE; 2787 #endif 2788 2789 #ifdef MC88MAGIC 2790 case bfd_arch_m88k: 2791 *magicp = MC88OMAGIC; 2792 return TRUE; 2793 #endif 2794 2795 #ifdef H8300MAGIC 2796 case bfd_arch_h8300: 2797 switch (bfd_get_mach (abfd)) 2798 { 2799 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE; 2800 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE; 2801 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE; 2802 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE; 2803 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE; 2804 default: break; 2805 } 2806 break; 2807 #endif 2808 2809 #ifdef SH_ARCH_MAGIC_BIG 2810 case bfd_arch_sh: 2811 #ifdef COFF_IMAGE_WITH_PE 2812 *magicp = SH_ARCH_MAGIC_WINCE; 2813 #else 2814 if (bfd_big_endian (abfd)) 2815 *magicp = SH_ARCH_MAGIC_BIG; 2816 else 2817 *magicp = SH_ARCH_MAGIC_LITTLE; 2818 #endif 2819 return TRUE; 2820 #endif 2821 2822 #ifdef MIPS_ARCH_MAGIC_WINCE 2823 case bfd_arch_mips: 2824 *magicp = MIPS_ARCH_MAGIC_WINCE; 2825 return TRUE; 2826 #endif 2827 2828 #ifdef SPARCMAGIC 2829 case bfd_arch_sparc: 2830 *magicp = SPARCMAGIC; 2831 #ifdef LYNXOS 2832 /* Just overwrite the usual value if we're doing Lynx. */ 2833 *magicp = LYNXCOFFMAGIC; 2834 #endif 2835 return TRUE; 2836 #endif 2837 2838 #ifdef H8500MAGIC 2839 case bfd_arch_h8500: 2840 *magicp = H8500MAGIC; 2841 return TRUE; 2842 break; 2843 #endif 2844 2845 #ifdef WE32KMAGIC 2846 case bfd_arch_we32k: 2847 *magicp = WE32KMAGIC; 2848 return TRUE; 2849 #endif 2850 2851 #ifdef RS6000COFF_C 2852 case bfd_arch_rs6000: 2853 #ifndef PPCMAGIC 2854 case bfd_arch_powerpc: 2855 #endif 2856 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour); 2857 *magicp = bfd_xcoff_magic_number (abfd); 2858 return TRUE; 2859 #endif 2860 2861 #ifdef MCOREMAGIC 2862 case bfd_arch_mcore: 2863 * magicp = MCOREMAGIC; 2864 return TRUE; 2865 #endif 2866 2867 #ifdef W65MAGIC 2868 case bfd_arch_w65: 2869 *magicp = W65MAGIC; 2870 return TRUE; 2871 #endif 2872 2873 #ifdef OR32_MAGIC_BIG 2874 case bfd_arch_or32: 2875 if (bfd_big_endian (abfd)) 2876 * magicp = OR32_MAGIC_BIG; 2877 else 2878 * magicp = OR32_MAGIC_LITTLE; 2879 return TRUE; 2880 #endif 2881 2882 #ifdef MAXQ20MAGIC 2883 case bfd_arch_maxq: 2884 * magicp = MAXQ20MAGIC; 2885 switch (bfd_get_mach (abfd)) 2886 { 2887 case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE; 2888 case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE; 2889 default: return FALSE; 2890 } 2891 #endif 2892 2893 default: /* Unknown architecture. */ 2894 /* Fall through to "return FALSE" below, to avoid 2895 "statement never reached" errors on the one below. */ 2896 break; 2897 } 2898 2899 return FALSE; 2900 } 2901 2902 static bfd_boolean 2903 coff_set_arch_mach (bfd * abfd, 2904 enum bfd_architecture arch, 2905 unsigned long machine) 2906 { 2907 unsigned dummy1; 2908 unsigned short dummy2; 2909 2910 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 2911 return FALSE; 2912 2913 if (arch != bfd_arch_unknown 2914 && ! coff_set_flags (abfd, &dummy1, &dummy2)) 2915 return FALSE; /* We can't represent this type. */ 2916 2917 return TRUE; /* We're easy... */ 2918 } 2919 2920 #ifdef COFF_IMAGE_WITH_PE 2921 2922 /* This is used to sort sections by VMA, as required by PE image 2923 files. */ 2924 2925 static int 2926 sort_by_secaddr (const void * arg1, const void * arg2) 2927 { 2928 const asection *a = *(const asection **) arg1; 2929 const asection *b = *(const asection **) arg2; 2930 2931 if (a->vma < b->vma) 2932 return -1; 2933 else if (a->vma > b->vma) 2934 return 1; 2935 2936 return 0; 2937 } 2938 2939 #endif /* COFF_IMAGE_WITH_PE */ 2940 2941 /* Calculate the file position for each section. */ 2942 2943 #ifndef I960 2944 #define ALIGN_SECTIONS_IN_FILE 2945 #endif 2946 #if defined(TIC80COFF) || defined(TICOFF) 2947 #undef ALIGN_SECTIONS_IN_FILE 2948 #endif 2949 2950 static bfd_boolean 2951 coff_compute_section_file_positions (bfd * abfd) 2952 { 2953 asection *current; 2954 asection *previous = NULL; 2955 file_ptr sofar = bfd_coff_filhsz (abfd); 2956 bfd_boolean align_adjust; 2957 #ifdef ALIGN_SECTIONS_IN_FILE 2958 file_ptr old_sofar; 2959 #endif 2960 2961 #ifdef RS6000COFF_C 2962 /* On XCOFF, if we have symbols, set up the .debug section. */ 2963 if (bfd_get_symcount (abfd) > 0) 2964 { 2965 bfd_size_type sz; 2966 bfd_size_type i, symcount; 2967 asymbol **symp; 2968 2969 sz = 0; 2970 symcount = bfd_get_symcount (abfd); 2971 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 2972 { 2973 coff_symbol_type *cf; 2974 2975 cf = coff_symbol_from (abfd, *symp); 2976 if (cf != NULL 2977 && cf->native != NULL 2978 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 2979 { 2980 size_t len; 2981 2982 len = strlen (bfd_asymbol_name (*symp)); 2983 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) 2984 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); 2985 } 2986 } 2987 if (sz > 0) 2988 { 2989 asection *dsec; 2990 2991 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG); 2992 if (dsec == NULL) 2993 abort (); 2994 dsec->size = sz; 2995 dsec->flags |= SEC_HAS_CONTENTS; 2996 } 2997 } 2998 #endif 2999 3000 #ifdef COFF_IMAGE_WITH_PE 3001 int page_size; 3002 3003 if (coff_data (abfd)->link_info) 3004 { 3005 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 3006 3007 /* If no file alignment has been set, default to one. 3008 This repairs 'ld -r' for arm-wince-pe target. */ 3009 if (page_size == 0) 3010 page_size = 1; 3011 } 3012 else 3013 page_size = PE_DEF_FILE_ALIGNMENT; 3014 #else 3015 #ifdef COFF_PAGE_SIZE 3016 int page_size = COFF_PAGE_SIZE; 3017 #endif 3018 #endif 3019 3020 if (bfd_get_start_address (abfd)) 3021 /* A start address may have been added to the original file. In this 3022 case it will need an optional header to record it. */ 3023 abfd->flags |= EXEC_P; 3024 3025 if (abfd->flags & EXEC_P) 3026 sofar += bfd_coff_aoutsz (abfd); 3027 #ifdef RS6000COFF_C 3028 else if (xcoff_data (abfd)->full_aouthdr) 3029 sofar += bfd_coff_aoutsz (abfd); 3030 else 3031 sofar += SMALL_AOUTSZ; 3032 #endif 3033 3034 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 3035 3036 #ifdef RS6000COFF_C 3037 /* XCOFF handles overflows in the reloc and line number count fields 3038 by allocating a new section header to hold the correct counts. */ 3039 for (current = abfd->sections; current != NULL; current = current->next) 3040 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3041 sofar += bfd_coff_scnhsz (abfd); 3042 #endif 3043 3044 #ifdef COFF_IMAGE_WITH_PE 3045 { 3046 /* PE requires the sections to be in memory order when listed in 3047 the section headers. It also does not like empty loadable 3048 sections. The sections apparently do not have to be in the 3049 right order in the image file itself, but we do need to get the 3050 target_index values right. */ 3051 3052 unsigned int count; 3053 asection **section_list; 3054 unsigned int i; 3055 int target_index; 3056 bfd_size_type amt; 3057 3058 count = 0; 3059 for (current = abfd->sections; current != NULL; current = current->next) 3060 ++count; 3061 3062 /* We allocate an extra cell to simplify the final loop. */ 3063 amt = sizeof (struct asection *) * (count + 1); 3064 section_list = bfd_malloc (amt); 3065 if (section_list == NULL) 3066 return FALSE; 3067 3068 i = 0; 3069 for (current = abfd->sections; current != NULL; current = current->next) 3070 { 3071 section_list[i] = current; 3072 ++i; 3073 } 3074 section_list[i] = NULL; 3075 3076 qsort (section_list, count, sizeof (asection *), sort_by_secaddr); 3077 3078 /* Rethread the linked list into sorted order; at the same time, 3079 assign target_index values. */ 3080 target_index = 1; 3081 abfd->sections = NULL; 3082 abfd->section_last = NULL; 3083 for (i = 0; i < count; i++) 3084 { 3085 current = section_list[i]; 3086 bfd_section_list_append (abfd, current); 3087 3088 /* Later, if the section has zero size, we'll be throwing it 3089 away, so we don't want to number it now. Note that having 3090 a zero size and having real contents are different 3091 concepts: .bss has no contents, but (usually) non-zero 3092 size. */ 3093 if (current->size == 0) 3094 { 3095 /* Discard. However, it still might have (valid) symbols 3096 in it, so arbitrarily set it to section 1 (indexing is 3097 1-based here; usually .text). __end__ and other 3098 contents of .endsection really have this happen. 3099 FIXME: This seems somewhat dubious. */ 3100 current->target_index = 1; 3101 } 3102 else 3103 current->target_index = target_index++; 3104 } 3105 3106 free (section_list); 3107 } 3108 #else /* ! COFF_IMAGE_WITH_PE */ 3109 { 3110 /* Set the target_index field. */ 3111 int target_index; 3112 3113 target_index = 1; 3114 for (current = abfd->sections; current != NULL; current = current->next) 3115 current->target_index = target_index++; 3116 } 3117 #endif /* ! COFF_IMAGE_WITH_PE */ 3118 3119 align_adjust = FALSE; 3120 for (current = abfd->sections; 3121 current != NULL; 3122 current = current->next) 3123 { 3124 #ifdef COFF_IMAGE_WITH_PE 3125 /* With PE we have to pad each section to be a multiple of its 3126 page size too, and remember both sizes. */ 3127 if (coff_section_data (abfd, current) == NULL) 3128 { 3129 bfd_size_type amt = sizeof (struct coff_section_tdata); 3130 3131 current->used_by_bfd = bfd_zalloc (abfd, amt); 3132 if (current->used_by_bfd == NULL) 3133 return FALSE; 3134 } 3135 if (pei_section_data (abfd, current) == NULL) 3136 { 3137 bfd_size_type amt = sizeof (struct pei_section_tdata); 3138 3139 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt); 3140 if (coff_section_data (abfd, current)->tdata == NULL) 3141 return FALSE; 3142 } 3143 if (pei_section_data (abfd, current)->virt_size == 0) 3144 pei_section_data (abfd, current)->virt_size = current->size; 3145 #endif 3146 3147 /* Only deal with sections which have contents. */ 3148 if (!(current->flags & SEC_HAS_CONTENTS)) 3149 continue; 3150 3151 #ifdef COFF_IMAGE_WITH_PE 3152 /* Make sure we skip empty sections in a PE image. */ 3153 if (current->size == 0) 3154 continue; 3155 #endif 3156 3157 /* Align the sections in the file to the same boundary on 3158 which they are aligned in virtual memory. I960 doesn't 3159 do this (FIXME) so we can stay in sync with Intel. 960 3160 doesn't yet page from files... */ 3161 #ifdef ALIGN_SECTIONS_IN_FILE 3162 if ((abfd->flags & EXEC_P) != 0) 3163 { 3164 /* Make sure this section is aligned on the right boundary - by 3165 padding the previous section up if necessary. */ 3166 old_sofar = sofar; 3167 3168 #ifdef RS6000COFF_C 3169 /* AIX loader checks the text section alignment of (vma - filepos) 3170 So even though the filepos may be aligned wrt the o_algntext, for 3171 AIX executables, this check fails. This shows up when a native 3172 AIX executable is stripped with gnu strip because the default vma 3173 of native is 0x10000150 but default for gnu is 0x10000140. Gnu 3174 stripped gnu excutable passes this check because the filepos is 3175 0x0140. This problem also show up with 64 bit shared objects. The 3176 data section must also be aligned. */ 3177 if (!strcmp (current->name, _TEXT) 3178 || !strcmp (current->name, _DATA)) 3179 { 3180 bfd_vma pad; 3181 bfd_vma align; 3182 3183 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3184 3185 align = 1 << current->alignment_power; 3186 pad = abs (current->vma - sofar) % align; 3187 3188 if (pad) 3189 { 3190 pad = align - pad; 3191 sofar += pad; 3192 } 3193 } 3194 else 3195 #else 3196 { 3197 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3198 } 3199 #endif 3200 if (previous != NULL) 3201 previous->size += sofar - old_sofar; 3202 } 3203 3204 #endif 3205 3206 /* In demand paged files the low order bits of the file offset 3207 must match the low order bits of the virtual address. */ 3208 #ifdef COFF_PAGE_SIZE 3209 if ((abfd->flags & D_PAGED) != 0 3210 && (current->flags & SEC_ALLOC) != 0) 3211 sofar += (current->vma - (bfd_vma) sofar) % page_size; 3212 #endif 3213 current->filepos = sofar; 3214 3215 #ifdef COFF_IMAGE_WITH_PE 3216 /* Set the padded size. */ 3217 current->size = (current->size + page_size -1) & -page_size; 3218 #endif 3219 3220 sofar += current->size; 3221 3222 #ifdef ALIGN_SECTIONS_IN_FILE 3223 /* Make sure that this section is of the right size too. */ 3224 if ((abfd->flags & EXEC_P) == 0) 3225 { 3226 bfd_size_type old_size; 3227 3228 old_size = current->size; 3229 current->size = BFD_ALIGN (current->size, 3230 1 << current->alignment_power); 3231 align_adjust = current->size != old_size; 3232 sofar += current->size - old_size; 3233 } 3234 else 3235 { 3236 old_sofar = sofar; 3237 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3238 align_adjust = sofar != old_sofar; 3239 current->size += sofar - old_sofar; 3240 } 3241 #endif 3242 3243 #ifdef COFF_IMAGE_WITH_PE 3244 /* For PE we need to make sure we pad out to the aligned 3245 size, in case the caller only writes out data to the 3246 unaligned size. */ 3247 if (pei_section_data (abfd, current)->virt_size < current->size) 3248 align_adjust = TRUE; 3249 #endif 3250 3251 #ifdef _LIB 3252 /* Force .lib sections to start at zero. The vma is then 3253 incremented in coff_set_section_contents. This is right for 3254 SVR3.2. */ 3255 if (strcmp (current->name, _LIB) == 0) 3256 bfd_set_section_vma (abfd, current, 0); 3257 #endif 3258 3259 previous = current; 3260 } 3261 3262 /* It is now safe to write to the output file. If we needed an 3263 alignment adjustment for the last section, then make sure that 3264 there is a byte at offset sofar. If there are no symbols and no 3265 relocs, then nothing follows the last section. If we don't force 3266 the last byte out, then the file may appear to be truncated. */ 3267 if (align_adjust) 3268 { 3269 bfd_byte b; 3270 3271 b = 0; 3272 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0 3273 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3274 return FALSE; 3275 } 3276 3277 /* Make sure the relocations are aligned. We don't need to make 3278 sure that this byte exists, because it will only matter if there 3279 really are relocs. */ 3280 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER); 3281 3282 obj_relocbase (abfd) = sofar; 3283 abfd->output_has_begun = TRUE; 3284 3285 return TRUE; 3286 } 3287 3288 #ifdef COFF_IMAGE_WITH_PE 3289 3290 static unsigned int pelength; 3291 static unsigned int peheader; 3292 3293 static bfd_boolean 3294 coff_read_word (bfd *abfd, unsigned int *value) 3295 { 3296 unsigned char b[2]; 3297 int status; 3298 3299 status = bfd_bread (b, (bfd_size_type) 2, abfd); 3300 if (status < 1) 3301 { 3302 *value = 0; 3303 return FALSE; 3304 } 3305 3306 if (status == 1) 3307 *value = (unsigned int) b[0]; 3308 else 3309 *value = (unsigned int) (b[0] + (b[1] << 8)); 3310 3311 pelength += (unsigned int) status; 3312 3313 return TRUE; 3314 } 3315 3316 static unsigned int 3317 coff_compute_checksum (bfd *abfd) 3318 { 3319 bfd_boolean more_data; 3320 file_ptr filepos; 3321 unsigned int value; 3322 unsigned int total; 3323 3324 total = 0; 3325 pelength = 0; 3326 filepos = (file_ptr) 0; 3327 3328 do 3329 { 3330 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 3331 return 0; 3332 3333 more_data = coff_read_word (abfd, &value); 3334 total += value; 3335 total = 0xffff & (total + (total >> 0x10)); 3336 filepos += 2; 3337 } 3338 while (more_data); 3339 3340 return (0xffff & (total + (total >> 0x10))); 3341 } 3342 3343 static bfd_boolean 3344 coff_apply_checksum (bfd *abfd) 3345 { 3346 unsigned int computed; 3347 unsigned int checksum = 0; 3348 3349 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0) 3350 return FALSE; 3351 3352 if (!coff_read_word (abfd, &peheader)) 3353 return FALSE; 3354 3355 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3356 return FALSE; 3357 3358 checksum = 0; 3359 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3360 3361 if (bfd_seek (abfd, peheader, SEEK_SET) != 0) 3362 return FALSE; 3363 3364 computed = coff_compute_checksum (abfd); 3365 3366 checksum = computed + pelength; 3367 3368 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3369 return FALSE; 3370 3371 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3372 3373 return TRUE; 3374 } 3375 3376 #endif /* COFF_IMAGE_WITH_PE */ 3377 3378 static bfd_boolean 3379 coff_write_object_contents (bfd * abfd) 3380 { 3381 asection *current; 3382 bfd_boolean hasrelocs = FALSE; 3383 bfd_boolean haslinno = FALSE; 3384 bfd_boolean hasdebug = FALSE; 3385 file_ptr scn_base; 3386 file_ptr reloc_base; 3387 file_ptr lineno_base; 3388 file_ptr sym_base; 3389 unsigned long reloc_size = 0, reloc_count = 0; 3390 unsigned long lnno_size = 0; 3391 bfd_boolean long_section_names; 3392 asection *text_sec = NULL; 3393 asection *data_sec = NULL; 3394 asection *bss_sec = NULL; 3395 struct internal_filehdr internal_f; 3396 struct internal_aouthdr internal_a; 3397 #ifdef COFF_LONG_SECTION_NAMES 3398 size_t string_size = STRING_SIZE_SIZE; 3399 #endif 3400 3401 bfd_set_error (bfd_error_system_call); 3402 3403 /* Make a pass through the symbol table to count line number entries and 3404 put them into the correct asections. */ 3405 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd); 3406 3407 if (! abfd->output_has_begun) 3408 { 3409 if (! coff_compute_section_file_positions (abfd)) 3410 return FALSE; 3411 } 3412 3413 reloc_base = obj_relocbase (abfd); 3414 3415 /* Work out the size of the reloc and linno areas. */ 3416 3417 for (current = abfd->sections; current != NULL; current = 3418 current->next) 3419 { 3420 #ifdef COFF_WITH_PE 3421 /* We store the actual reloc count in the first reloc's addr. */ 3422 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3423 reloc_count ++; 3424 #endif 3425 reloc_count += current->reloc_count; 3426 } 3427 3428 reloc_size = reloc_count * bfd_coff_relsz (abfd); 3429 3430 lineno_base = reloc_base + reloc_size; 3431 sym_base = lineno_base + lnno_size; 3432 3433 /* Indicate in each section->line_filepos its actual file address. */ 3434 for (current = abfd->sections; current != NULL; current = 3435 current->next) 3436 { 3437 if (current->lineno_count) 3438 { 3439 current->line_filepos = lineno_base; 3440 current->moving_line_filepos = lineno_base; 3441 lineno_base += current->lineno_count * bfd_coff_linesz (abfd); 3442 } 3443 else 3444 current->line_filepos = 0; 3445 3446 if (current->reloc_count) 3447 { 3448 current->rel_filepos = reloc_base; 3449 reloc_base += current->reloc_count * bfd_coff_relsz (abfd); 3450 #ifdef COFF_WITH_PE 3451 /* Extra reloc to hold real count. */ 3452 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3453 reloc_base += bfd_coff_relsz (abfd); 3454 #endif 3455 } 3456 else 3457 current->rel_filepos = 0; 3458 } 3459 3460 /* Write section headers to the file. */ 3461 internal_f.f_nscns = 0; 3462 3463 if ((abfd->flags & EXEC_P) != 0) 3464 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 3465 else 3466 { 3467 scn_base = bfd_coff_filhsz (abfd); 3468 #ifdef RS6000COFF_C 3469 #ifndef XCOFF64 3470 if (xcoff_data (abfd)->full_aouthdr) 3471 scn_base += bfd_coff_aoutsz (abfd); 3472 else 3473 scn_base += SMALL_AOUTSZ; 3474 #endif 3475 #endif 3476 } 3477 3478 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 3479 return FALSE; 3480 3481 long_section_names = FALSE; 3482 for (current = abfd->sections; 3483 current != NULL; 3484 current = current->next) 3485 { 3486 struct internal_scnhdr section; 3487 bfd_boolean is_reloc_section = FALSE; 3488 3489 #ifdef COFF_IMAGE_WITH_PE 3490 if (strcmp (current->name, ".reloc") == 0) 3491 { 3492 is_reloc_section = TRUE; 3493 hasrelocs = TRUE; 3494 pe_data (abfd)->has_reloc_section = 1; 3495 } 3496 #endif 3497 3498 internal_f.f_nscns++; 3499 3500 strncpy (section.s_name, current->name, SCNNMLEN); 3501 3502 #ifdef COFF_LONG_SECTION_NAMES 3503 /* Handle long section names as in PE. This must be compatible 3504 with the code in coff_write_symbols and _bfd_coff_final_link. */ 3505 { 3506 size_t len; 3507 3508 len = strlen (current->name); 3509 if (len > SCNNMLEN) 3510 { 3511 memset (section.s_name, 0, SCNNMLEN); 3512 sprintf (section.s_name, "/%lu", (unsigned long) string_size); 3513 string_size += len + 1; 3514 long_section_names = TRUE; 3515 } 3516 } 3517 #endif 3518 3519 #ifdef _LIB 3520 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2 3521 Ian Taylor <ian@cygnus.com>. */ 3522 if (strcmp (current->name, _LIB) == 0) 3523 section.s_vaddr = 0; 3524 else 3525 #endif 3526 section.s_vaddr = current->vma; 3527 section.s_paddr = current->lma; 3528 section.s_size = current->size; 3529 #ifdef coff_get_section_load_page 3530 section.s_page = coff_get_section_load_page (current); 3531 #endif 3532 3533 #ifdef COFF_WITH_PE 3534 section.s_paddr = 0; 3535 #endif 3536 #ifdef COFF_IMAGE_WITH_PE 3537 /* Reminder: s_paddr holds the virtual size of the section. */ 3538 if (coff_section_data (abfd, current) != NULL 3539 && pei_section_data (abfd, current) != NULL) 3540 section.s_paddr = pei_section_data (abfd, current)->virt_size; 3541 else 3542 section.s_paddr = 0; 3543 #endif 3544 3545 /* If this section has no size or is unloadable then the scnptr 3546 will be 0 too. */ 3547 if (current->size == 0 3548 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 3549 section.s_scnptr = 0; 3550 else 3551 section.s_scnptr = current->filepos; 3552 3553 section.s_relptr = current->rel_filepos; 3554 section.s_lnnoptr = current->line_filepos; 3555 section.s_nreloc = current->reloc_count; 3556 section.s_nlnno = current->lineno_count; 3557 #ifndef COFF_IMAGE_WITH_PE 3558 /* In PEI, relocs come in the .reloc section. */ 3559 if (current->reloc_count != 0) 3560 hasrelocs = TRUE; 3561 #endif 3562 if (current->lineno_count != 0) 3563 haslinno = TRUE; 3564 if ((current->flags & SEC_DEBUGGING) != 0 3565 && ! is_reloc_section) 3566 hasdebug = TRUE; 3567 3568 #ifdef RS6000COFF_C 3569 #ifndef XCOFF64 3570 /* Indicate the use of an XCOFF overflow section header. */ 3571 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3572 { 3573 section.s_nreloc = 0xffff; 3574 section.s_nlnno = 0xffff; 3575 } 3576 #endif 3577 #endif 3578 3579 section.s_flags = sec_to_styp_flags (current->name, current->flags); 3580 3581 if (!strcmp (current->name, _TEXT)) 3582 text_sec = current; 3583 else if (!strcmp (current->name, _DATA)) 3584 data_sec = current; 3585 else if (!strcmp (current->name, _BSS)) 3586 bss_sec = current; 3587 3588 #ifdef I960 3589 section.s_align = (current->alignment_power 3590 ? 1 << current->alignment_power 3591 : 0); 3592 #endif 3593 #ifdef TIC80COFF 3594 /* TI COFF puts the alignment power in bits 8-11 of the flags. */ 3595 section.s_flags |= (current->alignment_power & 0xF) << 8; 3596 #endif 3597 #ifdef COFF_ENCODE_ALIGNMENT 3598 COFF_ENCODE_ALIGNMENT(section, current->alignment_power); 3599 #endif 3600 3601 #ifdef COFF_IMAGE_WITH_PE 3602 /* Suppress output of the sections if they are null. ld 3603 includes the bss and data sections even if there is no size 3604 assigned to them. NT loader doesn't like it if these section 3605 headers are included if the sections themselves are not 3606 needed. See also coff_compute_section_file_positions. */ 3607 if (section.s_size == 0) 3608 internal_f.f_nscns--; 3609 else 3610 #endif 3611 { 3612 SCNHDR buff; 3613 bfd_size_type amt = bfd_coff_scnhsz (abfd); 3614 3615 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 3616 || bfd_bwrite (& buff, amt, abfd) != amt) 3617 return FALSE; 3618 } 3619 3620 #ifdef COFF_WITH_PE 3621 /* PE stores COMDAT section information in the symbol table. If 3622 this section is supposed to have some COMDAT info, track down 3623 the symbol in the symbol table and modify it. */ 3624 if ((current->flags & SEC_LINK_ONCE) != 0) 3625 { 3626 unsigned int i, count; 3627 asymbol **psym; 3628 coff_symbol_type *csym = NULL; 3629 asymbol **psymsec; 3630 3631 psymsec = NULL; 3632 count = bfd_get_symcount (abfd); 3633 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++) 3634 { 3635 if ((*psym)->section != current) 3636 continue; 3637 3638 /* Remember the location of the first symbol in this 3639 section. */ 3640 if (psymsec == NULL) 3641 psymsec = psym; 3642 3643 /* See if this is the section symbol. */ 3644 if (strcmp ((*psym)->name, current->name) == 0) 3645 { 3646 csym = coff_symbol_from (abfd, *psym); 3647 if (csym == NULL 3648 || csym->native == NULL 3649 || csym->native->u.syment.n_numaux < 1 3650 || csym->native->u.syment.n_sclass != C_STAT 3651 || csym->native->u.syment.n_type != T_NULL) 3652 continue; 3653 3654 /* Here *PSYM is the section symbol for CURRENT. */ 3655 3656 break; 3657 } 3658 } 3659 3660 /* Did we find it? 3661 Note that we might not if we're converting the file from 3662 some other object file format. */ 3663 if (i < count) 3664 { 3665 combined_entry_type *aux; 3666 3667 /* We don't touch the x_checksum field. The 3668 x_associated field is not currently supported. */ 3669 3670 aux = csym->native + 1; 3671 switch (current->flags & SEC_LINK_DUPLICATES) 3672 { 3673 case SEC_LINK_DUPLICATES_DISCARD: 3674 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY; 3675 break; 3676 3677 case SEC_LINK_DUPLICATES_ONE_ONLY: 3678 aux->u.auxent.x_scn.x_comdat = 3679 IMAGE_COMDAT_SELECT_NODUPLICATES; 3680 break; 3681 3682 case SEC_LINK_DUPLICATES_SAME_SIZE: 3683 aux->u.auxent.x_scn.x_comdat = 3684 IMAGE_COMDAT_SELECT_SAME_SIZE; 3685 break; 3686 3687 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 3688 aux->u.auxent.x_scn.x_comdat = 3689 IMAGE_COMDAT_SELECT_EXACT_MATCH; 3690 break; 3691 } 3692 3693 /* The COMDAT symbol must be the first symbol from this 3694 section in the symbol table. In order to make this 3695 work, we move the COMDAT symbol before the first 3696 symbol we found in the search above. It's OK to 3697 rearrange the symbol table at this point, because 3698 coff_renumber_symbols is going to rearrange it 3699 further and fix up all the aux entries. */ 3700 if (psym != psymsec) 3701 { 3702 asymbol *hold; 3703 asymbol **pcopy; 3704 3705 hold = *psym; 3706 for (pcopy = psym; pcopy > psymsec; pcopy--) 3707 pcopy[0] = pcopy[-1]; 3708 *psymsec = hold; 3709 } 3710 } 3711 } 3712 #endif /* COFF_WITH_PE */ 3713 } 3714 3715 #ifdef RS6000COFF_C 3716 #ifndef XCOFF64 3717 /* XCOFF handles overflows in the reloc and line number count fields 3718 by creating a new section header to hold the correct values. */ 3719 for (current = abfd->sections; current != NULL; current = current->next) 3720 { 3721 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3722 { 3723 struct internal_scnhdr scnhdr; 3724 SCNHDR buff; 3725 bfd_size_type amt; 3726 3727 internal_f.f_nscns++; 3728 strncpy (&(scnhdr.s_name[0]), current->name, 8); 3729 scnhdr.s_paddr = current->reloc_count; 3730 scnhdr.s_vaddr = current->lineno_count; 3731 scnhdr.s_size = 0; 3732 scnhdr.s_scnptr = 0; 3733 scnhdr.s_relptr = current->rel_filepos; 3734 scnhdr.s_lnnoptr = current->line_filepos; 3735 scnhdr.s_nreloc = current->target_index; 3736 scnhdr.s_nlnno = current->target_index; 3737 scnhdr.s_flags = STYP_OVRFLO; 3738 amt = bfd_coff_scnhsz (abfd); 3739 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0 3740 || bfd_bwrite (& buff, amt, abfd) != amt) 3741 return FALSE; 3742 } 3743 } 3744 #endif 3745 #endif 3746 3747 /* OK, now set up the filehdr... */ 3748 3749 /* Don't include the internal abs section in the section count */ 3750 3751 /* We will NOT put a fucking timestamp in the header here. Every time you 3752 put it back, I will come in and take it out again. I'm sorry. This 3753 field does not belong here. We fill it with a 0 so it compares the 3754 same but is not a reasonable time. -- gnu@cygnus.com */ 3755 internal_f.f_timdat = 0; 3756 internal_f.f_flags = 0; 3757 3758 if (abfd->flags & EXEC_P) 3759 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3760 else 3761 { 3762 internal_f.f_opthdr = 0; 3763 #ifdef RS6000COFF_C 3764 #ifndef XCOFF64 3765 if (xcoff_data (abfd)->full_aouthdr) 3766 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3767 else 3768 internal_f.f_opthdr = SMALL_AOUTSZ; 3769 #endif 3770 #endif 3771 } 3772 3773 if (!hasrelocs) 3774 internal_f.f_flags |= F_RELFLG; 3775 if (!haslinno) 3776 internal_f.f_flags |= F_LNNO; 3777 if (abfd->flags & EXEC_P) 3778 internal_f.f_flags |= F_EXEC; 3779 #ifdef COFF_IMAGE_WITH_PE 3780 if (! hasdebug) 3781 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED; 3782 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) 3783 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 3784 #endif 3785 3786 #ifndef COFF_WITH_pex64 3787 #ifdef COFF_WITH_PE 3788 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE; 3789 #else 3790 if (bfd_little_endian (abfd)) 3791 internal_f.f_flags |= F_AR32WR; 3792 else 3793 internal_f.f_flags |= F_AR32W; 3794 #endif 3795 #endif 3796 3797 #ifdef TI_TARGET_ID 3798 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field, 3799 but it doesn't hurt to set it internally. */ 3800 internal_f.f_target_id = TI_TARGET_ID; 3801 #endif 3802 #ifdef TIC80_TARGET_ID 3803 internal_f.f_target_id = TIC80_TARGET_ID; 3804 #endif 3805 3806 /* FIXME, should do something about the other byte orders and 3807 architectures. */ 3808 3809 #ifdef RS6000COFF_C 3810 if ((abfd->flags & DYNAMIC) != 0) 3811 internal_f.f_flags |= F_SHROBJ; 3812 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 3813 internal_f.f_flags |= F_DYNLOAD; 3814 #endif 3815 3816 memset (&internal_a, 0, sizeof internal_a); 3817 3818 /* Set up architecture-dependent stuff. */ 3819 { 3820 unsigned int magic = 0; 3821 unsigned short flags = 0; 3822 3823 coff_set_flags (abfd, &magic, &flags); 3824 internal_f.f_magic = magic; 3825 internal_f.f_flags |= flags; 3826 /* ...and the "opt"hdr... */ 3827 3828 #ifdef TICOFF_AOUT_MAGIC 3829 internal_a.magic = TICOFF_AOUT_MAGIC; 3830 #define __A_MAGIC_SET__ 3831 #endif 3832 #ifdef TIC80COFF 3833 internal_a.magic = TIC80_ARCH_MAGIC; 3834 #define __A_MAGIC_SET__ 3835 #endif /* TIC80 */ 3836 #ifdef I860 3837 /* FIXME: What are the a.out magic numbers for the i860? */ 3838 internal_a.magic = 0; 3839 #define __A_MAGIC_SET__ 3840 #endif /* I860 */ 3841 #ifdef I960 3842 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 3843 #define __A_MAGIC_SET__ 3844 #endif /* I960 */ 3845 #if M88 3846 #define __A_MAGIC_SET__ 3847 internal_a.magic = PAGEMAGICBCS; 3848 #endif /* M88 */ 3849 3850 #if APOLLO_M68 3851 #define __A_MAGIC_SET__ 3852 internal_a.magic = APOLLO_COFF_VERSION_NUMBER; 3853 #endif 3854 3855 #if defined(M68) || defined(WE32K) || defined(M68K) 3856 #define __A_MAGIC_SET__ 3857 #if defined(LYNXOS) 3858 internal_a.magic = LYNXCOFFMAGIC; 3859 #else 3860 #if defined(TARG_AUX) 3861 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED : 3862 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED : 3863 PAGEMAGICEXECSWAPPED); 3864 #else 3865 #if defined (PAGEMAGICPEXECPAGED) 3866 internal_a.magic = PAGEMAGICPEXECPAGED; 3867 #endif 3868 #endif /* TARG_AUX */ 3869 #endif /* LYNXOS */ 3870 #endif /* M68 || WE32K || M68K */ 3871 3872 #if defined(ARM) 3873 #define __A_MAGIC_SET__ 3874 internal_a.magic = ZMAGIC; 3875 #endif 3876 3877 #if defined(PPC_PE) 3878 #define __A_MAGIC_SET__ 3879 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 3880 #endif 3881 3882 #if defined MCORE_PE 3883 #define __A_MAGIC_SET__ 3884 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 3885 #endif 3886 3887 #if defined(I386) 3888 #define __A_MAGIC_SET__ 3889 #if defined LYNXOS 3890 internal_a.magic = LYNXCOFFMAGIC; 3891 #elif defined AMD64 3892 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; 3893 #else 3894 internal_a.magic = ZMAGIC; 3895 #endif 3896 #endif /* I386 */ 3897 3898 #if defined(IA64) 3899 #define __A_MAGIC_SET__ 3900 internal_a.magic = PE32PMAGIC; 3901 #endif /* IA64 */ 3902 3903 #if defined(SPARC) 3904 #define __A_MAGIC_SET__ 3905 #if defined(LYNXOS) 3906 internal_a.magic = LYNXCOFFMAGIC; 3907 #endif /* LYNXOS */ 3908 #endif /* SPARC */ 3909 3910 #ifdef RS6000COFF_C 3911 #define __A_MAGIC_SET__ 3912 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC : 3913 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC : 3914 RS6K_AOUTHDR_OMAGIC; 3915 #endif 3916 3917 #if defined(SH) && defined(COFF_WITH_PE) 3918 #define __A_MAGIC_SET__ 3919 internal_a.magic = SH_PE_MAGIC; 3920 #endif 3921 3922 #if defined(MIPS) && defined(COFF_WITH_PE) 3923 #define __A_MAGIC_SET__ 3924 internal_a.magic = MIPS_PE_MAGIC; 3925 #endif 3926 3927 #ifdef OR32 3928 #define __A_MAGIC_SET__ 3929 internal_a.magic = NMAGIC; /* Assume separate i/d. */ 3930 #endif 3931 3932 #ifdef MAXQ20MAGIC 3933 #define __A_MAGIC_SET__ 3934 internal_a.magic = MAXQ20MAGIC; 3935 #endif 3936 3937 #ifndef __A_MAGIC_SET__ 3938 #include "Your aouthdr magic number is not being set!" 3939 #else 3940 #undef __A_MAGIC_SET__ 3941 #endif 3942 } 3943 3944 /* FIXME: Does anybody ever set this to another value? */ 3945 internal_a.vstamp = 0; 3946 3947 /* Now should write relocs, strings, syms. */ 3948 obj_sym_filepos (abfd) = sym_base; 3949 3950 if (bfd_get_symcount (abfd) != 0) 3951 { 3952 int firstundef; 3953 3954 if (!coff_renumber_symbols (abfd, &firstundef)) 3955 return FALSE; 3956 coff_mangle_symbols (abfd); 3957 if (! coff_write_symbols (abfd)) 3958 return FALSE; 3959 if (! coff_write_linenumbers (abfd)) 3960 return FALSE; 3961 if (! coff_write_relocs (abfd, firstundef)) 3962 return FALSE; 3963 } 3964 #ifdef COFF_LONG_SECTION_NAMES 3965 else if (long_section_names && ! obj_coff_strings_written (abfd)) 3966 { 3967 /* If we have long section names we have to write out the string 3968 table even if there are no symbols. */ 3969 if (! coff_write_symbols (abfd)) 3970 return FALSE; 3971 } 3972 #endif 3973 #ifdef COFF_IMAGE_WITH_PE 3974 #ifdef PPC_PE 3975 else if ((abfd->flags & EXEC_P) != 0) 3976 { 3977 bfd_byte b; 3978 3979 /* PowerPC PE appears to require that all executable files be 3980 rounded up to the page size. */ 3981 b = 0; 3982 if (bfd_seek (abfd, 3983 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1, 3984 SEEK_SET) != 0 3985 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3986 return FALSE; 3987 } 3988 #endif 3989 #endif 3990 3991 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 3992 backend linker, and obj_raw_syment_count is not valid until after 3993 coff_write_symbols is called. */ 3994 if (obj_raw_syment_count (abfd) != 0) 3995 { 3996 internal_f.f_symptr = sym_base; 3997 #ifdef RS6000COFF_C 3998 /* AIX appears to require that F_RELFLG not be set if there are 3999 local symbols but no relocations. */ 4000 internal_f.f_flags &=~ F_RELFLG; 4001 #endif 4002 } 4003 else 4004 { 4005 if (long_section_names) 4006 internal_f.f_symptr = sym_base; 4007 else 4008 internal_f.f_symptr = 0; 4009 internal_f.f_flags |= F_LSYMS; 4010 } 4011 4012 if (text_sec) 4013 { 4014 internal_a.tsize = text_sec->size; 4015 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 4016 } 4017 if (data_sec) 4018 { 4019 internal_a.dsize = data_sec->size; 4020 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 4021 } 4022 if (bss_sec) 4023 { 4024 internal_a.bsize = bss_sec->size; 4025 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 4026 internal_a.data_start = bss_sec->vma; 4027 } 4028 4029 internal_a.entry = bfd_get_start_address (abfd); 4030 internal_f.f_nsyms = obj_raw_syment_count (abfd); 4031 4032 #ifdef RS6000COFF_C 4033 if (xcoff_data (abfd)->full_aouthdr) 4034 { 4035 bfd_vma toc; 4036 asection *loader_sec; 4037 4038 internal_a.vstamp = 1; 4039 4040 internal_a.o_snentry = xcoff_data (abfd)->snentry; 4041 if (internal_a.o_snentry == 0) 4042 internal_a.entry = (bfd_vma) -1; 4043 4044 if (text_sec != NULL) 4045 { 4046 internal_a.o_sntext = text_sec->target_index; 4047 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec); 4048 } 4049 else 4050 { 4051 internal_a.o_sntext = 0; 4052 internal_a.o_algntext = 0; 4053 } 4054 if (data_sec != NULL) 4055 { 4056 internal_a.o_sndata = data_sec->target_index; 4057 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec); 4058 } 4059 else 4060 { 4061 internal_a.o_sndata = 0; 4062 internal_a.o_algndata = 0; 4063 } 4064 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 4065 if (loader_sec != NULL) 4066 internal_a.o_snloader = loader_sec->target_index; 4067 else 4068 internal_a.o_snloader = 0; 4069 if (bss_sec != NULL) 4070 internal_a.o_snbss = bss_sec->target_index; 4071 else 4072 internal_a.o_snbss = 0; 4073 4074 toc = xcoff_data (abfd)->toc; 4075 internal_a.o_toc = toc; 4076 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 4077 4078 internal_a.o_modtype = xcoff_data (abfd)->modtype; 4079 if (xcoff_data (abfd)->cputype != -1) 4080 internal_a.o_cputype = xcoff_data (abfd)->cputype; 4081 else 4082 { 4083 switch (bfd_get_arch (abfd)) 4084 { 4085 case bfd_arch_rs6000: 4086 internal_a.o_cputype = 4; 4087 break; 4088 case bfd_arch_powerpc: 4089 if (bfd_get_mach (abfd) == bfd_mach_ppc) 4090 internal_a.o_cputype = 3; 4091 else 4092 internal_a.o_cputype = 1; 4093 break; 4094 default: 4095 abort (); 4096 } 4097 } 4098 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 4099 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 4100 } 4101 #endif 4102 4103 /* Now write them. */ 4104 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 4105 return FALSE; 4106 4107 { 4108 char * buff; 4109 bfd_size_type amount = bfd_coff_filhsz (abfd); 4110 4111 buff = bfd_malloc (amount); 4112 if (buff == NULL) 4113 return FALSE; 4114 4115 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff); 4116 amount = bfd_bwrite (buff, amount, abfd); 4117 4118 free (buff); 4119 4120 if (amount != bfd_coff_filhsz (abfd)) 4121 return FALSE; 4122 } 4123 4124 if (abfd->flags & EXEC_P) 4125 { 4126 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR. 4127 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */ 4128 char * buff; 4129 bfd_size_type amount = bfd_coff_aoutsz (abfd); 4130 4131 buff = bfd_malloc (amount); 4132 if (buff == NULL) 4133 return FALSE; 4134 4135 coff_swap_aouthdr_out (abfd, & internal_a, buff); 4136 amount = bfd_bwrite (buff, amount, abfd); 4137 4138 free (buff); 4139 4140 if (amount != bfd_coff_aoutsz (abfd)) 4141 return FALSE; 4142 4143 #ifdef COFF_IMAGE_WITH_PE 4144 if (! coff_apply_checksum (abfd)) 4145 return FALSE; 4146 #endif 4147 } 4148 #ifdef RS6000COFF_C 4149 else 4150 { 4151 AOUTHDR buff; 4152 size_t size; 4153 4154 /* XCOFF seems to always write at least a small a.out header. */ 4155 coff_swap_aouthdr_out (abfd, & internal_a, & buff); 4156 if (xcoff_data (abfd)->full_aouthdr) 4157 size = bfd_coff_aoutsz (abfd); 4158 else 4159 size = SMALL_AOUTSZ; 4160 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size) 4161 return FALSE; 4162 } 4163 #endif 4164 4165 return TRUE; 4166 } 4167 4168 static bfd_boolean 4169 coff_set_section_contents (bfd * abfd, 4170 sec_ptr section, 4171 const void * location, 4172 file_ptr offset, 4173 bfd_size_type count) 4174 { 4175 if (! abfd->output_has_begun) /* Set by bfd.c handler. */ 4176 { 4177 if (! coff_compute_section_file_positions (abfd)) 4178 return FALSE; 4179 } 4180 4181 #if defined(_LIB) && !defined(TARG_AUX) 4182 /* The physical address field of a .lib section is used to hold the 4183 number of shared libraries in the section. This code counts the 4184 number of sections being written, and increments the lma field 4185 with the number. 4186 4187 I have found no documentation on the contents of this section. 4188 Experimentation indicates that the section contains zero or more 4189 records, each of which has the following structure: 4190 4191 - a (four byte) word holding the length of this record, in words, 4192 - a word that always seems to be set to "2", 4193 - the path to a shared library, null-terminated and then padded 4194 to a whole word boundary. 4195 4196 bfd_assert calls have been added to alert if an attempt is made 4197 to write a section which doesn't follow these assumptions. The 4198 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe 4199 <robertl@arnet.com> (Thanks!). 4200 4201 Gvran Uddeborg <gvran@uddeborg.pp.se>. */ 4202 if (strcmp (section->name, _LIB) == 0) 4203 { 4204 bfd_byte *rec, *recend; 4205 4206 rec = (bfd_byte *) location; 4207 recend = rec + count; 4208 while (rec < recend) 4209 { 4210 ++section->lma; 4211 rec += bfd_get_32 (abfd, rec) * 4; 4212 } 4213 4214 BFD_ASSERT (rec == recend); 4215 } 4216 #endif 4217 4218 /* Don't write out bss sections - one way to do this is to 4219 see if the filepos has not been set. */ 4220 if (section->filepos == 0) 4221 return TRUE; 4222 4223 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0) 4224 return FALSE; 4225 4226 if (count == 0) 4227 return TRUE; 4228 4229 return bfd_bwrite (location, count, abfd) == count; 4230 } 4231 4232 static void * 4233 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size) 4234 { 4235 void * area = bfd_alloc (abfd, size); 4236 4237 if (!area) 4238 return (NULL); 4239 if (bfd_seek (abfd, where, SEEK_SET) != 0 4240 || bfd_bread (area, size, abfd) != size) 4241 return (NULL); 4242 return (area); 4243 } 4244 4245 /* 4246 SUBSUBSECTION 4247 Reading linenumbers 4248 4249 Creating the linenumber table is done by reading in the entire 4250 coff linenumber table, and creating another table for internal use. 4251 4252 A coff linenumber table is structured so that each function 4253 is marked as having a line number of 0. Each line within the 4254 function is an offset from the first line in the function. The 4255 base of the line number information for the table is stored in 4256 the symbol associated with the function. 4257 4258 Note: The PE format uses line number 0 for a flag indicating a 4259 new source file. 4260 4261 The information is copied from the external to the internal 4262 table, and each symbol which marks a function is marked by 4263 pointing its... 4264 4265 How does this work ? 4266 */ 4267 4268 static int 4269 coff_sort_func_alent (const void * arg1, const void * arg2) 4270 { 4271 const alent *al1 = *(const alent **) arg1; 4272 const alent *al2 = *(const alent **) arg2; 4273 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym); 4274 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym); 4275 4276 if (s1->symbol.value < s2->symbol.value) 4277 return -1; 4278 else if (s1->symbol.value > s2->symbol.value) 4279 return 1; 4280 4281 return 0; 4282 } 4283 4284 static bfd_boolean 4285 coff_slurp_line_table (bfd *abfd, asection *asect) 4286 { 4287 LINENO *native_lineno; 4288 alent *lineno_cache; 4289 bfd_size_type amt; 4290 unsigned int counter; 4291 alent *cache_ptr; 4292 bfd_vma prev_offset = 0; 4293 int ordered = 1; 4294 unsigned int nbr_func; 4295 LINENO *src; 4296 4297 BFD_ASSERT (asect->lineno == NULL); 4298 4299 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent); 4300 lineno_cache = bfd_alloc (abfd, amt); 4301 if (lineno_cache == NULL) 4302 return FALSE; 4303 4304 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count; 4305 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt); 4306 if (native_lineno == NULL) 4307 { 4308 (*_bfd_error_handler) 4309 (_("%B: warning: line number table read failed"), abfd); 4310 bfd_release (abfd, lineno_cache); 4311 return FALSE; 4312 } 4313 4314 cache_ptr = lineno_cache; 4315 asect->lineno = lineno_cache; 4316 src = native_lineno; 4317 nbr_func = 0; 4318 4319 for (counter = 0; counter < asect->lineno_count; counter++) 4320 { 4321 struct internal_lineno dst; 4322 4323 bfd_coff_swap_lineno_in (abfd, src, &dst); 4324 cache_ptr->line_number = dst.l_lnno; 4325 4326 if (cache_ptr->line_number == 0) 4327 { 4328 bfd_boolean warned; 4329 bfd_signed_vma symndx; 4330 coff_symbol_type *sym; 4331 4332 nbr_func++; 4333 warned = FALSE; 4334 symndx = dst.l_addr.l_symndx; 4335 if (symndx < 0 4336 || (bfd_vma) symndx >= obj_raw_syment_count (abfd)) 4337 { 4338 (*_bfd_error_handler) 4339 (_("%B: warning: illegal symbol index %ld in line numbers"), 4340 abfd, dst.l_addr.l_symndx); 4341 symndx = 0; 4342 warned = TRUE; 4343 } 4344 4345 /* FIXME: We should not be casting between ints and 4346 pointers like this. */ 4347 sym = ((coff_symbol_type *) 4348 ((symndx + obj_raw_syments (abfd)) 4349 ->u.syment._n._n_n._n_zeroes)); 4350 cache_ptr->u.sym = (asymbol *) sym; 4351 if (sym->lineno != NULL && ! warned) 4352 (*_bfd_error_handler) 4353 (_("%B: warning: duplicate line number information for `%s'"), 4354 abfd, bfd_asymbol_name (&sym->symbol)); 4355 4356 sym->lineno = cache_ptr; 4357 if (sym->symbol.value < prev_offset) 4358 ordered = 0; 4359 prev_offset = sym->symbol.value; 4360 } 4361 else 4362 cache_ptr->u.offset = dst.l_addr.l_paddr 4363 - bfd_section_vma (abfd, asect); 4364 4365 cache_ptr++; 4366 src++; 4367 } 4368 cache_ptr->line_number = 0; 4369 bfd_release (abfd, native_lineno); 4370 4371 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */ 4372 if (!ordered) 4373 { 4374 /* Sort the table. */ 4375 alent **func_table; 4376 alent *n_lineno_cache; 4377 4378 /* Create a table of functions. */ 4379 func_table = bfd_alloc (abfd, nbr_func * sizeof (alent *)); 4380 if (func_table != NULL) 4381 { 4382 alent **p = func_table; 4383 unsigned int i; 4384 4385 for (i = 0; i < counter; i++) 4386 if (lineno_cache[i].line_number == 0) 4387 *p++ = &lineno_cache[i]; 4388 4389 /* Sort by functions. */ 4390 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent); 4391 4392 /* Create the new sorted table. */ 4393 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent); 4394 n_lineno_cache = bfd_alloc (abfd, amt); 4395 if (n_lineno_cache != NULL) 4396 { 4397 alent *n_cache_ptr = n_lineno_cache; 4398 4399 for (i = 0; i < nbr_func; i++) 4400 { 4401 coff_symbol_type *sym; 4402 alent *old_ptr = func_table[i]; 4403 4404 /* Copy the function entry and update it. */ 4405 *n_cache_ptr = *old_ptr; 4406 sym = (coff_symbol_type *)n_cache_ptr->u.sym; 4407 sym->lineno = n_cache_ptr; 4408 n_cache_ptr++; 4409 old_ptr++; 4410 4411 /* Copy the line number entries. */ 4412 while (old_ptr->line_number != 0) 4413 *n_cache_ptr++ = *old_ptr++; 4414 } 4415 n_cache_ptr->line_number = 0; 4416 memcpy (lineno_cache, n_lineno_cache, amt); 4417 } 4418 bfd_release (abfd, func_table); 4419 } 4420 } 4421 4422 return TRUE; 4423 } 4424 4425 /* Slurp in the symbol table, converting it to generic form. Note 4426 that if coff_relocate_section is defined, the linker will read 4427 symbols via coff_link_add_symbols, rather than via this routine. */ 4428 4429 static bfd_boolean 4430 coff_slurp_symbol_table (bfd * abfd) 4431 { 4432 combined_entry_type *native_symbols; 4433 coff_symbol_type *cached_area; 4434 unsigned int *table_ptr; 4435 bfd_size_type amt; 4436 unsigned int number_of_symbols = 0; 4437 4438 if (obj_symbols (abfd)) 4439 return TRUE; 4440 4441 /* Read in the symbol table. */ 4442 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL) 4443 return FALSE; 4444 4445 /* Allocate enough room for all the symbols in cached form. */ 4446 amt = obj_raw_syment_count (abfd); 4447 amt *= sizeof (coff_symbol_type); 4448 cached_area = bfd_alloc (abfd, amt); 4449 if (cached_area == NULL) 4450 return FALSE; 4451 4452 amt = obj_raw_syment_count (abfd); 4453 amt *= sizeof (unsigned int); 4454 table_ptr = bfd_alloc (abfd, amt); 4455 4456 if (table_ptr == NULL) 4457 return FALSE; 4458 else 4459 { 4460 coff_symbol_type *dst = cached_area; 4461 unsigned int last_native_index = obj_raw_syment_count (abfd); 4462 unsigned int this_index = 0; 4463 4464 while (this_index < last_native_index) 4465 { 4466 combined_entry_type *src = native_symbols + this_index; 4467 table_ptr[this_index] = number_of_symbols; 4468 dst->symbol.the_bfd = abfd; 4469 4470 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset); 4471 /* We use the native name field to point to the cached field. */ 4472 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst; 4473 dst->symbol.section = coff_section_from_bfd_index (abfd, 4474 src->u.syment.n_scnum); 4475 dst->symbol.flags = 0; 4476 dst->done_lineno = FALSE; 4477 4478 switch (src->u.syment.n_sclass) 4479 { 4480 #ifdef I960 4481 case C_LEAFEXT: 4482 /* Fall through to next case. */ 4483 #endif 4484 4485 case C_EXT: 4486 case C_WEAKEXT: 4487 #if defined ARM 4488 case C_THUMBEXT: 4489 case C_THUMBEXTFUNC: 4490 #endif 4491 #ifdef RS6000COFF_C 4492 case C_HIDEXT: 4493 #endif 4494 #ifdef C_SYSTEM 4495 case C_SYSTEM: /* System Wide variable. */ 4496 #endif 4497 #ifdef COFF_WITH_PE 4498 /* In PE, 0x68 (104) denotes a section symbol. */ 4499 case C_SECTION: 4500 /* In PE, 0x69 (105) denotes a weak external symbol. */ 4501 case C_NT_WEAK: 4502 #endif 4503 switch (coff_classify_symbol (abfd, &src->u.syment)) 4504 { 4505 case COFF_SYMBOL_GLOBAL: 4506 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 4507 #if defined COFF_WITH_PE 4508 /* PE sets the symbol to a value relative to the 4509 start of the section. */ 4510 dst->symbol.value = src->u.syment.n_value; 4511 #else 4512 dst->symbol.value = (src->u.syment.n_value 4513 - dst->symbol.section->vma); 4514 #endif 4515 if (ISFCN ((src->u.syment.n_type))) 4516 /* A function ext does not go at the end of a 4517 file. */ 4518 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4519 break; 4520 4521 case COFF_SYMBOL_COMMON: 4522 dst->symbol.section = bfd_com_section_ptr; 4523 dst->symbol.value = src->u.syment.n_value; 4524 break; 4525 4526 case COFF_SYMBOL_UNDEFINED: 4527 dst->symbol.section = bfd_und_section_ptr; 4528 dst->symbol.value = 0; 4529 break; 4530 4531 case COFF_SYMBOL_PE_SECTION: 4532 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM; 4533 dst->symbol.value = 0; 4534 break; 4535 4536 case COFF_SYMBOL_LOCAL: 4537 dst->symbol.flags = BSF_LOCAL; 4538 #if defined COFF_WITH_PE 4539 /* PE sets the symbol to a value relative to the 4540 start of the section. */ 4541 dst->symbol.value = src->u.syment.n_value; 4542 #else 4543 dst->symbol.value = (src->u.syment.n_value 4544 - dst->symbol.section->vma); 4545 #endif 4546 if (ISFCN ((src->u.syment.n_type))) 4547 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4548 break; 4549 } 4550 4551 #ifdef RS6000COFF_C 4552 /* A symbol with a csect entry should not go at the end. */ 4553 if (src->u.syment.n_numaux > 0) 4554 dst->symbol.flags |= BSF_NOT_AT_END; 4555 #endif 4556 4557 #ifdef COFF_WITH_PE 4558 if (src->u.syment.n_sclass == C_NT_WEAK) 4559 dst->symbol.flags |= BSF_WEAK; 4560 4561 if (src->u.syment.n_sclass == C_SECTION 4562 && src->u.syment.n_scnum > 0) 4563 dst->symbol.flags = BSF_LOCAL; 4564 #endif 4565 if (src->u.syment.n_sclass == C_WEAKEXT) 4566 dst->symbol.flags |= BSF_WEAK; 4567 4568 break; 4569 4570 case C_STAT: /* Static. */ 4571 #ifdef I960 4572 case C_LEAFSTAT: /* Static leaf procedure. */ 4573 #endif 4574 #if defined ARM 4575 case C_THUMBSTAT: /* Thumb static. */ 4576 case C_THUMBLABEL: /* Thumb label. */ 4577 case C_THUMBSTATFUNC:/* Thumb static function. */ 4578 #endif 4579 case C_LABEL: /* Label. */ 4580 if (src->u.syment.n_scnum == N_DEBUG) 4581 dst->symbol.flags = BSF_DEBUGGING; 4582 else 4583 dst->symbol.flags = BSF_LOCAL; 4584 4585 /* Base the value as an index from the base of the 4586 section, if there is one. */ 4587 if (dst->symbol.section) 4588 { 4589 #if defined COFF_WITH_PE 4590 /* PE sets the symbol to a value relative to the 4591 start of the section. */ 4592 dst->symbol.value = src->u.syment.n_value; 4593 #else 4594 dst->symbol.value = (src->u.syment.n_value 4595 - dst->symbol.section->vma); 4596 #endif 4597 } 4598 else 4599 dst->symbol.value = src->u.syment.n_value; 4600 break; 4601 4602 case C_MOS: /* Member of structure. */ 4603 case C_EOS: /* End of structure. */ 4604 case C_REGPARM: /* Register parameter. */ 4605 case C_REG: /* register variable. */ 4606 /* C_AUTOARG conflicts with TI COFF C_UEXT. */ 4607 #if !defined (TIC80COFF) && !defined (TICOFF) 4608 #ifdef C_AUTOARG 4609 case C_AUTOARG: /* 960-specific storage class. */ 4610 #endif 4611 #endif 4612 case C_TPDEF: /* Type definition. */ 4613 case C_ARG: 4614 case C_AUTO: /* Automatic variable. */ 4615 case C_FIELD: /* Bit field. */ 4616 case C_ENTAG: /* Enumeration tag. */ 4617 case C_MOE: /* Member of enumeration. */ 4618 case C_MOU: /* Member of union. */ 4619 case C_UNTAG: /* Union tag. */ 4620 dst->symbol.flags = BSF_DEBUGGING; 4621 dst->symbol.value = (src->u.syment.n_value); 4622 break; 4623 4624 case C_FILE: /* File name. */ 4625 case C_STRTAG: /* Structure tag. */ 4626 #ifdef RS6000COFF_C 4627 case C_GSYM: 4628 case C_LSYM: 4629 case C_PSYM: 4630 case C_RSYM: 4631 case C_RPSYM: 4632 case C_STSYM: 4633 case C_TCSYM: 4634 case C_BCOMM: 4635 case C_ECOML: 4636 case C_ECOMM: 4637 case C_DECL: 4638 case C_ENTRY: 4639 case C_FUN: 4640 case C_ESTAT: 4641 #endif 4642 dst->symbol.flags = BSF_DEBUGGING; 4643 dst->symbol.value = (src->u.syment.n_value); 4644 break; 4645 4646 #ifdef RS6000COFF_C 4647 case C_BINCL: /* Beginning of include file. */ 4648 case C_EINCL: /* Ending of include file. */ 4649 /* The value is actually a pointer into the line numbers 4650 of the file. We locate the line number entry, and 4651 set the section to the section which contains it, and 4652 the value to the index in that section. */ 4653 { 4654 asection *sec; 4655 4656 dst->symbol.flags = BSF_DEBUGGING; 4657 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4658 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value 4659 && ((file_ptr) (sec->line_filepos 4660 + sec->lineno_count * bfd_coff_linesz (abfd)) 4661 > (file_ptr) src->u.syment.n_value)) 4662 break; 4663 if (sec == NULL) 4664 dst->symbol.value = 0; 4665 else 4666 { 4667 dst->symbol.section = sec; 4668 dst->symbol.value = ((src->u.syment.n_value 4669 - sec->line_filepos) 4670 / bfd_coff_linesz (abfd)); 4671 src->fix_line = 1; 4672 } 4673 } 4674 break; 4675 4676 case C_BSTAT: 4677 dst->symbol.flags = BSF_DEBUGGING; 4678 4679 /* The value is actually a symbol index. Save a pointer 4680 to the symbol instead of the index. FIXME: This 4681 should use a union. */ 4682 src->u.syment.n_value = 4683 (long) (native_symbols + src->u.syment.n_value); 4684 dst->symbol.value = src->u.syment.n_value; 4685 src->fix_value = 1; 4686 break; 4687 #endif 4688 4689 case C_BLOCK: /* ".bb" or ".eb". */ 4690 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */ 4691 case C_EFCN: /* Physical end of function. */ 4692 #if defined COFF_WITH_PE 4693 /* PE sets the symbol to a value relative to the start 4694 of the section. */ 4695 dst->symbol.value = src->u.syment.n_value; 4696 if (strcmp (dst->symbol.name, ".bf") != 0) 4697 { 4698 /* PE uses funny values for .ef and .lf; don't 4699 relocate them. */ 4700 dst->symbol.flags = BSF_DEBUGGING; 4701 } 4702 else 4703 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC; 4704 #else 4705 /* Base the value as an index from the base of the 4706 section. */ 4707 dst->symbol.flags = BSF_LOCAL; 4708 dst->symbol.value = (src->u.syment.n_value 4709 - dst->symbol.section->vma); 4710 #endif 4711 break; 4712 4713 case C_STATLAB: /* Static load time label. */ 4714 dst->symbol.value = src->u.syment.n_value; 4715 dst->symbol.flags = BSF_GLOBAL; 4716 break; 4717 4718 case C_NULL: 4719 /* PE DLLs sometimes have zeroed out symbols for some 4720 reason. Just ignore them without a warning. */ 4721 if (src->u.syment.n_type == 0 4722 && src->u.syment.n_value == 0 4723 && src->u.syment.n_scnum == 0) 4724 break; 4725 /* Fall through. */ 4726 case C_EXTDEF: /* External definition. */ 4727 case C_ULABEL: /* Undefined label. */ 4728 case C_USTATIC: /* Undefined static. */ 4729 #ifndef COFF_WITH_PE 4730 /* C_LINE in regular coff is 0x68. NT has taken over this storage 4731 class to represent a section symbol. */ 4732 case C_LINE: /* line # reformatted as symbol table entry. */ 4733 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 4734 case C_ALIAS: /* Duplicate tag. */ 4735 #endif 4736 /* New storage classes for TI COFF. */ 4737 #if defined(TIC80COFF) || defined(TICOFF) 4738 case C_UEXT: /* Tentative external definition. */ 4739 #endif 4740 case C_EXTLAB: /* External load time label. */ 4741 case C_HIDDEN: /* Ext symbol in dmert public lib. */ 4742 default: 4743 (*_bfd_error_handler) 4744 (_("%B: Unrecognized storage class %d for %s symbol `%s'"), 4745 abfd, src->u.syment.n_sclass, 4746 dst->symbol.section->name, dst->symbol.name); 4747 dst->symbol.flags = BSF_DEBUGGING; 4748 dst->symbol.value = (src->u.syment.n_value); 4749 break; 4750 } 4751 4752 dst->native = src; 4753 4754 dst->symbol.udata.i = 0; 4755 dst->lineno = NULL; 4756 this_index += (src->u.syment.n_numaux) + 1; 4757 dst++; 4758 number_of_symbols++; 4759 } 4760 } 4761 4762 obj_symbols (abfd) = cached_area; 4763 obj_raw_syments (abfd) = native_symbols; 4764 4765 bfd_get_symcount (abfd) = number_of_symbols; 4766 obj_convert (abfd) = table_ptr; 4767 /* Slurp the line tables for each section too. */ 4768 { 4769 asection *p; 4770 4771 p = abfd->sections; 4772 while (p) 4773 { 4774 coff_slurp_line_table (abfd, p); 4775 p = p->next; 4776 } 4777 } 4778 4779 return TRUE; 4780 } 4781 4782 /* Classify a COFF symbol. A couple of targets have globally visible 4783 symbols which are not class C_EXT, and this handles those. It also 4784 recognizes some special PE cases. */ 4785 4786 static enum coff_symbol_classification 4787 coff_classify_symbol (bfd *abfd, 4788 struct internal_syment *syment) 4789 { 4790 /* FIXME: This partially duplicates the switch in 4791 coff_slurp_symbol_table. */ 4792 switch (syment->n_sclass) 4793 { 4794 case C_EXT: 4795 case C_WEAKEXT: 4796 #ifdef I960 4797 case C_LEAFEXT: 4798 #endif 4799 #ifdef ARM 4800 case C_THUMBEXT: 4801 case C_THUMBEXTFUNC: 4802 #endif 4803 #ifdef C_SYSTEM 4804 case C_SYSTEM: 4805 #endif 4806 #ifdef COFF_WITH_PE 4807 case C_NT_WEAK: 4808 #endif 4809 if (syment->n_scnum == 0) 4810 { 4811 if (syment->n_value == 0) 4812 return COFF_SYMBOL_UNDEFINED; 4813 else 4814 return COFF_SYMBOL_COMMON; 4815 } 4816 return COFF_SYMBOL_GLOBAL; 4817 4818 default: 4819 break; 4820 } 4821 4822 #ifdef COFF_WITH_PE 4823 if (syment->n_sclass == C_STAT) 4824 { 4825 if (syment->n_scnum == 0) 4826 /* The Microsoft compiler sometimes generates these if a 4827 small static function is inlined every time it is used. 4828 The function is discarded, but the symbol table entry 4829 remains. */ 4830 return COFF_SYMBOL_LOCAL; 4831 4832 #ifdef STRICT_PE_FORMAT 4833 /* This is correct for Microsoft generated objects, but it 4834 breaks gas generated objects. */ 4835 if (syment->n_value == 0) 4836 { 4837 asection *sec; 4838 char buf[SYMNMLEN + 1]; 4839 4840 sec = coff_section_from_bfd_index (abfd, syment->n_scnum); 4841 if (sec != NULL 4842 && (strcmp (bfd_get_section_name (abfd, sec), 4843 _bfd_coff_internal_syment_name (abfd, syment, buf)) 4844 == 0)) 4845 return COFF_SYMBOL_PE_SECTION; 4846 } 4847 #endif 4848 4849 return COFF_SYMBOL_LOCAL; 4850 } 4851 4852 if (syment->n_sclass == C_SECTION) 4853 { 4854 /* In some cases in a DLL generated by the Microsoft linker, the 4855 n_value field will contain garbage. FIXME: This should 4856 probably be handled by the swapping function instead. */ 4857 syment->n_value = 0; 4858 if (syment->n_scnum == 0) 4859 return COFF_SYMBOL_UNDEFINED; 4860 return COFF_SYMBOL_PE_SECTION; 4861 } 4862 #endif /* COFF_WITH_PE */ 4863 4864 /* If it is not a global symbol, we presume it is a local symbol. */ 4865 if (syment->n_scnum == 0) 4866 { 4867 char buf[SYMNMLEN + 1]; 4868 4869 (*_bfd_error_handler) 4870 (_("warning: %B: local symbol `%s' has no section"), 4871 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf)); 4872 } 4873 4874 return COFF_SYMBOL_LOCAL; 4875 } 4876 4877 /* 4878 SUBSUBSECTION 4879 Reading relocations 4880 4881 Coff relocations are easily transformed into the internal BFD form 4882 (@code{arelent}). 4883 4884 Reading a coff relocation table is done in the following stages: 4885 4886 o Read the entire coff relocation table into memory. 4887 4888 o Process each relocation in turn; first swap it from the 4889 external to the internal form. 4890 4891 o Turn the symbol referenced in the relocation's symbol index 4892 into a pointer into the canonical symbol table. 4893 This table is the same as the one returned by a call to 4894 @code{bfd_canonicalize_symtab}. The back end will call that 4895 routine and save the result if a canonicalization hasn't been done. 4896 4897 o The reloc index is turned into a pointer to a howto 4898 structure, in a back end specific way. For instance, the 386 4899 and 960 use the @code{r_type} to directly produce an index 4900 into a howto table vector; the 88k subtracts a number from the 4901 @code{r_type} field and creates an addend field. 4902 */ 4903 4904 #ifndef CALC_ADDEND 4905 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 4906 { \ 4907 coff_symbol_type *coffsym = NULL; \ 4908 \ 4909 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 4910 coffsym = (obj_symbols (abfd) \ 4911 + (cache_ptr->sym_ptr_ptr - symbols)); \ 4912 else if (ptr) \ 4913 coffsym = coff_symbol_from (abfd, ptr); \ 4914 if (coffsym != NULL \ 4915 && coffsym->native->u.syment.n_scnum == 0) \ 4916 cache_ptr->addend = 0; \ 4917 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 4918 && ptr->section != NULL) \ 4919 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 4920 else \ 4921 cache_ptr->addend = 0; \ 4922 } 4923 #endif 4924 4925 static bfd_boolean 4926 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols) 4927 { 4928 RELOC *native_relocs; 4929 arelent *reloc_cache; 4930 arelent *cache_ptr; 4931 unsigned int idx; 4932 bfd_size_type amt; 4933 4934 if (asect->relocation) 4935 return TRUE; 4936 if (asect->reloc_count == 0) 4937 return TRUE; 4938 if (asect->flags & SEC_CONSTRUCTOR) 4939 return TRUE; 4940 if (!coff_slurp_symbol_table (abfd)) 4941 return FALSE; 4942 4943 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count; 4944 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt); 4945 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent); 4946 reloc_cache = bfd_alloc (abfd, amt); 4947 4948 if (reloc_cache == NULL || native_relocs == NULL) 4949 return FALSE; 4950 4951 for (idx = 0; idx < asect->reloc_count; idx++) 4952 { 4953 struct internal_reloc dst; 4954 struct external_reloc *src; 4955 #ifndef RELOC_PROCESSING 4956 asymbol *ptr; 4957 #endif 4958 4959 cache_ptr = reloc_cache + idx; 4960 src = native_relocs + idx; 4961 4962 dst.r_offset = 0; 4963 coff_swap_reloc_in (abfd, src, &dst); 4964 4965 #ifdef RELOC_PROCESSING 4966 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect); 4967 #else 4968 cache_ptr->address = dst.r_vaddr; 4969 4970 if (dst.r_symndx != -1) 4971 { 4972 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd)) 4973 { 4974 (*_bfd_error_handler) 4975 (_("%B: warning: illegal symbol index %ld in relocs"), 4976 abfd, dst.r_symndx); 4977 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 4978 ptr = NULL; 4979 } 4980 else 4981 { 4982 cache_ptr->sym_ptr_ptr = (symbols 4983 + obj_convert (abfd)[dst.r_symndx]); 4984 ptr = *(cache_ptr->sym_ptr_ptr); 4985 } 4986 } 4987 else 4988 { 4989 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 4990 ptr = NULL; 4991 } 4992 4993 /* The symbols definitions that we have read in have been 4994 relocated as if their sections started at 0. But the offsets 4995 refering to the symbols in the raw data have not been 4996 modified, so we have to have a negative addend to compensate. 4997 4998 Note that symbols which used to be common must be left alone. */ 4999 5000 /* Calculate any reloc addend by looking at the symbol. */ 5001 CALC_ADDEND (abfd, ptr, dst, cache_ptr); 5002 5003 cache_ptr->address -= asect->vma; 5004 /* !! cache_ptr->section = NULL;*/ 5005 5006 /* Fill in the cache_ptr->howto field from dst.r_type. */ 5007 RTYPE2HOWTO (cache_ptr, &dst); 5008 #endif /* RELOC_PROCESSING */ 5009 5010 if (cache_ptr->howto == NULL) 5011 { 5012 (*_bfd_error_handler) 5013 (_("%B: illegal relocation type %d at address 0x%lx"), 5014 abfd, dst.r_type, (long) dst.r_vaddr); 5015 bfd_set_error (bfd_error_bad_value); 5016 return FALSE; 5017 } 5018 } 5019 5020 asect->relocation = reloc_cache; 5021 return TRUE; 5022 } 5023 5024 #ifndef coff_rtype_to_howto 5025 #ifdef RTYPE2HOWTO 5026 5027 /* Get the howto structure for a reloc. This is only used if the file 5028 including this one defines coff_relocate_section to be 5029 _bfd_coff_generic_relocate_section, so it is OK if it does not 5030 always work. It is the responsibility of the including file to 5031 make sure it is reasonable if it is needed. */ 5032 5033 static reloc_howto_type * 5034 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 5035 asection *sec ATTRIBUTE_UNUSED, 5036 struct internal_reloc *rel, 5037 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED, 5038 struct internal_syment *sym ATTRIBUTE_UNUSED, 5039 bfd_vma *addendp ATTRIBUTE_UNUSED) 5040 { 5041 arelent genrel; 5042 5043 genrel.howto = NULL; 5044 RTYPE2HOWTO (&genrel, rel); 5045 return genrel.howto; 5046 } 5047 5048 #else /* ! defined (RTYPE2HOWTO) */ 5049 5050 #define coff_rtype_to_howto NULL 5051 5052 #endif /* ! defined (RTYPE2HOWTO) */ 5053 #endif /* ! defined (coff_rtype_to_howto) */ 5054 5055 /* This is stupid. This function should be a boolean predicate. */ 5056 5057 static long 5058 coff_canonicalize_reloc (bfd * abfd, 5059 sec_ptr section, 5060 arelent ** relptr, 5061 asymbol ** symbols) 5062 { 5063 arelent *tblptr = section->relocation; 5064 unsigned int count = 0; 5065 5066 if (section->flags & SEC_CONSTRUCTOR) 5067 { 5068 /* This section has relocs made up by us, they are not in the 5069 file, so take them out of their chain and place them into 5070 the data area provided. */ 5071 arelent_chain *chain = section->constructor_chain; 5072 5073 for (count = 0; count < section->reloc_count; count++) 5074 { 5075 *relptr++ = &chain->relent; 5076 chain = chain->next; 5077 } 5078 } 5079 else 5080 { 5081 if (! coff_slurp_reloc_table (abfd, section, symbols)) 5082 return -1; 5083 5084 tblptr = section->relocation; 5085 5086 for (; count++ < section->reloc_count;) 5087 *relptr++ = tblptr++; 5088 } 5089 *relptr = 0; 5090 return section->reloc_count; 5091 } 5092 5093 #ifndef coff_reloc16_estimate 5094 #define coff_reloc16_estimate dummy_reloc16_estimate 5095 5096 static int 5097 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED, 5098 asection *input_section ATTRIBUTE_UNUSED, 5099 arelent *reloc ATTRIBUTE_UNUSED, 5100 unsigned int shrink ATTRIBUTE_UNUSED, 5101 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 5102 { 5103 abort (); 5104 return 0; 5105 } 5106 5107 #endif 5108 5109 #ifndef coff_reloc16_extra_cases 5110 5111 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases 5112 5113 /* This works even if abort is not declared in any header file. */ 5114 5115 static void 5116 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED, 5117 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 5118 struct bfd_link_order *link_order ATTRIBUTE_UNUSED, 5119 arelent *reloc ATTRIBUTE_UNUSED, 5120 bfd_byte *data ATTRIBUTE_UNUSED, 5121 unsigned int *src_ptr ATTRIBUTE_UNUSED, 5122 unsigned int *dst_ptr ATTRIBUTE_UNUSED) 5123 { 5124 abort (); 5125 } 5126 #endif 5127 5128 #ifndef coff_bfd_link_hash_table_free 5129 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 5130 #endif 5131 5132 /* If coff_relocate_section is defined, we can use the optimized COFF 5133 backend linker. Otherwise we must continue to use the old linker. */ 5134 5135 #ifdef coff_relocate_section 5136 5137 #ifndef coff_bfd_link_hash_table_create 5138 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create 5139 #endif 5140 #ifndef coff_bfd_link_add_symbols 5141 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols 5142 #endif 5143 #ifndef coff_bfd_final_link 5144 #define coff_bfd_final_link _bfd_coff_final_link 5145 #endif 5146 5147 #else /* ! defined (coff_relocate_section) */ 5148 5149 #define coff_relocate_section NULL 5150 #ifndef coff_bfd_link_hash_table_create 5151 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 5152 #endif 5153 #ifndef coff_bfd_link_add_symbols 5154 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols 5155 #endif 5156 #define coff_bfd_final_link _bfd_generic_final_link 5157 5158 #endif /* ! defined (coff_relocate_section) */ 5159 5160 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms 5161 #define coff_bfd_link_split_section _bfd_generic_link_split_section 5162 5163 #ifndef coff_start_final_link 5164 #define coff_start_final_link NULL 5165 #endif 5166 5167 #ifndef coff_adjust_symndx 5168 #define coff_adjust_symndx NULL 5169 #endif 5170 5171 #ifndef coff_link_add_one_symbol 5172 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol 5173 #endif 5174 5175 #ifndef coff_link_output_has_begun 5176 5177 static bfd_boolean 5178 coff_link_output_has_begun (bfd * abfd, 5179 struct coff_final_link_info * info ATTRIBUTE_UNUSED) 5180 { 5181 return abfd->output_has_begun; 5182 } 5183 #endif 5184 5185 #ifndef coff_final_link_postscript 5186 5187 static bfd_boolean 5188 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED, 5189 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED) 5190 { 5191 return TRUE; 5192 } 5193 #endif 5194 5195 #ifndef coff_SWAP_aux_in 5196 #define coff_SWAP_aux_in coff_swap_aux_in 5197 #endif 5198 #ifndef coff_SWAP_sym_in 5199 #define coff_SWAP_sym_in coff_swap_sym_in 5200 #endif 5201 #ifndef coff_SWAP_lineno_in 5202 #define coff_SWAP_lineno_in coff_swap_lineno_in 5203 #endif 5204 #ifndef coff_SWAP_aux_out 5205 #define coff_SWAP_aux_out coff_swap_aux_out 5206 #endif 5207 #ifndef coff_SWAP_sym_out 5208 #define coff_SWAP_sym_out coff_swap_sym_out 5209 #endif 5210 #ifndef coff_SWAP_lineno_out 5211 #define coff_SWAP_lineno_out coff_swap_lineno_out 5212 #endif 5213 #ifndef coff_SWAP_reloc_out 5214 #define coff_SWAP_reloc_out coff_swap_reloc_out 5215 #endif 5216 #ifndef coff_SWAP_filehdr_out 5217 #define coff_SWAP_filehdr_out coff_swap_filehdr_out 5218 #endif 5219 #ifndef coff_SWAP_aouthdr_out 5220 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out 5221 #endif 5222 #ifndef coff_SWAP_scnhdr_out 5223 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out 5224 #endif 5225 #ifndef coff_SWAP_reloc_in 5226 #define coff_SWAP_reloc_in coff_swap_reloc_in 5227 #endif 5228 #ifndef coff_SWAP_filehdr_in 5229 #define coff_SWAP_filehdr_in coff_swap_filehdr_in 5230 #endif 5231 #ifndef coff_SWAP_aouthdr_in 5232 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in 5233 #endif 5234 #ifndef coff_SWAP_scnhdr_in 5235 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in 5236 #endif 5237 5238 static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED = 5239 { 5240 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5241 coff_SWAP_aux_out, coff_SWAP_sym_out, 5242 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5243 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5244 coff_SWAP_scnhdr_out, 5245 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5246 #ifdef COFF_LONG_FILENAMES 5247 TRUE, 5248 #else 5249 FALSE, 5250 #endif 5251 #ifdef COFF_LONG_SECTION_NAMES 5252 TRUE, 5253 #else 5254 FALSE, 5255 #endif 5256 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5257 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5258 TRUE, 5259 #else 5260 FALSE, 5261 #endif 5262 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5263 4, 5264 #else 5265 2, 5266 #endif 5267 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5268 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, 5269 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5270 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5271 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5272 coff_classify_symbol, coff_compute_section_file_positions, 5273 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5274 coff_adjust_symndx, coff_link_add_one_symbol, 5275 coff_link_output_has_begun, coff_final_link_postscript, 5276 bfd_pe_print_pdata 5277 }; 5278 5279 #ifdef TICOFF 5280 /* COFF0 differs in file/section header size and relocation entry size. */ 5281 5282 static const bfd_coff_backend_data ticoff0_swap_table = 5283 { 5284 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5285 coff_SWAP_aux_out, coff_SWAP_sym_out, 5286 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5287 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5288 coff_SWAP_scnhdr_out, 5289 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN, 5290 #ifdef COFF_LONG_FILENAMES 5291 TRUE, 5292 #else 5293 FALSE, 5294 #endif 5295 #ifdef COFF_LONG_SECTION_NAMES 5296 TRUE, 5297 #else 5298 FALSE, 5299 #endif 5300 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5301 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5302 TRUE, 5303 #else 5304 FALSE, 5305 #endif 5306 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5307 4, 5308 #else 5309 2, 5310 #endif 5311 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5312 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook, 5313 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5314 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5315 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5316 coff_classify_symbol, coff_compute_section_file_positions, 5317 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5318 coff_adjust_symndx, coff_link_add_one_symbol, 5319 coff_link_output_has_begun, coff_final_link_postscript, 5320 bfd_pe_print_pdata 5321 }; 5322 #endif 5323 5324 #ifdef TICOFF 5325 /* COFF1 differs in section header size. */ 5326 5327 static const bfd_coff_backend_data ticoff1_swap_table = 5328 { 5329 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5330 coff_SWAP_aux_out, coff_SWAP_sym_out, 5331 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5332 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5333 coff_SWAP_scnhdr_out, 5334 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5335 #ifdef COFF_LONG_FILENAMES 5336 TRUE, 5337 #else 5338 FALSE, 5339 #endif 5340 #ifdef COFF_LONG_SECTION_NAMES 5341 TRUE, 5342 #else 5343 FALSE, 5344 #endif 5345 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5346 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5347 TRUE, 5348 #else 5349 FALSE, 5350 #endif 5351 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5352 4, 5353 #else 5354 2, 5355 #endif 5356 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5357 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook, 5358 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5359 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5360 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5361 coff_classify_symbol, coff_compute_section_file_positions, 5362 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5363 coff_adjust_symndx, coff_link_add_one_symbol, 5364 coff_link_output_has_begun, coff_final_link_postscript, 5365 bfd_pe_print_pdata /* huh */ 5366 }; 5367 #endif 5368 5369 #ifndef coff_close_and_cleanup 5370 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup 5371 #endif 5372 5373 #ifndef coff_bfd_free_cached_info 5374 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 5375 #endif 5376 5377 #ifndef coff_get_section_contents 5378 #define coff_get_section_contents _bfd_generic_get_section_contents 5379 #endif 5380 5381 #ifndef coff_bfd_copy_private_symbol_data 5382 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 5383 #endif 5384 5385 #ifndef coff_bfd_copy_private_header_data 5386 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data 5387 #endif 5388 5389 #ifndef coff_bfd_copy_private_section_data 5390 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 5391 #endif 5392 5393 #ifndef coff_bfd_copy_private_bfd_data 5394 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data 5395 #endif 5396 5397 #ifndef coff_bfd_merge_private_bfd_data 5398 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 5399 #endif 5400 5401 #ifndef coff_bfd_set_private_flags 5402 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 5403 #endif 5404 5405 #ifndef coff_bfd_print_private_bfd_data 5406 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 5407 #endif 5408 5409 #ifndef coff_bfd_is_local_label_name 5410 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name 5411 #endif 5412 5413 #ifndef coff_bfd_is_target_special_symbol 5414 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 5415 #endif 5416 5417 #ifndef coff_read_minisymbols 5418 #define coff_read_minisymbols _bfd_generic_read_minisymbols 5419 #endif 5420 5421 #ifndef coff_minisymbol_to_symbol 5422 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 5423 #endif 5424 5425 /* The reloc lookup routine must be supplied by each individual COFF 5426 backend. */ 5427 #ifndef coff_bfd_reloc_type_lookup 5428 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 5429 #endif 5430 #ifndef coff_bfd_reloc_name_lookup 5431 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup 5432 #endif 5433 5434 #ifndef coff_bfd_get_relocated_section_contents 5435 #define coff_bfd_get_relocated_section_contents \ 5436 bfd_generic_get_relocated_section_contents 5437 #endif 5438 5439 #ifndef coff_bfd_relax_section 5440 #define coff_bfd_relax_section bfd_generic_relax_section 5441 #endif 5442 5443 #ifndef coff_bfd_gc_sections 5444 #define coff_bfd_gc_sections bfd_generic_gc_sections 5445 #endif 5446 5447 #ifndef coff_bfd_merge_sections 5448 #define coff_bfd_merge_sections bfd_generic_merge_sections 5449 #endif 5450 5451 #ifndef coff_bfd_is_group_section 5452 #define coff_bfd_is_group_section bfd_generic_is_group_section 5453 #endif 5454 5455 #ifndef coff_bfd_discard_group 5456 #define coff_bfd_discard_group bfd_generic_discard_group 5457 #endif 5458 5459 #ifndef coff_section_already_linked 5460 #define coff_section_already_linked \ 5461 _bfd_generic_section_already_linked 5462 #endif 5463 5464 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5465 const bfd_target VAR = \ 5466 { \ 5467 NAME , \ 5468 bfd_target_coff_flavour, \ 5469 BFD_ENDIAN_BIG, /* Data byte order is big. */ \ 5470 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5471 /* object flags */ \ 5472 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5473 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5474 /* section flags */ \ 5475 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5476 UNDER, /* Leading symbol underscore. */ \ 5477 '/', /* AR_pad_char. */ \ 5478 15, /* AR_max_namelen. */ \ 5479 \ 5480 /* Data conversion functions. */ \ 5481 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5482 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5483 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5484 \ 5485 /* Header conversion functions. */ \ 5486 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5487 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5488 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5489 \ 5490 /* bfd_check_format. */ \ 5491 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5492 _bfd_dummy_target }, \ 5493 /* bfd_set_format. */ \ 5494 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5495 /* bfd_write_contents. */ \ 5496 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5497 bfd_false }, \ 5498 \ 5499 BFD_JUMP_TABLE_GENERIC (coff), \ 5500 BFD_JUMP_TABLE_COPY (coff), \ 5501 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5502 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5503 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5504 BFD_JUMP_TABLE_RELOCS (coff), \ 5505 BFD_JUMP_TABLE_WRITE (coff), \ 5506 BFD_JUMP_TABLE_LINK (coff), \ 5507 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5508 \ 5509 ALTERNATIVE, \ 5510 \ 5511 SWAP_TABLE \ 5512 }; 5513 5514 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5515 const bfd_target VAR = \ 5516 { \ 5517 NAME , \ 5518 bfd_target_coff_flavour, \ 5519 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5520 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5521 /* object flags */ \ 5522 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5523 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5524 /* section flags */ \ 5525 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5526 UNDER, /* Leading symbol underscore. */ \ 5527 '/', /* AR_pad_char. */ \ 5528 15, /* AR_max_namelen. */ \ 5529 \ 5530 /* Data conversion functions. */ \ 5531 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5532 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5533 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5534 \ 5535 /* Header conversion functions. */ \ 5536 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5537 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5538 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5539 \ 5540 /* bfd_check_format. */ \ 5541 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5542 _bfd_dummy_target }, \ 5543 /* bfd_set_format. */ \ 5544 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5545 /* bfd_write_contents. */ \ 5546 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5547 bfd_false }, \ 5548 \ 5549 BFD_JUMP_TABLE_GENERIC (coff), \ 5550 BFD_JUMP_TABLE_COPY (coff), \ 5551 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5552 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5553 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5554 BFD_JUMP_TABLE_RELOCS (coff), \ 5555 BFD_JUMP_TABLE_WRITE (coff), \ 5556 BFD_JUMP_TABLE_LINK (coff), \ 5557 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5558 \ 5559 ALTERNATIVE, \ 5560 \ 5561 SWAP_TABLE \ 5562 }; 5563 5564 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5565 const bfd_target VAR = \ 5566 { \ 5567 NAME , \ 5568 bfd_target_coff_flavour, \ 5569 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5570 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \ 5571 /* object flags */ \ 5572 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5573 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5574 /* section flags */ \ 5575 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5576 UNDER, /* Leading symbol underscore. */ \ 5577 '/', /* AR_pad_char. */ \ 5578 15, /* AR_max_namelen. */ \ 5579 \ 5580 /* Data conversion functions. */ \ 5581 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5582 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5583 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5584 /* Header conversion functions. */ \ 5585 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5586 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5587 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5588 /* bfd_check_format. */ \ 5589 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5590 _bfd_dummy_target }, \ 5591 /* bfd_set_format. */ \ 5592 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5593 /* bfd_write_contents. */ \ 5594 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5595 bfd_false }, \ 5596 \ 5597 BFD_JUMP_TABLE_GENERIC (coff), \ 5598 BFD_JUMP_TABLE_COPY (coff), \ 5599 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5600 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5601 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5602 BFD_JUMP_TABLE_RELOCS (coff), \ 5603 BFD_JUMP_TABLE_WRITE (coff), \ 5604 BFD_JUMP_TABLE_LINK (coff), \ 5605 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5606 \ 5607 ALTERNATIVE, \ 5608 \ 5609 SWAP_TABLE \ 5610 }; 5611