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