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