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