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