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