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