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