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 AMD64MAGIC 1917 case AMD64MAGIC: 1918 arch = bfd_arch_i386; 1919 machine = bfd_mach_x86_64; 1920 break; 1921 #endif 1922 #ifdef IA64MAGIC 1923 case IA64MAGIC: 1924 arch = bfd_arch_ia64; 1925 break; 1926 #endif 1927 #ifdef A29K_MAGIC_BIG 1928 case A29K_MAGIC_BIG: 1929 case A29K_MAGIC_LITTLE: 1930 arch = bfd_arch_a29k; 1931 break; 1932 #endif 1933 #ifdef ARMMAGIC 1934 case ARMMAGIC: 1935 case ARMPEMAGIC: 1936 case THUMBPEMAGIC: 1937 arch = bfd_arch_arm; 1938 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 1939 if (machine == bfd_mach_arm_unknown) 1940 { 1941 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 1942 { 1943 case F_ARM_2: machine = bfd_mach_arm_2; break; 1944 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 1945 case F_ARM_3: machine = bfd_mach_arm_3; break; 1946 default: 1947 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 1948 case F_ARM_4: machine = bfd_mach_arm_4; break; 1949 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 1950 /* The COFF header does not have enough bits available 1951 to cover all the different ARM architectures. So 1952 we interpret F_ARM_5, the highest flag value to mean 1953 "the highest ARM architecture known to BFD" which is 1954 currently the XScale. */ 1955 case F_ARM_5: machine = bfd_mach_arm_XScale; break; 1956 } 1957 } 1958 break; 1959 #endif 1960 #ifdef MC68MAGIC 1961 case MC68MAGIC: 1962 case M68MAGIC: 1963 #ifdef MC68KBCSMAGIC 1964 case MC68KBCSMAGIC: 1965 #endif 1966 #ifdef APOLLOM68KMAGIC 1967 case APOLLOM68KMAGIC: 1968 #endif 1969 #ifdef LYNXCOFFMAGIC 1970 case LYNXCOFFMAGIC: 1971 #endif 1972 arch = bfd_arch_m68k; 1973 machine = bfd_mach_m68020; 1974 break; 1975 #endif 1976 #ifdef MC88MAGIC 1977 case MC88MAGIC: 1978 case MC88DMAGIC: 1979 case MC88OMAGIC: 1980 arch = bfd_arch_m88k; 1981 machine = 88100; 1982 break; 1983 #endif 1984 #ifdef Z8KMAGIC 1985 case Z8KMAGIC: 1986 arch = bfd_arch_z8k; 1987 switch (internal_f->f_flags & F_MACHMASK) 1988 { 1989 case F_Z8001: 1990 machine = bfd_mach_z8001; 1991 break; 1992 case F_Z8002: 1993 machine = bfd_mach_z8002; 1994 break; 1995 default: 1996 return FALSE; 1997 } 1998 break; 1999 #endif 2000 #ifdef I860 2001 case I860MAGIC: 2002 arch = bfd_arch_i860; 2003 break; 2004 #endif 2005 #ifdef I960 2006 #ifdef I960ROMAGIC 2007 case I960ROMAGIC: 2008 case I960RWMAGIC: 2009 arch = bfd_arch_i960; 2010 switch (F_I960TYPE & internal_f->f_flags) 2011 { 2012 default: 2013 case F_I960CORE: 2014 machine = bfd_mach_i960_core; 2015 break; 2016 case F_I960KB: 2017 machine = bfd_mach_i960_kb_sb; 2018 break; 2019 case F_I960MC: 2020 machine = bfd_mach_i960_mc; 2021 break; 2022 case F_I960XA: 2023 machine = bfd_mach_i960_xa; 2024 break; 2025 case F_I960CA: 2026 machine = bfd_mach_i960_ca; 2027 break; 2028 case F_I960KA: 2029 machine = bfd_mach_i960_ka_sa; 2030 break; 2031 case F_I960JX: 2032 machine = bfd_mach_i960_jx; 2033 break; 2034 case F_I960HX: 2035 machine = bfd_mach_i960_hx; 2036 break; 2037 } 2038 break; 2039 #endif 2040 #endif 2041 2042 #ifdef RS6000COFF_C 2043 #ifdef XCOFF64 2044 case U64_TOCMAGIC: 2045 case U803XTOCMAGIC: 2046 #else 2047 case U802ROMAGIC: 2048 case U802WRMAGIC: 2049 case U802TOCMAGIC: 2050 #endif 2051 { 2052 int cputype; 2053 2054 if (xcoff_data (abfd)->cputype != -1) 2055 cputype = xcoff_data (abfd)->cputype & 0xff; 2056 else 2057 { 2058 /* We did not get a value from the a.out header. If the 2059 file has not been stripped, we may be able to get the 2060 architecture information from the first symbol, if it 2061 is a .file symbol. */ 2062 if (obj_raw_syment_count (abfd) == 0) 2063 cputype = 0; 2064 else 2065 { 2066 bfd_byte *buf; 2067 struct internal_syment sym; 2068 bfd_size_type amt = bfd_coff_symesz (abfd); 2069 2070 buf = (bfd_byte *) bfd_malloc (amt); 2071 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 2072 || bfd_bread (buf, amt, abfd) != amt) 2073 { 2074 free (buf); 2075 return FALSE; 2076 } 2077 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym); 2078 if (sym.n_sclass == C_FILE) 2079 cputype = sym.n_type & 0xff; 2080 else 2081 cputype = 0; 2082 free (buf); 2083 } 2084 } 2085 2086 /* FIXME: We don't handle all cases here. */ 2087 switch (cputype) 2088 { 2089 default: 2090 case 0: 2091 arch = bfd_xcoff_architecture (abfd); 2092 machine = bfd_xcoff_machine (abfd); 2093 break; 2094 2095 case 1: 2096 arch = bfd_arch_powerpc; 2097 machine = bfd_mach_ppc_601; 2098 break; 2099 case 2: /* 64 bit PowerPC */ 2100 arch = bfd_arch_powerpc; 2101 machine = bfd_mach_ppc_620; 2102 break; 2103 case 3: 2104 arch = bfd_arch_powerpc; 2105 machine = bfd_mach_ppc; 2106 break; 2107 case 4: 2108 arch = bfd_arch_rs6000; 2109 machine = bfd_mach_rs6k; 2110 break; 2111 } 2112 } 2113 break; 2114 #endif 2115 2116 #ifdef WE32KMAGIC 2117 case WE32KMAGIC: 2118 arch = bfd_arch_we32k; 2119 break; 2120 #endif 2121 2122 #ifdef H8300MAGIC 2123 case H8300MAGIC: 2124 arch = bfd_arch_h8300; 2125 machine = bfd_mach_h8300; 2126 /* !! FIXME this probably isn't the right place for this. */ 2127 abfd->flags |= BFD_IS_RELAXABLE; 2128 break; 2129 #endif 2130 2131 #ifdef H8300HMAGIC 2132 case H8300HMAGIC: 2133 arch = bfd_arch_h8300; 2134 machine = bfd_mach_h8300h; 2135 /* !! FIXME this probably isn't the right place for this. */ 2136 abfd->flags |= BFD_IS_RELAXABLE; 2137 break; 2138 #endif 2139 2140 #ifdef H8300SMAGIC 2141 case H8300SMAGIC: 2142 arch = bfd_arch_h8300; 2143 machine = bfd_mach_h8300s; 2144 /* !! FIXME this probably isn't the right place for this. */ 2145 abfd->flags |= BFD_IS_RELAXABLE; 2146 break; 2147 #endif 2148 2149 #ifdef H8300HNMAGIC 2150 case H8300HNMAGIC: 2151 arch = bfd_arch_h8300; 2152 machine = bfd_mach_h8300hn; 2153 /* !! FIXME this probably isn't the right place for this. */ 2154 abfd->flags |= BFD_IS_RELAXABLE; 2155 break; 2156 #endif 2157 2158 #ifdef H8300SNMAGIC 2159 case H8300SNMAGIC: 2160 arch = bfd_arch_h8300; 2161 machine = bfd_mach_h8300sn; 2162 /* !! FIXME this probably isn't the right place for this. */ 2163 abfd->flags |= BFD_IS_RELAXABLE; 2164 break; 2165 #endif 2166 2167 #ifdef SH_ARCH_MAGIC_BIG 2168 case SH_ARCH_MAGIC_BIG: 2169 case SH_ARCH_MAGIC_LITTLE: 2170 #ifdef COFF_WITH_PE 2171 case SH_ARCH_MAGIC_WINCE: 2172 #endif 2173 arch = bfd_arch_sh; 2174 break; 2175 #endif 2176 2177 #ifdef MIPS_ARCH_MAGIC_WINCE 2178 case MIPS_ARCH_MAGIC_WINCE: 2179 arch = bfd_arch_mips; 2180 break; 2181 #endif 2182 2183 #ifdef H8500MAGIC 2184 case H8500MAGIC: 2185 arch = bfd_arch_h8500; 2186 break; 2187 #endif 2188 2189 #ifdef SPARCMAGIC 2190 case SPARCMAGIC: 2191 #ifdef LYNXCOFFMAGIC 2192 case LYNXCOFFMAGIC: 2193 #endif 2194 arch = bfd_arch_sparc; 2195 break; 2196 #endif 2197 2198 #ifdef TIC30MAGIC 2199 case TIC30MAGIC: 2200 arch = bfd_arch_tic30; 2201 break; 2202 #endif 2203 2204 #ifdef TICOFF0MAGIC 2205 #ifdef TICOFF_TARGET_ARCH 2206 /* This TI COFF section should be used by all new TI COFF v0 targets. */ 2207 case TICOFF0MAGIC: 2208 arch = TICOFF_TARGET_ARCH; 2209 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2210 break; 2211 #endif 2212 #endif 2213 2214 #ifdef TICOFF1MAGIC 2215 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */ 2216 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */ 2217 case TICOFF1MAGIC: 2218 case TICOFF2MAGIC: 2219 switch (internal_f->f_target_id) 2220 { 2221 #ifdef TI_TARGET_ID 2222 case TI_TARGET_ID: 2223 arch = TICOFF_TARGET_ARCH; 2224 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2225 break; 2226 #endif 2227 default: 2228 arch = bfd_arch_obscure; 2229 (*_bfd_error_handler) 2230 (_("Unrecognized TI COFF target id '0x%x'"), 2231 internal_f->f_target_id); 2232 break; 2233 } 2234 break; 2235 #endif 2236 2237 #ifdef TIC80_ARCH_MAGIC 2238 case TIC80_ARCH_MAGIC: 2239 arch = bfd_arch_tic80; 2240 break; 2241 #endif 2242 2243 #ifdef MCOREMAGIC 2244 case MCOREMAGIC: 2245 arch = bfd_arch_mcore; 2246 break; 2247 #endif 2248 2249 #ifdef W65MAGIC 2250 case W65MAGIC: 2251 arch = bfd_arch_w65; 2252 break; 2253 #endif 2254 2255 default: /* Unreadable input file type. */ 2256 arch = bfd_arch_obscure; 2257 break; 2258 } 2259 2260 bfd_default_set_arch_mach (abfd, arch, machine); 2261 return TRUE; 2262 } 2263 2264 #ifdef SYMNAME_IN_DEBUG 2265 2266 static bfd_boolean symname_in_debug_hook 2267 PARAMS ((bfd *, struct internal_syment *)); 2268 2269 static bfd_boolean 2270 symname_in_debug_hook (abfd, sym) 2271 bfd * abfd ATTRIBUTE_UNUSED; 2272 struct internal_syment *sym; 2273 { 2274 return SYMNAME_IN_DEBUG (sym) != 0; 2275 } 2276 2277 #else 2278 2279 #define symname_in_debug_hook \ 2280 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false 2281 2282 #endif 2283 2284 #ifdef RS6000COFF_C 2285 2286 #ifdef XCOFF64 2287 #define FORCE_SYMNAMES_IN_STRINGS 2288 #endif 2289 2290 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */ 2291 2292 static bfd_boolean coff_pointerize_aux_hook 2293 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 2294 unsigned int, combined_entry_type *)); 2295 2296 static bfd_boolean 2297 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) 2298 bfd *abfd ATTRIBUTE_UNUSED; 2299 combined_entry_type *table_base; 2300 combined_entry_type *symbol; 2301 unsigned int indaux; 2302 combined_entry_type *aux; 2303 { 2304 int class = symbol->u.syment.n_sclass; 2305 2306 if ((class == C_EXT || class == C_HIDEXT) 2307 && indaux + 1 == symbol->u.syment.n_numaux) 2308 { 2309 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 2310 { 2311 aux->u.auxent.x_csect.x_scnlen.p = 2312 table_base + aux->u.auxent.x_csect.x_scnlen.l; 2313 aux->fix_scnlen = 1; 2314 } 2315 2316 /* Return TRUE to indicate that the caller should not do any 2317 further work on this auxent. */ 2318 return TRUE; 2319 } 2320 2321 /* Return FALSE to indicate that this auxent should be handled by 2322 the caller. */ 2323 return FALSE; 2324 } 2325 2326 #else 2327 #ifdef I960 2328 2329 /* We don't want to pointerize bal entries. */ 2330 2331 static bfd_boolean coff_pointerize_aux_hook 2332 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *, 2333 unsigned int, combined_entry_type *)); 2334 2335 static bfd_boolean 2336 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux) 2337 bfd *abfd ATTRIBUTE_UNUSED; 2338 combined_entry_type *table_base ATTRIBUTE_UNUSED; 2339 combined_entry_type *symbol; 2340 unsigned int indaux; 2341 combined_entry_type *aux ATTRIBUTE_UNUSED; 2342 { 2343 /* Return TRUE if we don't want to pointerize this aux entry, which 2344 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 2345 return (indaux == 1 2346 && (symbol->u.syment.n_sclass == C_LEAFPROC 2347 || symbol->u.syment.n_sclass == C_LEAFSTAT 2348 || symbol->u.syment.n_sclass == C_LEAFEXT)); 2349 } 2350 2351 #else /* ! I960 */ 2352 2353 #define coff_pointerize_aux_hook 0 2354 2355 #endif /* ! I960 */ 2356 #endif /* ! RS6000COFF_C */ 2357 2358 /* Print an aux entry. This returns TRUE if it has printed it. */ 2359 2360 static bfd_boolean coff_print_aux 2361 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *, 2362 combined_entry_type *, unsigned int)); 2363 2364 static bfd_boolean 2365 coff_print_aux (abfd, file, table_base, symbol, aux, indaux) 2366 bfd *abfd ATTRIBUTE_UNUSED; 2367 FILE *file ATTRIBUTE_UNUSED; 2368 combined_entry_type *table_base ATTRIBUTE_UNUSED; 2369 combined_entry_type *symbol ATTRIBUTE_UNUSED; 2370 combined_entry_type *aux ATTRIBUTE_UNUSED; 2371 unsigned int indaux ATTRIBUTE_UNUSED; 2372 { 2373 #ifdef RS6000COFF_C 2374 if ((symbol->u.syment.n_sclass == C_EXT 2375 || symbol->u.syment.n_sclass == C_HIDEXT) 2376 && indaux + 1 == symbol->u.syment.n_numaux) 2377 { 2378 /* This is a csect entry. */ 2379 fprintf (file, "AUX "); 2380 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 2381 { 2382 BFD_ASSERT (! aux->fix_scnlen); 2383 #ifdef XCOFF64 2384 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l); 2385 #else 2386 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2387 #endif 2388 } 2389 else 2390 { 2391 fprintf (file, "indx "); 2392 if (! aux->fix_scnlen) 2393 #ifdef XCOFF64 2394 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l); 2395 #else 2396 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2397 #endif 2398 else 2399 fprintf (file, "%4ld", 2400 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 2401 } 2402 fprintf (file, 2403 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 2404 aux->u.auxent.x_csect.x_parmhash, 2405 (unsigned int) aux->u.auxent.x_csect.x_snhash, 2406 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 2407 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 2408 (unsigned int) aux->u.auxent.x_csect.x_smclas, 2409 aux->u.auxent.x_csect.x_stab, 2410 (unsigned int) aux->u.auxent.x_csect.x_snstab); 2411 return TRUE; 2412 } 2413 #endif 2414 2415 /* Return FALSE to indicate that no special action was taken. */ 2416 return FALSE; 2417 } 2418 2419 /* 2420 SUBSUBSECTION 2421 Writing relocations 2422 2423 To write relocations, the back end steps though the 2424 canonical relocation table and create an 2425 @code{internal_reloc}. The symbol index to use is removed from 2426 the @code{offset} field in the symbol table supplied. The 2427 address comes directly from the sum of the section base 2428 address and the relocation offset; the type is dug directly 2429 from the howto field. Then the @code{internal_reloc} is 2430 swapped into the shape of an @code{external_reloc} and written 2431 out to disk. 2432 2433 */ 2434 2435 #ifdef TARG_AUX 2436 2437 static int compare_arelent_ptr PARAMS ((const PTR, const PTR)); 2438 2439 /* AUX's ld wants relocations to be sorted. */ 2440 static int 2441 compare_arelent_ptr (x, y) 2442 const PTR x; 2443 const PTR y; 2444 { 2445 const arelent **a = (const arelent **) x; 2446 const arelent **b = (const arelent **) y; 2447 bfd_size_type aadr = (*a)->address; 2448 bfd_size_type badr = (*b)->address; 2449 2450 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 2451 } 2452 2453 #endif /* TARG_AUX */ 2454 2455 static bfd_boolean 2456 coff_write_relocs (abfd, first_undef) 2457 bfd * abfd; 2458 int first_undef; 2459 { 2460 asection *s; 2461 2462 for (s = abfd->sections; s != (asection *) NULL; s = s->next) 2463 { 2464 unsigned int i; 2465 struct external_reloc dst; 2466 arelent **p; 2467 2468 #ifndef TARG_AUX 2469 p = s->orelocation; 2470 #else 2471 { 2472 /* Sort relocations before we write them out. */ 2473 bfd_size_type amt; 2474 2475 amt = s->reloc_count; 2476 amt *= sizeof (arelent *); 2477 p = (arelent **) bfd_malloc (amt); 2478 if (p == NULL && s->reloc_count > 0) 2479 return FALSE; 2480 memcpy (p, s->orelocation, (size_t) amt); 2481 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 2482 } 2483 #endif 2484 2485 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 2486 return FALSE; 2487 2488 #ifdef COFF_WITH_PE 2489 if (obj_pe (abfd) && s->reloc_count >= 0xffff) 2490 { 2491 /* Encode real count here as first reloc. */ 2492 struct internal_reloc n; 2493 2494 memset ((PTR) & n, 0, sizeof (n)); 2495 /* Add one to count *this* reloc (grr). */ 2496 n.r_vaddr = s->reloc_count + 1; 2497 coff_swap_reloc_out (abfd, &n, &dst); 2498 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd), 2499 abfd) != bfd_coff_relsz (abfd)) 2500 return FALSE; 2501 } 2502 #endif 2503 2504 for (i = 0; i < s->reloc_count; i++) 2505 { 2506 struct internal_reloc n; 2507 arelent *q = p[i]; 2508 2509 memset ((PTR) & n, 0, sizeof (n)); 2510 2511 /* Now we've renumbered the symbols we know where the 2512 undefined symbols live in the table. Check the reloc 2513 entries for symbols who's output bfd isn't the right one. 2514 This is because the symbol was undefined (which means 2515 that all the pointers are never made to point to the same 2516 place). This is a bad thing,'cause the symbols attached 2517 to the output bfd are indexed, so that the relocation 2518 entries know which symbol index they point to. So we 2519 have to look up the output symbol here. */ 2520 2521 if (q->sym_ptr_ptr[0]->the_bfd != abfd) 2522 { 2523 int j; 2524 const char *sname = q->sym_ptr_ptr[0]->name; 2525 asymbol **outsyms = abfd->outsymbols; 2526 2527 for (j = first_undef; outsyms[j]; j++) 2528 { 2529 const char *intable = outsyms[j]->name; 2530 2531 if (strcmp (intable, sname) == 0) { 2532 /* Got a hit, so repoint the reloc. */ 2533 q->sym_ptr_ptr = outsyms + j; 2534 break; 2535 } 2536 } 2537 } 2538 2539 n.r_vaddr = q->address + s->vma; 2540 2541 #ifdef R_IHCONST 2542 /* The 29k const/consth reloc pair is a real kludge. The consth 2543 part doesn't have a symbol; it has an offset. So rebuilt 2544 that here. */ 2545 if (q->howto->type == R_IHCONST) 2546 n.r_symndx = q->addend; 2547 else 2548 #endif 2549 if (q->sym_ptr_ptr) 2550 { 2551 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P 2552 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s)) 2553 #else 2554 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr 2555 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0) 2556 #endif 2557 /* This is a relocation relative to the absolute symbol. */ 2558 n.r_symndx = -1; 2559 else 2560 { 2561 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 2562 /* Take notice if the symbol reloc points to a symbol 2563 we don't have in our symbol table. What should we 2564 do for this?? */ 2565 if (n.r_symndx > obj_conv_table_size (abfd)) 2566 abort (); 2567 } 2568 } 2569 2570 #ifdef SWAP_OUT_RELOC_OFFSET 2571 n.r_offset = q->addend; 2572 #endif 2573 2574 #ifdef SELECT_RELOC 2575 /* Work out reloc type from what is required. */ 2576 SELECT_RELOC (n, q->howto); 2577 #else 2578 n.r_type = q->howto->type; 2579 #endif 2580 coff_swap_reloc_out (abfd, &n, &dst); 2581 2582 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd), 2583 abfd) != bfd_coff_relsz (abfd)) 2584 return FALSE; 2585 } 2586 2587 #ifdef TARG_AUX 2588 if (p != NULL) 2589 free (p); 2590 #endif 2591 } 2592 2593 return TRUE; 2594 } 2595 2596 /* Set flags and magic number of a coff file from architecture and machine 2597 type. Result is TRUE if we can represent the arch&type, FALSE if not. */ 2598 2599 static bfd_boolean 2600 coff_set_flags (abfd, magicp, flagsp) 2601 bfd * abfd; 2602 unsigned int *magicp ATTRIBUTE_UNUSED; 2603 unsigned short *flagsp ATTRIBUTE_UNUSED; 2604 { 2605 switch (bfd_get_arch (abfd)) 2606 { 2607 #ifdef Z8KMAGIC 2608 case bfd_arch_z8k: 2609 *magicp = Z8KMAGIC; 2610 switch (bfd_get_mach (abfd)) 2611 { 2612 case bfd_mach_z8001: 2613 *flagsp = F_Z8001; 2614 break; 2615 case bfd_mach_z8002: 2616 *flagsp = F_Z8002; 2617 break; 2618 default: 2619 return FALSE; 2620 } 2621 return TRUE; 2622 #endif 2623 #ifdef I960ROMAGIC 2624 2625 case bfd_arch_i960: 2626 2627 { 2628 unsigned flags; 2629 *magicp = I960ROMAGIC; 2630 /* 2631 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC : 2632 I960RWMAGIC); FIXME??? 2633 */ 2634 switch (bfd_get_mach (abfd)) 2635 { 2636 case bfd_mach_i960_core: 2637 flags = F_I960CORE; 2638 break; 2639 case bfd_mach_i960_kb_sb: 2640 flags = F_I960KB; 2641 break; 2642 case bfd_mach_i960_mc: 2643 flags = F_I960MC; 2644 break; 2645 case bfd_mach_i960_xa: 2646 flags = F_I960XA; 2647 break; 2648 case bfd_mach_i960_ca: 2649 flags = F_I960CA; 2650 break; 2651 case bfd_mach_i960_ka_sa: 2652 flags = F_I960KA; 2653 break; 2654 case bfd_mach_i960_jx: 2655 flags = F_I960JX; 2656 break; 2657 case bfd_mach_i960_hx: 2658 flags = F_I960HX; 2659 break; 2660 default: 2661 return FALSE; 2662 } 2663 *flagsp = flags; 2664 return TRUE; 2665 } 2666 break; 2667 #endif 2668 2669 #ifdef TIC30MAGIC 2670 case bfd_arch_tic30: 2671 *magicp = TIC30MAGIC; 2672 return TRUE; 2673 #endif 2674 2675 #ifdef TICOFF_DEFAULT_MAGIC 2676 case TICOFF_TARGET_ARCH: 2677 /* If there's no indication of which version we want, use the default. */ 2678 if (!abfd->xvec ) 2679 *magicp = TICOFF_DEFAULT_MAGIC; 2680 else 2681 { 2682 /* We may want to output in a different COFF version. */ 2683 switch (abfd->xvec->name[4]) 2684 { 2685 case '0': 2686 *magicp = TICOFF0MAGIC; 2687 break; 2688 case '1': 2689 *magicp = TICOFF1MAGIC; 2690 break; 2691 case '2': 2692 *magicp = TICOFF2MAGIC; 2693 break; 2694 default: 2695 return FALSE; 2696 } 2697 } 2698 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd)); 2699 return TRUE; 2700 #endif 2701 2702 #ifdef TIC80_ARCH_MAGIC 2703 case bfd_arch_tic80: 2704 *magicp = TIC80_ARCH_MAGIC; 2705 return TRUE; 2706 #endif 2707 #ifdef ARMMAGIC 2708 case bfd_arch_arm: 2709 #ifdef ARM_WINCE 2710 * magicp = ARMPEMAGIC; 2711 #else 2712 * magicp = ARMMAGIC; 2713 #endif 2714 * flagsp = 0; 2715 if (APCS_SET (abfd)) 2716 { 2717 if (APCS_26_FLAG (abfd)) 2718 * flagsp |= F_APCS26; 2719 2720 if (APCS_FLOAT_FLAG (abfd)) 2721 * flagsp |= F_APCS_FLOAT; 2722 2723 if (PIC_FLAG (abfd)) 2724 * flagsp |= F_PIC; 2725 } 2726 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2727 * flagsp |= F_INTERWORK; 2728 switch (bfd_get_mach (abfd)) 2729 { 2730 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2731 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2732 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2733 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2734 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2735 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2736 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; 2737 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. 2738 See also the comment in coff_set_arch_mach_hook(). */ 2739 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; 2740 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; 2741 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; 2742 } 2743 return TRUE; 2744 #endif 2745 #ifdef PPCMAGIC 2746 case bfd_arch_powerpc: 2747 *magicp = PPCMAGIC; 2748 return TRUE; 2749 break; 2750 #endif 2751 #if defined(I386MAGIC) || defined(AMD64MAGIC) 2752 case bfd_arch_i386: 2753 #if defined(I386MAGIC) 2754 *magicp = I386MAGIC; 2755 #endif 2756 #ifdef LYNXOS 2757 /* Just overwrite the usual value if we're doing Lynx. */ 2758 *magicp = LYNXCOFFMAGIC; 2759 #endif 2760 #if defined AMD64MAGIC 2761 *magicp = AMD64MAGIC; 2762 #endif 2763 return TRUE; 2764 break; 2765 #endif 2766 #ifdef I860MAGIC 2767 case bfd_arch_i860: 2768 *magicp = I860MAGIC; 2769 return TRUE; 2770 break; 2771 #endif 2772 #ifdef IA64MAGIC 2773 case bfd_arch_ia64: 2774 *magicp = IA64MAGIC; 2775 return TRUE; 2776 break; 2777 #endif 2778 #ifdef MC68MAGIC 2779 case bfd_arch_m68k: 2780 #ifdef APOLLOM68KMAGIC 2781 *magicp = APOLLO_COFF_VERSION_NUMBER; 2782 #else 2783 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2784 #ifdef NAMES_HAVE_UNDERSCORE 2785 *magicp = MC68KBCSMAGIC; 2786 #else 2787 *magicp = MC68MAGIC; 2788 #endif 2789 #endif 2790 #ifdef LYNXOS 2791 /* Just overwrite the usual value if we're doing Lynx. */ 2792 *magicp = LYNXCOFFMAGIC; 2793 #endif 2794 return TRUE; 2795 break; 2796 #endif 2797 2798 #ifdef MC88MAGIC 2799 case bfd_arch_m88k: 2800 *magicp = MC88OMAGIC; 2801 return TRUE; 2802 break; 2803 #endif 2804 #ifdef H8300MAGIC 2805 case bfd_arch_h8300: 2806 switch (bfd_get_mach (abfd)) 2807 { 2808 case bfd_mach_h8300: 2809 *magicp = H8300MAGIC; 2810 return TRUE; 2811 case bfd_mach_h8300h: 2812 *magicp = H8300HMAGIC; 2813 return TRUE; 2814 case bfd_mach_h8300s: 2815 *magicp = H8300SMAGIC; 2816 return TRUE; 2817 case bfd_mach_h8300hn: 2818 *magicp = H8300HNMAGIC; 2819 return TRUE; 2820 case bfd_mach_h8300sn: 2821 *magicp = H8300SNMAGIC; 2822 return TRUE; 2823 } 2824 break; 2825 #endif 2826 2827 #ifdef SH_ARCH_MAGIC_BIG 2828 case bfd_arch_sh: 2829 #ifdef COFF_IMAGE_WITH_PE 2830 *magicp = SH_ARCH_MAGIC_WINCE; 2831 #else 2832 if (bfd_big_endian (abfd)) 2833 *magicp = SH_ARCH_MAGIC_BIG; 2834 else 2835 *magicp = SH_ARCH_MAGIC_LITTLE; 2836 #endif 2837 return TRUE; 2838 break; 2839 #endif 2840 2841 #ifdef MIPS_ARCH_MAGIC_WINCE 2842 case bfd_arch_mips: 2843 *magicp = MIPS_ARCH_MAGIC_WINCE; 2844 return TRUE; 2845 break; 2846 #endif 2847 2848 #ifdef SPARCMAGIC 2849 case bfd_arch_sparc: 2850 *magicp = SPARCMAGIC; 2851 #ifdef LYNXOS 2852 /* Just overwrite the usual value if we're doing Lynx. */ 2853 *magicp = LYNXCOFFMAGIC; 2854 #endif 2855 return TRUE; 2856 break; 2857 #endif 2858 2859 #ifdef H8500MAGIC 2860 case bfd_arch_h8500: 2861 *magicp = H8500MAGIC; 2862 return TRUE; 2863 break; 2864 #endif 2865 #ifdef A29K_MAGIC_BIG 2866 case bfd_arch_a29k: 2867 if (bfd_big_endian (abfd)) 2868 *magicp = A29K_MAGIC_BIG; 2869 else 2870 *magicp = A29K_MAGIC_LITTLE; 2871 return TRUE; 2872 break; 2873 #endif 2874 2875 #ifdef WE32KMAGIC 2876 case bfd_arch_we32k: 2877 *magicp = WE32KMAGIC; 2878 return TRUE; 2879 break; 2880 #endif 2881 2882 #ifdef RS6000COFF_C 2883 case bfd_arch_rs6000: 2884 #ifndef PPCMAGIC 2885 case bfd_arch_powerpc: 2886 #endif 2887 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour); 2888 *magicp = bfd_xcoff_magic_number (abfd); 2889 return TRUE; 2890 break; 2891 #endif 2892 2893 #ifdef MCOREMAGIC 2894 case bfd_arch_mcore: 2895 * magicp = MCOREMAGIC; 2896 return TRUE; 2897 #endif 2898 2899 #ifdef W65MAGIC 2900 case bfd_arch_w65: 2901 *magicp = W65MAGIC; 2902 return TRUE; 2903 #endif 2904 2905 #ifdef OR32_MAGIC_BIG 2906 case bfd_arch_or32: 2907 if (bfd_big_endian (abfd)) 2908 * magicp = OR32_MAGIC_BIG; 2909 else 2910 * magicp = OR32_MAGIC_LITTLE; 2911 return TRUE; 2912 #endif 2913 2914 default: /* Unknown architecture. */ 2915 /* Fall through to "return FALSE" below, to avoid 2916 "statement never reached" errors on the one below. */ 2917 break; 2918 } 2919 2920 return FALSE; 2921 } 2922 2923 static bfd_boolean 2924 coff_set_arch_mach (abfd, arch, machine) 2925 bfd * abfd; 2926 enum bfd_architecture arch; 2927 unsigned long machine; 2928 { 2929 unsigned dummy1; 2930 unsigned short dummy2; 2931 2932 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 2933 return FALSE; 2934 2935 if (arch != bfd_arch_unknown 2936 && ! coff_set_flags (abfd, &dummy1, &dummy2)) 2937 return FALSE; /* We can't represent this type */ 2938 2939 return TRUE; /* We're easy ... */ 2940 } 2941 2942 #ifdef COFF_IMAGE_WITH_PE 2943 2944 /* This is used to sort sections by VMA, as required by PE image 2945 files. */ 2946 2947 static int sort_by_secaddr PARAMS ((const PTR, const PTR)); 2948 2949 static int 2950 sort_by_secaddr (arg1, arg2) 2951 const PTR arg1; 2952 const PTR arg2; 2953 { 2954 const asection *a = *(const asection **) arg1; 2955 const asection *b = *(const asection **) arg2; 2956 2957 if (a->vma < b->vma) 2958 return -1; 2959 else if (a->vma > b->vma) 2960 return 1; 2961 else 2962 return 0; 2963 } 2964 2965 #endif /* COFF_IMAGE_WITH_PE */ 2966 2967 /* Calculate the file position for each section. */ 2968 2969 #ifndef I960 2970 #define ALIGN_SECTIONS_IN_FILE 2971 #endif 2972 #if defined(TIC80COFF) || defined(TICOFF) 2973 #undef ALIGN_SECTIONS_IN_FILE 2974 #endif 2975 2976 static bfd_boolean 2977 coff_compute_section_file_positions (abfd) 2978 bfd * abfd; 2979 { 2980 asection *current; 2981 asection *previous = (asection *) NULL; 2982 file_ptr sofar = bfd_coff_filhsz (abfd); 2983 bfd_boolean align_adjust; 2984 #ifdef ALIGN_SECTIONS_IN_FILE 2985 file_ptr old_sofar; 2986 #endif 2987 2988 #ifdef RS6000COFF_C 2989 /* On XCOFF, if we have symbols, set up the .debug section. */ 2990 if (bfd_get_symcount (abfd) > 0) 2991 { 2992 bfd_size_type sz; 2993 bfd_size_type i, symcount; 2994 asymbol **symp; 2995 2996 sz = 0; 2997 symcount = bfd_get_symcount (abfd); 2998 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 2999 { 3000 coff_symbol_type *cf; 3001 3002 cf = coff_symbol_from (abfd, *symp); 3003 if (cf != NULL 3004 && cf->native != NULL 3005 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 3006 { 3007 size_t len; 3008 3009 len = strlen (bfd_asymbol_name (*symp)); 3010 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) 3011 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); 3012 } 3013 } 3014 if (sz > 0) 3015 { 3016 asection *dsec; 3017 3018 dsec = bfd_make_section_old_way (abfd, ".debug"); 3019 if (dsec == NULL) 3020 abort (); 3021 dsec->_raw_size = sz; 3022 dsec->flags |= SEC_HAS_CONTENTS; 3023 } 3024 } 3025 #endif 3026 3027 #ifdef COFF_IMAGE_WITH_PE 3028 int page_size; 3029 if (coff_data (abfd)->link_info) 3030 { 3031 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 3032 3033 /* If no file alignment has been set, default to one. 3034 This repairs 'ld -r' for arm-wince-pe target. */ 3035 if (page_size == 0) 3036 page_size = 1; 3037 } 3038 else 3039 page_size = PE_DEF_FILE_ALIGNMENT; 3040 #else 3041 #ifdef COFF_PAGE_SIZE 3042 int page_size = COFF_PAGE_SIZE; 3043 #endif 3044 #endif 3045 3046 if (bfd_get_start_address (abfd)) 3047 { 3048 /* A start address may have been added to the original file. In this 3049 case it will need an optional header to record it. */ 3050 abfd->flags |= EXEC_P; 3051 } 3052 3053 if (abfd->flags & EXEC_P) 3054 sofar += bfd_coff_aoutsz (abfd); 3055 #ifdef RS6000COFF_C 3056 else if (xcoff_data (abfd)->full_aouthdr) 3057 sofar += bfd_coff_aoutsz (abfd); 3058 else 3059 sofar += SMALL_AOUTSZ; 3060 #endif 3061 3062 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 3063 3064 #ifdef RS6000COFF_C 3065 /* XCOFF handles overflows in the reloc and line number count fields 3066 by allocating a new section header to hold the correct counts. */ 3067 for (current = abfd->sections; current != NULL; current = current->next) 3068 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3069 sofar += bfd_coff_scnhsz (abfd); 3070 #endif 3071 3072 #ifdef COFF_IMAGE_WITH_PE 3073 { 3074 /* PE requires the sections to be in memory order when listed in 3075 the section headers. It also does not like empty loadable 3076 sections. The sections apparently do not have to be in the 3077 right order in the image file itself, but we do need to get the 3078 target_index values right. */ 3079 3080 unsigned int count; 3081 asection **section_list; 3082 unsigned int i; 3083 int target_index; 3084 bfd_size_type amt; 3085 3086 count = 0; 3087 for (current = abfd->sections; current != NULL; current = current->next) 3088 ++count; 3089 3090 /* We allocate an extra cell to simplify the final loop. */ 3091 amt = sizeof (struct asection *) * (count + 1); 3092 section_list = bfd_malloc (amt); 3093 if (section_list == NULL) 3094 return FALSE; 3095 3096 i = 0; 3097 for (current = abfd->sections; current != NULL; current = current->next) 3098 { 3099 section_list[i] = current; 3100 ++i; 3101 } 3102 section_list[i] = NULL; 3103 3104 qsort (section_list, count, sizeof (asection *), sort_by_secaddr); 3105 3106 /* Rethread the linked list into sorted order; at the same time, 3107 assign target_index values. */ 3108 target_index = 1; 3109 abfd->sections = section_list[0]; 3110 for (i = 0; i < count; i++) 3111 { 3112 current = section_list[i]; 3113 current->next = section_list[i + 1]; 3114 3115 /* Later, if the section has zero size, we'll be throwing it 3116 away, so we don't want to number it now. Note that having 3117 a zero size and having real contents are different 3118 concepts: .bss has no contents, but (usually) non-zero 3119 size. */ 3120 if (current->_raw_size == 0) 3121 { 3122 /* Discard. However, it still might have (valid) symbols 3123 in it, so arbitrarily set it to section 1 (indexing is 3124 1-based here; usually .text). __end__ and other 3125 contents of .endsection really have this happen. 3126 FIXME: This seems somewhat dubious. */ 3127 current->target_index = 1; 3128 } 3129 else 3130 current->target_index = target_index++; 3131 } 3132 abfd->section_tail = ¤t->next; 3133 3134 free (section_list); 3135 } 3136 #else /* ! COFF_IMAGE_WITH_PE */ 3137 { 3138 /* Set the target_index field. */ 3139 int target_index; 3140 3141 target_index = 1; 3142 for (current = abfd->sections; current != NULL; current = current->next) 3143 current->target_index = target_index++; 3144 } 3145 #endif /* ! COFF_IMAGE_WITH_PE */ 3146 3147 align_adjust = FALSE; 3148 for (current = abfd->sections; 3149 current != (asection *) NULL; 3150 current = current->next) 3151 { 3152 #ifdef COFF_IMAGE_WITH_PE 3153 /* With PE we have to pad each section to be a multiple of its 3154 page size too, and remember both sizes. */ 3155 if (coff_section_data (abfd, current) == NULL) 3156 { 3157 bfd_size_type amt = sizeof (struct coff_section_tdata); 3158 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt); 3159 if (current->used_by_bfd == NULL) 3160 return FALSE; 3161 } 3162 if (pei_section_data (abfd, current) == NULL) 3163 { 3164 bfd_size_type amt = sizeof (struct pei_section_tdata); 3165 coff_section_data (abfd, current)->tdata 3166 = (PTR) bfd_zalloc (abfd, amt); 3167 if (coff_section_data (abfd, current)->tdata == NULL) 3168 return FALSE; 3169 } 3170 if (pei_section_data (abfd, current)->virt_size == 0) 3171 pei_section_data (abfd, current)->virt_size = current->_raw_size; 3172 #endif 3173 3174 /* Only deal with sections which have contents. */ 3175 if (!(current->flags & SEC_HAS_CONTENTS)) 3176 continue; 3177 3178 #ifdef COFF_IMAGE_WITH_PE 3179 /* Make sure we skip empty sections in a PE image. */ 3180 if (current->_raw_size == 0) 3181 continue; 3182 #endif 3183 3184 /* Align the sections in the file to the same boundary on 3185 which they are aligned in virtual memory. I960 doesn't 3186 do this (FIXME) so we can stay in sync with Intel. 960 3187 doesn't yet page from files... */ 3188 #ifdef ALIGN_SECTIONS_IN_FILE 3189 if ((abfd->flags & EXEC_P) != 0) 3190 { 3191 /* Make sure this section is aligned on the right boundary - by 3192 padding the previous section up if necessary. */ 3193 3194 old_sofar = sofar; 3195 #ifdef RS6000COFF_C 3196 /* AIX loader checks the text section alignment of (vma - filepos) 3197 So even though the filepos may be aligned wrt the o_algntext, for 3198 AIX executables, this check fails. This shows up when a native 3199 AIX executable is stripped with gnu strip because the default vma 3200 of native is 0x10000150 but default for gnu is 0x10000140. Gnu 3201 stripped gnu excutable passes this check because the filepos is 3202 0x0140. This problem also show up with 64 bit shared objects. The 3203 data section must also be aligned. */ 3204 if (!strcmp (current->name, _TEXT) 3205 || !strcmp (current->name, _DATA)) 3206 { 3207 bfd_vma pad; 3208 bfd_vma align; 3209 3210 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3211 3212 align = 1 << current->alignment_power; 3213 pad = abs (current->vma - sofar) % align; 3214 3215 if (pad) 3216 { 3217 pad = align - pad; 3218 sofar += pad; 3219 } 3220 } 3221 else 3222 #else 3223 { 3224 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3225 } 3226 #endif 3227 if (previous != (asection *) NULL) 3228 previous->_raw_size += sofar - old_sofar; 3229 } 3230 3231 #endif 3232 3233 /* In demand paged files the low order bits of the file offset 3234 must match the low order bits of the virtual address. */ 3235 #ifdef COFF_PAGE_SIZE 3236 if ((abfd->flags & D_PAGED) != 0 3237 && (current->flags & SEC_ALLOC) != 0) 3238 sofar += (current->vma - sofar) % page_size; 3239 #endif 3240 current->filepos = sofar; 3241 3242 #ifdef COFF_IMAGE_WITH_PE 3243 /* Set the padded size. */ 3244 current->_raw_size = (current->_raw_size + page_size -1) & -page_size; 3245 #endif 3246 3247 sofar += current->_raw_size; 3248 3249 #ifdef ALIGN_SECTIONS_IN_FILE 3250 /* Make sure that this section is of the right size too. */ 3251 if ((abfd->flags & EXEC_P) == 0) 3252 { 3253 bfd_size_type old_size; 3254 3255 old_size = current->_raw_size; 3256 current->_raw_size = BFD_ALIGN (current->_raw_size, 3257 1 << current->alignment_power); 3258 align_adjust = current->_raw_size != old_size; 3259 sofar += current->_raw_size - old_size; 3260 } 3261 else 3262 { 3263 old_sofar = sofar; 3264 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3265 align_adjust = sofar != old_sofar; 3266 current->_raw_size += sofar - old_sofar; 3267 } 3268 #endif 3269 3270 #ifdef COFF_IMAGE_WITH_PE 3271 /* For PE we need to make sure we pad out to the aligned 3272 _raw_size, in case the caller only writes out data to the 3273 unaligned _raw_size. */ 3274 if (pei_section_data (abfd, current)->virt_size < current->_raw_size) 3275 align_adjust = TRUE; 3276 #endif 3277 3278 #ifdef _LIB 3279 /* Force .lib sections to start at zero. The vma is then 3280 incremented in coff_set_section_contents. This is right for 3281 SVR3.2. */ 3282 if (strcmp (current->name, _LIB) == 0) 3283 bfd_set_section_vma (abfd, current, 0); 3284 #endif 3285 3286 previous = current; 3287 } 3288 3289 /* It is now safe to write to the output file. If we needed an 3290 alignment adjustment for the last section, then make sure that 3291 there is a byte at offset sofar. If there are no symbols and no 3292 relocs, then nothing follows the last section. If we don't force 3293 the last byte out, then the file may appear to be truncated. */ 3294 if (align_adjust) 3295 { 3296 bfd_byte b; 3297 3298 b = 0; 3299 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0 3300 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3301 return FALSE; 3302 } 3303 3304 /* Make sure the relocations are aligned. We don't need to make 3305 sure that this byte exists, because it will only matter if there 3306 really are relocs. */ 3307 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER); 3308 3309 obj_relocbase (abfd) = sofar; 3310 abfd->output_has_begun = TRUE; 3311 3312 return TRUE; 3313 } 3314 3315 #if 0 3316 3317 /* This can never work, because it is called too late--after the 3318 section positions have been set. I can't figure out what it is 3319 for, so I am going to disable it--Ian Taylor 20 March 1996. */ 3320 3321 /* If .file, .text, .data, .bss symbols are missing, add them. */ 3322 /* @@ Should we only be adding missing symbols, or overriding the aux 3323 values for existing section symbols? */ 3324 static bfd_boolean 3325 coff_add_missing_symbols (abfd) 3326 bfd *abfd; 3327 { 3328 unsigned int nsyms = bfd_get_symcount (abfd); 3329 asymbol **sympp = abfd->outsymbols; 3330 asymbol **sympp2; 3331 unsigned int i; 3332 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1; 3333 bfd_size_type amt; 3334 3335 for (i = 0; i < nsyms; i++) 3336 { 3337 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]); 3338 const char *name; 3339 3340 if (csym) 3341 { 3342 /* Only do this if there is a coff representation of the input 3343 symbol. */ 3344 if (csym->native && csym->native->u.syment.n_sclass == C_FILE) 3345 { 3346 need_file = 0; 3347 continue; 3348 } 3349 name = csym->symbol.name; 3350 if (!name) 3351 continue; 3352 if (!strcmp (name, _TEXT)) 3353 need_text = 0; 3354 #ifdef APOLLO_M68 3355 else if (!strcmp (name, ".wtext")) 3356 need_text = 0; 3357 #endif 3358 else if (!strcmp (name, _DATA)) 3359 need_data = 0; 3360 else if (!strcmp (name, _BSS)) 3361 need_bss = 0; 3362 } 3363 } 3364 /* Now i == bfd_get_symcount (abfd). */ 3365 /* @@ For now, don't deal with .file symbol. */ 3366 need_file = 0; 3367 3368 if (!need_text && !need_data && !need_bss && !need_file) 3369 return TRUE; 3370 nsyms += need_text + need_data + need_bss + need_file; 3371 amt = nsyms; 3372 amt *= sizeof (asymbol *); 3373 sympp2 = (asymbol **) bfd_alloc (abfd, amt); 3374 if (!sympp2) 3375 return FALSE; 3376 memcpy (sympp2, sympp, i * sizeof (asymbol *)); 3377 3378 if (need_file) 3379 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */ 3380 abort (); 3381 3382 if (need_text) 3383 sympp2[i++] = coff_section_symbol (abfd, _TEXT); 3384 if (need_data) 3385 sympp2[i++] = coff_section_symbol (abfd, _DATA); 3386 if (need_bss) 3387 sympp2[i++] = coff_section_symbol (abfd, _BSS); 3388 BFD_ASSERT (i == nsyms); 3389 bfd_set_symtab (abfd, sympp2, nsyms); 3390 return TRUE; 3391 } 3392 3393 #endif /* 0 */ 3394 3395 #ifdef COFF_IMAGE_WITH_PE 3396 3397 static unsigned int pelength; 3398 static unsigned int peheader; 3399 3400 static bfd_boolean 3401 coff_read_word (abfd, value) 3402 bfd *abfd; 3403 unsigned int *value; 3404 { 3405 unsigned char b[2]; 3406 int status; 3407 3408 status = bfd_bread (b, (bfd_size_type) 2, abfd); 3409 if (status < 1) 3410 { 3411 *value = 0; 3412 return FALSE; 3413 } 3414 3415 if (status == 1) 3416 *value = (unsigned int) b[0]; 3417 else 3418 *value = (unsigned int) (b[0] + (b[1] << 8)); 3419 3420 pelength += (unsigned int) status; 3421 3422 return TRUE; 3423 } 3424 3425 static unsigned int 3426 coff_compute_checksum (abfd) 3427 bfd *abfd; 3428 { 3429 bfd_boolean more_data; 3430 file_ptr filepos; 3431 unsigned int value; 3432 unsigned int total; 3433 3434 total = 0; 3435 pelength = 0; 3436 filepos = (file_ptr) 0; 3437 3438 do 3439 { 3440 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 3441 return 0; 3442 3443 more_data = coff_read_word (abfd, &value); 3444 total += value; 3445 total = 0xffff & (total + (total >> 0x10)); 3446 filepos += 2; 3447 } 3448 while (more_data); 3449 3450 return (0xffff & (total + (total >> 0x10))); 3451 } 3452 3453 static bfd_boolean 3454 coff_apply_checksum (abfd) 3455 bfd *abfd; 3456 { 3457 unsigned int computed; 3458 unsigned int checksum = 0; 3459 3460 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0) 3461 return FALSE; 3462 3463 if (!coff_read_word (abfd, &peheader)) 3464 return FALSE; 3465 3466 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3467 return FALSE; 3468 3469 checksum = 0; 3470 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3471 3472 if (bfd_seek (abfd, peheader, SEEK_SET) != 0) 3473 return FALSE; 3474 3475 computed = coff_compute_checksum (abfd); 3476 3477 checksum = computed + pelength; 3478 3479 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3480 return FALSE; 3481 3482 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3483 3484 return TRUE; 3485 } 3486 3487 #endif /* COFF_IMAGE_WITH_PE */ 3488 3489 /* SUPPRESS 558 */ 3490 /* SUPPRESS 529 */ 3491 static bfd_boolean 3492 coff_write_object_contents (abfd) 3493 bfd * abfd; 3494 { 3495 asection *current; 3496 bfd_boolean hasrelocs = FALSE; 3497 bfd_boolean haslinno = FALSE; 3498 bfd_boolean hasdebug = FALSE; 3499 file_ptr scn_base; 3500 file_ptr reloc_base; 3501 file_ptr lineno_base; 3502 file_ptr sym_base; 3503 unsigned long reloc_size = 0, reloc_count = 0; 3504 unsigned long lnno_size = 0; 3505 bfd_boolean long_section_names; 3506 asection *text_sec = NULL; 3507 asection *data_sec = NULL; 3508 asection *bss_sec = NULL; 3509 struct internal_filehdr internal_f; 3510 struct internal_aouthdr internal_a; 3511 #ifdef COFF_LONG_SECTION_NAMES 3512 size_t string_size = STRING_SIZE_SIZE; 3513 #endif 3514 3515 bfd_set_error (bfd_error_system_call); 3516 3517 /* Make a pass through the symbol table to count line number entries and 3518 put them into the correct asections. */ 3519 3520 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd); 3521 3522 if (! abfd->output_has_begun) 3523 { 3524 if (! coff_compute_section_file_positions (abfd)) 3525 return FALSE; 3526 } 3527 3528 reloc_base = obj_relocbase (abfd); 3529 3530 /* Work out the size of the reloc and linno areas. */ 3531 3532 for (current = abfd->sections; current != NULL; current = 3533 current->next) 3534 { 3535 #ifdef COFF_WITH_PE 3536 /* We store the actual reloc count in the first reloc's addr. */ 3537 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3538 reloc_count ++; 3539 #endif 3540 reloc_count += current->reloc_count; 3541 } 3542 3543 reloc_size = reloc_count * bfd_coff_relsz (abfd); 3544 3545 lineno_base = reloc_base + reloc_size; 3546 sym_base = lineno_base + lnno_size; 3547 3548 /* Indicate in each section->line_filepos its actual file address. */ 3549 for (current = abfd->sections; current != NULL; current = 3550 current->next) 3551 { 3552 if (current->lineno_count) 3553 { 3554 current->line_filepos = lineno_base; 3555 current->moving_line_filepos = lineno_base; 3556 lineno_base += current->lineno_count * bfd_coff_linesz (abfd); 3557 } 3558 else 3559 { 3560 current->line_filepos = 0; 3561 } 3562 if (current->reloc_count) 3563 { 3564 current->rel_filepos = reloc_base; 3565 reloc_base += current->reloc_count * bfd_coff_relsz (abfd); 3566 #ifdef COFF_WITH_PE 3567 /* Extra reloc to hold real count. */ 3568 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3569 reloc_base += bfd_coff_relsz (abfd); 3570 #endif 3571 } 3572 else 3573 { 3574 current->rel_filepos = 0; 3575 } 3576 } 3577 3578 /* Write section headers to the file. */ 3579 internal_f.f_nscns = 0; 3580 3581 if ((abfd->flags & EXEC_P) != 0) 3582 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 3583 else 3584 { 3585 scn_base = bfd_coff_filhsz (abfd); 3586 #ifdef RS6000COFF_C 3587 #ifndef XCOFF64 3588 if (xcoff_data (abfd)->full_aouthdr) 3589 scn_base += bfd_coff_aoutsz (abfd); 3590 else 3591 scn_base += SMALL_AOUTSZ; 3592 #endif 3593 #endif 3594 } 3595 3596 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 3597 return FALSE; 3598 3599 long_section_names = FALSE; 3600 for (current = abfd->sections; 3601 current != NULL; 3602 current = current->next) 3603 { 3604 struct internal_scnhdr section; 3605 bfd_boolean is_reloc_section = FALSE; 3606 3607 #ifdef COFF_IMAGE_WITH_PE 3608 if (strcmp (current->name, ".reloc") == 0) 3609 { 3610 is_reloc_section = TRUE; 3611 hasrelocs = TRUE; 3612 pe_data (abfd)->has_reloc_section = 1; 3613 } 3614 #endif 3615 3616 internal_f.f_nscns++; 3617 3618 strncpy (section.s_name, current->name, SCNNMLEN); 3619 3620 #ifdef COFF_LONG_SECTION_NAMES 3621 /* Handle long section names as in PE. This must be compatible 3622 with the code in coff_write_symbols and _bfd_coff_final_link. */ 3623 { 3624 size_t len; 3625 3626 len = strlen (current->name); 3627 if (len > SCNNMLEN) 3628 { 3629 memset (section.s_name, 0, SCNNMLEN); 3630 sprintf (section.s_name, "/%lu", (unsigned long) string_size); 3631 string_size += len + 1; 3632 long_section_names = TRUE; 3633 } 3634 } 3635 #endif 3636 3637 #ifdef _LIB 3638 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2 3639 Ian Taylor <ian@cygnus.com>. */ 3640 if (strcmp (current->name, _LIB) == 0) 3641 section.s_vaddr = 0; 3642 else 3643 #endif 3644 section.s_vaddr = current->vma; 3645 section.s_paddr = current->lma; 3646 section.s_size = current->_raw_size; 3647 #ifdef coff_get_section_load_page 3648 section.s_page = coff_get_section_load_page (current); 3649 #endif 3650 3651 #ifdef COFF_WITH_PE 3652 section.s_paddr = 0; 3653 #endif 3654 #ifdef COFF_IMAGE_WITH_PE 3655 /* Reminder: s_paddr holds the virtual size of the section. */ 3656 if (coff_section_data (abfd, current) != NULL 3657 && pei_section_data (abfd, current) != NULL) 3658 section.s_paddr = pei_section_data (abfd, current)->virt_size; 3659 else 3660 section.s_paddr = 0; 3661 #endif 3662 3663 /* If this section has no size or is unloadable then the scnptr 3664 will be 0 too. */ 3665 if (current->_raw_size == 0 || 3666 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 3667 section.s_scnptr = 0; 3668 else 3669 section.s_scnptr = current->filepos; 3670 3671 section.s_relptr = current->rel_filepos; 3672 section.s_lnnoptr = current->line_filepos; 3673 section.s_nreloc = current->reloc_count; 3674 section.s_nlnno = current->lineno_count; 3675 #ifndef COFF_IMAGE_WITH_PE 3676 /* In PEI, relocs come in the .reloc section. */ 3677 if (current->reloc_count != 0) 3678 hasrelocs = TRUE; 3679 #endif 3680 if (current->lineno_count != 0) 3681 haslinno = TRUE; 3682 if ((current->flags & SEC_DEBUGGING) != 0 3683 && ! is_reloc_section) 3684 hasdebug = TRUE; 3685 3686 #ifdef RS6000COFF_C 3687 #ifndef XCOFF64 3688 /* Indicate the use of an XCOFF overflow section header. */ 3689 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3690 { 3691 section.s_nreloc = 0xffff; 3692 section.s_nlnno = 0xffff; 3693 } 3694 #endif 3695 #endif 3696 3697 section.s_flags = sec_to_styp_flags (current->name, current->flags); 3698 3699 if (!strcmp (current->name, _TEXT)) 3700 text_sec = current; 3701 else if (!strcmp (current->name, _DATA)) 3702 data_sec = current; 3703 else if (!strcmp (current->name, _BSS)) 3704 bss_sec = current; 3705 3706 #ifdef I960 3707 section.s_align = (current->alignment_power 3708 ? 1 << current->alignment_power 3709 : 0); 3710 #endif 3711 #ifdef TIC80COFF 3712 /* TI COFF puts the alignment power in bits 8-11 of the flags. */ 3713 section.s_flags |= (current->alignment_power & 0xF) << 8; 3714 #endif 3715 #ifdef COFF_ENCODE_ALIGNMENT 3716 COFF_ENCODE_ALIGNMENT(section, current->alignment_power); 3717 #endif 3718 3719 #ifdef COFF_IMAGE_WITH_PE 3720 /* Suppress output of the sections if they are null. ld 3721 includes the bss and data sections even if there is no size 3722 assigned to them. NT loader doesn't like it if these section 3723 headers are included if the sections themselves are not 3724 needed. See also coff_compute_section_file_positions. */ 3725 if (section.s_size == 0) 3726 internal_f.f_nscns--; 3727 else 3728 #endif 3729 { 3730 SCNHDR buff; 3731 bfd_size_type amt = bfd_coff_scnhsz (abfd); 3732 3733 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 3734 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt) 3735 return FALSE; 3736 } 3737 3738 #ifdef COFF_WITH_PE 3739 /* PE stores COMDAT section information in the symbol table. If 3740 this section is supposed to have some COMDAT info, track down 3741 the symbol in the symbol table and modify it. */ 3742 if ((current->flags & SEC_LINK_ONCE) != 0) 3743 { 3744 unsigned int i, count; 3745 asymbol **psym; 3746 coff_symbol_type *csym = NULL; 3747 asymbol **psymsec; 3748 3749 psymsec = NULL; 3750 count = bfd_get_symcount (abfd); 3751 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++) 3752 { 3753 if ((*psym)->section != current) 3754 continue; 3755 3756 /* Remember the location of the first symbol in this 3757 section. */ 3758 if (psymsec == NULL) 3759 psymsec = psym; 3760 3761 /* See if this is the section symbol. */ 3762 if (strcmp ((*psym)->name, current->name) == 0) 3763 { 3764 csym = coff_symbol_from (abfd, *psym); 3765 if (csym == NULL 3766 || csym->native == NULL 3767 || csym->native->u.syment.n_numaux < 1 3768 || csym->native->u.syment.n_sclass != C_STAT 3769 || csym->native->u.syment.n_type != T_NULL) 3770 continue; 3771 3772 /* Here *PSYM is the section symbol for CURRENT. */ 3773 3774 break; 3775 } 3776 } 3777 3778 /* Did we find it? 3779 Note that we might not if we're converting the file from 3780 some other object file format. */ 3781 if (i < count) 3782 { 3783 combined_entry_type *aux; 3784 3785 /* We don't touch the x_checksum field. The 3786 x_associated field is not currently supported. */ 3787 3788 aux = csym->native + 1; 3789 switch (current->flags & SEC_LINK_DUPLICATES) 3790 { 3791 case SEC_LINK_DUPLICATES_DISCARD: 3792 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY; 3793 break; 3794 3795 case SEC_LINK_DUPLICATES_ONE_ONLY: 3796 aux->u.auxent.x_scn.x_comdat = 3797 IMAGE_COMDAT_SELECT_NODUPLICATES; 3798 break; 3799 3800 case SEC_LINK_DUPLICATES_SAME_SIZE: 3801 aux->u.auxent.x_scn.x_comdat = 3802 IMAGE_COMDAT_SELECT_SAME_SIZE; 3803 break; 3804 3805 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 3806 aux->u.auxent.x_scn.x_comdat = 3807 IMAGE_COMDAT_SELECT_EXACT_MATCH; 3808 break; 3809 } 3810 3811 /* The COMDAT symbol must be the first symbol from this 3812 section in the symbol table. In order to make this 3813 work, we move the COMDAT symbol before the first 3814 symbol we found in the search above. It's OK to 3815 rearrange the symbol table at this point, because 3816 coff_renumber_symbols is going to rearrange it 3817 further and fix up all the aux entries. */ 3818 if (psym != psymsec) 3819 { 3820 asymbol *hold; 3821 asymbol **pcopy; 3822 3823 hold = *psym; 3824 for (pcopy = psym; pcopy > psymsec; pcopy--) 3825 pcopy[0] = pcopy[-1]; 3826 *psymsec = hold; 3827 } 3828 } 3829 } 3830 #endif /* COFF_WITH_PE */ 3831 } 3832 3833 #ifdef RS6000COFF_C 3834 #ifndef XCOFF64 3835 /* XCOFF handles overflows in the reloc and line number count fields 3836 by creating a new section header to hold the correct values. */ 3837 for (current = abfd->sections; current != NULL; current = current->next) 3838 { 3839 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3840 { 3841 struct internal_scnhdr scnhdr; 3842 SCNHDR buff; 3843 bfd_size_type amt; 3844 3845 internal_f.f_nscns++; 3846 strncpy (&(scnhdr.s_name[0]), current->name, 8); 3847 scnhdr.s_paddr = current->reloc_count; 3848 scnhdr.s_vaddr = current->lineno_count; 3849 scnhdr.s_size = 0; 3850 scnhdr.s_scnptr = 0; 3851 scnhdr.s_relptr = current->rel_filepos; 3852 scnhdr.s_lnnoptr = current->line_filepos; 3853 scnhdr.s_nreloc = current->target_index; 3854 scnhdr.s_nlnno = current->target_index; 3855 scnhdr.s_flags = STYP_OVRFLO; 3856 amt = bfd_coff_scnhsz (abfd); 3857 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0 3858 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt) 3859 return FALSE; 3860 } 3861 } 3862 #endif 3863 #endif 3864 3865 /* OK, now set up the filehdr... */ 3866 3867 /* Don't include the internal abs section in the section count */ 3868 3869 /* We will NOT put a fucking timestamp in the header here. Every time you 3870 put it back, I will come in and take it out again. I'm sorry. This 3871 field does not belong here. We fill it with a 0 so it compares the 3872 same but is not a reasonable time. -- gnu@cygnus.com */ 3873 internal_f.f_timdat = 0; 3874 internal_f.f_flags = 0; 3875 3876 if (abfd->flags & EXEC_P) 3877 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3878 else 3879 { 3880 internal_f.f_opthdr = 0; 3881 #ifdef RS6000COFF_C 3882 #ifndef XCOFF64 3883 if (xcoff_data (abfd)->full_aouthdr) 3884 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3885 else 3886 internal_f.f_opthdr = SMALL_AOUTSZ; 3887 #endif 3888 #endif 3889 } 3890 3891 if (!hasrelocs) 3892 internal_f.f_flags |= F_RELFLG; 3893 if (!haslinno) 3894 internal_f.f_flags |= F_LNNO; 3895 if (abfd->flags & EXEC_P) 3896 internal_f.f_flags |= F_EXEC; 3897 #ifdef COFF_IMAGE_WITH_PE 3898 if (! hasdebug) 3899 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED; 3900 #endif 3901 3902 #ifndef COFF_WITH_pex64 3903 #ifdef COFF_WITH_PE 3904 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE; 3905 #else 3906 if (bfd_little_endian (abfd)) 3907 internal_f.f_flags |= F_AR32WR; 3908 else 3909 internal_f.f_flags |= F_AR32W; 3910 #endif 3911 #endif 3912 3913 #ifdef TI_TARGET_ID 3914 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field, 3915 but it doesn't hurt to set it internally. */ 3916 internal_f.f_target_id = TI_TARGET_ID; 3917 #endif 3918 #ifdef TIC80_TARGET_ID 3919 internal_f.f_target_id = TIC80_TARGET_ID; 3920 #endif 3921 3922 /* FIXME, should do something about the other byte orders and 3923 architectures. */ 3924 3925 #ifdef RS6000COFF_C 3926 if ((abfd->flags & DYNAMIC) != 0) 3927 internal_f.f_flags |= F_SHROBJ; 3928 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 3929 internal_f.f_flags |= F_DYNLOAD; 3930 #endif 3931 3932 memset (&internal_a, 0, sizeof internal_a); 3933 3934 /* Set up architecture-dependent stuff. */ 3935 { 3936 unsigned int magic = 0; 3937 unsigned short flags = 0; 3938 3939 coff_set_flags (abfd, &magic, &flags); 3940 internal_f.f_magic = magic; 3941 internal_f.f_flags |= flags; 3942 /* ...and the "opt"hdr... */ 3943 3944 #ifdef A29K 3945 #ifdef ULTRA3 /* NYU's machine */ 3946 /* FIXME: This is a bogus check. I really want to see if there 3947 is a .shbss or a .shdata section, if so then set the magic 3948 number to indicate a shared data executable. */ 3949 if (internal_f.f_nscns >= 7) 3950 internal_a.magic = SHMAGIC; /* Shared magic. */ 3951 else 3952 #endif /* ULTRA3 */ 3953 internal_a.magic = NMAGIC; /* Assume separate i/d. */ 3954 #define __A_MAGIC_SET__ 3955 #endif /* A29K */ 3956 #ifdef TICOFF_AOUT_MAGIC 3957 internal_a.magic = TICOFF_AOUT_MAGIC; 3958 #define __A_MAGIC_SET__ 3959 #endif 3960 #ifdef TIC80COFF 3961 internal_a.magic = TIC80_ARCH_MAGIC; 3962 #define __A_MAGIC_SET__ 3963 #endif /* TIC80 */ 3964 #ifdef I860 3965 /* FIXME: What are the a.out magic numbers for the i860? */ 3966 internal_a.magic = 0; 3967 #define __A_MAGIC_SET__ 3968 #endif /* I860 */ 3969 #ifdef I960 3970 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 3971 #define __A_MAGIC_SET__ 3972 #endif /* I960 */ 3973 #if M88 3974 #define __A_MAGIC_SET__ 3975 internal_a.magic = PAGEMAGICBCS; 3976 #endif /* M88 */ 3977 3978 #if APOLLO_M68 3979 #define __A_MAGIC_SET__ 3980 internal_a.magic = APOLLO_COFF_VERSION_NUMBER; 3981 #endif 3982 3983 #if defined(M68) || defined(WE32K) || defined(M68K) 3984 #define __A_MAGIC_SET__ 3985 #if defined(LYNXOS) 3986 internal_a.magic = LYNXCOFFMAGIC; 3987 #else 3988 #if defined(TARG_AUX) 3989 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED : 3990 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED : 3991 PAGEMAGICEXECSWAPPED); 3992 #else 3993 #if defined (PAGEMAGICPEXECPAGED) 3994 internal_a.magic = PAGEMAGICPEXECPAGED; 3995 #endif 3996 #endif /* TARG_AUX */ 3997 #endif /* LYNXOS */ 3998 #endif /* M68 || WE32K || M68K */ 3999 4000 #if defined(ARM) 4001 #define __A_MAGIC_SET__ 4002 internal_a.magic = ZMAGIC; 4003 #endif 4004 4005 #if defined(PPC_PE) 4006 #define __A_MAGIC_SET__ 4007 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 4008 #endif 4009 4010 #if defined MCORE_PE 4011 #define __A_MAGIC_SET__ 4012 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 4013 #endif 4014 4015 #if defined(I386) 4016 #define __A_MAGIC_SET__ 4017 #if defined(LYNXOS) 4018 internal_a.magic = LYNXCOFFMAGIC; 4019 #elif defined AMD64 4020 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; 4021 #else /* LYNXOS */ 4022 internal_a.magic = ZMAGIC; 4023 #endif /* LYNXOS */ 4024 #endif /* I386 */ 4025 4026 #if defined(IA64) 4027 #define __A_MAGIC_SET__ 4028 internal_a.magic = ZMAGIC; 4029 #endif /* IA64 */ 4030 4031 #if defined(SPARC) 4032 #define __A_MAGIC_SET__ 4033 #if defined(LYNXOS) 4034 internal_a.magic = LYNXCOFFMAGIC; 4035 #endif /* LYNXOS */ 4036 #endif /* SPARC */ 4037 4038 #ifdef RS6000COFF_C 4039 #define __A_MAGIC_SET__ 4040 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC : 4041 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC : 4042 RS6K_AOUTHDR_OMAGIC; 4043 #endif 4044 4045 #if defined(SH) && defined(COFF_WITH_PE) 4046 #define __A_MAGIC_SET__ 4047 internal_a.magic = SH_PE_MAGIC; 4048 #endif 4049 4050 #if defined(MIPS) && defined(COFF_WITH_PE) 4051 #define __A_MAGIC_SET__ 4052 internal_a.magic = MIPS_PE_MAGIC; 4053 #endif 4054 4055 #ifdef OR32 4056 #define __A_MAGIC_SET__ 4057 internal_a.magic = NMAGIC; /* Assume separate i/d. */ 4058 #endif 4059 4060 #ifndef __A_MAGIC_SET__ 4061 #include "Your aouthdr magic number is not being set!" 4062 #else 4063 #undef __A_MAGIC_SET__ 4064 #endif 4065 } 4066 4067 /* FIXME: Does anybody ever set this to another value? */ 4068 internal_a.vstamp = 0; 4069 4070 /* Now should write relocs, strings, syms. */ 4071 obj_sym_filepos (abfd) = sym_base; 4072 4073 if (bfd_get_symcount (abfd) != 0) 4074 { 4075 int firstundef; 4076 #if 0 4077 if (!coff_add_missing_symbols (abfd)) 4078 return FALSE; 4079 #endif 4080 if (!coff_renumber_symbols (abfd, &firstundef)) 4081 return FALSE; 4082 coff_mangle_symbols (abfd); 4083 if (! coff_write_symbols (abfd)) 4084 return FALSE; 4085 if (! coff_write_linenumbers (abfd)) 4086 return FALSE; 4087 if (! coff_write_relocs (abfd, firstundef)) 4088 return FALSE; 4089 } 4090 #ifdef COFF_LONG_SECTION_NAMES 4091 else if (long_section_names && ! obj_coff_strings_written (abfd)) 4092 { 4093 /* If we have long section names we have to write out the string 4094 table even if there are no symbols. */ 4095 if (! coff_write_symbols (abfd)) 4096 return FALSE; 4097 } 4098 #endif 4099 #ifdef COFF_IMAGE_WITH_PE 4100 #ifdef PPC_PE 4101 else if ((abfd->flags & EXEC_P) != 0) 4102 { 4103 bfd_byte b; 4104 4105 /* PowerPC PE appears to require that all executable files be 4106 rounded up to the page size. */ 4107 b = 0; 4108 if (bfd_seek (abfd, 4109 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1, 4110 SEEK_SET) != 0 4111 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 4112 return FALSE; 4113 } 4114 #endif 4115 #endif 4116 4117 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 4118 backend linker, and obj_raw_syment_count is not valid until after 4119 coff_write_symbols is called. */ 4120 if (obj_raw_syment_count (abfd) != 0) 4121 { 4122 internal_f.f_symptr = sym_base; 4123 #ifdef RS6000COFF_C 4124 /* AIX appears to require that F_RELFLG not be set if there are 4125 local symbols but no relocations. */ 4126 internal_f.f_flags &=~ F_RELFLG; 4127 #endif 4128 } 4129 else 4130 { 4131 if (long_section_names) 4132 internal_f.f_symptr = sym_base; 4133 else 4134 internal_f.f_symptr = 0; 4135 internal_f.f_flags |= F_LSYMS; 4136 } 4137 4138 if (text_sec) 4139 { 4140 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec); 4141 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 4142 } 4143 if (data_sec) 4144 { 4145 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec); 4146 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 4147 } 4148 if (bss_sec) 4149 { 4150 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec); 4151 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 4152 internal_a.data_start = bss_sec->vma; 4153 } 4154 4155 internal_a.entry = bfd_get_start_address (abfd); 4156 internal_f.f_nsyms = obj_raw_syment_count (abfd); 4157 4158 #ifdef RS6000COFF_C 4159 if (xcoff_data (abfd)->full_aouthdr) 4160 { 4161 bfd_vma toc; 4162 asection *loader_sec; 4163 4164 internal_a.vstamp = 1; 4165 4166 internal_a.o_snentry = xcoff_data (abfd)->snentry; 4167 if (internal_a.o_snentry == 0) 4168 internal_a.entry = (bfd_vma) -1; 4169 4170 if (text_sec != NULL) 4171 { 4172 internal_a.o_sntext = text_sec->target_index; 4173 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec); 4174 } 4175 else 4176 { 4177 internal_a.o_sntext = 0; 4178 internal_a.o_algntext = 0; 4179 } 4180 if (data_sec != NULL) 4181 { 4182 internal_a.o_sndata = data_sec->target_index; 4183 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec); 4184 } 4185 else 4186 { 4187 internal_a.o_sndata = 0; 4188 internal_a.o_algndata = 0; 4189 } 4190 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 4191 if (loader_sec != NULL) 4192 internal_a.o_snloader = loader_sec->target_index; 4193 else 4194 internal_a.o_snloader = 0; 4195 if (bss_sec != NULL) 4196 internal_a.o_snbss = bss_sec->target_index; 4197 else 4198 internal_a.o_snbss = 0; 4199 4200 toc = xcoff_data (abfd)->toc; 4201 internal_a.o_toc = toc; 4202 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 4203 4204 internal_a.o_modtype = xcoff_data (abfd)->modtype; 4205 if (xcoff_data (abfd)->cputype != -1) 4206 internal_a.o_cputype = xcoff_data (abfd)->cputype; 4207 else 4208 { 4209 switch (bfd_get_arch (abfd)) 4210 { 4211 case bfd_arch_rs6000: 4212 internal_a.o_cputype = 4; 4213 break; 4214 case bfd_arch_powerpc: 4215 if (bfd_get_mach (abfd) == bfd_mach_ppc) 4216 internal_a.o_cputype = 3; 4217 else 4218 internal_a.o_cputype = 1; 4219 break; 4220 default: 4221 abort (); 4222 } 4223 } 4224 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 4225 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 4226 } 4227 #endif 4228 4229 /* now write them */ 4230 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 4231 return FALSE; 4232 4233 { 4234 char * buff; 4235 bfd_size_type amount = bfd_coff_filhsz (abfd); 4236 4237 buff = bfd_malloc (amount); 4238 if (buff == NULL) 4239 return FALSE; 4240 4241 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff); 4242 amount = bfd_bwrite ((PTR) buff, amount, abfd); 4243 4244 free (buff); 4245 4246 if (amount != bfd_coff_filhsz (abfd)) 4247 return FALSE; 4248 } 4249 4250 if (abfd->flags & EXEC_P) 4251 { 4252 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR. 4253 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */ 4254 char * buff; 4255 bfd_size_type amount = bfd_coff_aoutsz (abfd); 4256 4257 buff = bfd_malloc (amount); 4258 if (buff == NULL) 4259 return FALSE; 4260 4261 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff); 4262 amount = bfd_bwrite ((PTR) buff, amount, abfd); 4263 4264 free (buff); 4265 4266 if (amount != bfd_coff_aoutsz (abfd)) 4267 return FALSE; 4268 4269 #ifdef COFF_IMAGE_WITH_PE 4270 if (! coff_apply_checksum (abfd)) 4271 return FALSE; 4272 #endif 4273 } 4274 #ifdef RS6000COFF_C 4275 else 4276 { 4277 AOUTHDR buff; 4278 size_t size; 4279 4280 /* XCOFF seems to always write at least a small a.out header. */ 4281 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff); 4282 if (xcoff_data (abfd)->full_aouthdr) 4283 size = bfd_coff_aoutsz (abfd); 4284 else 4285 size = SMALL_AOUTSZ; 4286 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size) 4287 return FALSE; 4288 } 4289 #endif 4290 4291 return TRUE; 4292 } 4293 4294 static bfd_boolean 4295 coff_set_section_contents (abfd, section, location, offset, count) 4296 bfd * abfd; 4297 sec_ptr section; 4298 const PTR location; 4299 file_ptr offset; 4300 bfd_size_type count; 4301 { 4302 if (! abfd->output_has_begun) /* Set by bfd.c handler. */ 4303 { 4304 if (! coff_compute_section_file_positions (abfd)) 4305 return FALSE; 4306 } 4307 4308 #if defined(_LIB) && !defined(TARG_AUX) 4309 4310 /* The physical address field of a .lib section is used to hold the 4311 number of shared libraries in the section. This code counts the 4312 number of sections being written, and increments the lma field 4313 with the number. 4314 4315 I have found no documentation on the contents of this section. 4316 Experimentation indicates that the section contains zero or more 4317 records, each of which has the following structure: 4318 4319 - a (four byte) word holding the length of this record, in words, 4320 - a word that always seems to be set to "2", 4321 - the path to a shared library, null-terminated and then padded 4322 to a whole word boundary. 4323 4324 bfd_assert calls have been added to alert if an attempt is made 4325 to write a section which doesn't follow these assumptions. The 4326 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe 4327 <robertl@arnet.com> (Thanks!). 4328 4329 Gvran Uddeborg <gvran@uddeborg.pp.se>. */ 4330 4331 if (strcmp (section->name, _LIB) == 0) 4332 { 4333 bfd_byte *rec, *recend; 4334 4335 rec = (bfd_byte *) location; 4336 recend = rec + count; 4337 while (rec < recend) 4338 { 4339 ++section->lma; 4340 rec += bfd_get_32 (abfd, rec) * 4; 4341 } 4342 4343 BFD_ASSERT (rec == recend); 4344 } 4345 4346 #endif 4347 4348 /* Don't write out bss sections - one way to do this is to 4349 see if the filepos has not been set. */ 4350 if (section->filepos == 0) 4351 return TRUE; 4352 4353 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0) 4354 return FALSE; 4355 4356 if (count == 0) 4357 return TRUE; 4358 4359 return bfd_bwrite (location, count, abfd) == count; 4360 } 4361 #if 0 4362 static bfd_boolean 4363 coff_close_and_cleanup (abfd) 4364 bfd *abfd; 4365 { 4366 if (!bfd_read_p (abfd)) 4367 switch (abfd->format) 4368 { 4369 case bfd_archive: 4370 if (!_bfd_write_archive_contents (abfd)) 4371 return FALSE; 4372 break; 4373 case bfd_object: 4374 if (!coff_write_object_contents (abfd)) 4375 return FALSE; 4376 break; 4377 default: 4378 bfd_set_error (bfd_error_invalid_operation); 4379 return FALSE; 4380 } 4381 4382 /* We depend on bfd_close to free all the memory on the objalloc. */ 4383 return TRUE; 4384 } 4385 4386 #endif 4387 4388 static PTR 4389 buy_and_read (abfd, where, size) 4390 bfd *abfd; 4391 file_ptr where; 4392 bfd_size_type size; 4393 { 4394 PTR area = (PTR) bfd_alloc (abfd, size); 4395 if (!area) 4396 return (NULL); 4397 if (bfd_seek (abfd, where, SEEK_SET) != 0 4398 || bfd_bread (area, size, abfd) != size) 4399 return (NULL); 4400 return (area); 4401 } /* buy_and_read() */ 4402 4403 /* 4404 SUBSUBSECTION 4405 Reading linenumbers 4406 4407 Creating the linenumber table is done by reading in the entire 4408 coff linenumber table, and creating another table for internal use. 4409 4410 A coff linenumber table is structured so that each function 4411 is marked as having a line number of 0. Each line within the 4412 function is an offset from the first line in the function. The 4413 base of the line number information for the table is stored in 4414 the symbol associated with the function. 4415 4416 Note: The PE format uses line number 0 for a flag indicating a 4417 new source file. 4418 4419 The information is copied from the external to the internal 4420 table, and each symbol which marks a function is marked by 4421 pointing its... 4422 4423 How does this work ? 4424 4425 */ 4426 4427 static bfd_boolean 4428 coff_slurp_line_table (abfd, asect) 4429 bfd *abfd; 4430 asection *asect; 4431 { 4432 LINENO *native_lineno; 4433 alent *lineno_cache; 4434 bfd_size_type amt; 4435 4436 BFD_ASSERT (asect->lineno == (alent *) NULL); 4437 4438 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count; 4439 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt); 4440 if (native_lineno == NULL) 4441 { 4442 (*_bfd_error_handler) 4443 (_("%s: warning: line number table read failed"), 4444 bfd_archive_filename (abfd)); 4445 return FALSE; 4446 } 4447 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent); 4448 lineno_cache = (alent *) bfd_alloc (abfd, amt); 4449 if (lineno_cache == NULL) 4450 return FALSE; 4451 else 4452 { 4453 unsigned int counter = 0; 4454 alent *cache_ptr = lineno_cache; 4455 LINENO *src = native_lineno; 4456 4457 while (counter < asect->lineno_count) 4458 { 4459 struct internal_lineno dst; 4460 4461 bfd_coff_swap_lineno_in (abfd, src, &dst); 4462 cache_ptr->line_number = dst.l_lnno; 4463 4464 if (cache_ptr->line_number == 0) 4465 { 4466 bfd_boolean warned; 4467 bfd_signed_vma symndx; 4468 coff_symbol_type *sym; 4469 4470 warned = FALSE; 4471 symndx = dst.l_addr.l_symndx; 4472 if (symndx < 0 4473 || (bfd_vma) symndx >= obj_raw_syment_count (abfd)) 4474 { 4475 (*_bfd_error_handler) 4476 (_("%s: warning: illegal symbol index %ld in line numbers"), 4477 bfd_archive_filename (abfd), dst.l_addr.l_symndx); 4478 symndx = 0; 4479 warned = TRUE; 4480 } 4481 /* FIXME: We should not be casting between ints and 4482 pointers like this. */ 4483 sym = ((coff_symbol_type *) 4484 ((symndx + obj_raw_syments (abfd)) 4485 ->u.syment._n._n_n._n_zeroes)); 4486 cache_ptr->u.sym = (asymbol *) sym; 4487 if (sym->lineno != NULL && ! warned) 4488 { 4489 (*_bfd_error_handler) 4490 (_("%s: warning: duplicate line number information for `%s'"), 4491 bfd_archive_filename (abfd), 4492 bfd_asymbol_name (&sym->symbol)); 4493 } 4494 sym->lineno = cache_ptr; 4495 } 4496 else 4497 { 4498 cache_ptr->u.offset = dst.l_addr.l_paddr 4499 - bfd_section_vma (abfd, asect); 4500 } /* If no linenumber expect a symbol index */ 4501 4502 cache_ptr++; 4503 src++; 4504 counter++; 4505 } 4506 cache_ptr->line_number = 0; 4507 4508 } 4509 asect->lineno = lineno_cache; 4510 /* FIXME, free native_lineno here, or use alloca or something. */ 4511 return TRUE; 4512 } 4513 4514 /* Slurp in the symbol table, converting it to generic form. Note 4515 that if coff_relocate_section is defined, the linker will read 4516 symbols via coff_link_add_symbols, rather than via this routine. */ 4517 4518 static bfd_boolean 4519 coff_slurp_symbol_table (abfd) 4520 bfd * abfd; 4521 { 4522 combined_entry_type *native_symbols; 4523 coff_symbol_type *cached_area; 4524 unsigned int *table_ptr; 4525 bfd_size_type amt; 4526 unsigned int number_of_symbols = 0; 4527 4528 if (obj_symbols (abfd)) 4529 return TRUE; 4530 4531 /* Read in the symbol table. */ 4532 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL) 4533 return FALSE; 4534 4535 /* Allocate enough room for all the symbols in cached form. */ 4536 amt = obj_raw_syment_count (abfd); 4537 amt *= sizeof (coff_symbol_type); 4538 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt); 4539 if (cached_area == NULL) 4540 return FALSE; 4541 4542 amt = obj_raw_syment_count (abfd); 4543 amt *= sizeof (unsigned int); 4544 table_ptr = (unsigned int *) bfd_alloc (abfd, amt); 4545 4546 if (table_ptr == NULL) 4547 return FALSE; 4548 else 4549 { 4550 coff_symbol_type *dst = cached_area; 4551 unsigned int last_native_index = obj_raw_syment_count (abfd); 4552 unsigned int this_index = 0; 4553 4554 while (this_index < last_native_index) 4555 { 4556 combined_entry_type *src = native_symbols + this_index; 4557 table_ptr[this_index] = number_of_symbols; 4558 dst->symbol.the_bfd = abfd; 4559 4560 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset); 4561 /* We use the native name field to point to the cached field. */ 4562 src->u.syment._n._n_n._n_zeroes = (long) dst; 4563 dst->symbol.section = coff_section_from_bfd_index (abfd, 4564 src->u.syment.n_scnum); 4565 dst->symbol.flags = 0; 4566 dst->done_lineno = FALSE; 4567 4568 switch (src->u.syment.n_sclass) 4569 { 4570 #ifdef I960 4571 case C_LEAFEXT: 4572 #if 0 4573 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma; 4574 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 4575 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4576 #endif 4577 /* Fall through to next case. */ 4578 #endif 4579 4580 case C_EXT: 4581 case C_WEAKEXT: 4582 #if defined ARM 4583 case C_THUMBEXT: 4584 case C_THUMBEXTFUNC: 4585 #endif 4586 #ifdef RS6000COFF_C 4587 case C_HIDEXT: 4588 #endif 4589 #ifdef C_SYSTEM 4590 case C_SYSTEM: /* System Wide variable. */ 4591 #endif 4592 #ifdef COFF_WITH_PE 4593 /* In PE, 0x68 (104) denotes a section symbol. */ 4594 case C_SECTION: 4595 /* In PE, 0x69 (105) denotes a weak external symbol. */ 4596 case C_NT_WEAK: 4597 #endif 4598 switch (coff_classify_symbol (abfd, &src->u.syment)) 4599 { 4600 case COFF_SYMBOL_GLOBAL: 4601 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 4602 #if defined COFF_WITH_PE 4603 /* PE sets the symbol to a value relative to the 4604 start of the section. */ 4605 dst->symbol.value = src->u.syment.n_value; 4606 #else 4607 dst->symbol.value = (src->u.syment.n_value 4608 - dst->symbol.section->vma); 4609 #endif 4610 if (ISFCN ((src->u.syment.n_type))) 4611 { 4612 /* A function ext does not go at the end of a 4613 file. */ 4614 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4615 } 4616 break; 4617 4618 case COFF_SYMBOL_COMMON: 4619 dst->symbol.section = bfd_com_section_ptr; 4620 dst->symbol.value = src->u.syment.n_value; 4621 break; 4622 4623 case COFF_SYMBOL_UNDEFINED: 4624 dst->symbol.section = bfd_und_section_ptr; 4625 dst->symbol.value = 0; 4626 break; 4627 4628 case COFF_SYMBOL_PE_SECTION: 4629 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM; 4630 dst->symbol.value = 0; 4631 break; 4632 4633 case COFF_SYMBOL_LOCAL: 4634 dst->symbol.flags = BSF_LOCAL; 4635 #if defined COFF_WITH_PE 4636 /* PE sets the symbol to a value relative to the 4637 start of the section. */ 4638 dst->symbol.value = src->u.syment.n_value; 4639 #else 4640 dst->symbol.value = (src->u.syment.n_value 4641 - dst->symbol.section->vma); 4642 #endif 4643 if (ISFCN ((src->u.syment.n_type))) 4644 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4645 break; 4646 } 4647 4648 #ifdef RS6000COFF_C 4649 /* A symbol with a csect entry should not go at the end. */ 4650 if (src->u.syment.n_numaux > 0) 4651 dst->symbol.flags |= BSF_NOT_AT_END; 4652 #endif 4653 4654 #ifdef COFF_WITH_PE 4655 if (src->u.syment.n_sclass == C_NT_WEAK) 4656 dst->symbol.flags |= BSF_WEAK; 4657 4658 if (src->u.syment.n_sclass == C_SECTION 4659 && src->u.syment.n_scnum > 0) 4660 dst->symbol.flags = BSF_LOCAL; 4661 #endif 4662 if (src->u.syment.n_sclass == C_WEAKEXT) 4663 dst->symbol.flags |= BSF_WEAK; 4664 4665 break; 4666 4667 case C_STAT: /* Static. */ 4668 #ifdef I960 4669 case C_LEAFSTAT: /* Static leaf procedure. */ 4670 #endif 4671 #if defined ARM 4672 case C_THUMBSTAT: /* Thumb static. */ 4673 case C_THUMBLABEL: /* Thumb label. */ 4674 case C_THUMBSTATFUNC:/* Thumb static function. */ 4675 #endif 4676 case C_LABEL: /* Label. */ 4677 if (src->u.syment.n_scnum == N_DEBUG) 4678 dst->symbol.flags = BSF_DEBUGGING; 4679 else 4680 dst->symbol.flags = BSF_LOCAL; 4681 4682 /* Base the value as an index from the base of the 4683 section, if there is one. */ 4684 if (dst->symbol.section) 4685 { 4686 #if defined COFF_WITH_PE 4687 /* PE sets the symbol to a value relative to the 4688 start of the section. */ 4689 dst->symbol.value = src->u.syment.n_value; 4690 #else 4691 dst->symbol.value = (src->u.syment.n_value 4692 - dst->symbol.section->vma); 4693 #endif 4694 } 4695 else 4696 dst->symbol.value = src->u.syment.n_value; 4697 break; 4698 4699 case C_MOS: /* Member of structure. */ 4700 case C_EOS: /* End of structure. */ 4701 #ifdef NOTDEF /* C_AUTOARG has the same value. */ 4702 #ifdef C_GLBLREG 4703 case C_GLBLREG: /* A29k-specific storage class. */ 4704 #endif 4705 #endif 4706 case C_REGPARM: /* Register parameter. */ 4707 case C_REG: /* register variable. */ 4708 /* C_AUTOARG conflicts with TI COFF C_UEXT. */ 4709 #if !defined (TIC80COFF) && !defined (TICOFF) 4710 #ifdef C_AUTOARG 4711 case C_AUTOARG: /* 960-specific storage class. */ 4712 #endif 4713 #endif 4714 case C_TPDEF: /* Type definition. */ 4715 case C_ARG: 4716 case C_AUTO: /* Automatic variable. */ 4717 case C_FIELD: /* Bit field. */ 4718 case C_ENTAG: /* Enumeration tag. */ 4719 case C_MOE: /* Member of enumeration. */ 4720 case C_MOU: /* Member of union. */ 4721 case C_UNTAG: /* Union tag. */ 4722 dst->symbol.flags = BSF_DEBUGGING; 4723 dst->symbol.value = (src->u.syment.n_value); 4724 break; 4725 4726 case C_FILE: /* File name. */ 4727 case C_STRTAG: /* Structure tag. */ 4728 #ifdef RS6000COFF_C 4729 case C_GSYM: 4730 case C_LSYM: 4731 case C_PSYM: 4732 case C_RSYM: 4733 case C_RPSYM: 4734 case C_STSYM: 4735 case C_TCSYM: 4736 case C_BCOMM: 4737 case C_ECOML: 4738 case C_ECOMM: 4739 case C_DECL: 4740 case C_ENTRY: 4741 case C_FUN: 4742 case C_ESTAT: 4743 #endif 4744 dst->symbol.flags = BSF_DEBUGGING; 4745 dst->symbol.value = (src->u.syment.n_value); 4746 break; 4747 4748 #ifdef RS6000COFF_C 4749 case C_BINCL: /* Beginning of include file. */ 4750 case C_EINCL: /* Ending of include file. */ 4751 /* The value is actually a pointer into the line numbers 4752 of the file. We locate the line number entry, and 4753 set the section to the section which contains it, and 4754 the value to the index in that section. */ 4755 { 4756 asection *sec; 4757 4758 dst->symbol.flags = BSF_DEBUGGING; 4759 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4760 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value 4761 && ((file_ptr) (sec->line_filepos 4762 + sec->lineno_count * bfd_coff_linesz (abfd)) 4763 > (file_ptr) src->u.syment.n_value)) 4764 break; 4765 if (sec == NULL) 4766 dst->symbol.value = 0; 4767 else 4768 { 4769 dst->symbol.section = sec; 4770 dst->symbol.value = ((src->u.syment.n_value 4771 - sec->line_filepos) 4772 / bfd_coff_linesz (abfd)); 4773 src->fix_line = 1; 4774 } 4775 } 4776 break; 4777 4778 case C_BSTAT: 4779 dst->symbol.flags = BSF_DEBUGGING; 4780 4781 /* The value is actually a symbol index. Save a pointer 4782 to the symbol instead of the index. FIXME: This 4783 should use a union. */ 4784 src->u.syment.n_value = 4785 (long) (native_symbols + src->u.syment.n_value); 4786 dst->symbol.value = src->u.syment.n_value; 4787 src->fix_value = 1; 4788 break; 4789 #endif 4790 4791 case C_BLOCK: /* ".bb" or ".eb". */ 4792 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */ 4793 case C_EFCN: /* Physical end of function. */ 4794 #if defined COFF_WITH_PE 4795 /* PE sets the symbol to a value relative to the start 4796 of the section. */ 4797 dst->symbol.value = src->u.syment.n_value; 4798 if (strcmp (dst->symbol.name, ".bf") != 0) 4799 { 4800 /* PE uses funny values for .ef and .lf; don't 4801 relocate them. */ 4802 dst->symbol.flags = BSF_DEBUGGING; 4803 } 4804 else 4805 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC; 4806 #else 4807 /* Base the value as an index from the base of the 4808 section. */ 4809 dst->symbol.flags = BSF_LOCAL; 4810 dst->symbol.value = (src->u.syment.n_value 4811 - dst->symbol.section->vma); 4812 #endif 4813 break; 4814 4815 case C_STATLAB: /* Static load time label. */ 4816 dst->symbol.value = src->u.syment.n_value; 4817 dst->symbol.flags = BSF_GLOBAL; 4818 break; 4819 4820 case C_NULL: 4821 /* PE DLLs sometimes have zeroed out symbols for some 4822 reason. Just ignore them without a warning. */ 4823 if (src->u.syment.n_type == 0 4824 && src->u.syment.n_value == 0 4825 && src->u.syment.n_scnum == 0) 4826 break; 4827 /* Fall through. */ 4828 case C_EXTDEF: /* External definition. */ 4829 case C_ULABEL: /* Undefined label. */ 4830 case C_USTATIC: /* Undefined static. */ 4831 #ifndef COFF_WITH_PE 4832 /* C_LINE in regular coff is 0x68. NT has taken over this storage 4833 class to represent a section symbol. */ 4834 case C_LINE: /* line # reformatted as symbol table entry. */ 4835 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 4836 case C_ALIAS: /* Duplicate tag. */ 4837 #endif 4838 /* New storage classes for TI COFF. */ 4839 #if defined(TIC80COFF) || defined(TICOFF) 4840 case C_UEXT: /* Tentative external definition. */ 4841 #endif 4842 case C_EXTLAB: /* External load time label. */ 4843 case C_HIDDEN: /* Ext symbol in dmert public lib. */ 4844 default: 4845 (*_bfd_error_handler) 4846 (_("%s: Unrecognized storage class %d for %s symbol `%s'"), 4847 bfd_archive_filename (abfd), src->u.syment.n_sclass, 4848 dst->symbol.section->name, dst->symbol.name); 4849 dst->symbol.flags = BSF_DEBUGGING; 4850 dst->symbol.value = (src->u.syment.n_value); 4851 break; 4852 } 4853 4854 /* BFD_ASSERT(dst->symbol.flags != 0);*/ 4855 4856 dst->native = src; 4857 4858 dst->symbol.udata.i = 0; 4859 dst->lineno = (alent *) NULL; 4860 this_index += (src->u.syment.n_numaux) + 1; 4861 dst++; 4862 number_of_symbols++; 4863 } 4864 } 4865 4866 obj_symbols (abfd) = cached_area; 4867 obj_raw_syments (abfd) = native_symbols; 4868 4869 bfd_get_symcount (abfd) = number_of_symbols; 4870 obj_convert (abfd) = table_ptr; 4871 /* Slurp the line tables for each section too. */ 4872 { 4873 asection *p; 4874 4875 p = abfd->sections; 4876 while (p) 4877 { 4878 coff_slurp_line_table (abfd, p); 4879 p = p->next; 4880 } 4881 } 4882 4883 return TRUE; 4884 } /* coff_slurp_symbol_table() */ 4885 4886 /* Classify a COFF symbol. A couple of targets have globally visible 4887 symbols which are not class C_EXT, and this handles those. It also 4888 recognizes some special PE cases. */ 4889 4890 static enum coff_symbol_classification 4891 coff_classify_symbol (abfd, syment) 4892 bfd *abfd; 4893 struct internal_syment *syment; 4894 { 4895 /* FIXME: This partially duplicates the switch in 4896 coff_slurp_symbol_table. */ 4897 switch (syment->n_sclass) 4898 { 4899 case C_EXT: 4900 case C_WEAKEXT: 4901 #ifdef I960 4902 case C_LEAFEXT: 4903 #endif 4904 #ifdef ARM 4905 case C_THUMBEXT: 4906 case C_THUMBEXTFUNC: 4907 #endif 4908 #ifdef C_SYSTEM 4909 case C_SYSTEM: 4910 #endif 4911 #ifdef COFF_WITH_PE 4912 case C_NT_WEAK: 4913 #endif 4914 if (syment->n_scnum == 0) 4915 { 4916 if (syment->n_value == 0) 4917 return COFF_SYMBOL_UNDEFINED; 4918 else 4919 return COFF_SYMBOL_COMMON; 4920 } 4921 return COFF_SYMBOL_GLOBAL; 4922 4923 default: 4924 break; 4925 } 4926 4927 #ifdef COFF_WITH_PE 4928 if (syment->n_sclass == C_STAT) 4929 { 4930 if (syment->n_scnum == 0) 4931 { 4932 /* The Microsoft compiler sometimes generates these if a 4933 small static function is inlined every time it is used. 4934 The function is discarded, but the symbol table entry 4935 remains. */ 4936 return COFF_SYMBOL_LOCAL; 4937 } 4938 4939 #ifdef STRICT_PE_FORMAT 4940 /* This is correct for Microsoft generated objects, but it 4941 breaks gas generated objects. */ 4942 4943 if (syment->n_value == 0) 4944 { 4945 asection *sec; 4946 char buf[SYMNMLEN + 1]; 4947 4948 sec = coff_section_from_bfd_index (abfd, syment->n_scnum); 4949 if (sec != NULL 4950 && (strcmp (bfd_get_section_name (abfd, sec), 4951 _bfd_coff_internal_syment_name (abfd, syment, buf)) 4952 == 0)) 4953 return COFF_SYMBOL_PE_SECTION; 4954 } 4955 #endif 4956 4957 return COFF_SYMBOL_LOCAL; 4958 } 4959 4960 if (syment->n_sclass == C_SECTION) 4961 { 4962 /* In some cases in a DLL generated by the Microsoft linker, the 4963 n_value field will contain garbage. FIXME: This should 4964 probably be handled by the swapping function instead. */ 4965 syment->n_value = 0; 4966 if (syment->n_scnum == 0) 4967 return COFF_SYMBOL_UNDEFINED; 4968 return COFF_SYMBOL_PE_SECTION; 4969 } 4970 #endif /* COFF_WITH_PE */ 4971 4972 /* If it is not a global symbol, we presume it is a local symbol. */ 4973 4974 if (syment->n_scnum == 0) 4975 { 4976 char buf[SYMNMLEN + 1]; 4977 4978 (*_bfd_error_handler) 4979 (_("warning: %s: local symbol `%s' has no section"), 4980 bfd_archive_filename (abfd), 4981 _bfd_coff_internal_syment_name (abfd, syment, buf)); 4982 } 4983 4984 return COFF_SYMBOL_LOCAL; 4985 } 4986 4987 /* 4988 SUBSUBSECTION 4989 Reading relocations 4990 4991 Coff relocations are easily transformed into the internal BFD form 4992 (@code{arelent}). 4993 4994 Reading a coff relocation table is done in the following stages: 4995 4996 o Read the entire coff relocation table into memory. 4997 4998 o Process each relocation in turn; first swap it from the 4999 external to the internal form. 5000 5001 o Turn the symbol referenced in the relocation's symbol index 5002 into a pointer into the canonical symbol table. 5003 This table is the same as the one returned by a call to 5004 @code{bfd_canonicalize_symtab}. The back end will call that 5005 routine and save the result if a canonicalization hasn't been done. 5006 5007 o The reloc index is turned into a pointer to a howto 5008 structure, in a back end specific way. For instance, the 386 5009 and 960 use the @code{r_type} to directly produce an index 5010 into a howto table vector; the 88k subtracts a number from the 5011 @code{r_type} field and creates an addend field. 5012 5013 */ 5014 5015 #ifndef CALC_ADDEND 5016 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 5017 { \ 5018 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \ 5019 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 5020 coffsym = (obj_symbols (abfd) \ 5021 + (cache_ptr->sym_ptr_ptr - symbols)); \ 5022 else if (ptr) \ 5023 coffsym = coff_symbol_from (abfd, ptr); \ 5024 if (coffsym != (coff_symbol_type *) NULL \ 5025 && coffsym->native->u.syment.n_scnum == 0) \ 5026 cache_ptr->addend = 0; \ 5027 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 5028 && ptr->section != (asection *) NULL) \ 5029 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 5030 else \ 5031 cache_ptr->addend = 0; \ 5032 } 5033 #endif 5034 5035 static bfd_boolean 5036 coff_slurp_reloc_table (abfd, asect, symbols) 5037 bfd * abfd; 5038 sec_ptr asect; 5039 asymbol ** symbols; 5040 { 5041 RELOC *native_relocs; 5042 arelent *reloc_cache; 5043 arelent *cache_ptr; 5044 unsigned int idx; 5045 bfd_size_type amt; 5046 5047 if (asect->relocation) 5048 return TRUE; 5049 if (asect->reloc_count == 0) 5050 return TRUE; 5051 if (asect->flags & SEC_CONSTRUCTOR) 5052 return TRUE; 5053 if (!coff_slurp_symbol_table (abfd)) 5054 return FALSE; 5055 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count; 5056 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt); 5057 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent); 5058 reloc_cache = (arelent *) bfd_alloc (abfd, amt); 5059 5060 if (reloc_cache == NULL) 5061 return FALSE; 5062 5063 for (idx = 0; idx < asect->reloc_count; idx++) 5064 { 5065 struct internal_reloc dst; 5066 struct external_reloc *src; 5067 #ifndef RELOC_PROCESSING 5068 asymbol *ptr; 5069 #endif 5070 5071 cache_ptr = reloc_cache + idx; 5072 src = native_relocs + idx; 5073 5074 coff_swap_reloc_in (abfd, src, &dst); 5075 5076 #ifdef RELOC_PROCESSING 5077 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect); 5078 #else 5079 cache_ptr->address = dst.r_vaddr; 5080 5081 if (dst.r_symndx != -1) 5082 { 5083 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd)) 5084 { 5085 (*_bfd_error_handler) 5086 (_("%s: warning: illegal symbol index %ld in relocs"), 5087 bfd_archive_filename (abfd), dst.r_symndx); 5088 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 5089 ptr = NULL; 5090 } 5091 else 5092 { 5093 cache_ptr->sym_ptr_ptr = (symbols 5094 + obj_convert (abfd)[dst.r_symndx]); 5095 ptr = *(cache_ptr->sym_ptr_ptr); 5096 } 5097 } 5098 else 5099 { 5100 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 5101 ptr = NULL; 5102 } 5103 5104 /* The symbols definitions that we have read in have been 5105 relocated as if their sections started at 0. But the offsets 5106 refering to the symbols in the raw data have not been 5107 modified, so we have to have a negative addend to compensate. 5108 5109 Note that symbols which used to be common must be left alone. */ 5110 5111 /* Calculate any reloc addend by looking at the symbol. */ 5112 CALC_ADDEND (abfd, ptr, dst, cache_ptr); 5113 5114 cache_ptr->address -= asect->vma; 5115 /* !! cache_ptr->section = (asection *) NULL;*/ 5116 5117 /* Fill in the cache_ptr->howto field from dst.r_type. */ 5118 RTYPE2HOWTO (cache_ptr, &dst); 5119 #endif /* RELOC_PROCESSING */ 5120 5121 if (cache_ptr->howto == NULL) 5122 { 5123 (*_bfd_error_handler) 5124 (_("%s: illegal relocation type %d at address 0x%lx"), 5125 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr); 5126 bfd_set_error (bfd_error_bad_value); 5127 return FALSE; 5128 } 5129 } 5130 5131 asect->relocation = reloc_cache; 5132 return TRUE; 5133 } 5134 5135 #ifndef coff_rtype_to_howto 5136 #ifdef RTYPE2HOWTO 5137 5138 /* Get the howto structure for a reloc. This is only used if the file 5139 including this one defines coff_relocate_section to be 5140 _bfd_coff_generic_relocate_section, so it is OK if it does not 5141 always work. It is the responsibility of the including file to 5142 make sure it is reasonable if it is needed. */ 5143 5144 static reloc_howto_type *coff_rtype_to_howto 5145 PARAMS ((bfd *, asection *, struct internal_reloc *, 5146 struct coff_link_hash_entry *, struct internal_syment *, 5147 bfd_vma *)); 5148 5149 static reloc_howto_type * 5150 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp) 5151 bfd *abfd ATTRIBUTE_UNUSED; 5152 asection *sec ATTRIBUTE_UNUSED; 5153 struct internal_reloc *rel; 5154 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED; 5155 struct internal_syment *sym ATTRIBUTE_UNUSED; 5156 bfd_vma *addendp ATTRIBUTE_UNUSED; 5157 { 5158 arelent genrel; 5159 5160 RTYPE2HOWTO (&genrel, rel); 5161 return genrel.howto; 5162 } 5163 5164 #else /* ! defined (RTYPE2HOWTO) */ 5165 5166 #define coff_rtype_to_howto NULL 5167 5168 #endif /* ! defined (RTYPE2HOWTO) */ 5169 #endif /* ! defined (coff_rtype_to_howto) */ 5170 5171 /* This is stupid. This function should be a boolean predicate. */ 5172 static long 5173 coff_canonicalize_reloc (abfd, section, relptr, symbols) 5174 bfd * abfd; 5175 sec_ptr section; 5176 arelent ** relptr; 5177 asymbol ** symbols; 5178 { 5179 arelent *tblptr = section->relocation; 5180 unsigned int count = 0; 5181 5182 if (section->flags & SEC_CONSTRUCTOR) 5183 { 5184 /* This section has relocs made up by us, they are not in the 5185 file, so take them out of their chain and place them into 5186 the data area provided. */ 5187 arelent_chain *chain = section->constructor_chain; 5188 5189 for (count = 0; count < section->reloc_count; count++) 5190 { 5191 *relptr++ = &chain->relent; 5192 chain = chain->next; 5193 } 5194 } 5195 else 5196 { 5197 if (! coff_slurp_reloc_table (abfd, section, symbols)) 5198 return -1; 5199 5200 tblptr = section->relocation; 5201 5202 for (; count++ < section->reloc_count;) 5203 *relptr++ = tblptr++; 5204 } 5205 *relptr = 0; 5206 return section->reloc_count; 5207 } 5208 5209 #ifdef GNU960 5210 file_ptr 5211 coff_sym_filepos (abfd) 5212 bfd *abfd; 5213 { 5214 return obj_sym_filepos (abfd); 5215 } 5216 #endif 5217 5218 #ifndef coff_reloc16_estimate 5219 #define coff_reloc16_estimate dummy_reloc16_estimate 5220 5221 static int dummy_reloc16_estimate 5222 PARAMS ((bfd *, asection *, arelent *, unsigned int, 5223 struct bfd_link_info *)); 5224 5225 static int 5226 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info) 5227 bfd *abfd ATTRIBUTE_UNUSED; 5228 asection *input_section ATTRIBUTE_UNUSED; 5229 arelent *reloc ATTRIBUTE_UNUSED; 5230 unsigned int shrink ATTRIBUTE_UNUSED; 5231 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 5232 { 5233 abort (); 5234 return 0; 5235 } 5236 5237 #endif 5238 5239 #ifndef coff_reloc16_extra_cases 5240 5241 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases 5242 5243 /* This works even if abort is not declared in any header file. */ 5244 5245 static void dummy_reloc16_extra_cases 5246 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 5247 bfd_byte *, unsigned int *, unsigned int *)); 5248 5249 static void 5250 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr, 5251 dst_ptr) 5252 bfd *abfd ATTRIBUTE_UNUSED; 5253 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 5254 struct bfd_link_order *link_order ATTRIBUTE_UNUSED; 5255 arelent *reloc ATTRIBUTE_UNUSED; 5256 bfd_byte *data ATTRIBUTE_UNUSED; 5257 unsigned int *src_ptr ATTRIBUTE_UNUSED; 5258 unsigned int *dst_ptr ATTRIBUTE_UNUSED; 5259 { 5260 abort (); 5261 } 5262 #endif 5263 5264 #ifndef coff_bfd_link_hash_table_free 5265 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 5266 #endif 5267 5268 /* If coff_relocate_section is defined, we can use the optimized COFF 5269 backend linker. Otherwise we must continue to use the old linker. */ 5270 #ifdef coff_relocate_section 5271 #ifndef coff_bfd_link_hash_table_create 5272 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create 5273 #endif 5274 #ifndef coff_bfd_link_add_symbols 5275 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols 5276 #endif 5277 #ifndef coff_bfd_final_link 5278 #define coff_bfd_final_link _bfd_coff_final_link 5279 #endif 5280 #else /* ! defined (coff_relocate_section) */ 5281 #define coff_relocate_section NULL 5282 #ifndef coff_bfd_link_hash_table_create 5283 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 5284 #endif 5285 #ifndef coff_bfd_link_add_symbols 5286 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols 5287 #endif 5288 #define coff_bfd_final_link _bfd_generic_final_link 5289 #endif /* ! defined (coff_relocate_section) */ 5290 5291 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms 5292 #define coff_bfd_link_split_section _bfd_generic_link_split_section 5293 5294 #ifndef coff_start_final_link 5295 #define coff_start_final_link NULL 5296 #endif 5297 5298 #ifndef coff_adjust_symndx 5299 #define coff_adjust_symndx NULL 5300 #endif 5301 5302 #ifndef coff_link_add_one_symbol 5303 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol 5304 #endif 5305 5306 #ifndef coff_link_output_has_begun 5307 5308 static bfd_boolean coff_link_output_has_begun 5309 PARAMS ((bfd *, struct coff_final_link_info *)); 5310 5311 static bfd_boolean 5312 coff_link_output_has_begun (abfd, info) 5313 bfd * abfd; 5314 struct coff_final_link_info * info ATTRIBUTE_UNUSED; 5315 { 5316 return abfd->output_has_begun; 5317 } 5318 #endif 5319 5320 #ifndef coff_final_link_postscript 5321 5322 static bfd_boolean coff_final_link_postscript 5323 PARAMS ((bfd *, struct coff_final_link_info *)); 5324 5325 static bfd_boolean 5326 coff_final_link_postscript (abfd, pfinfo) 5327 bfd * abfd ATTRIBUTE_UNUSED; 5328 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED; 5329 { 5330 return TRUE; 5331 } 5332 #endif 5333 5334 #ifndef coff_SWAP_aux_in 5335 #define coff_SWAP_aux_in coff_swap_aux_in 5336 #endif 5337 #ifndef coff_SWAP_sym_in 5338 #define coff_SWAP_sym_in coff_swap_sym_in 5339 #endif 5340 #ifndef coff_SWAP_lineno_in 5341 #define coff_SWAP_lineno_in coff_swap_lineno_in 5342 #endif 5343 #ifndef coff_SWAP_aux_out 5344 #define coff_SWAP_aux_out coff_swap_aux_out 5345 #endif 5346 #ifndef coff_SWAP_sym_out 5347 #define coff_SWAP_sym_out coff_swap_sym_out 5348 #endif 5349 #ifndef coff_SWAP_lineno_out 5350 #define coff_SWAP_lineno_out coff_swap_lineno_out 5351 #endif 5352 #ifndef coff_SWAP_reloc_out 5353 #define coff_SWAP_reloc_out coff_swap_reloc_out 5354 #endif 5355 #ifndef coff_SWAP_filehdr_out 5356 #define coff_SWAP_filehdr_out coff_swap_filehdr_out 5357 #endif 5358 #ifndef coff_SWAP_aouthdr_out 5359 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out 5360 #endif 5361 #ifndef coff_SWAP_scnhdr_out 5362 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out 5363 #endif 5364 #ifndef coff_SWAP_reloc_in 5365 #define coff_SWAP_reloc_in coff_swap_reloc_in 5366 #endif 5367 #ifndef coff_SWAP_filehdr_in 5368 #define coff_SWAP_filehdr_in coff_swap_filehdr_in 5369 #endif 5370 #ifndef coff_SWAP_aouthdr_in 5371 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in 5372 #endif 5373 #ifndef coff_SWAP_scnhdr_in 5374 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in 5375 #endif 5376 5377 static const bfd_coff_backend_data bfd_coff_std_swap_table = 5378 { 5379 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5380 coff_SWAP_aux_out, coff_SWAP_sym_out, 5381 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5382 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5383 coff_SWAP_scnhdr_out, 5384 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5385 #ifdef COFF_LONG_FILENAMES 5386 TRUE, 5387 #else 5388 FALSE, 5389 #endif 5390 #ifdef COFF_LONG_SECTION_NAMES 5391 TRUE, 5392 #else 5393 FALSE, 5394 #endif 5395 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5396 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5397 TRUE, 5398 #else 5399 FALSE, 5400 #endif 5401 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5402 4, 5403 #else 5404 2, 5405 #endif 5406 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5407 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, 5408 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5409 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5410 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5411 coff_classify_symbol, coff_compute_section_file_positions, 5412 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5413 coff_adjust_symndx, coff_link_add_one_symbol, 5414 coff_link_output_has_begun, coff_final_link_postscript 5415 }; 5416 5417 #ifdef TICOFF 5418 /* COFF0 differs in file/section header size and relocation entry size. */ 5419 static const bfd_coff_backend_data ticoff0_swap_table = 5420 { 5421 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5422 coff_SWAP_aux_out, coff_SWAP_sym_out, 5423 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5424 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5425 coff_SWAP_scnhdr_out, 5426 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN, 5427 #ifdef COFF_LONG_FILENAMES 5428 TRUE, 5429 #else 5430 FALSE, 5431 #endif 5432 #ifdef COFF_LONG_SECTION_NAMES 5433 TRUE, 5434 #else 5435 FALSE, 5436 #endif 5437 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5438 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5439 TRUE, 5440 #else 5441 FALSE, 5442 #endif 5443 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5444 4, 5445 #else 5446 2, 5447 #endif 5448 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5449 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook, 5450 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5451 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5452 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5453 coff_classify_symbol, coff_compute_section_file_positions, 5454 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5455 coff_adjust_symndx, coff_link_add_one_symbol, 5456 coff_link_output_has_begun, coff_final_link_postscript 5457 }; 5458 #endif 5459 5460 #ifdef TICOFF 5461 /* COFF1 differs in section header size. */ 5462 static const bfd_coff_backend_data ticoff1_swap_table = 5463 { 5464 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5465 coff_SWAP_aux_out, coff_SWAP_sym_out, 5466 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5467 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5468 coff_SWAP_scnhdr_out, 5469 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5470 #ifdef COFF_LONG_FILENAMES 5471 TRUE, 5472 #else 5473 FALSE, 5474 #endif 5475 #ifdef COFF_LONG_SECTION_NAMES 5476 TRUE, 5477 #else 5478 FALSE, 5479 #endif 5480 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5481 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5482 TRUE, 5483 #else 5484 FALSE, 5485 #endif 5486 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5487 4, 5488 #else 5489 2, 5490 #endif 5491 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5492 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook, 5493 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5494 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5495 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5496 coff_classify_symbol, coff_compute_section_file_positions, 5497 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5498 coff_adjust_symndx, coff_link_add_one_symbol, 5499 coff_link_output_has_begun, coff_final_link_postscript 5500 }; 5501 #endif 5502 5503 #ifndef coff_close_and_cleanup 5504 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup 5505 #endif 5506 5507 #ifndef coff_bfd_free_cached_info 5508 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 5509 #endif 5510 5511 #ifndef coff_get_section_contents 5512 #define coff_get_section_contents _bfd_generic_get_section_contents 5513 #endif 5514 5515 #ifndef coff_bfd_copy_private_symbol_data 5516 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 5517 #endif 5518 5519 #ifndef coff_bfd_copy_private_section_data 5520 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 5521 #endif 5522 5523 #ifndef coff_bfd_copy_private_bfd_data 5524 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data 5525 #endif 5526 5527 #ifndef coff_bfd_merge_private_bfd_data 5528 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 5529 #endif 5530 5531 #ifndef coff_bfd_set_private_flags 5532 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 5533 #endif 5534 5535 #ifndef coff_bfd_print_private_bfd_data 5536 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 5537 #endif 5538 5539 #ifndef coff_bfd_is_local_label_name 5540 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name 5541 #endif 5542 5543 #ifndef coff_read_minisymbols 5544 #define coff_read_minisymbols _bfd_generic_read_minisymbols 5545 #endif 5546 5547 #ifndef coff_minisymbol_to_symbol 5548 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 5549 #endif 5550 5551 /* The reloc lookup routine must be supplied by each individual COFF 5552 backend. */ 5553 #ifndef coff_bfd_reloc_type_lookup 5554 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 5555 #endif 5556 5557 #ifndef coff_bfd_get_relocated_section_contents 5558 #define coff_bfd_get_relocated_section_contents \ 5559 bfd_generic_get_relocated_section_contents 5560 #endif 5561 5562 #ifndef coff_bfd_relax_section 5563 #define coff_bfd_relax_section bfd_generic_relax_section 5564 #endif 5565 5566 #ifndef coff_bfd_gc_sections 5567 #define coff_bfd_gc_sections bfd_generic_gc_sections 5568 #endif 5569 5570 #ifndef coff_bfd_merge_sections 5571 #define coff_bfd_merge_sections bfd_generic_merge_sections 5572 #endif 5573 5574 #ifndef coff_bfd_discard_group 5575 #define coff_bfd_discard_group bfd_generic_discard_group 5576 #endif 5577 5578 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5579 const bfd_target VAR = \ 5580 { \ 5581 NAME , \ 5582 bfd_target_coff_flavour, \ 5583 BFD_ENDIAN_BIG, /* data byte order is big */ \ 5584 BFD_ENDIAN_BIG, /* header byte order is big */ \ 5585 /* object flags */ \ 5586 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5587 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5588 /* section flags */ \ 5589 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5590 UNDER, /* leading symbol underscore */ \ 5591 '/', /* ar_pad_char */ \ 5592 15, /* ar_max_namelen */ \ 5593 \ 5594 /* Data conversion functions. */ \ 5595 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5596 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5597 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5598 \ 5599 /* Header conversion functions. */ \ 5600 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5601 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5602 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5603 \ 5604 /* bfd_check_format */ \ 5605 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5606 _bfd_dummy_target }, \ 5607 /* bfd_set_format */ \ 5608 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5609 /* bfd_write_contents */ \ 5610 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5611 bfd_false }, \ 5612 \ 5613 BFD_JUMP_TABLE_GENERIC (coff), \ 5614 BFD_JUMP_TABLE_COPY (coff), \ 5615 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5616 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5617 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5618 BFD_JUMP_TABLE_RELOCS (coff), \ 5619 BFD_JUMP_TABLE_WRITE (coff), \ 5620 BFD_JUMP_TABLE_LINK (coff), \ 5621 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5622 \ 5623 ALTERNATIVE, \ 5624 \ 5625 SWAP_TABLE \ 5626 }; 5627 5628 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5629 const bfd_target VAR = \ 5630 { \ 5631 NAME , \ 5632 bfd_target_coff_flavour, \ 5633 BFD_ENDIAN_LITTLE, /* data byte order is little */ \ 5634 BFD_ENDIAN_BIG, /* header byte order is big */ \ 5635 /* object flags */ \ 5636 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5637 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5638 /* section flags */ \ 5639 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5640 UNDER, /* leading symbol underscore */ \ 5641 '/', /* ar_pad_char */ \ 5642 15, /* ar_max_namelen */ \ 5643 \ 5644 /* Data conversion functions. */ \ 5645 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5646 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5647 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5648 \ 5649 /* Header conversion functions. */ \ 5650 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5651 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5652 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5653 \ 5654 /* bfd_check_format */ \ 5655 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5656 _bfd_dummy_target }, \ 5657 /* bfd_set_format */ \ 5658 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5659 /* bfd_write_contents */ \ 5660 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5661 bfd_false }, \ 5662 \ 5663 BFD_JUMP_TABLE_GENERIC (coff), \ 5664 BFD_JUMP_TABLE_COPY (coff), \ 5665 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5666 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5667 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5668 BFD_JUMP_TABLE_RELOCS (coff), \ 5669 BFD_JUMP_TABLE_WRITE (coff), \ 5670 BFD_JUMP_TABLE_LINK (coff), \ 5671 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5672 \ 5673 ALTERNATIVE, \ 5674 \ 5675 SWAP_TABLE \ 5676 }; 5677 5678 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5679 const bfd_target VAR = \ 5680 { \ 5681 NAME , \ 5682 bfd_target_coff_flavour, \ 5683 BFD_ENDIAN_LITTLE, /* data byte order is little */ \ 5684 BFD_ENDIAN_LITTLE, /* header byte order is little */ \ 5685 /* object flags */ \ 5686 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5687 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5688 /* section flags */ \ 5689 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5690 UNDER, /* leading symbol underscore */ \ 5691 '/', /* ar_pad_char */ \ 5692 15, /* ar_max_namelen */ \ 5693 \ 5694 /* Data conversion functions. */ \ 5695 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5696 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5697 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5698 /* Header conversion functions. */ \ 5699 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5700 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5701 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5702 /* bfd_check_format */ \ 5703 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5704 _bfd_dummy_target }, \ 5705 /* bfd_set_format */ \ 5706 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5707 /* bfd_write_contents */ \ 5708 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5709 bfd_false }, \ 5710 \ 5711 BFD_JUMP_TABLE_GENERIC (coff), \ 5712 BFD_JUMP_TABLE_COPY (coff), \ 5713 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5714 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5715 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5716 BFD_JUMP_TABLE_RELOCS (coff), \ 5717 BFD_JUMP_TABLE_WRITE (coff), \ 5718 BFD_JUMP_TABLE_LINK (coff), \ 5719 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5720 \ 5721 ALTERNATIVE, \ 5722 \ 5723 SWAP_TABLE \ 5724 }; 5725