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