1 /* Support for the generic parts of most COFF variants, for BFD. 2 Copyright (C) 1990-2014 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 (at) 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(); */ 477 478 #if defined (COFF_LONG_SECTION_NAMES) 479 static bfd_boolean 480 bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable) 481 { 482 coff_backend_info (abfd)->_bfd_coff_long_section_names = enable; 483 return TRUE; 484 } 485 #else /* !defined (COFF_LONG_SECTION_NAMES) */ 486 static bfd_boolean 487 bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable) 488 { 489 (void) abfd; 490 (void) enable; 491 return FALSE; 492 } 493 #endif /* defined (COFF_LONG_SECTION_NAMES) */ 494 495 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent 496 the incoming SEC_* flags. The inverse of this function is 497 styp_to_sec_flags(). NOTE: If you add to/change this routine, you 498 should probably mirror the changes in styp_to_sec_flags(). */ 499 500 #ifndef COFF_WITH_PE 501 502 /* Macros for setting debugging flags. */ 503 504 #ifdef STYP_DEBUG 505 #define STYP_XCOFF_DEBUG STYP_DEBUG 506 #else 507 #define STYP_XCOFF_DEBUG STYP_INFO 508 #endif 509 510 #ifdef COFF_ALIGN_IN_S_FLAGS 511 #define STYP_DEBUG_INFO STYP_DSECT 512 #else 513 #define STYP_DEBUG_INFO STYP_INFO 514 #endif 515 516 static long 517 sec_to_styp_flags (const char *sec_name, flagword sec_flags) 518 { 519 long styp_flags = 0; 520 521 if (!strcmp (sec_name, _TEXT)) 522 { 523 styp_flags = STYP_TEXT; 524 } 525 else if (!strcmp (sec_name, _DATA)) 526 { 527 styp_flags = STYP_DATA; 528 } 529 else if (!strcmp (sec_name, _BSS)) 530 { 531 styp_flags = STYP_BSS; 532 #ifdef _COMMENT 533 } 534 else if (!strcmp (sec_name, _COMMENT)) 535 { 536 styp_flags = STYP_INFO; 537 #endif /* _COMMENT */ 538 #ifdef _LIB 539 } 540 else if (!strcmp (sec_name, _LIB)) 541 { 542 styp_flags = STYP_LIB; 543 #endif /* _LIB */ 544 #ifdef _LIT 545 } 546 else if (!strcmp (sec_name, _LIT)) 547 { 548 styp_flags = STYP_LIT; 549 #endif /* _LIT */ 550 } 551 else if (CONST_STRNEQ (sec_name, DOT_DEBUG) 552 || CONST_STRNEQ (sec_name, DOT_ZDEBUG)) 553 { 554 /* Handle the XCOFF debug section and DWARF2 debug sections. */ 555 if (!sec_name[6]) 556 styp_flags = STYP_XCOFF_DEBUG; 557 else 558 styp_flags = STYP_DEBUG_INFO; 559 } 560 else if (CONST_STRNEQ (sec_name, ".stab")) 561 { 562 styp_flags = STYP_DEBUG_INFO; 563 } 564 #ifdef COFF_LONG_SECTION_NAMES 565 else if (CONST_STRNEQ (sec_name, GNU_LINKONCE_WI) 566 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT)) 567 { 568 styp_flags = STYP_DEBUG_INFO; 569 } 570 #endif 571 #ifdef RS6000COFF_C 572 else if (!strcmp (sec_name, _PAD)) 573 { 574 styp_flags = STYP_PAD; 575 } 576 else if (!strcmp (sec_name, _LOADER)) 577 { 578 styp_flags = STYP_LOADER; 579 } 580 else if (!strcmp (sec_name, _EXCEPT)) 581 { 582 styp_flags = STYP_EXCEPT; 583 } 584 else if (!strcmp (sec_name, _TYPCHK)) 585 { 586 styp_flags = STYP_TYPCHK; 587 } 588 else if (sec_flags & SEC_DEBUGGING) 589 { 590 int i; 591 592 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++) 593 if (!strcmp (sec_name, xcoff_dwsect_names[i].name)) 594 { 595 styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag; 596 break; 597 } 598 } 599 #endif 600 /* Try and figure out what it should be */ 601 else if (sec_flags & SEC_CODE) 602 { 603 styp_flags = STYP_TEXT; 604 } 605 else if (sec_flags & SEC_DATA) 606 { 607 styp_flags = STYP_DATA; 608 } 609 else if (sec_flags & SEC_READONLY) 610 { 611 #ifdef STYP_LIT /* 29k readonly text/data section */ 612 styp_flags = STYP_LIT; 613 #else 614 styp_flags = STYP_TEXT; 615 #endif /* STYP_LIT */ 616 } 617 else if (sec_flags & SEC_LOAD) 618 { 619 styp_flags = STYP_TEXT; 620 } 621 else if (sec_flags & SEC_ALLOC) 622 { 623 styp_flags = STYP_BSS; 624 } 625 626 #ifdef STYP_CLINK 627 if (sec_flags & SEC_TIC54X_CLINK) 628 styp_flags |= STYP_CLINK; 629 #endif 630 631 #ifdef STYP_BLOCK 632 if (sec_flags & SEC_TIC54X_BLOCK) 633 styp_flags |= STYP_BLOCK; 634 #endif 635 636 #ifdef STYP_NOLOAD 637 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0) 638 styp_flags |= STYP_NOLOAD; 639 #endif 640 641 return styp_flags; 642 } 643 644 #else /* COFF_WITH_PE */ 645 646 /* The PE version; see above for the general comments. The non-PE 647 case seems to be more guessing, and breaks PE format; specifically, 648 .rdata is readonly, but it sure ain't text. Really, all this 649 should be set up properly in gas (or whatever assembler is in use), 650 and honor whatever objcopy/strip, etc. sent us as input. */ 651 652 static long 653 sec_to_styp_flags (const char *sec_name, flagword sec_flags) 654 { 655 long styp_flags = 0; 656 bfd_boolean is_dbg = FALSE; 657 658 if (CONST_STRNEQ (sec_name, DOT_DEBUG) 659 || CONST_STRNEQ (sec_name, DOT_ZDEBUG) 660 #ifdef COFF_LONG_SECTION_NAMES 661 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WI) 662 || CONST_STRNEQ (sec_name, GNU_LINKONCE_WT) 663 #endif 664 || CONST_STRNEQ (sec_name, ".stab")) 665 is_dbg = TRUE; 666 667 /* caution: there are at least three groups of symbols that have 668 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*. 669 SEC_* are the BFD internal flags, used for generic BFD 670 information. STYP_* are the COFF section flags which appear in 671 COFF files. IMAGE_SCN_* are the PE section flags which appear in 672 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap, 673 but there are more IMAGE_SCN_* flags. */ 674 675 /* FIXME: There is no gas syntax to specify the debug section flag. */ 676 if (is_dbg) 677 { 678 sec_flags &= (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD 679 | SEC_LINK_DUPLICATES_SAME_CONTENTS 680 | SEC_LINK_DUPLICATES_SAME_SIZE); 681 sec_flags |= SEC_DEBUGGING | SEC_READONLY; 682 } 683 684 /* skip LOAD */ 685 /* READONLY later */ 686 /* skip RELOC */ 687 if ((sec_flags & SEC_CODE) != 0) 688 styp_flags |= IMAGE_SCN_CNT_CODE; 689 if ((sec_flags & (SEC_DATA | SEC_DEBUGGING)) != 0) 690 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA; 691 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0) 692 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */ 693 /* skip ROM */ 694 /* skip constRUCTOR */ 695 /* skip CONTENTS */ 696 if ((sec_flags & SEC_IS_COMMON) != 0) 697 styp_flags |= IMAGE_SCN_LNK_COMDAT; 698 if ((sec_flags & SEC_DEBUGGING) != 0) 699 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE; 700 if ((sec_flags & SEC_EXCLUDE) != 0 && !is_dbg) 701 styp_flags |= IMAGE_SCN_LNK_REMOVE; 702 if ((sec_flags & SEC_NEVER_LOAD) != 0 && !is_dbg) 703 styp_flags |= IMAGE_SCN_LNK_REMOVE; 704 /* skip IN_MEMORY */ 705 /* skip SORT */ 706 if (sec_flags & SEC_LINK_ONCE) 707 styp_flags |= IMAGE_SCN_LNK_COMDAT; 708 if ((sec_flags 709 & (SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_SAME_CONTENTS 710 | SEC_LINK_DUPLICATES_SAME_SIZE)) != 0) 711 styp_flags |= IMAGE_SCN_LNK_COMDAT; 712 713 /* skip LINKER_CREATED */ 714 715 if ((sec_flags & SEC_COFF_NOREAD) == 0) 716 styp_flags |= IMAGE_SCN_MEM_READ; /* Invert NOREAD for read. */ 717 if ((sec_flags & SEC_READONLY) == 0) 718 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */ 719 if (sec_flags & SEC_CODE) 720 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */ 721 if (sec_flags & SEC_COFF_SHARED) 722 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */ 723 724 return styp_flags; 725 } 726 727 #endif /* COFF_WITH_PE */ 728 729 /* Return a word with SEC_* flags set to represent the incoming STYP_* 730 flags (from scnhdr.s_flags). The inverse of this function is 731 sec_to_styp_flags(). NOTE: If you add to/change this routine, you 732 should probably mirror the changes in sec_to_styp_flags(). */ 733 734 #ifndef COFF_WITH_PE 735 736 static bfd_boolean 737 styp_to_sec_flags (bfd *abfd ATTRIBUTE_UNUSED, 738 void * hdr, 739 const char *name, 740 asection *section ATTRIBUTE_UNUSED, 741 flagword *flags_ptr) 742 { 743 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 744 long styp_flags = internal_s->s_flags; 745 flagword sec_flags = 0; 746 747 #ifdef STYP_BLOCK 748 if (styp_flags & STYP_BLOCK) 749 sec_flags |= SEC_TIC54X_BLOCK; 750 #endif 751 752 #ifdef STYP_CLINK 753 if (styp_flags & STYP_CLINK) 754 sec_flags |= SEC_TIC54X_CLINK; 755 #endif 756 757 #ifdef STYP_NOLOAD 758 if (styp_flags & STYP_NOLOAD) 759 sec_flags |= SEC_NEVER_LOAD; 760 #endif /* STYP_NOLOAD */ 761 762 /* For 386 COFF, at least, an unloadable text or data section is 763 actually a shared library section. */ 764 if (styp_flags & STYP_TEXT) 765 { 766 if (sec_flags & SEC_NEVER_LOAD) 767 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 768 else 769 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 770 } 771 else if (styp_flags & STYP_DATA) 772 { 773 if (sec_flags & SEC_NEVER_LOAD) 774 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 775 else 776 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 777 } 778 else if (styp_flags & STYP_BSS) 779 { 780 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 781 if (sec_flags & SEC_NEVER_LOAD) 782 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 783 else 784 #endif 785 sec_flags |= SEC_ALLOC; 786 } 787 else if (styp_flags & STYP_INFO) 788 { 789 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is 790 defined. coff_compute_section_file_positions uses 791 COFF_PAGE_SIZE to ensure that the low order bits of the 792 section VMA and the file offset match. If we don't know 793 COFF_PAGE_SIZE, we can't ensure the correct correspondence, 794 and demand page loading of the file will fail. */ 795 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS) 796 sec_flags |= SEC_DEBUGGING; 797 #endif 798 } 799 else if (styp_flags & STYP_PAD) 800 sec_flags = 0; 801 #ifdef RS6000COFF_C 802 else if (styp_flags & STYP_EXCEPT) 803 sec_flags |= SEC_LOAD; 804 else if (styp_flags & STYP_LOADER) 805 sec_flags |= SEC_LOAD; 806 else if (styp_flags & STYP_TYPCHK) 807 sec_flags |= SEC_LOAD; 808 else if (styp_flags & STYP_DWARF) 809 sec_flags |= SEC_DEBUGGING; 810 #endif 811 else if (strcmp (name, _TEXT) == 0) 812 { 813 if (sec_flags & SEC_NEVER_LOAD) 814 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY; 815 else 816 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC; 817 } 818 else if (strcmp (name, _DATA) == 0) 819 { 820 if (sec_flags & SEC_NEVER_LOAD) 821 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY; 822 else 823 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC; 824 } 825 else if (strcmp (name, _BSS) == 0) 826 { 827 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY 828 if (sec_flags & SEC_NEVER_LOAD) 829 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY; 830 else 831 #endif 832 sec_flags |= SEC_ALLOC; 833 } 834 else if (CONST_STRNEQ (name, DOT_DEBUG) 835 || CONST_STRNEQ (name, DOT_ZDEBUG) 836 #ifdef _COMMENT 837 || strcmp (name, _COMMENT) == 0 838 #endif 839 #ifdef COFF_LONG_SECTION_NAMES 840 || CONST_STRNEQ (name, GNU_LINKONCE_WI) 841 || CONST_STRNEQ (name, GNU_LINKONCE_WT) 842 #endif 843 || CONST_STRNEQ (name, ".stab")) 844 { 845 #ifdef COFF_PAGE_SIZE 846 sec_flags |= SEC_DEBUGGING; 847 #endif 848 } 849 #ifdef _LIB 850 else if (strcmp (name, _LIB) == 0) 851 ; 852 #endif 853 #ifdef _LIT 854 else if (strcmp (name, _LIT) == 0) 855 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY; 856 #endif 857 else 858 sec_flags |= SEC_ALLOC | SEC_LOAD; 859 860 #ifdef STYP_LIT /* A29k readonly text/data section type. */ 861 if ((styp_flags & STYP_LIT) == STYP_LIT) 862 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY); 863 #endif /* STYP_LIT */ 864 865 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */ 866 if (styp_flags & STYP_OTHER_LOAD) 867 sec_flags = (SEC_LOAD | SEC_ALLOC); 868 #endif /* STYP_SDATA */ 869 870 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) 871 /* As a GNU extension, if the name begins with .gnu.linkonce, we 872 only link a single copy of the section. This is used to support 873 g++. g++ will emit each template expansion in its own section. 874 The symbols will be defined as weak, so that multiple definitions 875 are permitted. The GNU linker extension is to actually discard 876 all but one of the sections. */ 877 if (CONST_STRNEQ (name, ".gnu.linkonce")) 878 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 879 #endif 880 881 if (flags_ptr == NULL) 882 return FALSE; 883 884 * flags_ptr = sec_flags; 885 return TRUE; 886 } 887 888 #else /* COFF_WITH_PE */ 889 890 static flagword 891 handle_COMDAT (bfd * abfd, 892 flagword sec_flags, 893 void * hdr, 894 const char *name, 895 asection *section) 896 { 897 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 898 bfd_byte *esymstart, *esym, *esymend; 899 int seen_state = 0; 900 char *target_name = NULL; 901 902 sec_flags |= SEC_LINK_ONCE; 903 904 /* Unfortunately, the PE format stores essential information in 905 the symbol table, of all places. We need to extract that 906 information now, so that objdump and the linker will know how 907 to handle the section without worrying about the symbols. We 908 can't call slurp_symtab, because the linker doesn't want the 909 swapped symbols. */ 910 911 /* COMDAT sections are special. The first symbol is the section 912 symbol, which tells what kind of COMDAT section it is. The 913 second symbol is the "comdat symbol" - the one with the 914 unique name. GNU uses the section symbol for the unique 915 name; MS uses ".text" for every comdat section. Sigh. - DJ */ 916 917 /* This is not mirrored in sec_to_styp_flags(), but there 918 doesn't seem to be a need to, either, and it would at best be 919 rather messy. */ 920 921 if (! _bfd_coff_get_external_symbols (abfd)) 922 return sec_flags; 923 924 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd); 925 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd); 926 927 while (esym < esymend) 928 { 929 struct internal_syment isym; 930 char buf[SYMNMLEN + 1]; 931 const char *symname; 932 933 bfd_coff_swap_sym_in (abfd, esym, & isym); 934 935 BFD_ASSERT (sizeof (internal_s->s_name) <= SYMNMLEN); 936 937 if (isym.n_scnum == section->target_index) 938 { 939 /* According to the MSVC documentation, the first 940 TWO entries with the section # are both of 941 interest to us. The first one is the "section 942 symbol" (section name). The second is the comdat 943 symbol name. Here, we've found the first 944 qualifying entry; we distinguish it from the 945 second with a state flag. 946 947 In the case of gas-generated (at least until that 948 is fixed) .o files, it isn't necessarily the 949 second one. It may be some other later symbol. 950 951 Since gas also doesn't follow MS conventions and 952 emits the section similar to .text$<name>, where 953 <something> is the name we're looking for, we 954 distinguish the two as follows: 955 956 If the section name is simply a section name (no 957 $) we presume it's MS-generated, and look at 958 precisely the second symbol for the comdat name. 959 If the section name has a $, we assume it's 960 gas-generated, and look for <something> (whatever 961 follows the $) as the comdat symbol. */ 962 963 /* All 3 branches use this. */ 964 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf); 965 966 /* PR 17512 file: 078-11867-0.004 */ 967 if (symname == NULL) 968 { 969 _bfd_error_handler (_("%B: unable to load COMDAT section name"), abfd); 970 break; 971 } 972 973 switch (seen_state) 974 { 975 case 0: 976 { 977 /* The first time we've seen the symbol. */ 978 union internal_auxent aux; 979 980 /* If it isn't the stuff we're expecting, die; 981 The MS documentation is vague, but it 982 appears that the second entry serves BOTH 983 as the comdat symbol and the defining 984 symbol record (either C_STAT or C_EXT, 985 possibly with an aux entry with debug 986 information if it's a function.) It 987 appears the only way to find the second one 988 is to count. (On Intel, they appear to be 989 adjacent, but on Alpha, they have been 990 found separated.) 991 992 Here, we think we've found the first one, 993 but there's some checking we can do to be 994 sure. */ 995 996 if (! ((isym.n_sclass == C_STAT 997 || isym.n_sclass == C_EXT) 998 && BTYPE (isym.n_type) == T_NULL 999 && isym.n_value == 0)) 1000 abort (); 1001 1002 /* FIXME LATER: MSVC generates section names 1003 like .text for comdats. Gas generates 1004 names like .text$foo__Fv (in the case of a 1005 function). See comment above for more. */ 1006 1007 if (isym.n_sclass == C_STAT && strcmp (name, symname) != 0) 1008 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"), 1009 abfd, symname, name); 1010 1011 seen_state = 1; 1012 1013 /* This is the section symbol. */ 1014 bfd_coff_swap_aux_in (abfd, (esym + bfd_coff_symesz (abfd)), 1015 isym.n_type, isym.n_sclass, 1016 0, isym.n_numaux, & aux); 1017 1018 target_name = strchr (name, '$'); 1019 if (target_name != NULL) 1020 { 1021 /* Gas mode. */ 1022 seen_state = 2; 1023 /* Skip the `$'. */ 1024 target_name += 1; 1025 } 1026 1027 /* FIXME: Microsoft uses NODUPLICATES and 1028 ASSOCIATIVE, but gnu uses ANY and 1029 SAME_SIZE. Unfortunately, gnu doesn't do 1030 the comdat symbols right. So, until we can 1031 fix it to do the right thing, we are 1032 temporarily disabling comdats for the MS 1033 types (they're used in DLLs and C++, but we 1034 don't support *their* C++ libraries anyway 1035 - DJ. */ 1036 1037 /* Cygwin does not follow the MS style, and 1038 uses ANY and SAME_SIZE where NODUPLICATES 1039 and ASSOCIATIVE should be used. For 1040 Interix, we just do the right thing up 1041 front. */ 1042 1043 switch (aux.x_scn.x_comdat) 1044 { 1045 case IMAGE_COMDAT_SELECT_NODUPLICATES: 1046 #ifdef STRICT_PE_FORMAT 1047 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY; 1048 #else 1049 sec_flags &= ~SEC_LINK_ONCE; 1050 #endif 1051 break; 1052 1053 case IMAGE_COMDAT_SELECT_ANY: 1054 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 1055 break; 1056 1057 case IMAGE_COMDAT_SELECT_SAME_SIZE: 1058 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE; 1059 break; 1060 1061 case IMAGE_COMDAT_SELECT_EXACT_MATCH: 1062 /* Not yet fully implemented ??? */ 1063 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS; 1064 break; 1065 1066 /* debug$S gets this case; other 1067 implications ??? */ 1068 1069 /* There may be no symbol... we'll search 1070 the whole table... Is this the right 1071 place to play this game? Or should we do 1072 it when reading it in. */ 1073 case IMAGE_COMDAT_SELECT_ASSOCIATIVE: 1074 #ifdef STRICT_PE_FORMAT 1075 /* FIXME: This is not currently implemented. */ 1076 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 1077 #else 1078 sec_flags &= ~SEC_LINK_ONCE; 1079 #endif 1080 break; 1081 1082 default: /* 0 means "no symbol" */ 1083 /* debug$F gets this case; other 1084 implications ??? */ 1085 sec_flags |= SEC_LINK_DUPLICATES_DISCARD; 1086 break; 1087 } 1088 } 1089 break; 1090 1091 case 2: 1092 /* Gas mode: the first matching on partial name. */ 1093 1094 #ifndef TARGET_UNDERSCORE 1095 #define TARGET_UNDERSCORE 0 1096 #endif 1097 /* Is this the name we're looking for ? */ 1098 if (strcmp (target_name, 1099 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0) 1100 { 1101 /* Not the name we're looking for */ 1102 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); 1103 continue; 1104 } 1105 /* Fall through. */ 1106 case 1: 1107 /* MSVC mode: the lexically second symbol (or 1108 drop through from the above). */ 1109 { 1110 char *newname; 1111 bfd_size_type amt; 1112 1113 /* This must the second symbol with the 1114 section #. It is the actual symbol name. 1115 Intel puts the two adjacent, but Alpha (at 1116 least) spreads them out. */ 1117 1118 amt = sizeof (struct coff_comdat_info); 1119 coff_section_data (abfd, section)->comdat 1120 = (struct coff_comdat_info *) bfd_alloc (abfd, amt); 1121 if (coff_section_data (abfd, section)->comdat == NULL) 1122 abort (); 1123 1124 coff_section_data (abfd, section)->comdat->symbol = 1125 (esym - esymstart) / bfd_coff_symesz (abfd); 1126 1127 amt = strlen (symname) + 1; 1128 newname = (char *) bfd_alloc (abfd, amt); 1129 if (newname == NULL) 1130 abort (); 1131 1132 strcpy (newname, symname); 1133 coff_section_data (abfd, section)->comdat->name 1134 = newname; 1135 } 1136 1137 goto breakloop; 1138 } 1139 } 1140 1141 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd); 1142 } 1143 1144 breakloop: 1145 return sec_flags; 1146 } 1147 1148 1149 /* The PE version; see above for the general comments. 1150 1151 Since to set the SEC_LINK_ONCE and associated flags, we have to 1152 look at the symbol table anyway, we return the symbol table index 1153 of the symbol being used as the COMDAT symbol. This is admittedly 1154 ugly, but there's really nowhere else that we have access to the 1155 required information. FIXME: Is the COMDAT symbol index used for 1156 any purpose other than objdump? */ 1157 1158 static bfd_boolean 1159 styp_to_sec_flags (bfd *abfd, 1160 void * hdr, 1161 const char *name, 1162 asection *section, 1163 flagword *flags_ptr) 1164 { 1165 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr; 1166 long styp_flags = internal_s->s_flags; 1167 flagword sec_flags; 1168 bfd_boolean result = TRUE; 1169 bfd_boolean is_dbg = FALSE; 1170 1171 if (CONST_STRNEQ (name, DOT_DEBUG) 1172 || CONST_STRNEQ (name, DOT_ZDEBUG) 1173 #ifdef COFF_LONG_SECTION_NAMES 1174 || CONST_STRNEQ (name, GNU_LINKONCE_WI) 1175 || CONST_STRNEQ (name, GNU_LINKONCE_WT) 1176 #endif 1177 || CONST_STRNEQ (name, ".stab")) 1178 is_dbg = TRUE; 1179 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */ 1180 sec_flags = SEC_READONLY; 1181 1182 /* If section disallows read, then set the NOREAD flag. */ 1183 if ((styp_flags & IMAGE_SCN_MEM_READ) == 0) 1184 sec_flags |= SEC_COFF_NOREAD; 1185 1186 /* Process each flag bit in styp_flags in turn. */ 1187 while (styp_flags) 1188 { 1189 long flag = styp_flags & - styp_flags; 1190 char * unhandled = NULL; 1191 1192 styp_flags &= ~ flag; 1193 1194 /* We infer from the distinct read/write/execute bits the settings 1195 of some of the bfd flags; the actual values, should we need them, 1196 are also in pei_section_data (abfd, section)->pe_flags. */ 1197 1198 switch (flag) 1199 { 1200 case STYP_DSECT: 1201 unhandled = "STYP_DSECT"; 1202 break; 1203 case STYP_GROUP: 1204 unhandled = "STYP_GROUP"; 1205 break; 1206 case STYP_COPY: 1207 unhandled = "STYP_COPY"; 1208 break; 1209 case STYP_OVER: 1210 unhandled = "STYP_OVER"; 1211 break; 1212 #ifdef SEC_NEVER_LOAD 1213 case STYP_NOLOAD: 1214 sec_flags |= SEC_NEVER_LOAD; 1215 break; 1216 #endif 1217 case IMAGE_SCN_MEM_READ: 1218 sec_flags &= ~SEC_COFF_NOREAD; 1219 break; 1220 case IMAGE_SCN_TYPE_NO_PAD: 1221 /* Skip. */ 1222 break; 1223 case IMAGE_SCN_LNK_OTHER: 1224 unhandled = "IMAGE_SCN_LNK_OTHER"; 1225 break; 1226 case IMAGE_SCN_MEM_NOT_CACHED: 1227 unhandled = "IMAGE_SCN_MEM_NOT_CACHED"; 1228 break; 1229 case IMAGE_SCN_MEM_NOT_PAGED: 1230 /* Generate a warning message rather using the 'unhandled' 1231 variable as this will allow some .sys files generate by 1232 other toolchains to be processed. See bugzilla issue 196. */ 1233 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"), 1234 abfd, name); 1235 break; 1236 case IMAGE_SCN_MEM_EXECUTE: 1237 sec_flags |= SEC_CODE; 1238 break; 1239 case IMAGE_SCN_MEM_WRITE: 1240 sec_flags &= ~ SEC_READONLY; 1241 break; 1242 case IMAGE_SCN_MEM_DISCARDABLE: 1243 /* The MS PE spec says that debug sections are DISCARDABLE, 1244 but the presence of a DISCARDABLE flag does not necessarily 1245 mean that a given section contains debug information. Thus 1246 we only set the SEC_DEBUGGING flag on sections that we 1247 recognise as containing debug information. */ 1248 if (is_dbg 1249 #ifdef _COMMENT 1250 || strcmp (name, _COMMENT) == 0 1251 #endif 1252 ) 1253 { 1254 sec_flags |= SEC_DEBUGGING | SEC_READONLY; 1255 } 1256 break; 1257 case IMAGE_SCN_MEM_SHARED: 1258 sec_flags |= SEC_COFF_SHARED; 1259 break; 1260 case IMAGE_SCN_LNK_REMOVE: 1261 if (!is_dbg) 1262 sec_flags |= SEC_EXCLUDE; 1263 break; 1264 case IMAGE_SCN_CNT_CODE: 1265 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD; 1266 break; 1267 case IMAGE_SCN_CNT_INITIALIZED_DATA: 1268 if (is_dbg) 1269 sec_flags |= SEC_DEBUGGING; 1270 else 1271 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD; 1272 break; 1273 case IMAGE_SCN_CNT_UNINITIALIZED_DATA: 1274 sec_flags |= SEC_ALLOC; 1275 break; 1276 case IMAGE_SCN_LNK_INFO: 1277 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is 1278 defined. coff_compute_section_file_positions uses 1279 COFF_PAGE_SIZE to ensure that the low order bits of the 1280 section VMA and the file offset match. If we don't know 1281 COFF_PAGE_SIZE, we can't ensure the correct correspondence, 1282 and demand page loading of the file will fail. */ 1283 #ifdef COFF_PAGE_SIZE 1284 sec_flags |= SEC_DEBUGGING; 1285 #endif 1286 break; 1287 case IMAGE_SCN_LNK_COMDAT: 1288 /* COMDAT gets very special treatment. */ 1289 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section); 1290 break; 1291 default: 1292 /* Silently ignore for now. */ 1293 break; 1294 } 1295 1296 /* If the section flag was not handled, report it here. */ 1297 if (unhandled != NULL) 1298 { 1299 (*_bfd_error_handler) 1300 (_("%B (%s): Section flag %s (0x%x) ignored"), 1301 abfd, name, unhandled, flag); 1302 result = FALSE; 1303 } 1304 } 1305 1306 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE) 1307 /* As a GNU extension, if the name begins with .gnu.linkonce, we 1308 only link a single copy of the section. This is used to support 1309 g++. g++ will emit each template expansion in its own section. 1310 The symbols will be defined as weak, so that multiple definitions 1311 are permitted. The GNU linker extension is to actually discard 1312 all but one of the sections. */ 1313 if (CONST_STRNEQ (name, ".gnu.linkonce")) 1314 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD; 1315 #endif 1316 1317 if (flags_ptr) 1318 * flags_ptr = sec_flags; 1319 1320 return result; 1321 } 1322 1323 #endif /* COFF_WITH_PE */ 1324 1325 #define get_index(symbol) ((symbol)->udata.i) 1326 1327 /* 1328 INTERNAL_DEFINITION 1329 bfd_coff_backend_data 1330 1331 CODE_FRAGMENT 1332 1333 .{* COFF symbol classifications. *} 1334 . 1335 .enum coff_symbol_classification 1336 .{ 1337 . {* Global symbol. *} 1338 . COFF_SYMBOL_GLOBAL, 1339 . {* Common symbol. *} 1340 . COFF_SYMBOL_COMMON, 1341 . {* Undefined symbol. *} 1342 . COFF_SYMBOL_UNDEFINED, 1343 . {* Local symbol. *} 1344 . COFF_SYMBOL_LOCAL, 1345 . {* PE section symbol. *} 1346 . COFF_SYMBOL_PE_SECTION 1347 .}; 1348 . 1349 Special entry points for gdb to swap in coff symbol table parts: 1350 .typedef struct 1351 .{ 1352 . void (*_bfd_coff_swap_aux_in) 1353 . (bfd *, void *, int, int, int, int, void *); 1354 . 1355 . void (*_bfd_coff_swap_sym_in) 1356 . (bfd *, void *, void *); 1357 . 1358 . void (*_bfd_coff_swap_lineno_in) 1359 . (bfd *, void *, void *); 1360 . 1361 . unsigned int (*_bfd_coff_swap_aux_out) 1362 . (bfd *, void *, int, int, int, int, void *); 1363 . 1364 . unsigned int (*_bfd_coff_swap_sym_out) 1365 . (bfd *, void *, void *); 1366 . 1367 . unsigned int (*_bfd_coff_swap_lineno_out) 1368 . (bfd *, void *, void *); 1369 . 1370 . unsigned int (*_bfd_coff_swap_reloc_out) 1371 . (bfd *, void *, void *); 1372 . 1373 . unsigned int (*_bfd_coff_swap_filehdr_out) 1374 . (bfd *, void *, void *); 1375 . 1376 . unsigned int (*_bfd_coff_swap_aouthdr_out) 1377 . (bfd *, void *, void *); 1378 . 1379 . unsigned int (*_bfd_coff_swap_scnhdr_out) 1380 . (bfd *, void *, void *); 1381 . 1382 . unsigned int _bfd_filhsz; 1383 . unsigned int _bfd_aoutsz; 1384 . unsigned int _bfd_scnhsz; 1385 . unsigned int _bfd_symesz; 1386 . unsigned int _bfd_auxesz; 1387 . unsigned int _bfd_relsz; 1388 . unsigned int _bfd_linesz; 1389 . unsigned int _bfd_filnmlen; 1390 . bfd_boolean _bfd_coff_long_filenames; 1391 . 1392 . bfd_boolean _bfd_coff_long_section_names; 1393 . bfd_boolean (*_bfd_coff_set_long_section_names) 1394 . (bfd *, int); 1395 . 1396 . unsigned int _bfd_coff_default_section_alignment_power; 1397 . bfd_boolean _bfd_coff_force_symnames_in_strings; 1398 . unsigned int _bfd_coff_debug_string_prefix_length; 1399 . unsigned int _bfd_coff_max_nscns; 1400 . 1401 . void (*_bfd_coff_swap_filehdr_in) 1402 . (bfd *, void *, void *); 1403 . 1404 . void (*_bfd_coff_swap_aouthdr_in) 1405 . (bfd *, void *, void *); 1406 . 1407 . void (*_bfd_coff_swap_scnhdr_in) 1408 . (bfd *, void *, void *); 1409 . 1410 . void (*_bfd_coff_swap_reloc_in) 1411 . (bfd *abfd, void *, void *); 1412 . 1413 . bfd_boolean (*_bfd_coff_bad_format_hook) 1414 . (bfd *, void *); 1415 . 1416 . bfd_boolean (*_bfd_coff_set_arch_mach_hook) 1417 . (bfd *, void *); 1418 . 1419 . void * (*_bfd_coff_mkobject_hook) 1420 . (bfd *, void *, void *); 1421 . 1422 . bfd_boolean (*_bfd_styp_to_sec_flags_hook) 1423 . (bfd *, void *, const char *, asection *, flagword *); 1424 . 1425 . void (*_bfd_set_alignment_hook) 1426 . (bfd *, asection *, void *); 1427 . 1428 . bfd_boolean (*_bfd_coff_slurp_symbol_table) 1429 . (bfd *); 1430 . 1431 . bfd_boolean (*_bfd_coff_symname_in_debug) 1432 . (bfd *, struct internal_syment *); 1433 . 1434 . bfd_boolean (*_bfd_coff_pointerize_aux_hook) 1435 . (bfd *, combined_entry_type *, combined_entry_type *, 1436 . unsigned int, combined_entry_type *); 1437 . 1438 . bfd_boolean (*_bfd_coff_print_aux) 1439 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *, 1440 . combined_entry_type *, unsigned int); 1441 . 1442 . void (*_bfd_coff_reloc16_extra_cases) 1443 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *, 1444 . bfd_byte *, unsigned int *, unsigned int *); 1445 . 1446 . int (*_bfd_coff_reloc16_estimate) 1447 . (bfd *, asection *, arelent *, unsigned int, 1448 . struct bfd_link_info *); 1449 . 1450 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) 1451 . (bfd *, struct internal_syment *); 1452 . 1453 . bfd_boolean (*_bfd_coff_compute_section_file_positions) 1454 . (bfd *); 1455 . 1456 . bfd_boolean (*_bfd_coff_start_final_link) 1457 . (bfd *, struct bfd_link_info *); 1458 . 1459 . bfd_boolean (*_bfd_coff_relocate_section) 1460 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 1461 . struct internal_reloc *, struct internal_syment *, asection **); 1462 . 1463 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) 1464 . (bfd *, asection *, struct internal_reloc *, 1465 . struct coff_link_hash_entry *, struct internal_syment *, 1466 . bfd_vma *); 1467 . 1468 . bfd_boolean (*_bfd_coff_adjust_symndx) 1469 . (bfd *, struct bfd_link_info *, bfd *, asection *, 1470 . struct internal_reloc *, bfd_boolean *); 1471 . 1472 . bfd_boolean (*_bfd_coff_link_add_one_symbol) 1473 . (struct bfd_link_info *, bfd *, const char *, flagword, 1474 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean, 1475 . struct bfd_link_hash_entry **); 1476 . 1477 . bfd_boolean (*_bfd_coff_link_output_has_begun) 1478 . (bfd *, struct coff_final_link_info *); 1479 . 1480 . bfd_boolean (*_bfd_coff_final_link_postscript) 1481 . (bfd *, struct coff_final_link_info *); 1482 . 1483 . bfd_boolean (*_bfd_coff_print_pdata) 1484 . (bfd *, void *); 1485 . 1486 .} bfd_coff_backend_data; 1487 . 1488 .#define coff_backend_info(abfd) \ 1489 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data) 1490 . 1491 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \ 1492 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i)) 1493 . 1494 .#define bfd_coff_swap_sym_in(a,e,i) \ 1495 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i)) 1496 . 1497 .#define bfd_coff_swap_lineno_in(a,e,i) \ 1498 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i)) 1499 . 1500 .#define bfd_coff_swap_reloc_out(abfd, i, o) \ 1501 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o)) 1502 . 1503 .#define bfd_coff_swap_lineno_out(abfd, i, o) \ 1504 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o)) 1505 . 1506 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \ 1507 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o)) 1508 . 1509 .#define bfd_coff_swap_sym_out(abfd, i,o) \ 1510 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o)) 1511 . 1512 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \ 1513 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o)) 1514 . 1515 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \ 1516 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o)) 1517 . 1518 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \ 1519 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o)) 1520 . 1521 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz) 1522 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz) 1523 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz) 1524 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz) 1525 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz) 1526 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz) 1527 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz) 1528 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen) 1529 .#define bfd_coff_long_filenames(abfd) \ 1530 . (coff_backend_info (abfd)->_bfd_coff_long_filenames) 1531 .#define bfd_coff_long_section_names(abfd) \ 1532 . (coff_backend_info (abfd)->_bfd_coff_long_section_names) 1533 .#define bfd_coff_set_long_section_names(abfd, enable) \ 1534 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable)) 1535 .#define bfd_coff_default_section_alignment_power(abfd) \ 1536 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power) 1537 .#define bfd_coff_max_nscns(abfd) \ 1538 . (coff_backend_info (abfd)->_bfd_coff_max_nscns) 1539 . 1540 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \ 1541 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o)) 1542 . 1543 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \ 1544 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o)) 1545 . 1546 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \ 1547 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o)) 1548 . 1549 .#define bfd_coff_swap_reloc_in(abfd, i, o) \ 1550 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o)) 1551 . 1552 .#define bfd_coff_bad_format_hook(abfd, filehdr) \ 1553 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr)) 1554 . 1555 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\ 1556 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr)) 1557 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\ 1558 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\ 1559 . (abfd, filehdr, aouthdr)) 1560 . 1561 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\ 1562 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\ 1563 . (abfd, scnhdr, name, section, flags_ptr)) 1564 . 1565 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\ 1566 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr)) 1567 . 1568 .#define bfd_coff_slurp_symbol_table(abfd)\ 1569 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd)) 1570 . 1571 .#define bfd_coff_symname_in_debug(abfd, sym)\ 1572 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym)) 1573 . 1574 .#define bfd_coff_force_symnames_in_strings(abfd)\ 1575 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings) 1576 . 1577 .#define bfd_coff_debug_string_prefix_length(abfd)\ 1578 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length) 1579 . 1580 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\ 1581 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\ 1582 . (abfd, file, base, symbol, aux, indaux)) 1583 . 1584 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\ 1585 . reloc, data, src_ptr, dst_ptr)\ 1586 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\ 1587 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)) 1588 . 1589 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\ 1590 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\ 1591 . (abfd, section, reloc, shrink, link_info)) 1592 . 1593 .#define bfd_coff_classify_symbol(abfd, sym)\ 1594 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\ 1595 . (abfd, sym)) 1596 . 1597 .#define bfd_coff_compute_section_file_positions(abfd)\ 1598 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\ 1599 . (abfd)) 1600 . 1601 .#define bfd_coff_start_final_link(obfd, info)\ 1602 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\ 1603 . (obfd, info)) 1604 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\ 1605 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\ 1606 . (obfd, info, ibfd, o, con, rel, isyms, secs)) 1607 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\ 1608 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\ 1609 . (abfd, sec, rel, h, sym, addendp)) 1610 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\ 1611 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\ 1612 . (obfd, info, ibfd, sec, rel, adjustedp)) 1613 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\ 1614 . value, string, cp, coll, hashp)\ 1615 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\ 1616 . (info, abfd, name, flags, section, value, string, cp, coll, hashp)) 1617 . 1618 .#define bfd_coff_link_output_has_begun(a,p) \ 1619 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p)) 1620 .#define bfd_coff_final_link_postscript(a,p) \ 1621 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p)) 1622 . 1623 .#define bfd_coff_have_print_pdata(a) \ 1624 . (coff_backend_info (a)->_bfd_coff_print_pdata) 1625 .#define bfd_coff_print_pdata(a,p) \ 1626 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p)) 1627 . 1628 .{* Macro: Returns true if the bfd is a PE executable as opposed to a 1629 . PE object file. *} 1630 .#define bfd_pei_p(abfd) \ 1631 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-")) 1632 */ 1633 1634 /* See whether the magic number matches. */ 1635 1636 static bfd_boolean 1637 coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr) 1638 { 1639 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1640 1641 if (BADMAG (*internal_f)) 1642 return FALSE; 1643 1644 /* If the optional header is NULL or not the correct size then 1645 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC) 1646 and Intel 960 readwrite headers (I960WRMAGIC) is that the 1647 optional header is of a different size. 1648 1649 But the mips keeps extra stuff in it's opthdr, so dont check 1650 when doing that. */ 1651 1652 #if defined(M88) || defined(I960) 1653 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr) 1654 return FALSE; 1655 #endif 1656 1657 return TRUE; 1658 } 1659 1660 #ifdef TICOFF 1661 static bfd_boolean 1662 ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr) 1663 { 1664 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1665 1666 if (COFF0_BADMAG (*internal_f)) 1667 return FALSE; 1668 1669 return TRUE; 1670 } 1671 #endif 1672 1673 #ifdef TICOFF 1674 static bfd_boolean 1675 ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr) 1676 { 1677 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1678 1679 if (COFF1_BADMAG (*internal_f)) 1680 return FALSE; 1681 1682 return TRUE; 1683 } 1684 #endif 1685 1686 /* Check whether this section uses an alignment other than the 1687 default. */ 1688 1689 static void 1690 coff_set_custom_section_alignment (bfd *abfd ATTRIBUTE_UNUSED, 1691 asection *section, 1692 const struct coff_section_alignment_entry *alignment_table, 1693 const unsigned int table_size) 1694 { 1695 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; 1696 unsigned int i; 1697 1698 for (i = 0; i < table_size; ++i) 1699 { 1700 const char *secname = bfd_get_section_name (abfd, section); 1701 1702 if (alignment_table[i].comparison_length == (unsigned int) -1 1703 ? strcmp (alignment_table[i].name, secname) == 0 1704 : strncmp (alignment_table[i].name, secname, 1705 alignment_table[i].comparison_length) == 0) 1706 break; 1707 } 1708 if (i >= table_size) 1709 return; 1710 1711 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY 1712 && default_alignment < alignment_table[i].default_alignment_min) 1713 return; 1714 1715 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY 1716 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0 1717 && default_alignment > alignment_table[i].default_alignment_max 1718 #endif 1719 ) 1720 return; 1721 1722 section->alignment_power = alignment_table[i].alignment_power; 1723 } 1724 1725 /* Custom section alignment records. */ 1726 1727 static const struct coff_section_alignment_entry 1728 coff_section_alignment_table[] = 1729 { 1730 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES 1731 COFF_SECTION_ALIGNMENT_ENTRIES, 1732 #endif 1733 /* There must not be any gaps between .stabstr sections. */ 1734 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"), 1735 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, 1736 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */ 1737 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"), 1738 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, 1739 /* Similarly for the .ctors and .dtors sections. */ 1740 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"), 1741 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, 1742 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"), 1743 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 } 1744 }; 1745 1746 static const unsigned int coff_section_alignment_table_size = 1747 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0]; 1748 1749 /* Initialize a section structure with information peculiar to this 1750 particular implementation of COFF. */ 1751 1752 static bfd_boolean 1753 coff_new_section_hook (bfd * abfd, asection * section) 1754 { 1755 combined_entry_type *native; 1756 bfd_size_type amt; 1757 unsigned char sclass = C_STAT; 1758 1759 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER; 1760 1761 #ifdef RS6000COFF_C 1762 if (bfd_xcoff_text_align_power (abfd) != 0 1763 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0) 1764 section->alignment_power = bfd_xcoff_text_align_power (abfd); 1765 else if (bfd_xcoff_data_align_power (abfd) != 0 1766 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0) 1767 section->alignment_power = bfd_xcoff_data_align_power (abfd); 1768 else 1769 { 1770 int i; 1771 1772 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++) 1773 if (strcmp (bfd_get_section_name (abfd, section), 1774 xcoff_dwsect_names[i].name) == 0) 1775 { 1776 section->alignment_power = 0; 1777 sclass = C_DWARF; 1778 break; 1779 } 1780 } 1781 #endif 1782 1783 /* Set up the section symbol. */ 1784 if (!_bfd_generic_new_section_hook (abfd, section)) 1785 return FALSE; 1786 1787 /* Allocate aux records for section symbols, to store size and 1788 related info. 1789 1790 @@ The 10 is a guess at a plausible maximum number of aux entries 1791 (but shouldn't be a constant). */ 1792 amt = sizeof (combined_entry_type) * 10; 1793 native = (combined_entry_type *) bfd_zalloc (abfd, amt); 1794 if (native == NULL) 1795 return FALSE; 1796 1797 /* We don't need to set up n_name, n_value, or n_scnum in the native 1798 symbol information, since they'll be overridden by the BFD symbol 1799 anyhow. However, we do need to set the type and storage class, 1800 in case this symbol winds up getting written out. The value 0 1801 for n_numaux is already correct. */ 1802 1803 native->is_sym = TRUE; 1804 native->u.syment.n_type = T_NULL; 1805 native->u.syment.n_sclass = sclass; 1806 1807 coffsymbol (section->symbol)->native = native; 1808 1809 coff_set_custom_section_alignment (abfd, section, 1810 coff_section_alignment_table, 1811 coff_section_alignment_table_size); 1812 1813 return TRUE; 1814 } 1815 1816 #ifdef COFF_ALIGN_IN_SECTION_HEADER 1817 1818 /* Set the alignment of a BFD section. */ 1819 1820 static void 1821 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1822 asection * section, 1823 void * scnhdr) 1824 { 1825 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1826 unsigned int i; 1827 1828 #ifdef I960 1829 /* Extract ALIGN from 2**ALIGN stored in section header. */ 1830 for (i = 0; i < 32; i++) 1831 if ((1 << i) >= hdr->s_align) 1832 break; 1833 #endif 1834 #ifdef TIC80COFF 1835 /* TI tools puts the alignment power in bits 8-11. */ 1836 i = (hdr->s_flags >> 8) & 0xF ; 1837 #endif 1838 #ifdef COFF_DECODE_ALIGNMENT 1839 i = COFF_DECODE_ALIGNMENT(hdr->s_flags); 1840 #endif 1841 section->alignment_power = i; 1842 1843 #ifdef coff_set_section_load_page 1844 coff_set_section_load_page (section, hdr->s_page); 1845 #endif 1846 } 1847 1848 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1849 #ifdef COFF_WITH_PE 1850 1851 static void 1852 coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1853 asection * section, 1854 void * scnhdr) 1855 { 1856 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1857 bfd_size_type amt; 1858 unsigned int alignment_power_const 1859 = hdr->s_flags & IMAGE_SCN_ALIGN_POWER_BIT_MASK; 1860 1861 switch (alignment_power_const) 1862 { 1863 case IMAGE_SCN_ALIGN_8192BYTES: 1864 case IMAGE_SCN_ALIGN_4096BYTES: 1865 case IMAGE_SCN_ALIGN_2048BYTES: 1866 case IMAGE_SCN_ALIGN_1024BYTES: 1867 case IMAGE_SCN_ALIGN_512BYTES: 1868 case IMAGE_SCN_ALIGN_256BYTES: 1869 case IMAGE_SCN_ALIGN_128BYTES: 1870 case IMAGE_SCN_ALIGN_64BYTES: 1871 case IMAGE_SCN_ALIGN_32BYTES: 1872 case IMAGE_SCN_ALIGN_16BYTES: 1873 case IMAGE_SCN_ALIGN_8BYTES: 1874 case IMAGE_SCN_ALIGN_4BYTES: 1875 case IMAGE_SCN_ALIGN_2BYTES: 1876 case IMAGE_SCN_ALIGN_1BYTES: 1877 section->alignment_power 1878 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const); 1879 break; 1880 default: 1881 break; 1882 } 1883 1884 /* In a PE image file, the s_paddr field holds the virtual size of a 1885 section, while the s_size field holds the raw size. We also keep 1886 the original section flag value, since not every bit can be 1887 mapped onto a generic BFD section bit. */ 1888 if (coff_section_data (abfd, section) == NULL) 1889 { 1890 amt = sizeof (struct coff_section_tdata); 1891 section->used_by_bfd = bfd_zalloc (abfd, amt); 1892 if (section->used_by_bfd == NULL) 1893 /* FIXME: Return error. */ 1894 abort (); 1895 } 1896 1897 if (pei_section_data (abfd, section) == NULL) 1898 { 1899 amt = sizeof (struct pei_section_tdata); 1900 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt); 1901 if (coff_section_data (abfd, section)->tdata == NULL) 1902 /* FIXME: Return error. */ 1903 abort (); 1904 } 1905 pei_section_data (abfd, section)->virt_size = hdr->s_paddr; 1906 pei_section_data (abfd, section)->pe_flags = hdr->s_flags; 1907 1908 section->lma = hdr->s_vaddr; 1909 1910 /* Check for extended relocs. */ 1911 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL) 1912 { 1913 struct external_reloc dst; 1914 struct internal_reloc n; 1915 file_ptr oldpos = bfd_tell (abfd); 1916 bfd_size_type relsz = bfd_coff_relsz (abfd); 1917 1918 if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0) 1919 return; 1920 if (bfd_bread (& dst, relsz, abfd) != relsz) 1921 return; 1922 1923 coff_swap_reloc_in (abfd, &dst, &n); 1924 if (bfd_seek (abfd, oldpos, 0) != 0) 1925 return; 1926 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1; 1927 section->rel_filepos += relsz; 1928 } 1929 else if (hdr->s_nreloc == 0xffff) 1930 (*_bfd_error_handler) 1931 ("%s: warning: claims to have 0xffff relocs, without overflow", 1932 bfd_get_filename (abfd)); 1933 } 1934 #undef ALIGN_SET 1935 #undef ELIFALIGN_SET 1936 1937 #else /* ! COFF_WITH_PE */ 1938 #ifdef RS6000COFF_C 1939 1940 /* We grossly abuse this function to handle XCOFF overflow headers. 1941 When we see one, we correct the reloc and line number counts in the 1942 real header, and remove the section we just created. */ 1943 1944 static void 1945 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr) 1946 { 1947 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1948 asection *real_sec; 1949 1950 if ((hdr->s_flags & STYP_OVRFLO) == 0) 1951 return; 1952 1953 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc); 1954 if (real_sec == NULL) 1955 return; 1956 1957 real_sec->reloc_count = hdr->s_paddr; 1958 real_sec->lineno_count = hdr->s_vaddr; 1959 1960 if (!bfd_section_removed_from_list (abfd, section)) 1961 { 1962 bfd_section_list_remove (abfd, section); 1963 --abfd->section_count; 1964 } 1965 } 1966 1967 #else /* ! RS6000COFF_C */ 1968 1969 #define coff_set_alignment_hook \ 1970 ((void (*) (bfd *, asection *, void *)) bfd_void) 1971 1972 #endif /* ! RS6000COFF_C */ 1973 #endif /* ! COFF_WITH_PE */ 1974 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1975 1976 #ifndef coff_mkobject 1977 1978 static bfd_boolean 1979 coff_mkobject (bfd * abfd) 1980 { 1981 coff_data_type *coff; 1982 bfd_size_type amt = sizeof (coff_data_type); 1983 1984 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt); 1985 if (abfd->tdata.coff_obj_data == NULL) 1986 return FALSE; 1987 coff = coff_data (abfd); 1988 coff->symbols = NULL; 1989 coff->conversion_table = NULL; 1990 coff->raw_syments = NULL; 1991 coff->relocbase = 0; 1992 coff->local_toc_sym_map = 0; 1993 1994 /* make_abs_section(abfd);*/ 1995 1996 return TRUE; 1997 } 1998 #endif 1999 2000 /* Create the COFF backend specific information. */ 2001 2002 #ifndef coff_mkobject_hook 2003 static void * 2004 coff_mkobject_hook (bfd * abfd, 2005 void * filehdr, 2006 void * aouthdr ATTRIBUTE_UNUSED) 2007 { 2008 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 2009 coff_data_type *coff; 2010 2011 if (! coff_mkobject (abfd)) 2012 return NULL; 2013 2014 coff = coff_data (abfd); 2015 2016 coff->sym_filepos = internal_f->f_symptr; 2017 2018 /* These members communicate important constants about the symbol 2019 table to GDB's symbol-reading code. These `constants' 2020 unfortunately vary among coff implementations... */ 2021 coff->local_n_btmask = N_BTMASK; 2022 coff->local_n_btshft = N_BTSHFT; 2023 coff->local_n_tmask = N_TMASK; 2024 coff->local_n_tshift = N_TSHIFT; 2025 coff->local_symesz = bfd_coff_symesz (abfd); 2026 coff->local_auxesz = bfd_coff_auxesz (abfd); 2027 coff->local_linesz = bfd_coff_linesz (abfd); 2028 2029 coff->timestamp = internal_f->f_timdat; 2030 2031 obj_raw_syment_count (abfd) = 2032 obj_conv_table_size (abfd) = 2033 internal_f->f_nsyms; 2034 2035 #ifdef RS6000COFF_C 2036 if ((internal_f->f_flags & F_SHROBJ) != 0) 2037 abfd->flags |= DYNAMIC; 2038 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)) 2039 { 2040 struct internal_aouthdr *internal_a = 2041 (struct internal_aouthdr *) aouthdr; 2042 struct xcoff_tdata *xcoff; 2043 2044 xcoff = xcoff_data (abfd); 2045 # ifdef U803XTOCMAGIC 2046 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC; 2047 # else 2048 xcoff->xcoff64 = 0; 2049 # endif 2050 xcoff->full_aouthdr = TRUE; 2051 xcoff->toc = internal_a->o_toc; 2052 xcoff->sntoc = internal_a->o_sntoc; 2053 xcoff->snentry = internal_a->o_snentry; 2054 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext; 2055 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata; 2056 xcoff->modtype = internal_a->o_modtype; 2057 xcoff->cputype = internal_a->o_cputype; 2058 xcoff->maxdata = internal_a->o_maxdata; 2059 xcoff->maxstack = internal_a->o_maxstack; 2060 } 2061 #endif 2062 2063 #ifdef ARM 2064 /* Set the flags field from the COFF header read in. */ 2065 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 2066 coff->flags = 0; 2067 #endif 2068 2069 #ifdef COFF_WITH_PE 2070 /* FIXME: I'm not sure this is ever executed, since peicode.h 2071 defines coff_mkobject_hook. */ 2072 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 2073 abfd->flags |= HAS_DEBUG; 2074 #endif 2075 2076 if ((internal_f->f_flags & F_GO32STUB) != 0) 2077 coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE); 2078 if (coff->go32stub != NULL) 2079 memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE); 2080 2081 return coff; 2082 } 2083 #endif 2084 2085 /* Determine the machine architecture and type. FIXME: This is target 2086 dependent because the magic numbers are defined in the target 2087 dependent header files. But there is no particular need for this. 2088 If the magic numbers were moved to a separate file, this function 2089 would be target independent and would also be much more successful 2090 at linking together COFF files for different architectures. */ 2091 2092 static bfd_boolean 2093 coff_set_arch_mach_hook (bfd *abfd, void * filehdr) 2094 { 2095 unsigned long machine; 2096 enum bfd_architecture arch; 2097 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 2098 2099 /* Zero selects the default machine for an arch. */ 2100 machine = 0; 2101 switch (internal_f->f_magic) 2102 { 2103 #ifdef PPCMAGIC 2104 case PPCMAGIC: 2105 arch = bfd_arch_powerpc; 2106 break; 2107 #endif 2108 #ifdef I386MAGIC 2109 case I386MAGIC: 2110 case I386PTXMAGIC: 2111 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */ 2112 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */ 2113 arch = bfd_arch_i386; 2114 break; 2115 #endif 2116 #ifdef AMD64MAGIC 2117 case AMD64MAGIC: 2118 arch = bfd_arch_i386; 2119 machine = bfd_mach_x86_64; 2120 break; 2121 #endif 2122 #ifdef IA64MAGIC 2123 case IA64MAGIC: 2124 arch = bfd_arch_ia64; 2125 break; 2126 #endif 2127 #ifdef ARMMAGIC 2128 case ARMMAGIC: 2129 case ARMPEMAGIC: 2130 case THUMBPEMAGIC: 2131 arch = bfd_arch_arm; 2132 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 2133 if (machine == bfd_mach_arm_unknown) 2134 { 2135 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 2136 { 2137 case F_ARM_2: machine = bfd_mach_arm_2; break; 2138 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 2139 case F_ARM_3: machine = bfd_mach_arm_3; break; 2140 default: 2141 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 2142 case F_ARM_4: machine = bfd_mach_arm_4; break; 2143 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 2144 /* The COFF header does not have enough bits available 2145 to cover all the different ARM architectures. So 2146 we interpret F_ARM_5, the highest flag value to mean 2147 "the highest ARM architecture known to BFD" which is 2148 currently the XScale. */ 2149 case F_ARM_5: machine = bfd_mach_arm_XScale; break; 2150 } 2151 } 2152 break; 2153 #endif 2154 #ifdef MC68MAGIC 2155 case MC68MAGIC: 2156 case M68MAGIC: 2157 #ifdef MC68KBCSMAGIC 2158 case MC68KBCSMAGIC: 2159 #endif 2160 #ifdef APOLLOM68KMAGIC 2161 case APOLLOM68KMAGIC: 2162 #endif 2163 #ifdef LYNXCOFFMAGIC 2164 case LYNXCOFFMAGIC: 2165 #endif 2166 arch = bfd_arch_m68k; 2167 machine = bfd_mach_m68020; 2168 break; 2169 #endif 2170 #ifdef MC88MAGIC 2171 case MC88MAGIC: 2172 case MC88DMAGIC: 2173 case MC88OMAGIC: 2174 arch = bfd_arch_m88k; 2175 machine = 88100; 2176 break; 2177 #endif 2178 #ifdef Z80MAGIC 2179 case Z80MAGIC: 2180 arch = bfd_arch_z80; 2181 switch (internal_f->f_flags & F_MACHMASK) 2182 { 2183 case 0: 2184 case bfd_mach_z80strict << 12: 2185 case bfd_mach_z80 << 12: 2186 case bfd_mach_z80full << 12: 2187 case bfd_mach_r800 << 12: 2188 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12; 2189 break; 2190 default: 2191 return FALSE; 2192 } 2193 break; 2194 #endif 2195 #ifdef Z8KMAGIC 2196 case Z8KMAGIC: 2197 arch = bfd_arch_z8k; 2198 switch (internal_f->f_flags & F_MACHMASK) 2199 { 2200 case F_Z8001: 2201 machine = bfd_mach_z8001; 2202 break; 2203 case F_Z8002: 2204 machine = bfd_mach_z8002; 2205 break; 2206 default: 2207 return FALSE; 2208 } 2209 break; 2210 #endif 2211 #ifdef I860 2212 case I860MAGIC: 2213 arch = bfd_arch_i860; 2214 break; 2215 #endif 2216 #ifdef I960 2217 #ifdef I960ROMAGIC 2218 case I960ROMAGIC: 2219 case I960RWMAGIC: 2220 arch = bfd_arch_i960; 2221 switch (F_I960TYPE & internal_f->f_flags) 2222 { 2223 default: 2224 case F_I960CORE: 2225 machine = bfd_mach_i960_core; 2226 break; 2227 case F_I960KB: 2228 machine = bfd_mach_i960_kb_sb; 2229 break; 2230 case F_I960MC: 2231 machine = bfd_mach_i960_mc; 2232 break; 2233 case F_I960XA: 2234 machine = bfd_mach_i960_xa; 2235 break; 2236 case F_I960CA: 2237 machine = bfd_mach_i960_ca; 2238 break; 2239 case F_I960KA: 2240 machine = bfd_mach_i960_ka_sa; 2241 break; 2242 case F_I960JX: 2243 machine = bfd_mach_i960_jx; 2244 break; 2245 case F_I960HX: 2246 machine = bfd_mach_i960_hx; 2247 break; 2248 } 2249 break; 2250 #endif 2251 #endif 2252 2253 #ifdef RS6000COFF_C 2254 #ifdef XCOFF64 2255 case U64_TOCMAGIC: 2256 case U803XTOCMAGIC: 2257 #else 2258 case U802ROMAGIC: 2259 case U802WRMAGIC: 2260 case U802TOCMAGIC: 2261 #endif 2262 { 2263 int cputype; 2264 2265 if (xcoff_data (abfd)->cputype != -1) 2266 cputype = xcoff_data (abfd)->cputype & 0xff; 2267 else 2268 { 2269 /* We did not get a value from the a.out header. If the 2270 file has not been stripped, we may be able to get the 2271 architecture information from the first symbol, if it 2272 is a .file symbol. */ 2273 if (obj_raw_syment_count (abfd) == 0) 2274 cputype = 0; 2275 else 2276 { 2277 bfd_byte *buf; 2278 struct internal_syment sym; 2279 bfd_size_type amt = bfd_coff_symesz (abfd); 2280 2281 buf = bfd_malloc (amt); 2282 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 2283 || bfd_bread (buf, amt, abfd) != amt) 2284 { 2285 free (buf); 2286 return FALSE; 2287 } 2288 bfd_coff_swap_sym_in (abfd, buf, & sym); 2289 if (sym.n_sclass == C_FILE) 2290 cputype = sym.n_type & 0xff; 2291 else 2292 cputype = 0; 2293 free (buf); 2294 } 2295 } 2296 2297 /* FIXME: We don't handle all cases here. */ 2298 switch (cputype) 2299 { 2300 default: 2301 case 0: 2302 arch = bfd_xcoff_architecture (abfd); 2303 machine = bfd_xcoff_machine (abfd); 2304 break; 2305 2306 case 1: 2307 arch = bfd_arch_powerpc; 2308 machine = bfd_mach_ppc_601; 2309 break; 2310 case 2: /* 64 bit PowerPC */ 2311 arch = bfd_arch_powerpc; 2312 machine = bfd_mach_ppc_620; 2313 break; 2314 case 3: 2315 arch = bfd_arch_powerpc; 2316 machine = bfd_mach_ppc; 2317 break; 2318 case 4: 2319 arch = bfd_arch_rs6000; 2320 machine = bfd_mach_rs6k; 2321 break; 2322 } 2323 } 2324 break; 2325 #endif 2326 2327 #ifdef WE32KMAGIC 2328 case WE32KMAGIC: 2329 arch = bfd_arch_we32k; 2330 break; 2331 #endif 2332 2333 #ifdef H8300MAGIC 2334 case H8300MAGIC: 2335 arch = bfd_arch_h8300; 2336 machine = bfd_mach_h8300; 2337 /* !! FIXME this probably isn't the right place for this. */ 2338 abfd->flags |= BFD_IS_RELAXABLE; 2339 break; 2340 #endif 2341 2342 #ifdef H8300HMAGIC 2343 case H8300HMAGIC: 2344 arch = bfd_arch_h8300; 2345 machine = bfd_mach_h8300h; 2346 /* !! FIXME this probably isn't the right place for this. */ 2347 abfd->flags |= BFD_IS_RELAXABLE; 2348 break; 2349 #endif 2350 2351 #ifdef H8300SMAGIC 2352 case H8300SMAGIC: 2353 arch = bfd_arch_h8300; 2354 machine = bfd_mach_h8300s; 2355 /* !! FIXME this probably isn't the right place for this. */ 2356 abfd->flags |= BFD_IS_RELAXABLE; 2357 break; 2358 #endif 2359 2360 #ifdef H8300HNMAGIC 2361 case H8300HNMAGIC: 2362 arch = bfd_arch_h8300; 2363 machine = bfd_mach_h8300hn; 2364 /* !! FIXME this probably isn't the right place for this. */ 2365 abfd->flags |= BFD_IS_RELAXABLE; 2366 break; 2367 #endif 2368 2369 #ifdef H8300SNMAGIC 2370 case H8300SNMAGIC: 2371 arch = bfd_arch_h8300; 2372 machine = bfd_mach_h8300sn; 2373 /* !! FIXME this probably isn't the right place for this. */ 2374 abfd->flags |= BFD_IS_RELAXABLE; 2375 break; 2376 #endif 2377 2378 #ifdef SH_ARCH_MAGIC_BIG 2379 case SH_ARCH_MAGIC_BIG: 2380 case SH_ARCH_MAGIC_LITTLE: 2381 #ifdef COFF_WITH_PE 2382 case SH_ARCH_MAGIC_WINCE: 2383 #endif 2384 arch = bfd_arch_sh; 2385 break; 2386 #endif 2387 2388 #ifdef MIPS_ARCH_MAGIC_WINCE 2389 case MIPS_ARCH_MAGIC_WINCE: 2390 arch = bfd_arch_mips; 2391 break; 2392 #endif 2393 2394 #ifdef H8500MAGIC 2395 case H8500MAGIC: 2396 arch = bfd_arch_h8500; 2397 break; 2398 #endif 2399 2400 #ifdef SPARCMAGIC 2401 case SPARCMAGIC: 2402 #ifdef LYNXCOFFMAGIC 2403 case LYNXCOFFMAGIC: 2404 #endif 2405 arch = bfd_arch_sparc; 2406 break; 2407 #endif 2408 2409 #ifdef TIC30MAGIC 2410 case TIC30MAGIC: 2411 arch = bfd_arch_tic30; 2412 break; 2413 #endif 2414 2415 #ifdef TICOFF0MAGIC 2416 #ifdef TICOFF_TARGET_ARCH 2417 /* This TI COFF section should be used by all new TI COFF v0 targets. */ 2418 case TICOFF0MAGIC: 2419 arch = TICOFF_TARGET_ARCH; 2420 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2421 break; 2422 #endif 2423 #endif 2424 2425 #ifdef TICOFF1MAGIC 2426 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */ 2427 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */ 2428 case TICOFF1MAGIC: 2429 case TICOFF2MAGIC: 2430 switch (internal_f->f_target_id) 2431 { 2432 #ifdef TI_TARGET_ID 2433 case TI_TARGET_ID: 2434 arch = TICOFF_TARGET_ARCH; 2435 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2436 break; 2437 #endif 2438 default: 2439 arch = bfd_arch_obscure; 2440 (*_bfd_error_handler) 2441 (_("Unrecognized TI COFF target id '0x%x'"), 2442 internal_f->f_target_id); 2443 break; 2444 } 2445 break; 2446 #endif 2447 2448 #ifdef TIC80_ARCH_MAGIC 2449 case TIC80_ARCH_MAGIC: 2450 arch = bfd_arch_tic80; 2451 break; 2452 #endif 2453 2454 #ifdef MCOREMAGIC 2455 case MCOREMAGIC: 2456 arch = bfd_arch_mcore; 2457 break; 2458 #endif 2459 2460 #ifdef W65MAGIC 2461 case W65MAGIC: 2462 arch = bfd_arch_w65; 2463 break; 2464 #endif 2465 2466 default: /* Unreadable input file type. */ 2467 arch = bfd_arch_obscure; 2468 break; 2469 } 2470 2471 bfd_default_set_arch_mach (abfd, arch, machine); 2472 return TRUE; 2473 } 2474 2475 #ifdef SYMNAME_IN_DEBUG 2476 2477 static bfd_boolean 2478 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym) 2479 { 2480 return SYMNAME_IN_DEBUG (sym) != 0; 2481 } 2482 2483 #else 2484 2485 #define symname_in_debug_hook \ 2486 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false 2487 2488 #endif 2489 2490 #ifdef RS6000COFF_C 2491 2492 #ifdef XCOFF64 2493 #define FORCE_SYMNAMES_IN_STRINGS 2494 #endif 2495 2496 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */ 2497 2498 static bfd_boolean 2499 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2500 combined_entry_type *table_base, 2501 combined_entry_type *symbol, 2502 unsigned int indaux, 2503 combined_entry_type *aux) 2504 { 2505 BFD_ASSERT (symbol->is_sym); 2506 int n_sclass = symbol->u.syment.n_sclass; 2507 2508 if (CSECT_SYM_P (n_sclass) 2509 && indaux + 1 == symbol->u.syment.n_numaux) 2510 { 2511 BFD_ASSERT (! aux->is_sym); 2512 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 2513 { 2514 aux->u.auxent.x_csect.x_scnlen.p = 2515 table_base + aux->u.auxent.x_csect.x_scnlen.l; 2516 aux->fix_scnlen = 1; 2517 } 2518 2519 /* Return TRUE to indicate that the caller should not do any 2520 further work on this auxent. */ 2521 return TRUE; 2522 } 2523 2524 /* Return FALSE to indicate that this auxent should be handled by 2525 the caller. */ 2526 return FALSE; 2527 } 2528 2529 #else 2530 #ifdef I960 2531 2532 /* We don't want to pointerize bal entries. */ 2533 2534 static bfd_boolean 2535 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2536 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2537 combined_entry_type *symbol, 2538 unsigned int indaux, 2539 combined_entry_type *aux ATTRIBUTE_UNUSED) 2540 { 2541 /* Return TRUE if we don't want to pointerize this aux entry, which 2542 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 2543 return (indaux == 1 2544 && symbol->is_sym 2545 && (symbol->u.syment.n_sclass == C_LEAFPROC 2546 || symbol->u.syment.n_sclass == C_LEAFSTAT 2547 || symbol->u.syment.n_sclass == C_LEAFEXT)); 2548 } 2549 2550 #else /* ! I960 */ 2551 2552 #define coff_pointerize_aux_hook 0 2553 2554 #endif /* ! I960 */ 2555 #endif /* ! RS6000COFF_C */ 2556 2557 /* Print an aux entry. This returns TRUE if it has printed it. */ 2558 2559 static bfd_boolean 2560 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED, 2561 FILE *file ATTRIBUTE_UNUSED, 2562 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2563 combined_entry_type *symbol ATTRIBUTE_UNUSED, 2564 combined_entry_type *aux ATTRIBUTE_UNUSED, 2565 unsigned int indaux ATTRIBUTE_UNUSED) 2566 { 2567 BFD_ASSERT (symbol->is_sym); 2568 BFD_ASSERT (! aux->is_sym); 2569 #ifdef RS6000COFF_C 2570 if (CSECT_SYM_P (symbol->u.syment.n_sclass) 2571 && indaux + 1 == symbol->u.syment.n_numaux) 2572 { 2573 /* This is a csect entry. */ 2574 fprintf (file, "AUX "); 2575 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 2576 { 2577 BFD_ASSERT (! aux->fix_scnlen); 2578 #ifdef XCOFF64 2579 fprintf (file, "val %5lld", 2580 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2581 #else 2582 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2583 #endif 2584 } 2585 else 2586 { 2587 fprintf (file, "indx "); 2588 if (! aux->fix_scnlen) 2589 #ifdef XCOFF64 2590 fprintf (file, "%4lld", 2591 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2592 #else 2593 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2594 #endif 2595 else 2596 fprintf (file, "%4ld", 2597 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 2598 } 2599 fprintf (file, 2600 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 2601 aux->u.auxent.x_csect.x_parmhash, 2602 (unsigned int) aux->u.auxent.x_csect.x_snhash, 2603 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 2604 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 2605 (unsigned int) aux->u.auxent.x_csect.x_smclas, 2606 aux->u.auxent.x_csect.x_stab, 2607 (unsigned int) aux->u.auxent.x_csect.x_snstab); 2608 return TRUE; 2609 } 2610 #endif 2611 2612 /* Return FALSE to indicate that no special action was taken. */ 2613 return FALSE; 2614 } 2615 2616 /* 2617 SUBSUBSECTION 2618 Writing relocations 2619 2620 To write relocations, the back end steps though the 2621 canonical relocation table and create an 2622 @code{internal_reloc}. The symbol index to use is removed from 2623 the @code{offset} field in the symbol table supplied. The 2624 address comes directly from the sum of the section base 2625 address and the relocation offset; the type is dug directly 2626 from the howto field. Then the @code{internal_reloc} is 2627 swapped into the shape of an @code{external_reloc} and written 2628 out to disk. 2629 2630 */ 2631 2632 #ifdef TARG_AUX 2633 2634 2635 /* AUX's ld wants relocations to be sorted. */ 2636 static int 2637 compare_arelent_ptr (const void * x, const void * y) 2638 { 2639 const arelent **a = (const arelent **) x; 2640 const arelent **b = (const arelent **) y; 2641 bfd_size_type aadr = (*a)->address; 2642 bfd_size_type badr = (*b)->address; 2643 2644 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 2645 } 2646 2647 #endif /* TARG_AUX */ 2648 2649 static bfd_boolean 2650 coff_write_relocs (bfd * abfd, int first_undef) 2651 { 2652 asection *s; 2653 2654 for (s = abfd->sections; s != NULL; s = s->next) 2655 { 2656 unsigned int i; 2657 struct external_reloc dst; 2658 arelent **p; 2659 2660 #ifndef TARG_AUX 2661 p = s->orelocation; 2662 #else 2663 { 2664 /* Sort relocations before we write them out. */ 2665 bfd_size_type amt; 2666 2667 amt = s->reloc_count; 2668 amt *= sizeof (arelent *); 2669 p = bfd_malloc (amt); 2670 if (p == NULL && s->reloc_count > 0) 2671 return FALSE; 2672 memcpy (p, s->orelocation, (size_t) amt); 2673 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 2674 } 2675 #endif 2676 2677 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 2678 return FALSE; 2679 2680 #ifdef COFF_WITH_PE 2681 if (obj_pe (abfd) && s->reloc_count >= 0xffff) 2682 { 2683 /* Encode real count here as first reloc. */ 2684 struct internal_reloc n; 2685 2686 memset (& n, 0, sizeof (n)); 2687 /* Add one to count *this* reloc (grr). */ 2688 n.r_vaddr = s->reloc_count + 1; 2689 coff_swap_reloc_out (abfd, &n, &dst); 2690 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2691 abfd) != bfd_coff_relsz (abfd)) 2692 return FALSE; 2693 } 2694 #endif 2695 2696 for (i = 0; i < s->reloc_count; i++) 2697 { 2698 struct internal_reloc n; 2699 arelent *q = p[i]; 2700 2701 memset (& n, 0, sizeof (n)); 2702 2703 /* Now we've renumbered the symbols we know where the 2704 undefined symbols live in the table. Check the reloc 2705 entries for symbols who's output bfd isn't the right one. 2706 This is because the symbol was undefined (which means 2707 that all the pointers are never made to point to the same 2708 place). This is a bad thing,'cause the symbols attached 2709 to the output bfd are indexed, so that the relocation 2710 entries know which symbol index they point to. So we 2711 have to look up the output symbol here. */ 2712 2713 if (q->sym_ptr_ptr[0] != NULL && q->sym_ptr_ptr[0]->the_bfd != abfd) 2714 { 2715 int j; 2716 const char *sname = q->sym_ptr_ptr[0]->name; 2717 asymbol **outsyms = abfd->outsymbols; 2718 2719 for (j = first_undef; outsyms[j]; j++) 2720 { 2721 const char *intable = outsyms[j]->name; 2722 2723 if (strcmp (intable, sname) == 0) 2724 { 2725 /* Got a hit, so repoint the reloc. */ 2726 q->sym_ptr_ptr = outsyms + j; 2727 break; 2728 } 2729 } 2730 } 2731 2732 n.r_vaddr = q->address + s->vma; 2733 2734 #ifdef R_IHCONST 2735 /* The 29k const/consth reloc pair is a real kludge. The consth 2736 part doesn't have a symbol; it has an offset. So rebuilt 2737 that here. */ 2738 if (q->howto->type == R_IHCONST) 2739 n.r_symndx = q->addend; 2740 else 2741 #endif 2742 if (q->sym_ptr_ptr && q->sym_ptr_ptr[0] != NULL) 2743 { 2744 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P 2745 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s)) 2746 #else 2747 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr 2748 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0) 2749 #endif 2750 /* This is a relocation relative to the absolute symbol. */ 2751 n.r_symndx = -1; 2752 else 2753 { 2754 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 2755 /* Check to see if the symbol reloc points to a symbol 2756 we don't have in our symbol table. */ 2757 if (n.r_symndx > obj_conv_table_size (abfd)) 2758 { 2759 bfd_set_error (bfd_error_bad_value); 2760 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"), 2761 abfd, n.r_symndx); 2762 return FALSE; 2763 } 2764 } 2765 } 2766 2767 #ifdef SWAP_OUT_RELOC_OFFSET 2768 n.r_offset = q->addend; 2769 #endif 2770 2771 #ifdef SELECT_RELOC 2772 /* Work out reloc type from what is required. */ 2773 SELECT_RELOC (n, q->howto); 2774 #else 2775 n.r_type = q->howto->type; 2776 #endif 2777 coff_swap_reloc_out (abfd, &n, &dst); 2778 2779 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2780 abfd) != bfd_coff_relsz (abfd)) 2781 return FALSE; 2782 } 2783 2784 #ifdef TARG_AUX 2785 if (p != NULL) 2786 free (p); 2787 #endif 2788 } 2789 2790 return TRUE; 2791 } 2792 2793 /* Set flags and magic number of a coff file from architecture and machine 2794 type. Result is TRUE if we can represent the arch&type, FALSE if not. */ 2795 2796 static bfd_boolean 2797 coff_set_flags (bfd * abfd, 2798 unsigned int *magicp ATTRIBUTE_UNUSED, 2799 unsigned short *flagsp ATTRIBUTE_UNUSED) 2800 { 2801 switch (bfd_get_arch (abfd)) 2802 { 2803 #ifdef Z80MAGIC 2804 case bfd_arch_z80: 2805 *magicp = Z80MAGIC; 2806 switch (bfd_get_mach (abfd)) 2807 { 2808 case 0: 2809 case bfd_mach_z80strict: 2810 case bfd_mach_z80: 2811 case bfd_mach_z80full: 2812 case bfd_mach_r800: 2813 *flagsp = bfd_get_mach (abfd) << 12; 2814 break; 2815 default: 2816 return FALSE; 2817 } 2818 return TRUE; 2819 #endif 2820 2821 #ifdef Z8KMAGIC 2822 case bfd_arch_z8k: 2823 *magicp = Z8KMAGIC; 2824 2825 switch (bfd_get_mach (abfd)) 2826 { 2827 case bfd_mach_z8001: *flagsp = F_Z8001; break; 2828 case bfd_mach_z8002: *flagsp = F_Z8002; break; 2829 default: return FALSE; 2830 } 2831 return TRUE; 2832 #endif 2833 2834 #ifdef I960ROMAGIC 2835 case bfd_arch_i960: 2836 2837 { 2838 unsigned flags; 2839 2840 *magicp = I960ROMAGIC; 2841 2842 switch (bfd_get_mach (abfd)) 2843 { 2844 case bfd_mach_i960_core: flags = F_I960CORE; break; 2845 case bfd_mach_i960_kb_sb: flags = F_I960KB; break; 2846 case bfd_mach_i960_mc: flags = F_I960MC; break; 2847 case bfd_mach_i960_xa: flags = F_I960XA; break; 2848 case bfd_mach_i960_ca: flags = F_I960CA; break; 2849 case bfd_mach_i960_ka_sa: flags = F_I960KA; break; 2850 case bfd_mach_i960_jx: flags = F_I960JX; break; 2851 case bfd_mach_i960_hx: flags = F_I960HX; break; 2852 default: return FALSE; 2853 } 2854 *flagsp = flags; 2855 return TRUE; 2856 } 2857 break; 2858 #endif 2859 2860 #ifdef TIC30MAGIC 2861 case bfd_arch_tic30: 2862 *magicp = TIC30MAGIC; 2863 return TRUE; 2864 #endif 2865 2866 #ifdef TICOFF_DEFAULT_MAGIC 2867 case TICOFF_TARGET_ARCH: 2868 /* If there's no indication of which version we want, use the default. */ 2869 if (!abfd->xvec ) 2870 *magicp = TICOFF_DEFAULT_MAGIC; 2871 else 2872 { 2873 /* We may want to output in a different COFF version. */ 2874 switch (abfd->xvec->name[4]) 2875 { 2876 case '0': 2877 *magicp = TICOFF0MAGIC; 2878 break; 2879 case '1': 2880 *magicp = TICOFF1MAGIC; 2881 break; 2882 case '2': 2883 *magicp = TICOFF2MAGIC; 2884 break; 2885 default: 2886 return FALSE; 2887 } 2888 } 2889 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd)); 2890 return TRUE; 2891 #endif 2892 2893 #ifdef TIC80_ARCH_MAGIC 2894 case bfd_arch_tic80: 2895 *magicp = TIC80_ARCH_MAGIC; 2896 return TRUE; 2897 #endif 2898 2899 #ifdef ARMMAGIC 2900 case bfd_arch_arm: 2901 #ifdef ARM_WINCE 2902 * magicp = ARMPEMAGIC; 2903 #else 2904 * magicp = ARMMAGIC; 2905 #endif 2906 * flagsp = 0; 2907 if (APCS_SET (abfd)) 2908 { 2909 if (APCS_26_FLAG (abfd)) 2910 * flagsp |= F_APCS26; 2911 2912 if (APCS_FLOAT_FLAG (abfd)) 2913 * flagsp |= F_APCS_FLOAT; 2914 2915 if (PIC_FLAG (abfd)) 2916 * flagsp |= F_PIC; 2917 } 2918 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2919 * flagsp |= F_INTERWORK; 2920 switch (bfd_get_mach (abfd)) 2921 { 2922 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2923 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2924 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2925 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2926 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2927 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2928 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; 2929 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. 2930 See also the comment in coff_set_arch_mach_hook(). */ 2931 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; 2932 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; 2933 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; 2934 } 2935 return TRUE; 2936 #endif 2937 2938 #ifdef PPCMAGIC 2939 case bfd_arch_powerpc: 2940 *magicp = PPCMAGIC; 2941 return TRUE; 2942 #endif 2943 2944 #if defined(I386MAGIC) || defined(AMD64MAGIC) 2945 case bfd_arch_i386: 2946 #if defined(I386MAGIC) 2947 *magicp = I386MAGIC; 2948 #endif 2949 #if defined LYNXOS 2950 /* Just overwrite the usual value if we're doing Lynx. */ 2951 *magicp = LYNXCOFFMAGIC; 2952 #endif 2953 #if defined AMD64MAGIC 2954 *magicp = AMD64MAGIC; 2955 #endif 2956 return TRUE; 2957 #endif 2958 2959 #ifdef I860MAGIC 2960 case bfd_arch_i860: 2961 *magicp = I860MAGIC; 2962 return TRUE; 2963 #endif 2964 2965 #ifdef IA64MAGIC 2966 case bfd_arch_ia64: 2967 *magicp = IA64MAGIC; 2968 return TRUE; 2969 #endif 2970 2971 #ifdef MC68MAGIC 2972 case bfd_arch_m68k: 2973 #ifdef APOLLOM68KMAGIC 2974 *magicp = APOLLO_COFF_VERSION_NUMBER; 2975 #else 2976 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2977 #ifdef NAMES_HAVE_UNDERSCORE 2978 *magicp = MC68KBCSMAGIC; 2979 #else 2980 *magicp = MC68MAGIC; 2981 #endif 2982 #endif 2983 #ifdef LYNXOS 2984 /* Just overwrite the usual value if we're doing Lynx. */ 2985 *magicp = LYNXCOFFMAGIC; 2986 #endif 2987 return TRUE; 2988 #endif 2989 2990 #ifdef MC88MAGIC 2991 case bfd_arch_m88k: 2992 *magicp = MC88OMAGIC; 2993 return TRUE; 2994 #endif 2995 2996 #ifdef H8300MAGIC 2997 case bfd_arch_h8300: 2998 switch (bfd_get_mach (abfd)) 2999 { 3000 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE; 3001 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE; 3002 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE; 3003 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE; 3004 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE; 3005 default: break; 3006 } 3007 break; 3008 #endif 3009 3010 #ifdef SH_ARCH_MAGIC_BIG 3011 case bfd_arch_sh: 3012 #ifdef COFF_IMAGE_WITH_PE 3013 *magicp = SH_ARCH_MAGIC_WINCE; 3014 #else 3015 if (bfd_big_endian (abfd)) 3016 *magicp = SH_ARCH_MAGIC_BIG; 3017 else 3018 *magicp = SH_ARCH_MAGIC_LITTLE; 3019 #endif 3020 return TRUE; 3021 #endif 3022 3023 #ifdef MIPS_ARCH_MAGIC_WINCE 3024 case bfd_arch_mips: 3025 *magicp = MIPS_ARCH_MAGIC_WINCE; 3026 return TRUE; 3027 #endif 3028 3029 #ifdef SPARCMAGIC 3030 case bfd_arch_sparc: 3031 *magicp = SPARCMAGIC; 3032 #ifdef LYNXOS 3033 /* Just overwrite the usual value if we're doing Lynx. */ 3034 *magicp = LYNXCOFFMAGIC; 3035 #endif 3036 return TRUE; 3037 #endif 3038 3039 #ifdef H8500MAGIC 3040 case bfd_arch_h8500: 3041 *magicp = H8500MAGIC; 3042 return TRUE; 3043 break; 3044 #endif 3045 3046 #ifdef WE32KMAGIC 3047 case bfd_arch_we32k: 3048 *magicp = WE32KMAGIC; 3049 return TRUE; 3050 #endif 3051 3052 #ifdef RS6000COFF_C 3053 case bfd_arch_rs6000: 3054 #ifndef PPCMAGIC 3055 case bfd_arch_powerpc: 3056 #endif 3057 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour); 3058 *magicp = bfd_xcoff_magic_number (abfd); 3059 return TRUE; 3060 #endif 3061 3062 #ifdef MCOREMAGIC 3063 case bfd_arch_mcore: 3064 * magicp = MCOREMAGIC; 3065 return TRUE; 3066 #endif 3067 3068 #ifdef W65MAGIC 3069 case bfd_arch_w65: 3070 *magicp = W65MAGIC; 3071 return TRUE; 3072 #endif 3073 3074 default: /* Unknown architecture. */ 3075 /* Fall through to "return FALSE" below, to avoid 3076 "statement never reached" errors on the one below. */ 3077 break; 3078 } 3079 3080 return FALSE; 3081 } 3082 3083 static bfd_boolean 3084 coff_set_arch_mach (bfd * abfd, 3085 enum bfd_architecture arch, 3086 unsigned long machine) 3087 { 3088 unsigned dummy1; 3089 unsigned short dummy2; 3090 3091 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 3092 return FALSE; 3093 3094 if (arch != bfd_arch_unknown 3095 && ! coff_set_flags (abfd, &dummy1, &dummy2)) 3096 return FALSE; /* We can't represent this type. */ 3097 3098 return TRUE; /* We're easy... */ 3099 } 3100 3101 #ifdef COFF_IMAGE_WITH_PE 3102 3103 /* This is used to sort sections by VMA, as required by PE image 3104 files. */ 3105 3106 static int 3107 sort_by_secaddr (const void * arg1, const void * arg2) 3108 { 3109 const asection *a = *(const asection **) arg1; 3110 const asection *b = *(const asection **) arg2; 3111 3112 if (a->vma < b->vma) 3113 return -1; 3114 else if (a->vma > b->vma) 3115 return 1; 3116 3117 return 0; 3118 } 3119 3120 #endif /* COFF_IMAGE_WITH_PE */ 3121 3122 /* Calculate the file position for each section. */ 3123 3124 #ifndef I960 3125 #define ALIGN_SECTIONS_IN_FILE 3126 #endif 3127 #if defined(TIC80COFF) || defined(TICOFF) 3128 #undef ALIGN_SECTIONS_IN_FILE 3129 #endif 3130 3131 static bfd_boolean 3132 coff_compute_section_file_positions (bfd * abfd) 3133 { 3134 asection *current; 3135 file_ptr sofar = bfd_coff_filhsz (abfd); 3136 bfd_boolean align_adjust; 3137 unsigned int target_index; 3138 #ifdef ALIGN_SECTIONS_IN_FILE 3139 asection *previous = NULL; 3140 file_ptr old_sofar; 3141 #endif 3142 3143 #ifdef COFF_IMAGE_WITH_PE 3144 int page_size; 3145 3146 if (coff_data (abfd)->link_info 3147 || (pe_data (abfd) && pe_data (abfd)->pe_opthdr.FileAlignment)) 3148 { 3149 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 3150 3151 /* If no file alignment has been set, default to one. 3152 This repairs 'ld -r' for arm-wince-pe target. */ 3153 if (page_size == 0) 3154 page_size = 1; 3155 } 3156 else 3157 page_size = PE_DEF_FILE_ALIGNMENT; 3158 #else 3159 #ifdef COFF_PAGE_SIZE 3160 int page_size = COFF_PAGE_SIZE; 3161 #endif 3162 #endif 3163 3164 #ifdef RS6000COFF_C 3165 /* On XCOFF, if we have symbols, set up the .debug section. */ 3166 if (bfd_get_symcount (abfd) > 0) 3167 { 3168 bfd_size_type sz; 3169 bfd_size_type i, symcount; 3170 asymbol **symp; 3171 3172 sz = 0; 3173 symcount = bfd_get_symcount (abfd); 3174 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 3175 { 3176 coff_symbol_type *cf; 3177 3178 cf = coff_symbol_from (abfd, *symp); 3179 if (cf != NULL 3180 && cf->native != NULL 3181 && cf->native->is_sym 3182 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 3183 { 3184 size_t len; 3185 3186 len = strlen (bfd_asymbol_name (*symp)); 3187 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) 3188 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); 3189 } 3190 } 3191 if (sz > 0) 3192 { 3193 asection *dsec; 3194 3195 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG); 3196 if (dsec == NULL) 3197 abort (); 3198 dsec->size = sz; 3199 dsec->flags |= SEC_HAS_CONTENTS; 3200 } 3201 } 3202 #endif 3203 3204 if (bfd_get_start_address (abfd)) 3205 /* A start address may have been added to the original file. In this 3206 case it will need an optional header to record it. */ 3207 abfd->flags |= EXEC_P; 3208 3209 if (abfd->flags & EXEC_P) 3210 sofar += bfd_coff_aoutsz (abfd); 3211 #ifdef RS6000COFF_C 3212 else if (xcoff_data (abfd)->full_aouthdr) 3213 sofar += bfd_coff_aoutsz (abfd); 3214 else 3215 sofar += SMALL_AOUTSZ; 3216 #endif 3217 3218 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 3219 3220 #ifdef RS6000COFF_C 3221 /* XCOFF handles overflows in the reloc and line number count fields 3222 by allocating a new section header to hold the correct counts. */ 3223 for (current = abfd->sections; current != NULL; current = current->next) 3224 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3225 sofar += bfd_coff_scnhsz (abfd); 3226 #endif 3227 3228 #ifdef COFF_IMAGE_WITH_PE 3229 { 3230 /* PE requires the sections to be in memory order when listed in 3231 the section headers. It also does not like empty loadable 3232 sections. The sections apparently do not have to be in the 3233 right order in the image file itself, but we do need to get the 3234 target_index values right. */ 3235 3236 unsigned int count; 3237 asection **section_list; 3238 unsigned int i; 3239 bfd_size_type amt; 3240 3241 #ifdef COFF_PAGE_SIZE 3242 /* Clear D_PAGED if section alignment is smaller than 3243 COFF_PAGE_SIZE. */ 3244 if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE) 3245 abfd->flags &= ~D_PAGED; 3246 #endif 3247 3248 count = 0; 3249 for (current = abfd->sections; current != NULL; current = current->next) 3250 ++count; 3251 3252 /* We allocate an extra cell to simplify the final loop. */ 3253 amt = sizeof (struct asection *) * (count + 1); 3254 section_list = (asection **) bfd_malloc (amt); 3255 if (section_list == NULL) 3256 return FALSE; 3257 3258 i = 0; 3259 for (current = abfd->sections; current != NULL; current = current->next) 3260 { 3261 section_list[i] = current; 3262 ++i; 3263 } 3264 section_list[i] = NULL; 3265 3266 qsort (section_list, count, sizeof (asection *), sort_by_secaddr); 3267 3268 /* Rethread the linked list into sorted order; at the same time, 3269 assign target_index values. */ 3270 target_index = 1; 3271 abfd->sections = NULL; 3272 abfd->section_last = NULL; 3273 for (i = 0; i < count; i++) 3274 { 3275 current = section_list[i]; 3276 bfd_section_list_append (abfd, current); 3277 3278 /* Later, if the section has zero size, we'll be throwing it 3279 away, so we don't want to number it now. Note that having 3280 a zero size and having real contents are different 3281 concepts: .bss has no contents, but (usually) non-zero 3282 size. */ 3283 if (current->size == 0) 3284 { 3285 /* Discard. However, it still might have (valid) symbols 3286 in it, so arbitrarily set it to section 1 (indexing is 3287 1-based here; usually .text). __end__ and other 3288 contents of .endsection really have this happen. 3289 FIXME: This seems somewhat dubious. */ 3290 current->target_index = 1; 3291 } 3292 else 3293 current->target_index = target_index++; 3294 } 3295 3296 free (section_list); 3297 } 3298 #else /* ! COFF_IMAGE_WITH_PE */ 3299 { 3300 /* Set the target_index field. */ 3301 target_index = 1; 3302 for (current = abfd->sections; current != NULL; current = current->next) 3303 current->target_index = target_index++; 3304 } 3305 #endif /* ! COFF_IMAGE_WITH_PE */ 3306 3307 if (target_index >= bfd_coff_max_nscns (abfd)) 3308 { 3309 bfd_set_error (bfd_error_file_too_big); 3310 (*_bfd_error_handler) 3311 (_("%B: too many sections (%d)"), abfd, target_index); 3312 return FALSE; 3313 } 3314 3315 align_adjust = FALSE; 3316 for (current = abfd->sections; 3317 current != NULL; 3318 current = current->next) 3319 { 3320 #ifdef COFF_IMAGE_WITH_PE 3321 /* With PE we have to pad each section to be a multiple of its 3322 page size too, and remember both sizes. */ 3323 if (coff_section_data (abfd, current) == NULL) 3324 { 3325 bfd_size_type amt = sizeof (struct coff_section_tdata); 3326 3327 current->used_by_bfd = bfd_zalloc (abfd, amt); 3328 if (current->used_by_bfd == NULL) 3329 return FALSE; 3330 } 3331 if (pei_section_data (abfd, current) == NULL) 3332 { 3333 bfd_size_type amt = sizeof (struct pei_section_tdata); 3334 3335 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt); 3336 if (coff_section_data (abfd, current)->tdata == NULL) 3337 return FALSE; 3338 } 3339 if (pei_section_data (abfd, current)->virt_size == 0) 3340 pei_section_data (abfd, current)->virt_size = current->size; 3341 #endif 3342 3343 /* Only deal with sections which have contents. */ 3344 if (!(current->flags & SEC_HAS_CONTENTS)) 3345 continue; 3346 3347 current->rawsize = current->size; 3348 3349 #ifdef COFF_IMAGE_WITH_PE 3350 /* Make sure we skip empty sections in a PE image. */ 3351 if (current->size == 0) 3352 continue; 3353 #endif 3354 3355 /* Align the sections in the file to the same boundary on 3356 which they are aligned in virtual memory. I960 doesn't 3357 do this (FIXME) so we can stay in sync with Intel. 960 3358 doesn't yet page from files... */ 3359 #ifdef ALIGN_SECTIONS_IN_FILE 3360 if ((abfd->flags & EXEC_P) != 0) 3361 { 3362 /* Make sure this section is aligned on the right boundary - by 3363 padding the previous section up if necessary. */ 3364 old_sofar = sofar; 3365 3366 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3367 3368 #ifdef RS6000COFF_C 3369 /* Make sure the file offset and the vma of .text/.data are at the 3370 same page offset, so that the file can be mmap'ed without being 3371 relocated. Failing that, AIX is able to load and execute the 3372 program, but it will be silently relocated (possible as 3373 executables are PIE). But the relocation is slightly costly and 3374 complexify the use of addr2line or gdb. So better to avoid it, 3375 like does the native linker. Usually gnu ld makes sure that 3376 the vma of .text is the file offset so this issue shouldn't 3377 appear unless you are stripping such an executable. 3378 3379 AIX loader checks the text section alignment of (vma - filepos), 3380 and the native linker doesn't try to align the text sections. 3381 For example: 3382 3383 0 .text 000054cc 10000128 10000128 00000128 2**5 3384 CONTENTS, ALLOC, LOAD, CODE 3385 */ 3386 3387 if (!strcmp (current->name, _TEXT) 3388 || !strcmp (current->name, _DATA)) 3389 { 3390 bfd_vma align = 4096; 3391 bfd_vma sofar_off = sofar % align; 3392 bfd_vma vma_off = current->vma % align; 3393 3394 if (vma_off > sofar_off) 3395 sofar += vma_off - sofar_off; 3396 else if (vma_off < sofar_off) 3397 sofar += align + vma_off - sofar_off; 3398 } 3399 #endif 3400 if (previous != NULL) 3401 previous->size += sofar - old_sofar; 3402 } 3403 3404 #endif 3405 3406 /* In demand paged files the low order bits of the file offset 3407 must match the low order bits of the virtual address. */ 3408 #ifdef COFF_PAGE_SIZE 3409 if ((abfd->flags & D_PAGED) != 0 3410 && (current->flags & SEC_ALLOC) != 0) 3411 sofar += (current->vma - (bfd_vma) sofar) % page_size; 3412 #endif 3413 current->filepos = sofar; 3414 3415 #ifdef COFF_IMAGE_WITH_PE 3416 /* Set the padded size. */ 3417 current->size = (current->size + page_size - 1) & -page_size; 3418 #endif 3419 3420 sofar += current->size; 3421 3422 #ifdef ALIGN_SECTIONS_IN_FILE 3423 /* Make sure that this section is of the right size too. */ 3424 if ((abfd->flags & EXEC_P) == 0) 3425 { 3426 bfd_size_type old_size; 3427 3428 old_size = current->size; 3429 current->size = BFD_ALIGN (current->size, 3430 1 << current->alignment_power); 3431 align_adjust = current->size != old_size; 3432 sofar += current->size - old_size; 3433 } 3434 else 3435 { 3436 old_sofar = sofar; 3437 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3438 align_adjust = sofar != old_sofar; 3439 current->size += sofar - old_sofar; 3440 } 3441 #endif 3442 3443 #ifdef COFF_IMAGE_WITH_PE 3444 /* For PE we need to make sure we pad out to the aligned 3445 size, in case the caller only writes out data to the 3446 unaligned size. */ 3447 if (pei_section_data (abfd, current)->virt_size < current->size) 3448 align_adjust = TRUE; 3449 #endif 3450 3451 #ifdef _LIB 3452 /* Force .lib sections to start at zero. The vma is then 3453 incremented in coff_set_section_contents. This is right for 3454 SVR3.2. */ 3455 if (strcmp (current->name, _LIB) == 0) 3456 (void) bfd_set_section_vma (abfd, current, 0); 3457 #endif 3458 3459 #ifdef ALIGN_SECTIONS_IN_FILE 3460 previous = current; 3461 #endif 3462 } 3463 3464 /* It is now safe to write to the output file. If we needed an 3465 alignment adjustment for the last section, then make sure that 3466 there is a byte at offset sofar. If there are no symbols and no 3467 relocs, then nothing follows the last section. If we don't force 3468 the last byte out, then the file may appear to be truncated. */ 3469 if (align_adjust) 3470 { 3471 bfd_byte b; 3472 3473 b = 0; 3474 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0 3475 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3476 return FALSE; 3477 } 3478 3479 /* Make sure the relocations are aligned. We don't need to make 3480 sure that this byte exists, because it will only matter if there 3481 really are relocs. */ 3482 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER); 3483 3484 obj_relocbase (abfd) = sofar; 3485 abfd->output_has_begun = TRUE; 3486 3487 return TRUE; 3488 } 3489 3490 #ifdef COFF_IMAGE_WITH_PE 3491 3492 static unsigned int pelength; 3493 static unsigned int peheader; 3494 3495 static bfd_boolean 3496 coff_read_word (bfd *abfd, unsigned int *value) 3497 { 3498 unsigned char b[2]; 3499 int status; 3500 3501 status = bfd_bread (b, (bfd_size_type) 2, abfd); 3502 if (status < 1) 3503 { 3504 *value = 0; 3505 return FALSE; 3506 } 3507 3508 if (status == 1) 3509 *value = (unsigned int) b[0]; 3510 else 3511 *value = (unsigned int) (b[0] + (b[1] << 8)); 3512 3513 pelength += (unsigned int) status; 3514 3515 return TRUE; 3516 } 3517 3518 static unsigned int 3519 coff_compute_checksum (bfd *abfd) 3520 { 3521 bfd_boolean more_data; 3522 file_ptr filepos; 3523 unsigned int value; 3524 unsigned int total; 3525 3526 total = 0; 3527 pelength = 0; 3528 filepos = (file_ptr) 0; 3529 3530 do 3531 { 3532 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 3533 return 0; 3534 3535 more_data = coff_read_word (abfd, &value); 3536 total += value; 3537 total = 0xffff & (total + (total >> 0x10)); 3538 filepos += 2; 3539 } 3540 while (more_data); 3541 3542 return (0xffff & (total + (total >> 0x10))); 3543 } 3544 3545 static bfd_boolean 3546 coff_apply_checksum (bfd *abfd) 3547 { 3548 unsigned int computed; 3549 unsigned int checksum = 0; 3550 3551 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0) 3552 return FALSE; 3553 3554 if (!coff_read_word (abfd, &peheader)) 3555 return FALSE; 3556 3557 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3558 return FALSE; 3559 3560 checksum = 0; 3561 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3562 3563 if (bfd_seek (abfd, peheader, SEEK_SET) != 0) 3564 return FALSE; 3565 3566 computed = coff_compute_checksum (abfd); 3567 3568 checksum = computed + pelength; 3569 3570 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3571 return FALSE; 3572 3573 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3574 3575 return TRUE; 3576 } 3577 3578 #endif /* COFF_IMAGE_WITH_PE */ 3579 3580 static bfd_boolean 3581 coff_write_object_contents (bfd * abfd) 3582 { 3583 asection *current; 3584 bfd_boolean hasrelocs = FALSE; 3585 bfd_boolean haslinno = FALSE; 3586 #ifdef COFF_IMAGE_WITH_PE 3587 bfd_boolean hasdebug = FALSE; 3588 #endif 3589 file_ptr scn_base; 3590 file_ptr reloc_base; 3591 file_ptr lineno_base; 3592 file_ptr sym_base; 3593 unsigned long reloc_size = 0, reloc_count = 0; 3594 unsigned long lnno_size = 0; 3595 bfd_boolean long_section_names; 3596 asection *text_sec = NULL; 3597 asection *data_sec = NULL; 3598 asection *bss_sec = NULL; 3599 struct internal_filehdr internal_f; 3600 struct internal_aouthdr internal_a; 3601 #ifdef COFF_LONG_SECTION_NAMES 3602 size_t string_size = STRING_SIZE_SIZE; 3603 #endif 3604 3605 bfd_set_error (bfd_error_system_call); 3606 3607 /* Make a pass through the symbol table to count line number entries and 3608 put them into the correct asections. */ 3609 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd); 3610 3611 if (! abfd->output_has_begun) 3612 { 3613 if (! coff_compute_section_file_positions (abfd)) 3614 return FALSE; 3615 } 3616 3617 reloc_base = obj_relocbase (abfd); 3618 3619 /* Work out the size of the reloc and linno areas. */ 3620 3621 for (current = abfd->sections; current != NULL; current = 3622 current->next) 3623 { 3624 #ifdef COFF_WITH_PE 3625 /* We store the actual reloc count in the first reloc's addr. */ 3626 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3627 reloc_count ++; 3628 #endif 3629 reloc_count += current->reloc_count; 3630 } 3631 3632 reloc_size = reloc_count * bfd_coff_relsz (abfd); 3633 3634 lineno_base = reloc_base + reloc_size; 3635 sym_base = lineno_base + lnno_size; 3636 3637 /* Indicate in each section->line_filepos its actual file address. */ 3638 for (current = abfd->sections; current != NULL; current = 3639 current->next) 3640 { 3641 if (current->lineno_count) 3642 { 3643 current->line_filepos = lineno_base; 3644 current->moving_line_filepos = lineno_base; 3645 lineno_base += current->lineno_count * bfd_coff_linesz (abfd); 3646 } 3647 else 3648 current->line_filepos = 0; 3649 3650 if (current->reloc_count) 3651 { 3652 current->rel_filepos = reloc_base; 3653 reloc_base += current->reloc_count * bfd_coff_relsz (abfd); 3654 #ifdef COFF_WITH_PE 3655 /* Extra reloc to hold real count. */ 3656 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3657 reloc_base += bfd_coff_relsz (abfd); 3658 #endif 3659 } 3660 else 3661 current->rel_filepos = 0; 3662 } 3663 3664 /* Write section headers to the file. */ 3665 internal_f.f_nscns = 0; 3666 3667 if ((abfd->flags & EXEC_P) != 0) 3668 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 3669 else 3670 { 3671 scn_base = bfd_coff_filhsz (abfd); 3672 #ifdef RS6000COFF_C 3673 #ifndef XCOFF64 3674 if (xcoff_data (abfd)->full_aouthdr) 3675 scn_base += bfd_coff_aoutsz (abfd); 3676 else 3677 scn_base += SMALL_AOUTSZ; 3678 #endif 3679 #endif 3680 } 3681 3682 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 3683 return FALSE; 3684 3685 long_section_names = FALSE; 3686 for (current = abfd->sections; 3687 current != NULL; 3688 current = current->next) 3689 { 3690 struct internal_scnhdr section; 3691 #ifdef COFF_IMAGE_WITH_PE 3692 bfd_boolean is_reloc_section = FALSE; 3693 3694 if (strcmp (current->name, DOT_RELOC) == 0) 3695 { 3696 is_reloc_section = TRUE; 3697 hasrelocs = TRUE; 3698 pe_data (abfd)->has_reloc_section = 1; 3699 } 3700 #endif 3701 3702 internal_f.f_nscns++; 3703 3704 strncpy (section.s_name, current->name, SCNNMLEN); 3705 3706 #ifdef COFF_LONG_SECTION_NAMES 3707 /* Handle long section names as in PE. This must be compatible 3708 with the code in coff_write_symbols and _bfd_coff_final_link. */ 3709 if (bfd_coff_long_section_names (abfd)) 3710 { 3711 size_t len; 3712 3713 len = strlen (current->name); 3714 if (len > SCNNMLEN) 3715 { 3716 /* The s_name field is defined to be NUL-padded but need not be 3717 NUL-terminated. We use a temporary buffer so that we can still 3718 sprintf all eight chars without splatting a terminating NUL 3719 over the first byte of the following member (s_paddr). */ 3720 char s_name_buf[SCNNMLEN + 1]; 3721 3722 /* An inherent limitation of the /nnnnnnn notation used to indicate 3723 the offset of the long name in the string table is that we 3724 cannot address entries beyone the ten million byte boundary. */ 3725 if (string_size >= 10000000) 3726 { 3727 bfd_set_error (bfd_error_file_too_big); 3728 (*_bfd_error_handler) 3729 (_("%B: section %s: string table overflow at offset %ld"), 3730 abfd, current->name, string_size); 3731 return FALSE; 3732 } 3733 3734 /* snprintf not strictly necessary now we've verified the value 3735 has less than eight ASCII digits, but never mind. */ 3736 snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size); 3737 /* Then strncpy takes care of any padding for us. */ 3738 strncpy (section.s_name, s_name_buf, SCNNMLEN); 3739 string_size += len + 1; 3740 long_section_names = TRUE; 3741 } 3742 } 3743 #endif 3744 3745 #ifdef _LIB 3746 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2 3747 Ian Taylor <ian (at) cygnus.com>. */ 3748 if (strcmp (current->name, _LIB) == 0) 3749 section.s_vaddr = 0; 3750 else 3751 #endif 3752 section.s_vaddr = current->vma; 3753 section.s_paddr = current->lma; 3754 section.s_size = current->size; 3755 #ifdef coff_get_section_load_page 3756 section.s_page = coff_get_section_load_page (current); 3757 #else 3758 section.s_page = 0; 3759 #endif 3760 3761 #ifdef COFF_WITH_PE 3762 section.s_paddr = 0; 3763 #endif 3764 #ifdef COFF_IMAGE_WITH_PE 3765 /* Reminder: s_paddr holds the virtual size of the section. */ 3766 if (coff_section_data (abfd, current) != NULL 3767 && pei_section_data (abfd, current) != NULL) 3768 section.s_paddr = pei_section_data (abfd, current)->virt_size; 3769 else 3770 section.s_paddr = 0; 3771 #endif 3772 3773 /* If this section has no size or is unloadable then the scnptr 3774 will be 0 too. */ 3775 if (current->size == 0 3776 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 3777 section.s_scnptr = 0; 3778 else 3779 section.s_scnptr = current->filepos; 3780 3781 section.s_relptr = current->rel_filepos; 3782 section.s_lnnoptr = current->line_filepos; 3783 section.s_nreloc = current->reloc_count; 3784 section.s_nlnno = current->lineno_count; 3785 #ifndef COFF_IMAGE_WITH_PE 3786 /* In PEI, relocs come in the .reloc section. */ 3787 if (current->reloc_count != 0) 3788 hasrelocs = TRUE; 3789 #endif 3790 if (current->lineno_count != 0) 3791 haslinno = TRUE; 3792 #ifdef COFF_IMAGE_WITH_PE 3793 if ((current->flags & SEC_DEBUGGING) != 0 3794 && ! is_reloc_section) 3795 hasdebug = TRUE; 3796 #endif 3797 3798 #ifdef RS6000COFF_C 3799 #ifndef XCOFF64 3800 /* Indicate the use of an XCOFF overflow section header. */ 3801 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3802 { 3803 section.s_nreloc = 0xffff; 3804 section.s_nlnno = 0xffff; 3805 } 3806 #endif 3807 #endif 3808 3809 section.s_flags = sec_to_styp_flags (current->name, current->flags); 3810 3811 if (!strcmp (current->name, _TEXT)) 3812 text_sec = current; 3813 else if (!strcmp (current->name, _DATA)) 3814 data_sec = current; 3815 else if (!strcmp (current->name, _BSS)) 3816 bss_sec = current; 3817 3818 #ifdef I960 3819 section.s_align = (current->alignment_power 3820 ? 1 << current->alignment_power 3821 : 0); 3822 #endif 3823 #ifdef TIC80COFF 3824 /* TI COFF puts the alignment power in bits 8-11 of the flags. */ 3825 section.s_flags |= (current->alignment_power & 0xF) << 8; 3826 #endif 3827 #ifdef COFF_ENCODE_ALIGNMENT 3828 COFF_ENCODE_ALIGNMENT(section, current->alignment_power); 3829 #endif 3830 3831 #ifdef COFF_IMAGE_WITH_PE 3832 /* Suppress output of the sections if they are null. ld 3833 includes the bss and data sections even if there is no size 3834 assigned to them. NT loader doesn't like it if these section 3835 headers are included if the sections themselves are not 3836 needed. See also coff_compute_section_file_positions. */ 3837 if (section.s_size == 0) 3838 internal_f.f_nscns--; 3839 else 3840 #endif 3841 { 3842 SCNHDR buff; 3843 bfd_size_type amt = bfd_coff_scnhsz (abfd); 3844 3845 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 3846 || bfd_bwrite (& buff, amt, abfd) != amt) 3847 return FALSE; 3848 } 3849 3850 #ifdef COFF_WITH_PE 3851 /* PE stores COMDAT section information in the symbol table. If 3852 this section is supposed to have some COMDAT info, track down 3853 the symbol in the symbol table and modify it. */ 3854 if ((current->flags & SEC_LINK_ONCE) != 0) 3855 { 3856 unsigned int i, count; 3857 asymbol **psym; 3858 coff_symbol_type *csym = NULL; 3859 asymbol **psymsec; 3860 3861 psymsec = NULL; 3862 count = bfd_get_symcount (abfd); 3863 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++) 3864 { 3865 if ((*psym)->section != current) 3866 continue; 3867 3868 /* Remember the location of the first symbol in this 3869 section. */ 3870 if (psymsec == NULL) 3871 psymsec = psym; 3872 3873 /* See if this is the section symbol. */ 3874 if (strcmp ((*psym)->name, current->name) == 0) 3875 { 3876 csym = coff_symbol_from (abfd, *psym); 3877 if (csym == NULL 3878 || csym->native == NULL 3879 || ! csym->native->is_sym 3880 || csym->native->u.syment.n_numaux < 1 3881 || csym->native->u.syment.n_sclass != C_STAT 3882 || csym->native->u.syment.n_type != T_NULL) 3883 continue; 3884 3885 /* Here *PSYM is the section symbol for CURRENT. */ 3886 3887 break; 3888 } 3889 } 3890 3891 /* Did we find it? 3892 Note that we might not if we're converting the file from 3893 some other object file format. */ 3894 if (i < count) 3895 { 3896 combined_entry_type *aux; 3897 3898 /* We don't touch the x_checksum field. The 3899 x_associated field is not currently supported. */ 3900 3901 aux = csym->native + 1; 3902 BFD_ASSERT (! aux->is_sym); 3903 switch (current->flags & SEC_LINK_DUPLICATES) 3904 { 3905 case SEC_LINK_DUPLICATES_DISCARD: 3906 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY; 3907 break; 3908 3909 case SEC_LINK_DUPLICATES_ONE_ONLY: 3910 aux->u.auxent.x_scn.x_comdat = 3911 IMAGE_COMDAT_SELECT_NODUPLICATES; 3912 break; 3913 3914 case SEC_LINK_DUPLICATES_SAME_SIZE: 3915 aux->u.auxent.x_scn.x_comdat = 3916 IMAGE_COMDAT_SELECT_SAME_SIZE; 3917 break; 3918 3919 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 3920 aux->u.auxent.x_scn.x_comdat = 3921 IMAGE_COMDAT_SELECT_EXACT_MATCH; 3922 break; 3923 } 3924 3925 /* The COMDAT symbol must be the first symbol from this 3926 section in the symbol table. In order to make this 3927 work, we move the COMDAT symbol before the first 3928 symbol we found in the search above. It's OK to 3929 rearrange the symbol table at this point, because 3930 coff_renumber_symbols is going to rearrange it 3931 further and fix up all the aux entries. */ 3932 if (psym != psymsec) 3933 { 3934 asymbol *hold; 3935 asymbol **pcopy; 3936 3937 hold = *psym; 3938 for (pcopy = psym; pcopy > psymsec; pcopy--) 3939 pcopy[0] = pcopy[-1]; 3940 *psymsec = hold; 3941 } 3942 } 3943 } 3944 #endif /* COFF_WITH_PE */ 3945 } 3946 3947 #ifdef RS6000COFF_C 3948 #ifndef XCOFF64 3949 /* XCOFF handles overflows in the reloc and line number count fields 3950 by creating a new section header to hold the correct values. */ 3951 for (current = abfd->sections; current != NULL; current = current->next) 3952 { 3953 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3954 { 3955 struct internal_scnhdr scnhdr; 3956 SCNHDR buff; 3957 bfd_size_type amt; 3958 3959 internal_f.f_nscns++; 3960 memcpy (scnhdr.s_name, ".ovrflo", 8); 3961 scnhdr.s_paddr = current->reloc_count; 3962 scnhdr.s_vaddr = current->lineno_count; 3963 scnhdr.s_size = 0; 3964 scnhdr.s_scnptr = 0; 3965 scnhdr.s_relptr = current->rel_filepos; 3966 scnhdr.s_lnnoptr = current->line_filepos; 3967 scnhdr.s_nreloc = current->target_index; 3968 scnhdr.s_nlnno = current->target_index; 3969 scnhdr.s_flags = STYP_OVRFLO; 3970 amt = bfd_coff_scnhsz (abfd); 3971 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0 3972 || bfd_bwrite (& buff, amt, abfd) != amt) 3973 return FALSE; 3974 } 3975 } 3976 #endif 3977 #endif 3978 3979 /* OK, now set up the filehdr... */ 3980 3981 /* Don't include the internal abs section in the section count */ 3982 3983 /* We will NOT put a fucking timestamp in the header here. Every time you 3984 put it back, I will come in and take it out again. I'm sorry. This 3985 field does not belong here. We fill it with a 0 so it compares the 3986 same but is not a reasonable time. -- gnu (at) cygnus.com */ 3987 internal_f.f_timdat = 0; 3988 internal_f.f_flags = 0; 3989 3990 if (abfd->flags & EXEC_P) 3991 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3992 else 3993 { 3994 internal_f.f_opthdr = 0; 3995 #ifdef RS6000COFF_C 3996 #ifndef XCOFF64 3997 if (xcoff_data (abfd)->full_aouthdr) 3998 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3999 else 4000 internal_f.f_opthdr = SMALL_AOUTSZ; 4001 #endif 4002 #endif 4003 } 4004 4005 if (!hasrelocs) 4006 internal_f.f_flags |= F_RELFLG; 4007 if (!haslinno) 4008 internal_f.f_flags |= F_LNNO; 4009 if (abfd->flags & EXEC_P) 4010 internal_f.f_flags |= F_EXEC; 4011 #ifdef COFF_IMAGE_WITH_PE 4012 if (! hasdebug) 4013 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED; 4014 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) 4015 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 4016 #endif 4017 4018 #ifndef COFF_WITH_pex64 4019 #ifdef COFF_WITH_PE 4020 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE; 4021 #else 4022 if (bfd_little_endian (abfd)) 4023 internal_f.f_flags |= F_AR32WR; 4024 else 4025 internal_f.f_flags |= F_AR32W; 4026 #endif 4027 #endif 4028 4029 #ifdef TI_TARGET_ID 4030 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field, 4031 but it doesn't hurt to set it internally. */ 4032 internal_f.f_target_id = TI_TARGET_ID; 4033 #endif 4034 #ifdef TIC80_TARGET_ID 4035 internal_f.f_target_id = TIC80_TARGET_ID; 4036 #endif 4037 4038 /* FIXME, should do something about the other byte orders and 4039 architectures. */ 4040 4041 #ifdef RS6000COFF_C 4042 if ((abfd->flags & DYNAMIC) != 0) 4043 internal_f.f_flags |= F_SHROBJ; 4044 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 4045 internal_f.f_flags |= F_DYNLOAD; 4046 #endif 4047 4048 /* Set up architecture-dependent stuff. */ 4049 { 4050 unsigned int magic = 0; 4051 unsigned short flags = 0; 4052 4053 coff_set_flags (abfd, &magic, &flags); 4054 internal_f.f_magic = magic; 4055 internal_f.f_flags |= flags; 4056 /* ...and the "opt"hdr... */ 4057 4058 #ifdef TICOFF_AOUT_MAGIC 4059 internal_a.magic = TICOFF_AOUT_MAGIC; 4060 #define __A_MAGIC_SET__ 4061 #endif 4062 #ifdef TIC80COFF 4063 internal_a.magic = TIC80_ARCH_MAGIC; 4064 #define __A_MAGIC_SET__ 4065 #endif /* TIC80 */ 4066 #ifdef I860 4067 /* FIXME: What are the a.out magic numbers for the i860? */ 4068 internal_a.magic = 0; 4069 #define __A_MAGIC_SET__ 4070 #endif /* I860 */ 4071 #ifdef I960 4072 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 4073 #define __A_MAGIC_SET__ 4074 #endif /* I960 */ 4075 #if M88 4076 #define __A_MAGIC_SET__ 4077 internal_a.magic = PAGEMAGICBCS; 4078 #endif /* M88 */ 4079 4080 #if APOLLO_M68 4081 #define __A_MAGIC_SET__ 4082 internal_a.magic = APOLLO_COFF_VERSION_NUMBER; 4083 #endif 4084 4085 #if defined(M68) || defined(WE32K) || defined(M68K) 4086 #define __A_MAGIC_SET__ 4087 #if defined(LYNXOS) 4088 internal_a.magic = LYNXCOFFMAGIC; 4089 #else 4090 #if defined(TARG_AUX) 4091 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED : 4092 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED : 4093 PAGEMAGICEXECSWAPPED); 4094 #else 4095 #if defined (PAGEMAGICPEXECPAGED) 4096 internal_a.magic = PAGEMAGICPEXECPAGED; 4097 #endif 4098 #endif /* TARG_AUX */ 4099 #endif /* LYNXOS */ 4100 #endif /* M68 || WE32K || M68K */ 4101 4102 #if defined(ARM) 4103 #define __A_MAGIC_SET__ 4104 internal_a.magic = ZMAGIC; 4105 #endif 4106 4107 #if defined(PPC_PE) 4108 #define __A_MAGIC_SET__ 4109 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 4110 #endif 4111 4112 #if defined MCORE_PE 4113 #define __A_MAGIC_SET__ 4114 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 4115 #endif 4116 4117 #if defined(I386) 4118 #define __A_MAGIC_SET__ 4119 #if defined LYNXOS 4120 internal_a.magic = LYNXCOFFMAGIC; 4121 #elif defined AMD64 4122 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; 4123 #else 4124 internal_a.magic = ZMAGIC; 4125 #endif 4126 #endif /* I386 */ 4127 4128 #if defined(IA64) 4129 #define __A_MAGIC_SET__ 4130 internal_a.magic = PE32PMAGIC; 4131 #endif /* IA64 */ 4132 4133 #if defined(SPARC) 4134 #define __A_MAGIC_SET__ 4135 #if defined(LYNXOS) 4136 internal_a.magic = LYNXCOFFMAGIC; 4137 #endif /* LYNXOS */ 4138 #endif /* SPARC */ 4139 4140 #ifdef RS6000COFF_C 4141 #define __A_MAGIC_SET__ 4142 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC : 4143 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC : 4144 RS6K_AOUTHDR_OMAGIC; 4145 #endif 4146 4147 #if defined(SH) && defined(COFF_WITH_PE) 4148 #define __A_MAGIC_SET__ 4149 internal_a.magic = SH_PE_MAGIC; 4150 #endif 4151 4152 #if defined(MIPS) && defined(COFF_WITH_PE) 4153 #define __A_MAGIC_SET__ 4154 internal_a.magic = MIPS_PE_MAGIC; 4155 #endif 4156 4157 #ifndef __A_MAGIC_SET__ 4158 #include "Your aouthdr magic number is not being set!" 4159 #else 4160 #undef __A_MAGIC_SET__ 4161 #endif 4162 } 4163 4164 /* FIXME: Does anybody ever set this to another value? */ 4165 internal_a.vstamp = 0; 4166 4167 /* Now should write relocs, strings, syms. */ 4168 obj_sym_filepos (abfd) = sym_base; 4169 4170 if (bfd_get_symcount (abfd) != 0) 4171 { 4172 int firstundef; 4173 4174 if (!coff_renumber_symbols (abfd, &firstundef)) 4175 return FALSE; 4176 coff_mangle_symbols (abfd); 4177 if (! coff_write_symbols (abfd)) 4178 return FALSE; 4179 if (! coff_write_linenumbers (abfd)) 4180 return FALSE; 4181 if (! coff_write_relocs (abfd, firstundef)) 4182 return FALSE; 4183 } 4184 #ifdef COFF_LONG_SECTION_NAMES 4185 else if (long_section_names && ! obj_coff_strings_written (abfd)) 4186 { 4187 /* If we have long section names we have to write out the string 4188 table even if there are no symbols. */ 4189 if (! coff_write_symbols (abfd)) 4190 return FALSE; 4191 } 4192 #endif 4193 #ifdef COFF_IMAGE_WITH_PE 4194 #ifdef PPC_PE 4195 else if ((abfd->flags & EXEC_P) != 0) 4196 { 4197 bfd_byte b; 4198 4199 /* PowerPC PE appears to require that all executable files be 4200 rounded up to the page size. */ 4201 b = 0; 4202 if (bfd_seek (abfd, 4203 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1, 4204 SEEK_SET) != 0 4205 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 4206 return FALSE; 4207 } 4208 #endif 4209 #endif 4210 4211 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 4212 backend linker, and obj_raw_syment_count is not valid until after 4213 coff_write_symbols is called. */ 4214 if (obj_raw_syment_count (abfd) != 0) 4215 { 4216 internal_f.f_symptr = sym_base; 4217 #ifdef RS6000COFF_C 4218 /* AIX appears to require that F_RELFLG not be set if there are 4219 local symbols but no relocations. */ 4220 internal_f.f_flags &=~ F_RELFLG; 4221 #endif 4222 } 4223 else 4224 { 4225 if (long_section_names) 4226 internal_f.f_symptr = sym_base; 4227 else 4228 internal_f.f_symptr = 0; 4229 internal_f.f_flags |= F_LSYMS; 4230 } 4231 4232 if (text_sec) 4233 { 4234 internal_a.tsize = text_sec->size; 4235 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 4236 } 4237 if (data_sec) 4238 { 4239 internal_a.dsize = data_sec->size; 4240 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 4241 } 4242 if (bss_sec) 4243 { 4244 internal_a.bsize = bss_sec->size; 4245 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 4246 internal_a.data_start = bss_sec->vma; 4247 } 4248 4249 internal_a.entry = bfd_get_start_address (abfd); 4250 internal_f.f_nsyms = obj_raw_syment_count (abfd); 4251 4252 #ifdef RS6000COFF_C 4253 if (xcoff_data (abfd)->full_aouthdr) 4254 { 4255 bfd_vma toc; 4256 asection *loader_sec; 4257 4258 internal_a.vstamp = 1; 4259 4260 internal_a.o_snentry = xcoff_data (abfd)->snentry; 4261 if (internal_a.o_snentry == 0) 4262 internal_a.entry = (bfd_vma) -1; 4263 4264 if (text_sec != NULL) 4265 { 4266 internal_a.o_sntext = text_sec->target_index; 4267 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec); 4268 } 4269 else 4270 { 4271 internal_a.o_sntext = 0; 4272 internal_a.o_algntext = 0; 4273 } 4274 if (data_sec != NULL) 4275 { 4276 internal_a.o_sndata = data_sec->target_index; 4277 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec); 4278 } 4279 else 4280 { 4281 internal_a.o_sndata = 0; 4282 internal_a.o_algndata = 0; 4283 } 4284 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 4285 if (loader_sec != NULL) 4286 internal_a.o_snloader = loader_sec->target_index; 4287 else 4288 internal_a.o_snloader = 0; 4289 if (bss_sec != NULL) 4290 internal_a.o_snbss = bss_sec->target_index; 4291 else 4292 internal_a.o_snbss = 0; 4293 4294 toc = xcoff_data (abfd)->toc; 4295 internal_a.o_toc = toc; 4296 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 4297 4298 internal_a.o_modtype = xcoff_data (abfd)->modtype; 4299 if (xcoff_data (abfd)->cputype != -1) 4300 internal_a.o_cputype = xcoff_data (abfd)->cputype; 4301 else 4302 { 4303 switch (bfd_get_arch (abfd)) 4304 { 4305 case bfd_arch_rs6000: 4306 internal_a.o_cputype = 4; 4307 break; 4308 case bfd_arch_powerpc: 4309 if (bfd_get_mach (abfd) == bfd_mach_ppc) 4310 internal_a.o_cputype = 3; 4311 else 4312 internal_a.o_cputype = 1; 4313 break; 4314 default: 4315 abort (); 4316 } 4317 } 4318 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 4319 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 4320 } 4321 #endif 4322 4323 #ifdef COFF_WITH_PE 4324 { 4325 /* After object contents are finalized so we can compute a reasonable hash, 4326 but before header is written so we can update it to point to debug directory. */ 4327 struct pe_tdata *pe = pe_data (abfd); 4328 4329 if (pe->build_id.after_write_object_contents != NULL) 4330 (*pe->build_id.after_write_object_contents) (abfd); 4331 } 4332 #endif 4333 4334 /* Now write header. */ 4335 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 4336 return FALSE; 4337 4338 { 4339 char * buff; 4340 bfd_size_type amount = bfd_coff_filhsz (abfd); 4341 4342 buff = (char *) bfd_malloc (amount); 4343 if (buff == NULL) 4344 return FALSE; 4345 4346 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff); 4347 amount = bfd_bwrite (buff, amount, abfd); 4348 4349 free (buff); 4350 4351 if (amount != bfd_coff_filhsz (abfd)) 4352 return FALSE; 4353 } 4354 4355 if (abfd->flags & EXEC_P) 4356 { 4357 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR. 4358 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */ 4359 char * buff; 4360 bfd_size_type amount = bfd_coff_aoutsz (abfd); 4361 4362 buff = (char *) bfd_malloc (amount); 4363 if (buff == NULL) 4364 return FALSE; 4365 4366 coff_swap_aouthdr_out (abfd, & internal_a, buff); 4367 amount = bfd_bwrite (buff, amount, abfd); 4368 4369 free (buff); 4370 4371 if (amount != bfd_coff_aoutsz (abfd)) 4372 return FALSE; 4373 4374 #ifdef COFF_IMAGE_WITH_PE 4375 if (! coff_apply_checksum (abfd)) 4376 return FALSE; 4377 #endif 4378 } 4379 #ifdef RS6000COFF_C 4380 else 4381 { 4382 AOUTHDR buff; 4383 size_t size; 4384 4385 /* XCOFF seems to always write at least a small a.out header. */ 4386 coff_swap_aouthdr_out (abfd, & internal_a, & buff); 4387 if (xcoff_data (abfd)->full_aouthdr) 4388 size = bfd_coff_aoutsz (abfd); 4389 else 4390 size = SMALL_AOUTSZ; 4391 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size) 4392 return FALSE; 4393 } 4394 #endif 4395 4396 return TRUE; 4397 } 4398 4399 static bfd_boolean 4400 coff_set_section_contents (bfd * abfd, 4401 sec_ptr section, 4402 const void * location, 4403 file_ptr offset, 4404 bfd_size_type count) 4405 { 4406 if (! abfd->output_has_begun) /* Set by bfd.c handler. */ 4407 { 4408 if (! coff_compute_section_file_positions (abfd)) 4409 return FALSE; 4410 } 4411 4412 #if defined(_LIB) && !defined(TARG_AUX) 4413 /* The physical address field of a .lib section is used to hold the 4414 number of shared libraries in the section. This code counts the 4415 number of sections being written, and increments the lma field 4416 with the number. 4417 4418 I have found no documentation on the contents of this section. 4419 Experimentation indicates that the section contains zero or more 4420 records, each of which has the following structure: 4421 4422 - a (four byte) word holding the length of this record, in words, 4423 - a word that always seems to be set to "2", 4424 - the path to a shared library, null-terminated and then padded 4425 to a whole word boundary. 4426 4427 bfd_assert calls have been added to alert if an attempt is made 4428 to write a section which doesn't follow these assumptions. The 4429 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe 4430 <robertl (at) arnet.com> (Thanks!). 4431 4432 Gvran Uddeborg <gvran (at) uddeborg.pp.se>. */ 4433 if (strcmp (section->name, _LIB) == 0) 4434 { 4435 bfd_byte *rec, *recend; 4436 4437 rec = (bfd_byte *) location; 4438 recend = rec + count; 4439 while (rec < recend) 4440 { 4441 ++section->lma; 4442 rec += bfd_get_32 (abfd, rec) * 4; 4443 } 4444 4445 BFD_ASSERT (rec == recend); 4446 } 4447 #endif 4448 4449 /* Don't write out bss sections - one way to do this is to 4450 see if the filepos has not been set. */ 4451 if (section->filepos == 0) 4452 return TRUE; 4453 4454 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0) 4455 return FALSE; 4456 4457 if (count == 0) 4458 return TRUE; 4459 4460 return bfd_bwrite (location, count, abfd) == count; 4461 } 4462 4463 static void * 4464 buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size) 4465 { 4466 void * area = bfd_alloc (abfd, size); 4467 4468 if (!area) 4469 return NULL; 4470 if (bfd_seek (abfd, where, SEEK_SET) != 0 4471 || bfd_bread (area, size, abfd) != size) 4472 return NULL; 4473 return area; 4474 } 4475 4476 /* 4477 SUBSUBSECTION 4478 Reading linenumbers 4479 4480 Creating the linenumber table is done by reading in the entire 4481 coff linenumber table, and creating another table for internal use. 4482 4483 A coff linenumber table is structured so that each function 4484 is marked as having a line number of 0. Each line within the 4485 function is an offset from the first line in the function. The 4486 base of the line number information for the table is stored in 4487 the symbol associated with the function. 4488 4489 Note: The PE format uses line number 0 for a flag indicating a 4490 new source file. 4491 4492 The information is copied from the external to the internal 4493 table, and each symbol which marks a function is marked by 4494 pointing its... 4495 4496 How does this work ? 4497 */ 4498 4499 static int 4500 coff_sort_func_alent (const void * arg1, const void * arg2) 4501 { 4502 const alent *al1 = *(const alent **) arg1; 4503 const alent *al2 = *(const alent **) arg2; 4504 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym); 4505 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym); 4506 4507 if (s1 == NULL || s2 == NULL) 4508 return 0; 4509 if (s1->symbol.value < s2->symbol.value) 4510 return -1; 4511 else if (s1->symbol.value > s2->symbol.value) 4512 return 1; 4513 4514 return 0; 4515 } 4516 4517 static bfd_boolean 4518 coff_slurp_line_table (bfd *abfd, asection *asect) 4519 { 4520 LINENO *native_lineno; 4521 alent *lineno_cache; 4522 bfd_size_type amt; 4523 unsigned int counter; 4524 alent *cache_ptr; 4525 bfd_vma prev_offset = 0; 4526 bfd_boolean ordered = TRUE; 4527 unsigned int nbr_func; 4528 LINENO *src; 4529 bfd_boolean have_func; 4530 4531 BFD_ASSERT (asect->lineno == NULL); 4532 4533 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent); 4534 lineno_cache = (alent *) bfd_alloc (abfd, amt); 4535 if (lineno_cache == NULL) 4536 return FALSE; 4537 4538 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count; 4539 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt); 4540 if (native_lineno == NULL) 4541 { 4542 (*_bfd_error_handler) 4543 (_("%B: warning: line number table read failed"), abfd); 4544 bfd_release (abfd, lineno_cache); 4545 return FALSE; 4546 } 4547 4548 cache_ptr = lineno_cache; 4549 asect->lineno = lineno_cache; 4550 src = native_lineno; 4551 nbr_func = 0; 4552 have_func = FALSE; 4553 4554 for (counter = 0; counter < asect->lineno_count; counter++, src++) 4555 { 4556 struct internal_lineno dst; 4557 4558 bfd_coff_swap_lineno_in (abfd, src, &dst); 4559 cache_ptr->line_number = dst.l_lnno; 4560 /* Appease memory checkers that get all excited about 4561 uninitialised memory when copying alents if u.offset is 4562 larger than u.sym. (64-bit BFD on 32-bit host.) */ 4563 memset (&cache_ptr->u, 0, sizeof (cache_ptr->u)); 4564 4565 if (cache_ptr->line_number == 0) 4566 { 4567 combined_entry_type * ent; 4568 bfd_vma symndx; 4569 coff_symbol_type *sym; 4570 4571 have_func = FALSE; 4572 symndx = dst.l_addr.l_symndx; 4573 if (symndx >= obj_raw_syment_count (abfd)) 4574 { 4575 (*_bfd_error_handler) 4576 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"), 4577 abfd, (long) symndx, counter); 4578 cache_ptr->line_number = -1; 4579 continue; 4580 } 4581 4582 ent = obj_raw_syments (abfd) + symndx; 4583 /* FIXME: We should not be casting between ints and 4584 pointers like this. */ 4585 if (! ent->is_sym) 4586 { 4587 (*_bfd_error_handler) 4588 (_("%B: warning: illegal symbol index 0x%lx in line number entry %d"), 4589 abfd, (long) symndx, counter); 4590 cache_ptr->line_number = -1; 4591 continue; 4592 } 4593 sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes); 4594 4595 /* PR 17512 file: 078-10659-0.004 */ 4596 if (sym < obj_symbols (abfd) 4597 || sym >= obj_symbols (abfd) + bfd_get_symcount (abfd)) 4598 { 4599 (*_bfd_error_handler) 4600 (_("%B: warning: illegal symbol in line number entry %d"), 4601 abfd, counter); 4602 cache_ptr->line_number = -1; 4603 continue; 4604 } 4605 4606 have_func = TRUE; 4607 nbr_func++; 4608 cache_ptr->u.sym = (asymbol *) sym; 4609 if (sym->lineno != NULL) 4610 (*_bfd_error_handler) 4611 (_("%B: warning: duplicate line number information for `%s'"), 4612 abfd, bfd_asymbol_name (&sym->symbol)); 4613 4614 sym->lineno = cache_ptr; 4615 if (sym->symbol.value < prev_offset) 4616 ordered = FALSE; 4617 prev_offset = sym->symbol.value; 4618 } 4619 else if (!have_func) 4620 /* Drop line information that has no associated function. 4621 PR 17521: file: 078-10659-0.004. */ 4622 continue; 4623 else 4624 cache_ptr->u.offset = (dst.l_addr.l_paddr 4625 - bfd_section_vma (abfd, asect)); 4626 cache_ptr++; 4627 } 4628 4629 asect->lineno_count = cache_ptr - lineno_cache; 4630 memset (cache_ptr, 0, sizeof (*cache_ptr)); 4631 bfd_release (abfd, native_lineno); 4632 4633 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */ 4634 if (!ordered) 4635 { 4636 /* Sort the table. */ 4637 alent **func_table; 4638 alent *n_lineno_cache; 4639 4640 /* Create a table of functions. */ 4641 func_table = (alent **) bfd_alloc (abfd, nbr_func * sizeof (alent *)); 4642 if (func_table != NULL) 4643 { 4644 alent **p = func_table; 4645 unsigned int i; 4646 4647 for (i = 0; i < asect->lineno_count; i++) 4648 if (lineno_cache[i].line_number == 0) 4649 *p++ = &lineno_cache[i]; 4650 4651 BFD_ASSERT ((unsigned int) (p - func_table) == nbr_func); 4652 4653 /* Sort by functions. */ 4654 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent); 4655 4656 /* Create the new sorted table. */ 4657 amt = (bfd_size_type) asect->lineno_count * sizeof (alent); 4658 n_lineno_cache = (alent *) bfd_alloc (abfd, amt); 4659 if (n_lineno_cache != NULL) 4660 { 4661 alent *n_cache_ptr = n_lineno_cache; 4662 4663 for (i = 0; i < nbr_func; i++) 4664 { 4665 coff_symbol_type *sym; 4666 alent *old_ptr = func_table[i]; 4667 4668 /* Update the function entry. */ 4669 sym = (coff_symbol_type *) old_ptr->u.sym; 4670 /* PR binutils/17512: Point the lineno to where 4671 this entry will be after the memcpy below. */ 4672 sym->lineno = lineno_cache + (n_cache_ptr - n_lineno_cache); 4673 /* Copy the function and line number entries. */ 4674 do 4675 *n_cache_ptr++ = *old_ptr++; 4676 while (old_ptr->line_number != 0); 4677 } 4678 BFD_ASSERT ((bfd_size_type) (n_cache_ptr - n_lineno_cache) == (amt / sizeof (alent))); 4679 4680 memcpy (lineno_cache, n_lineno_cache, amt); 4681 } 4682 bfd_release (abfd, func_table); 4683 } 4684 } 4685 4686 return TRUE; 4687 } 4688 4689 /* Slurp in the symbol table, converting it to generic form. Note 4690 that if coff_relocate_section is defined, the linker will read 4691 symbols via coff_link_add_symbols, rather than via this routine. */ 4692 4693 static bfd_boolean 4694 coff_slurp_symbol_table (bfd * abfd) 4695 { 4696 combined_entry_type *native_symbols; 4697 coff_symbol_type *cached_area; 4698 unsigned int *table_ptr; 4699 bfd_size_type amt; 4700 unsigned int number_of_symbols = 0; 4701 4702 if (obj_symbols (abfd)) 4703 return TRUE; 4704 4705 /* Read in the symbol table. */ 4706 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL) 4707 return FALSE; 4708 4709 /* Allocate enough room for all the symbols in cached form. */ 4710 amt = obj_raw_syment_count (abfd); 4711 amt *= sizeof (coff_symbol_type); 4712 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt); 4713 if (cached_area == NULL) 4714 return FALSE; 4715 4716 amt = obj_raw_syment_count (abfd); 4717 amt *= sizeof (unsigned int); 4718 table_ptr = (unsigned int *) bfd_zalloc (abfd, amt); 4719 4720 if (table_ptr == NULL) 4721 return FALSE; 4722 else 4723 { 4724 coff_symbol_type *dst = cached_area; 4725 unsigned int last_native_index = obj_raw_syment_count (abfd); 4726 unsigned int this_index = 0; 4727 4728 while (this_index < last_native_index) 4729 { 4730 combined_entry_type *src = native_symbols + this_index; 4731 table_ptr[this_index] = number_of_symbols; 4732 4733 dst->symbol.the_bfd = abfd; 4734 BFD_ASSERT (src->is_sym); 4735 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset); 4736 /* We use the native name field to point to the cached field. */ 4737 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst; 4738 dst->symbol.section = coff_section_from_bfd_index (abfd, 4739 src->u.syment.n_scnum); 4740 dst->symbol.flags = 0; 4741 /* PR 17512: file: 079-7098-0.001:0.1. */ 4742 dst->symbol.value = 0; 4743 dst->done_lineno = FALSE; 4744 4745 switch (src->u.syment.n_sclass) 4746 { 4747 #ifdef I960 4748 case C_LEAFEXT: 4749 /* Fall through to next case. */ 4750 #endif 4751 4752 case C_EXT: 4753 case C_WEAKEXT: 4754 #if defined ARM 4755 case C_THUMBEXT: 4756 case C_THUMBEXTFUNC: 4757 #endif 4758 #ifdef RS6000COFF_C 4759 case C_HIDEXT: 4760 #endif 4761 #ifdef C_SYSTEM 4762 case C_SYSTEM: /* System Wide variable. */ 4763 #endif 4764 #ifdef COFF_WITH_PE 4765 /* In PE, 0x68 (104) denotes a section symbol. */ 4766 case C_SECTION: 4767 /* In PE, 0x69 (105) denotes a weak external symbol. */ 4768 case C_NT_WEAK: 4769 #endif 4770 switch (coff_classify_symbol (abfd, &src->u.syment)) 4771 { 4772 case COFF_SYMBOL_GLOBAL: 4773 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 4774 #if defined COFF_WITH_PE 4775 /* PE sets the symbol to a value relative to the 4776 start of the section. */ 4777 dst->symbol.value = src->u.syment.n_value; 4778 #else 4779 dst->symbol.value = (src->u.syment.n_value 4780 - dst->symbol.section->vma); 4781 #endif 4782 if (ISFCN ((src->u.syment.n_type))) 4783 /* A function ext does not go at the end of a 4784 file. */ 4785 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4786 break; 4787 4788 case COFF_SYMBOL_COMMON: 4789 dst->symbol.section = bfd_com_section_ptr; 4790 dst->symbol.value = src->u.syment.n_value; 4791 break; 4792 4793 case COFF_SYMBOL_UNDEFINED: 4794 dst->symbol.section = bfd_und_section_ptr; 4795 dst->symbol.value = 0; 4796 break; 4797 4798 case COFF_SYMBOL_PE_SECTION: 4799 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM; 4800 dst->symbol.value = 0; 4801 break; 4802 4803 case COFF_SYMBOL_LOCAL: 4804 dst->symbol.flags = BSF_LOCAL; 4805 #if defined COFF_WITH_PE 4806 /* PE sets the symbol to a value relative to the 4807 start of the section. */ 4808 dst->symbol.value = src->u.syment.n_value; 4809 #else 4810 dst->symbol.value = (src->u.syment.n_value 4811 - dst->symbol.section->vma); 4812 #endif 4813 if (ISFCN ((src->u.syment.n_type))) 4814 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4815 break; 4816 } 4817 4818 #ifdef RS6000COFF_C 4819 /* A symbol with a csect entry should not go at the end. */ 4820 if (src->u.syment.n_numaux > 0) 4821 dst->symbol.flags |= BSF_NOT_AT_END; 4822 #endif 4823 4824 #ifdef COFF_WITH_PE 4825 if (src->u.syment.n_sclass == C_NT_WEAK) 4826 dst->symbol.flags |= BSF_WEAK; 4827 4828 if (src->u.syment.n_sclass == C_SECTION 4829 && src->u.syment.n_scnum > 0) 4830 dst->symbol.flags = BSF_LOCAL; 4831 #endif 4832 if (src->u.syment.n_sclass == C_WEAKEXT) 4833 dst->symbol.flags |= BSF_WEAK; 4834 4835 break; 4836 4837 case C_STAT: /* Static. */ 4838 #ifdef I960 4839 case C_LEAFSTAT: /* Static leaf procedure. */ 4840 #endif 4841 #if defined ARM 4842 case C_THUMBSTAT: /* Thumb static. */ 4843 case C_THUMBLABEL: /* Thumb label. */ 4844 case C_THUMBSTATFUNC:/* Thumb static function. */ 4845 #endif 4846 #ifdef RS6000COFF_C 4847 case C_DWARF: /* A label in a dwarf section. */ 4848 case C_INFO: /* A label in a comment section. */ 4849 #endif 4850 case C_LABEL: /* Label. */ 4851 if (src->u.syment.n_scnum == N_DEBUG) 4852 dst->symbol.flags = BSF_DEBUGGING; 4853 else 4854 dst->symbol.flags = BSF_LOCAL; 4855 4856 /* Base the value as an index from the base of the 4857 section, if there is one. */ 4858 if (dst->symbol.section) 4859 { 4860 #if defined COFF_WITH_PE 4861 /* PE sets the symbol to a value relative to the 4862 start of the section. */ 4863 dst->symbol.value = src->u.syment.n_value; 4864 #else 4865 dst->symbol.value = (src->u.syment.n_value 4866 - dst->symbol.section->vma); 4867 #endif 4868 } 4869 else 4870 dst->symbol.value = src->u.syment.n_value; 4871 break; 4872 4873 case C_MOS: /* Member of structure. */ 4874 case C_EOS: /* End of structure. */ 4875 case C_REGPARM: /* Register parameter. */ 4876 case C_REG: /* register variable. */ 4877 /* C_AUTOARG conflicts with TI COFF C_UEXT. */ 4878 #if !defined (TIC80COFF) && !defined (TICOFF) 4879 #ifdef C_AUTOARG 4880 case C_AUTOARG: /* 960-specific storage class. */ 4881 #endif 4882 #endif 4883 case C_TPDEF: /* Type definition. */ 4884 case C_ARG: 4885 case C_AUTO: /* Automatic variable. */ 4886 case C_FIELD: /* Bit field. */ 4887 case C_ENTAG: /* Enumeration tag. */ 4888 case C_MOE: /* Member of enumeration. */ 4889 case C_MOU: /* Member of union. */ 4890 case C_UNTAG: /* Union tag. */ 4891 dst->symbol.flags = BSF_DEBUGGING; 4892 dst->symbol.value = (src->u.syment.n_value); 4893 break; 4894 4895 case C_FILE: /* File name. */ 4896 case C_STRTAG: /* Structure tag. */ 4897 #ifdef RS6000COFF_C 4898 case C_GSYM: 4899 case C_LSYM: 4900 case C_PSYM: 4901 case C_RSYM: 4902 case C_RPSYM: 4903 case C_STSYM: 4904 case C_TCSYM: 4905 case C_BCOMM: 4906 case C_ECOML: 4907 case C_ECOMM: 4908 case C_DECL: 4909 case C_ENTRY: 4910 case C_FUN: 4911 case C_ESTAT: 4912 #endif 4913 dst->symbol.flags = BSF_DEBUGGING; 4914 dst->symbol.value = (src->u.syment.n_value); 4915 break; 4916 4917 #ifdef RS6000COFF_C 4918 case C_BINCL: /* Beginning of include file. */ 4919 case C_EINCL: /* Ending of include file. */ 4920 /* The value is actually a pointer into the line numbers 4921 of the file. We locate the line number entry, and 4922 set the section to the section which contains it, and 4923 the value to the index in that section. */ 4924 { 4925 asection *sec; 4926 4927 dst->symbol.flags = BSF_DEBUGGING; 4928 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4929 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value 4930 && ((file_ptr) (sec->line_filepos 4931 + sec->lineno_count * bfd_coff_linesz (abfd)) 4932 > (file_ptr) src->u.syment.n_value)) 4933 break; 4934 if (sec == NULL) 4935 dst->symbol.value = 0; 4936 else 4937 { 4938 dst->symbol.section = sec; 4939 dst->symbol.value = ((src->u.syment.n_value 4940 - sec->line_filepos) 4941 / bfd_coff_linesz (abfd)); 4942 src->fix_line = 1; 4943 } 4944 } 4945 break; 4946 4947 case C_BSTAT: 4948 dst->symbol.flags = BSF_DEBUGGING; 4949 4950 /* The value is actually a symbol index. Save a pointer 4951 to the symbol instead of the index. FIXME: This 4952 should use a union. */ 4953 src->u.syment.n_value = 4954 (long) (intptr_t) (native_symbols + src->u.syment.n_value); 4955 dst->symbol.value = src->u.syment.n_value; 4956 src->fix_value = 1; 4957 break; 4958 #endif 4959 4960 case C_BLOCK: /* ".bb" or ".eb". */ 4961 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */ 4962 case C_EFCN: /* Physical end of function. */ 4963 #if defined COFF_WITH_PE 4964 /* PE sets the symbol to a value relative to the start 4965 of the section. */ 4966 dst->symbol.value = src->u.syment.n_value; 4967 if (strcmp (dst->symbol.name, ".bf") != 0) 4968 { 4969 /* PE uses funny values for .ef and .lf; don't 4970 relocate them. */ 4971 dst->symbol.flags = BSF_DEBUGGING; 4972 } 4973 else 4974 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC; 4975 #else 4976 /* Base the value as an index from the base of the 4977 section. */ 4978 dst->symbol.flags = BSF_LOCAL; 4979 dst->symbol.value = (src->u.syment.n_value 4980 - dst->symbol.section->vma); 4981 #endif 4982 break; 4983 4984 case C_STATLAB: /* Static load time label. */ 4985 dst->symbol.value = src->u.syment.n_value; 4986 dst->symbol.flags = BSF_GLOBAL; 4987 break; 4988 4989 case C_NULL: 4990 /* PE DLLs sometimes have zeroed out symbols for some 4991 reason. Just ignore them without a warning. */ 4992 if (src->u.syment.n_type == 0 4993 && src->u.syment.n_value == 0 4994 && src->u.syment.n_scnum == 0) 4995 break; 4996 #ifdef RS6000COFF_C 4997 /* XCOFF specific: deleted entry. */ 4998 if (src->u.syment.n_value == C_NULL_VALUE) 4999 break; 5000 #endif 5001 /* Fall through. */ 5002 case C_EXTDEF: /* External definition. */ 5003 case C_ULABEL: /* Undefined label. */ 5004 case C_USTATIC: /* Undefined static. */ 5005 #ifndef COFF_WITH_PE 5006 /* C_LINE in regular coff is 0x68. NT has taken over this storage 5007 class to represent a section symbol. */ 5008 case C_LINE: /* line # reformatted as symbol table entry. */ 5009 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 5010 case C_ALIAS: /* Duplicate tag. */ 5011 #endif 5012 /* New storage classes for TI COFF. */ 5013 #if defined(TIC80COFF) || defined(TICOFF) 5014 case C_UEXT: /* Tentative external definition. */ 5015 #endif 5016 case C_EXTLAB: /* External load time label. */ 5017 case C_HIDDEN: /* Ext symbol in dmert public lib. */ 5018 default: 5019 (*_bfd_error_handler) 5020 (_("%B: Unrecognized storage class %d for %s symbol `%s'"), 5021 abfd, src->u.syment.n_sclass, 5022 dst->symbol.section->name, dst->symbol.name); 5023 dst->symbol.flags = BSF_DEBUGGING; 5024 dst->symbol.value = (src->u.syment.n_value); 5025 break; 5026 } 5027 5028 dst->native = src; 5029 dst->symbol.udata.i = 0; 5030 dst->lineno = NULL; 5031 5032 this_index += (src->u.syment.n_numaux) + 1; 5033 dst++; 5034 number_of_symbols++; 5035 } 5036 } 5037 5038 obj_symbols (abfd) = cached_area; 5039 obj_raw_syments (abfd) = native_symbols; 5040 5041 bfd_get_symcount (abfd) = number_of_symbols; 5042 obj_convert (abfd) = table_ptr; 5043 /* Slurp the line tables for each section too. */ 5044 { 5045 asection *p; 5046 5047 p = abfd->sections; 5048 while (p) 5049 { 5050 coff_slurp_line_table (abfd, p); 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 (abfd, 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, 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
