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 if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0) 1864 return; 1865 if (bfd_bread (& dst, relsz, abfd) != relsz) 1866 return; 1867 1868 coff_swap_reloc_in (abfd, &dst, &n); 1869 if (bfd_seek (abfd, oldpos, 0) != 0) 1870 return; 1871 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1; 1872 section->rel_filepos += relsz; 1873 } 1874 else if (hdr->s_nreloc == 0xffff) 1875 (*_bfd_error_handler) 1876 ("%s: warning: claims to have 0xffff relocs, without overflow", 1877 bfd_get_filename (abfd)); 1878 } 1879 #undef ALIGN_SET 1880 #undef ELIFALIGN_SET 1881 1882 #else /* ! COFF_WITH_PE */ 1883 #ifdef RS6000COFF_C 1884 1885 /* We grossly abuse this function to handle XCOFF overflow headers. 1886 When we see one, we correct the reloc and line number counts in the 1887 real header, and remove the section we just created. */ 1888 1889 static void 1890 coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr) 1891 { 1892 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1893 asection *real_sec; 1894 1895 if ((hdr->s_flags & STYP_OVRFLO) == 0) 1896 return; 1897 1898 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc); 1899 if (real_sec == NULL) 1900 return; 1901 1902 real_sec->reloc_count = hdr->s_paddr; 1903 real_sec->lineno_count = hdr->s_vaddr; 1904 1905 if (!bfd_section_removed_from_list (abfd, section)) 1906 { 1907 bfd_section_list_remove (abfd, section); 1908 --abfd->section_count; 1909 } 1910 } 1911 1912 #else /* ! RS6000COFF_C */ 1913 1914 #define coff_set_alignment_hook \ 1915 ((void (*) (bfd *, asection *, void *)) bfd_void) 1916 1917 #endif /* ! RS6000COFF_C */ 1918 #endif /* ! COFF_WITH_PE */ 1919 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1920 1921 #ifndef coff_mkobject 1922 1923 static bfd_boolean 1924 coff_mkobject (bfd * abfd) 1925 { 1926 coff_data_type *coff; 1927 bfd_size_type amt = sizeof (coff_data_type); 1928 1929 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt); 1930 if (abfd->tdata.coff_obj_data == NULL) 1931 return FALSE; 1932 coff = coff_data (abfd); 1933 coff->symbols = NULL; 1934 coff->conversion_table = NULL; 1935 coff->raw_syments = NULL; 1936 coff->relocbase = 0; 1937 coff->local_toc_sym_map = 0; 1938 1939 /* make_abs_section(abfd);*/ 1940 1941 return TRUE; 1942 } 1943 #endif 1944 1945 /* Create the COFF backend specific information. */ 1946 1947 #ifndef coff_mkobject_hook 1948 static void * 1949 coff_mkobject_hook (bfd * abfd, 1950 void * filehdr, 1951 void * aouthdr ATTRIBUTE_UNUSED) 1952 { 1953 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1954 coff_data_type *coff; 1955 1956 if (! coff_mkobject (abfd)) 1957 return NULL; 1958 1959 coff = coff_data (abfd); 1960 1961 coff->sym_filepos = internal_f->f_symptr; 1962 1963 /* These members communicate important constants about the symbol 1964 table to GDB's symbol-reading code. These `constants' 1965 unfortunately vary among coff implementations... */ 1966 coff->local_n_btmask = N_BTMASK; 1967 coff->local_n_btshft = N_BTSHFT; 1968 coff->local_n_tmask = N_TMASK; 1969 coff->local_n_tshift = N_TSHIFT; 1970 coff->local_symesz = bfd_coff_symesz (abfd); 1971 coff->local_auxesz = bfd_coff_auxesz (abfd); 1972 coff->local_linesz = bfd_coff_linesz (abfd); 1973 1974 coff->timestamp = internal_f->f_timdat; 1975 1976 obj_raw_syment_count (abfd) = 1977 obj_conv_table_size (abfd) = 1978 internal_f->f_nsyms; 1979 1980 #ifdef RS6000COFF_C 1981 if ((internal_f->f_flags & F_SHROBJ) != 0) 1982 abfd->flags |= DYNAMIC; 1983 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)) 1984 { 1985 struct internal_aouthdr *internal_a = 1986 (struct internal_aouthdr *) aouthdr; 1987 struct xcoff_tdata *xcoff; 1988 1989 xcoff = xcoff_data (abfd); 1990 # ifdef U803XTOCMAGIC 1991 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC; 1992 # else 1993 xcoff->xcoff64 = 0; 1994 # endif 1995 xcoff->full_aouthdr = TRUE; 1996 xcoff->toc = internal_a->o_toc; 1997 xcoff->sntoc = internal_a->o_sntoc; 1998 xcoff->snentry = internal_a->o_snentry; 1999 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext; 2000 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata; 2001 xcoff->modtype = internal_a->o_modtype; 2002 xcoff->cputype = internal_a->o_cputype; 2003 xcoff->maxdata = internal_a->o_maxdata; 2004 xcoff->maxstack = internal_a->o_maxstack; 2005 } 2006 #endif 2007 2008 #ifdef ARM 2009 /* Set the flags field from the COFF header read in. */ 2010 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 2011 coff->flags = 0; 2012 #endif 2013 2014 #ifdef COFF_WITH_PE 2015 /* FIXME: I'm not sure this is ever executed, since peicode.h 2016 defines coff_mkobject_hook. */ 2017 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 2018 abfd->flags |= HAS_DEBUG; 2019 #endif 2020 2021 if ((internal_f->f_flags & F_GO32STUB) != 0) 2022 coff->go32stub = (char *) bfd_alloc (abfd, (bfd_size_type) GO32_STUBSIZE); 2023 if (coff->go32stub != NULL) 2024 memcpy (coff->go32stub, internal_f->go32stub, GO32_STUBSIZE); 2025 2026 return coff; 2027 } 2028 #endif 2029 2030 /* Determine the machine architecture and type. FIXME: This is target 2031 dependent because the magic numbers are defined in the target 2032 dependent header files. But there is no particular need for this. 2033 If the magic numbers were moved to a separate file, this function 2034 would be target independent and would also be much more successful 2035 at linking together COFF files for different architectures. */ 2036 2037 static bfd_boolean 2038 coff_set_arch_mach_hook (bfd *abfd, void * filehdr) 2039 { 2040 unsigned long machine; 2041 enum bfd_architecture arch; 2042 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 2043 2044 /* Zero selects the default machine for an arch. */ 2045 machine = 0; 2046 switch (internal_f->f_magic) 2047 { 2048 #ifdef OR32_MAGIC_BIG 2049 case OR32_MAGIC_BIG: 2050 case OR32_MAGIC_LITTLE: 2051 arch = bfd_arch_or32; 2052 break; 2053 #endif 2054 #ifdef PPCMAGIC 2055 case PPCMAGIC: 2056 arch = bfd_arch_powerpc; 2057 break; 2058 #endif 2059 #ifdef I386MAGIC 2060 case I386MAGIC: 2061 case I386PTXMAGIC: 2062 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler. */ 2063 case LYNXCOFFMAGIC: /* Shadows the m68k Lynx number below, sigh. */ 2064 arch = bfd_arch_i386; 2065 break; 2066 #endif 2067 #ifdef AMD64MAGIC 2068 case AMD64MAGIC: 2069 arch = bfd_arch_i386; 2070 machine = bfd_mach_x86_64; 2071 break; 2072 #endif 2073 #ifdef IA64MAGIC 2074 case IA64MAGIC: 2075 arch = bfd_arch_ia64; 2076 break; 2077 #endif 2078 #ifdef ARMMAGIC 2079 case ARMMAGIC: 2080 case ARMPEMAGIC: 2081 case THUMBPEMAGIC: 2082 arch = bfd_arch_arm; 2083 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 2084 if (machine == bfd_mach_arm_unknown) 2085 { 2086 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 2087 { 2088 case F_ARM_2: machine = bfd_mach_arm_2; break; 2089 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 2090 case F_ARM_3: machine = bfd_mach_arm_3; break; 2091 default: 2092 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 2093 case F_ARM_4: machine = bfd_mach_arm_4; break; 2094 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 2095 /* The COFF header does not have enough bits available 2096 to cover all the different ARM architectures. So 2097 we interpret F_ARM_5, the highest flag value to mean 2098 "the highest ARM architecture known to BFD" which is 2099 currently the XScale. */ 2100 case F_ARM_5: machine = bfd_mach_arm_XScale; break; 2101 } 2102 } 2103 break; 2104 #endif 2105 #ifdef MC68MAGIC 2106 case MC68MAGIC: 2107 case M68MAGIC: 2108 #ifdef MC68KBCSMAGIC 2109 case MC68KBCSMAGIC: 2110 #endif 2111 #ifdef APOLLOM68KMAGIC 2112 case APOLLOM68KMAGIC: 2113 #endif 2114 #ifdef LYNXCOFFMAGIC 2115 case LYNXCOFFMAGIC: 2116 #endif 2117 arch = bfd_arch_m68k; 2118 machine = bfd_mach_m68020; 2119 break; 2120 #endif 2121 #ifdef MC88MAGIC 2122 case MC88MAGIC: 2123 case MC88DMAGIC: 2124 case MC88OMAGIC: 2125 arch = bfd_arch_m88k; 2126 machine = 88100; 2127 break; 2128 #endif 2129 #ifdef Z80MAGIC 2130 case Z80MAGIC: 2131 arch = bfd_arch_z80; 2132 switch (internal_f->f_flags & F_MACHMASK) 2133 { 2134 case 0: 2135 case bfd_mach_z80strict << 12: 2136 case bfd_mach_z80 << 12: 2137 case bfd_mach_z80full << 12: 2138 case bfd_mach_r800 << 12: 2139 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12; 2140 break; 2141 default: 2142 return FALSE; 2143 } 2144 break; 2145 #endif 2146 #ifdef Z8KMAGIC 2147 case Z8KMAGIC: 2148 arch = bfd_arch_z8k; 2149 switch (internal_f->f_flags & F_MACHMASK) 2150 { 2151 case F_Z8001: 2152 machine = bfd_mach_z8001; 2153 break; 2154 case F_Z8002: 2155 machine = bfd_mach_z8002; 2156 break; 2157 default: 2158 return FALSE; 2159 } 2160 break; 2161 #endif 2162 #ifdef I860 2163 case I860MAGIC: 2164 arch = bfd_arch_i860; 2165 break; 2166 #endif 2167 #ifdef I960 2168 #ifdef I960ROMAGIC 2169 case I960ROMAGIC: 2170 case I960RWMAGIC: 2171 arch = bfd_arch_i960; 2172 switch (F_I960TYPE & internal_f->f_flags) 2173 { 2174 default: 2175 case F_I960CORE: 2176 machine = bfd_mach_i960_core; 2177 break; 2178 case F_I960KB: 2179 machine = bfd_mach_i960_kb_sb; 2180 break; 2181 case F_I960MC: 2182 machine = bfd_mach_i960_mc; 2183 break; 2184 case F_I960XA: 2185 machine = bfd_mach_i960_xa; 2186 break; 2187 case F_I960CA: 2188 machine = bfd_mach_i960_ca; 2189 break; 2190 case F_I960KA: 2191 machine = bfd_mach_i960_ka_sa; 2192 break; 2193 case F_I960JX: 2194 machine = bfd_mach_i960_jx; 2195 break; 2196 case F_I960HX: 2197 machine = bfd_mach_i960_hx; 2198 break; 2199 } 2200 break; 2201 #endif 2202 #endif 2203 2204 #ifdef RS6000COFF_C 2205 #ifdef XCOFF64 2206 case U64_TOCMAGIC: 2207 case U803XTOCMAGIC: 2208 #else 2209 case U802ROMAGIC: 2210 case U802WRMAGIC: 2211 case U802TOCMAGIC: 2212 #endif 2213 { 2214 int cputype; 2215 2216 if (xcoff_data (abfd)->cputype != -1) 2217 cputype = xcoff_data (abfd)->cputype & 0xff; 2218 else 2219 { 2220 /* We did not get a value from the a.out header. If the 2221 file has not been stripped, we may be able to get the 2222 architecture information from the first symbol, if it 2223 is a .file symbol. */ 2224 if (obj_raw_syment_count (abfd) == 0) 2225 cputype = 0; 2226 else 2227 { 2228 bfd_byte *buf; 2229 struct internal_syment sym; 2230 bfd_size_type amt = bfd_coff_symesz (abfd); 2231 2232 buf = bfd_malloc (amt); 2233 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 2234 || bfd_bread (buf, amt, abfd) != amt) 2235 { 2236 free (buf); 2237 return FALSE; 2238 } 2239 bfd_coff_swap_sym_in (abfd, buf, & sym); 2240 if (sym.n_sclass == C_FILE) 2241 cputype = sym.n_type & 0xff; 2242 else 2243 cputype = 0; 2244 free (buf); 2245 } 2246 } 2247 2248 /* FIXME: We don't handle all cases here. */ 2249 switch (cputype) 2250 { 2251 default: 2252 case 0: 2253 arch = bfd_xcoff_architecture (abfd); 2254 machine = bfd_xcoff_machine (abfd); 2255 break; 2256 2257 case 1: 2258 arch = bfd_arch_powerpc; 2259 machine = bfd_mach_ppc_601; 2260 break; 2261 case 2: /* 64 bit PowerPC */ 2262 arch = bfd_arch_powerpc; 2263 machine = bfd_mach_ppc_620; 2264 break; 2265 case 3: 2266 arch = bfd_arch_powerpc; 2267 machine = bfd_mach_ppc; 2268 break; 2269 case 4: 2270 arch = bfd_arch_rs6000; 2271 machine = bfd_mach_rs6k; 2272 break; 2273 } 2274 } 2275 break; 2276 #endif 2277 2278 #ifdef WE32KMAGIC 2279 case WE32KMAGIC: 2280 arch = bfd_arch_we32k; 2281 break; 2282 #endif 2283 2284 #ifdef H8300MAGIC 2285 case H8300MAGIC: 2286 arch = bfd_arch_h8300; 2287 machine = bfd_mach_h8300; 2288 /* !! FIXME this probably isn't the right place for this. */ 2289 abfd->flags |= BFD_IS_RELAXABLE; 2290 break; 2291 #endif 2292 2293 #ifdef H8300HMAGIC 2294 case H8300HMAGIC: 2295 arch = bfd_arch_h8300; 2296 machine = bfd_mach_h8300h; 2297 /* !! FIXME this probably isn't the right place for this. */ 2298 abfd->flags |= BFD_IS_RELAXABLE; 2299 break; 2300 #endif 2301 2302 #ifdef H8300SMAGIC 2303 case H8300SMAGIC: 2304 arch = bfd_arch_h8300; 2305 machine = bfd_mach_h8300s; 2306 /* !! FIXME this probably isn't the right place for this. */ 2307 abfd->flags |= BFD_IS_RELAXABLE; 2308 break; 2309 #endif 2310 2311 #ifdef H8300HNMAGIC 2312 case H8300HNMAGIC: 2313 arch = bfd_arch_h8300; 2314 machine = bfd_mach_h8300hn; 2315 /* !! FIXME this probably isn't the right place for this. */ 2316 abfd->flags |= BFD_IS_RELAXABLE; 2317 break; 2318 #endif 2319 2320 #ifdef H8300SNMAGIC 2321 case H8300SNMAGIC: 2322 arch = bfd_arch_h8300; 2323 machine = bfd_mach_h8300sn; 2324 /* !! FIXME this probably isn't the right place for this. */ 2325 abfd->flags |= BFD_IS_RELAXABLE; 2326 break; 2327 #endif 2328 2329 #ifdef SH_ARCH_MAGIC_BIG 2330 case SH_ARCH_MAGIC_BIG: 2331 case SH_ARCH_MAGIC_LITTLE: 2332 #ifdef COFF_WITH_PE 2333 case SH_ARCH_MAGIC_WINCE: 2334 #endif 2335 arch = bfd_arch_sh; 2336 break; 2337 #endif 2338 2339 #ifdef MIPS_ARCH_MAGIC_WINCE 2340 case MIPS_ARCH_MAGIC_WINCE: 2341 arch = bfd_arch_mips; 2342 break; 2343 #endif 2344 2345 #ifdef H8500MAGIC 2346 case H8500MAGIC: 2347 arch = bfd_arch_h8500; 2348 break; 2349 #endif 2350 2351 #ifdef SPARCMAGIC 2352 case SPARCMAGIC: 2353 #ifdef LYNXCOFFMAGIC 2354 case LYNXCOFFMAGIC: 2355 #endif 2356 arch = bfd_arch_sparc; 2357 break; 2358 #endif 2359 2360 #ifdef TIC30MAGIC 2361 case TIC30MAGIC: 2362 arch = bfd_arch_tic30; 2363 break; 2364 #endif 2365 2366 #ifdef TICOFF0MAGIC 2367 #ifdef TICOFF_TARGET_ARCH 2368 /* This TI COFF section should be used by all new TI COFF v0 targets. */ 2369 case TICOFF0MAGIC: 2370 arch = TICOFF_TARGET_ARCH; 2371 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2372 break; 2373 #endif 2374 #endif 2375 2376 #ifdef TICOFF1MAGIC 2377 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */ 2378 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */ 2379 case TICOFF1MAGIC: 2380 case TICOFF2MAGIC: 2381 switch (internal_f->f_target_id) 2382 { 2383 #ifdef TI_TARGET_ID 2384 case TI_TARGET_ID: 2385 arch = TICOFF_TARGET_ARCH; 2386 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2387 break; 2388 #endif 2389 default: 2390 arch = bfd_arch_obscure; 2391 (*_bfd_error_handler) 2392 (_("Unrecognized TI COFF target id '0x%x'"), 2393 internal_f->f_target_id); 2394 break; 2395 } 2396 break; 2397 #endif 2398 2399 #ifdef TIC80_ARCH_MAGIC 2400 case TIC80_ARCH_MAGIC: 2401 arch = bfd_arch_tic80; 2402 break; 2403 #endif 2404 2405 #ifdef MCOREMAGIC 2406 case MCOREMAGIC: 2407 arch = bfd_arch_mcore; 2408 break; 2409 #endif 2410 2411 #ifdef W65MAGIC 2412 case W65MAGIC: 2413 arch = bfd_arch_w65; 2414 break; 2415 #endif 2416 2417 default: /* Unreadable input file type. */ 2418 arch = bfd_arch_obscure; 2419 break; 2420 } 2421 2422 bfd_default_set_arch_mach (abfd, arch, machine); 2423 return TRUE; 2424 } 2425 2426 #ifdef SYMNAME_IN_DEBUG 2427 2428 static bfd_boolean 2429 symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym) 2430 { 2431 return SYMNAME_IN_DEBUG (sym) != 0; 2432 } 2433 2434 #else 2435 2436 #define symname_in_debug_hook \ 2437 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false 2438 2439 #endif 2440 2441 #ifdef RS6000COFF_C 2442 2443 #ifdef XCOFF64 2444 #define FORCE_SYMNAMES_IN_STRINGS 2445 #endif 2446 2447 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */ 2448 2449 static bfd_boolean 2450 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2451 combined_entry_type *table_base, 2452 combined_entry_type *symbol, 2453 unsigned int indaux, 2454 combined_entry_type *aux) 2455 { 2456 int n_sclass = symbol->u.syment.n_sclass; 2457 2458 if (CSECT_SYM_P (n_sclass) 2459 && indaux + 1 == symbol->u.syment.n_numaux) 2460 { 2461 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 2462 { 2463 aux->u.auxent.x_csect.x_scnlen.p = 2464 table_base + aux->u.auxent.x_csect.x_scnlen.l; 2465 aux->fix_scnlen = 1; 2466 } 2467 2468 /* Return TRUE to indicate that the caller should not do any 2469 further work on this auxent. */ 2470 return TRUE; 2471 } 2472 2473 /* Return FALSE to indicate that this auxent should be handled by 2474 the caller. */ 2475 return FALSE; 2476 } 2477 2478 #else 2479 #ifdef I960 2480 2481 /* We don't want to pointerize bal entries. */ 2482 2483 static bfd_boolean 2484 coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2485 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2486 combined_entry_type *symbol, 2487 unsigned int indaux, 2488 combined_entry_type *aux ATTRIBUTE_UNUSED) 2489 { 2490 /* Return TRUE if we don't want to pointerize this aux entry, which 2491 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 2492 return (indaux == 1 2493 && (symbol->u.syment.n_sclass == C_LEAFPROC 2494 || symbol->u.syment.n_sclass == C_LEAFSTAT 2495 || symbol->u.syment.n_sclass == C_LEAFEXT)); 2496 } 2497 2498 #else /* ! I960 */ 2499 2500 #define coff_pointerize_aux_hook 0 2501 2502 #endif /* ! I960 */ 2503 #endif /* ! RS6000COFF_C */ 2504 2505 /* Print an aux entry. This returns TRUE if it has printed it. */ 2506 2507 static bfd_boolean 2508 coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED, 2509 FILE *file ATTRIBUTE_UNUSED, 2510 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2511 combined_entry_type *symbol ATTRIBUTE_UNUSED, 2512 combined_entry_type *aux ATTRIBUTE_UNUSED, 2513 unsigned int indaux ATTRIBUTE_UNUSED) 2514 { 2515 #ifdef RS6000COFF_C 2516 if (CSECT_SYM_P (symbol->u.syment.n_sclass) 2517 && indaux + 1 == symbol->u.syment.n_numaux) 2518 { 2519 /* This is a csect entry. */ 2520 fprintf (file, "AUX "); 2521 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 2522 { 2523 BFD_ASSERT (! aux->fix_scnlen); 2524 #ifdef XCOFF64 2525 fprintf (file, "val %5lld", 2526 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2527 #else 2528 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2529 #endif 2530 } 2531 else 2532 { 2533 fprintf (file, "indx "); 2534 if (! aux->fix_scnlen) 2535 #ifdef XCOFF64 2536 fprintf (file, "%4lld", 2537 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2538 #else 2539 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2540 #endif 2541 else 2542 fprintf (file, "%4ld", 2543 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 2544 } 2545 fprintf (file, 2546 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 2547 aux->u.auxent.x_csect.x_parmhash, 2548 (unsigned int) aux->u.auxent.x_csect.x_snhash, 2549 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 2550 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 2551 (unsigned int) aux->u.auxent.x_csect.x_smclas, 2552 aux->u.auxent.x_csect.x_stab, 2553 (unsigned int) aux->u.auxent.x_csect.x_snstab); 2554 return TRUE; 2555 } 2556 #endif 2557 2558 /* Return FALSE to indicate that no special action was taken. */ 2559 return FALSE; 2560 } 2561 2562 /* 2563 SUBSUBSECTION 2564 Writing relocations 2565 2566 To write relocations, the back end steps though the 2567 canonical relocation table and create an 2568 @code{internal_reloc}. The symbol index to use is removed from 2569 the @code{offset} field in the symbol table supplied. The 2570 address comes directly from the sum of the section base 2571 address and the relocation offset; the type is dug directly 2572 from the howto field. Then the @code{internal_reloc} is 2573 swapped into the shape of an @code{external_reloc} and written 2574 out to disk. 2575 2576 */ 2577 2578 #ifdef TARG_AUX 2579 2580 2581 /* AUX's ld wants relocations to be sorted. */ 2582 static int 2583 compare_arelent_ptr (const void * x, const void * y) 2584 { 2585 const arelent **a = (const arelent **) x; 2586 const arelent **b = (const arelent **) y; 2587 bfd_size_type aadr = (*a)->address; 2588 bfd_size_type badr = (*b)->address; 2589 2590 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 2591 } 2592 2593 #endif /* TARG_AUX */ 2594 2595 static bfd_boolean 2596 coff_write_relocs (bfd * abfd, int first_undef) 2597 { 2598 asection *s; 2599 2600 for (s = abfd->sections; s != NULL; s = s->next) 2601 { 2602 unsigned int i; 2603 struct external_reloc dst; 2604 arelent **p; 2605 2606 #ifndef TARG_AUX 2607 p = s->orelocation; 2608 #else 2609 { 2610 /* Sort relocations before we write them out. */ 2611 bfd_size_type amt; 2612 2613 amt = s->reloc_count; 2614 amt *= sizeof (arelent *); 2615 p = bfd_malloc (amt); 2616 if (p == NULL && s->reloc_count > 0) 2617 return FALSE; 2618 memcpy (p, s->orelocation, (size_t) amt); 2619 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 2620 } 2621 #endif 2622 2623 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 2624 return FALSE; 2625 2626 #ifdef COFF_WITH_PE 2627 if (obj_pe (abfd) && s->reloc_count >= 0xffff) 2628 { 2629 /* Encode real count here as first reloc. */ 2630 struct internal_reloc n; 2631 2632 memset (& n, 0, sizeof (n)); 2633 /* Add one to count *this* reloc (grr). */ 2634 n.r_vaddr = s->reloc_count + 1; 2635 coff_swap_reloc_out (abfd, &n, &dst); 2636 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2637 abfd) != bfd_coff_relsz (abfd)) 2638 return FALSE; 2639 } 2640 #endif 2641 2642 for (i = 0; i < s->reloc_count; i++) 2643 { 2644 struct internal_reloc n; 2645 arelent *q = p[i]; 2646 2647 memset (& n, 0, sizeof (n)); 2648 2649 /* Now we've renumbered the symbols we know where the 2650 undefined symbols live in the table. Check the reloc 2651 entries for symbols who's output bfd isn't the right one. 2652 This is because the symbol was undefined (which means 2653 that all the pointers are never made to point to the same 2654 place). This is a bad thing,'cause the symbols attached 2655 to the output bfd are indexed, so that the relocation 2656 entries know which symbol index they point to. So we 2657 have to look up the output symbol here. */ 2658 2659 if (q->sym_ptr_ptr[0] != NULL && q->sym_ptr_ptr[0]->the_bfd != abfd) 2660 { 2661 int j; 2662 const char *sname = q->sym_ptr_ptr[0]->name; 2663 asymbol **outsyms = abfd->outsymbols; 2664 2665 for (j = first_undef; outsyms[j]; j++) 2666 { 2667 const char *intable = outsyms[j]->name; 2668 2669 if (strcmp (intable, sname) == 0) 2670 { 2671 /* Got a hit, so repoint the reloc. */ 2672 q->sym_ptr_ptr = outsyms + j; 2673 break; 2674 } 2675 } 2676 } 2677 2678 n.r_vaddr = q->address + s->vma; 2679 2680 #ifdef R_IHCONST 2681 /* The 29k const/consth reloc pair is a real kludge. The consth 2682 part doesn't have a symbol; it has an offset. So rebuilt 2683 that here. */ 2684 if (q->howto->type == R_IHCONST) 2685 n.r_symndx = q->addend; 2686 else 2687 #endif 2688 if (q->sym_ptr_ptr && q->sym_ptr_ptr[0] != NULL) 2689 { 2690 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P 2691 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s)) 2692 #else 2693 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr 2694 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0) 2695 #endif 2696 /* This is a relocation relative to the absolute symbol. */ 2697 n.r_symndx = -1; 2698 else 2699 { 2700 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 2701 /* Check to see if the symbol reloc points to a symbol 2702 we don't have in our symbol table. */ 2703 if (n.r_symndx > obj_conv_table_size (abfd)) 2704 { 2705 bfd_set_error (bfd_error_bad_value); 2706 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"), 2707 abfd, n.r_symndx); 2708 return FALSE; 2709 } 2710 } 2711 } 2712 2713 #ifdef SWAP_OUT_RELOC_OFFSET 2714 n.r_offset = q->addend; 2715 #endif 2716 2717 #ifdef SELECT_RELOC 2718 /* Work out reloc type from what is required. */ 2719 SELECT_RELOC (n, q->howto); 2720 #else 2721 n.r_type = q->howto->type; 2722 #endif 2723 coff_swap_reloc_out (abfd, &n, &dst); 2724 2725 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2726 abfd) != bfd_coff_relsz (abfd)) 2727 return FALSE; 2728 } 2729 2730 #ifdef TARG_AUX 2731 if (p != NULL) 2732 free (p); 2733 #endif 2734 } 2735 2736 return TRUE; 2737 } 2738 2739 /* Set flags and magic number of a coff file from architecture and machine 2740 type. Result is TRUE if we can represent the arch&type, FALSE if not. */ 2741 2742 static bfd_boolean 2743 coff_set_flags (bfd * abfd, 2744 unsigned int *magicp ATTRIBUTE_UNUSED, 2745 unsigned short *flagsp ATTRIBUTE_UNUSED) 2746 { 2747 switch (bfd_get_arch (abfd)) 2748 { 2749 #ifdef Z80MAGIC 2750 case bfd_arch_z80: 2751 *magicp = Z80MAGIC; 2752 switch (bfd_get_mach (abfd)) 2753 { 2754 case 0: 2755 case bfd_mach_z80strict: 2756 case bfd_mach_z80: 2757 case bfd_mach_z80full: 2758 case bfd_mach_r800: 2759 *flagsp = bfd_get_mach (abfd) << 12; 2760 break; 2761 default: 2762 return FALSE; 2763 } 2764 return TRUE; 2765 #endif 2766 2767 #ifdef Z8KMAGIC 2768 case bfd_arch_z8k: 2769 *magicp = Z8KMAGIC; 2770 2771 switch (bfd_get_mach (abfd)) 2772 { 2773 case bfd_mach_z8001: *flagsp = F_Z8001; break; 2774 case bfd_mach_z8002: *flagsp = F_Z8002; break; 2775 default: return FALSE; 2776 } 2777 return TRUE; 2778 #endif 2779 2780 #ifdef I960ROMAGIC 2781 case bfd_arch_i960: 2782 2783 { 2784 unsigned flags; 2785 2786 *magicp = I960ROMAGIC; 2787 2788 switch (bfd_get_mach (abfd)) 2789 { 2790 case bfd_mach_i960_core: flags = F_I960CORE; break; 2791 case bfd_mach_i960_kb_sb: flags = F_I960KB; break; 2792 case bfd_mach_i960_mc: flags = F_I960MC; break; 2793 case bfd_mach_i960_xa: flags = F_I960XA; break; 2794 case bfd_mach_i960_ca: flags = F_I960CA; break; 2795 case bfd_mach_i960_ka_sa: flags = F_I960KA; break; 2796 case bfd_mach_i960_jx: flags = F_I960JX; break; 2797 case bfd_mach_i960_hx: flags = F_I960HX; break; 2798 default: return FALSE; 2799 } 2800 *flagsp = flags; 2801 return TRUE; 2802 } 2803 break; 2804 #endif 2805 2806 #ifdef TIC30MAGIC 2807 case bfd_arch_tic30: 2808 *magicp = TIC30MAGIC; 2809 return TRUE; 2810 #endif 2811 2812 #ifdef TICOFF_DEFAULT_MAGIC 2813 case TICOFF_TARGET_ARCH: 2814 /* If there's no indication of which version we want, use the default. */ 2815 if (!abfd->xvec ) 2816 *magicp = TICOFF_DEFAULT_MAGIC; 2817 else 2818 { 2819 /* We may want to output in a different COFF version. */ 2820 switch (abfd->xvec->name[4]) 2821 { 2822 case '0': 2823 *magicp = TICOFF0MAGIC; 2824 break; 2825 case '1': 2826 *magicp = TICOFF1MAGIC; 2827 break; 2828 case '2': 2829 *magicp = TICOFF2MAGIC; 2830 break; 2831 default: 2832 return FALSE; 2833 } 2834 } 2835 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd)); 2836 return TRUE; 2837 #endif 2838 2839 #ifdef TIC80_ARCH_MAGIC 2840 case bfd_arch_tic80: 2841 *magicp = TIC80_ARCH_MAGIC; 2842 return TRUE; 2843 #endif 2844 2845 #ifdef ARMMAGIC 2846 case bfd_arch_arm: 2847 #ifdef ARM_WINCE 2848 * magicp = ARMPEMAGIC; 2849 #else 2850 * magicp = ARMMAGIC; 2851 #endif 2852 * flagsp = 0; 2853 if (APCS_SET (abfd)) 2854 { 2855 if (APCS_26_FLAG (abfd)) 2856 * flagsp |= F_APCS26; 2857 2858 if (APCS_FLOAT_FLAG (abfd)) 2859 * flagsp |= F_APCS_FLOAT; 2860 2861 if (PIC_FLAG (abfd)) 2862 * flagsp |= F_PIC; 2863 } 2864 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2865 * flagsp |= F_INTERWORK; 2866 switch (bfd_get_mach (abfd)) 2867 { 2868 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2869 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2870 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2871 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2872 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2873 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2874 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; 2875 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. 2876 See also the comment in coff_set_arch_mach_hook(). */ 2877 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; 2878 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; 2879 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; 2880 } 2881 return TRUE; 2882 #endif 2883 2884 #ifdef PPCMAGIC 2885 case bfd_arch_powerpc: 2886 *magicp = PPCMAGIC; 2887 return TRUE; 2888 #endif 2889 2890 #if defined(I386MAGIC) || defined(AMD64MAGIC) 2891 case bfd_arch_i386: 2892 #if defined(I386MAGIC) 2893 *magicp = I386MAGIC; 2894 #endif 2895 #if defined LYNXOS 2896 /* Just overwrite the usual value if we're doing Lynx. */ 2897 *magicp = LYNXCOFFMAGIC; 2898 #endif 2899 #if defined AMD64MAGIC 2900 *magicp = AMD64MAGIC; 2901 #endif 2902 return TRUE; 2903 #endif 2904 2905 #ifdef I860MAGIC 2906 case bfd_arch_i860: 2907 *magicp = I860MAGIC; 2908 return TRUE; 2909 #endif 2910 2911 #ifdef IA64MAGIC 2912 case bfd_arch_ia64: 2913 *magicp = IA64MAGIC; 2914 return TRUE; 2915 #endif 2916 2917 #ifdef MC68MAGIC 2918 case bfd_arch_m68k: 2919 #ifdef APOLLOM68KMAGIC 2920 *magicp = APOLLO_COFF_VERSION_NUMBER; 2921 #else 2922 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2923 #ifdef NAMES_HAVE_UNDERSCORE 2924 *magicp = MC68KBCSMAGIC; 2925 #else 2926 *magicp = MC68MAGIC; 2927 #endif 2928 #endif 2929 #ifdef LYNXOS 2930 /* Just overwrite the usual value if we're doing Lynx. */ 2931 *magicp = LYNXCOFFMAGIC; 2932 #endif 2933 return TRUE; 2934 #endif 2935 2936 #ifdef MC88MAGIC 2937 case bfd_arch_m88k: 2938 *magicp = MC88OMAGIC; 2939 return TRUE; 2940 #endif 2941 2942 #ifdef H8300MAGIC 2943 case bfd_arch_h8300: 2944 switch (bfd_get_mach (abfd)) 2945 { 2946 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE; 2947 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE; 2948 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE; 2949 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE; 2950 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE; 2951 default: break; 2952 } 2953 break; 2954 #endif 2955 2956 #ifdef SH_ARCH_MAGIC_BIG 2957 case bfd_arch_sh: 2958 #ifdef COFF_IMAGE_WITH_PE 2959 *magicp = SH_ARCH_MAGIC_WINCE; 2960 #else 2961 if (bfd_big_endian (abfd)) 2962 *magicp = SH_ARCH_MAGIC_BIG; 2963 else 2964 *magicp = SH_ARCH_MAGIC_LITTLE; 2965 #endif 2966 return TRUE; 2967 #endif 2968 2969 #ifdef MIPS_ARCH_MAGIC_WINCE 2970 case bfd_arch_mips: 2971 *magicp = MIPS_ARCH_MAGIC_WINCE; 2972 return TRUE; 2973 #endif 2974 2975 #ifdef SPARCMAGIC 2976 case bfd_arch_sparc: 2977 *magicp = SPARCMAGIC; 2978 #ifdef LYNXOS 2979 /* Just overwrite the usual value if we're doing Lynx. */ 2980 *magicp = LYNXCOFFMAGIC; 2981 #endif 2982 return TRUE; 2983 #endif 2984 2985 #ifdef H8500MAGIC 2986 case bfd_arch_h8500: 2987 *magicp = H8500MAGIC; 2988 return TRUE; 2989 break; 2990 #endif 2991 2992 #ifdef WE32KMAGIC 2993 case bfd_arch_we32k: 2994 *magicp = WE32KMAGIC; 2995 return TRUE; 2996 #endif 2997 2998 #ifdef RS6000COFF_C 2999 case bfd_arch_rs6000: 3000 #ifndef PPCMAGIC 3001 case bfd_arch_powerpc: 3002 #endif 3003 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour); 3004 *magicp = bfd_xcoff_magic_number (abfd); 3005 return TRUE; 3006 #endif 3007 3008 #ifdef MCOREMAGIC 3009 case bfd_arch_mcore: 3010 * magicp = MCOREMAGIC; 3011 return TRUE; 3012 #endif 3013 3014 #ifdef W65MAGIC 3015 case bfd_arch_w65: 3016 *magicp = W65MAGIC; 3017 return TRUE; 3018 #endif 3019 3020 #ifdef OR32_MAGIC_BIG 3021 case bfd_arch_or32: 3022 if (bfd_big_endian (abfd)) 3023 * magicp = OR32_MAGIC_BIG; 3024 else 3025 * magicp = OR32_MAGIC_LITTLE; 3026 return TRUE; 3027 #endif 3028 3029 default: /* Unknown architecture. */ 3030 /* Fall through to "return FALSE" below, to avoid 3031 "statement never reached" errors on the one below. */ 3032 break; 3033 } 3034 3035 return FALSE; 3036 } 3037 3038 static bfd_boolean 3039 coff_set_arch_mach (bfd * abfd, 3040 enum bfd_architecture arch, 3041 unsigned long machine) 3042 { 3043 unsigned dummy1; 3044 unsigned short dummy2; 3045 3046 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 3047 return FALSE; 3048 3049 if (arch != bfd_arch_unknown 3050 && ! coff_set_flags (abfd, &dummy1, &dummy2)) 3051 return FALSE; /* We can't represent this type. */ 3052 3053 return TRUE; /* We're easy... */ 3054 } 3055 3056 #ifdef COFF_IMAGE_WITH_PE 3057 3058 /* This is used to sort sections by VMA, as required by PE image 3059 files. */ 3060 3061 static int 3062 sort_by_secaddr (const void * arg1, const void * arg2) 3063 { 3064 const asection *a = *(const asection **) arg1; 3065 const asection *b = *(const asection **) arg2; 3066 3067 if (a->vma < b->vma) 3068 return -1; 3069 else if (a->vma > b->vma) 3070 return 1; 3071 3072 return 0; 3073 } 3074 3075 #endif /* COFF_IMAGE_WITH_PE */ 3076 3077 /* Calculate the file position for each section. */ 3078 3079 #ifndef I960 3080 #define ALIGN_SECTIONS_IN_FILE 3081 #endif 3082 #if defined(TIC80COFF) || defined(TICOFF) 3083 #undef ALIGN_SECTIONS_IN_FILE 3084 #endif 3085 3086 static bfd_boolean 3087 coff_compute_section_file_positions (bfd * abfd) 3088 { 3089 asection *current; 3090 file_ptr sofar = bfd_coff_filhsz (abfd); 3091 bfd_boolean align_adjust; 3092 int target_index; 3093 #ifdef ALIGN_SECTIONS_IN_FILE 3094 asection *previous = NULL; 3095 file_ptr old_sofar; 3096 #endif 3097 3098 #ifdef COFF_IMAGE_WITH_PE 3099 int page_size; 3100 3101 if (coff_data (abfd)->link_info) 3102 { 3103 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 3104 3105 /* If no file alignment has been set, default to one. 3106 This repairs 'ld -r' for arm-wince-pe target. */ 3107 if (page_size == 0) 3108 page_size = 1; 3109 } 3110 else 3111 page_size = PE_DEF_FILE_ALIGNMENT; 3112 #else 3113 #ifdef COFF_PAGE_SIZE 3114 int page_size = COFF_PAGE_SIZE; 3115 #endif 3116 #endif 3117 3118 #ifdef RS6000COFF_C 3119 /* On XCOFF, if we have symbols, set up the .debug section. */ 3120 if (bfd_get_symcount (abfd) > 0) 3121 { 3122 bfd_size_type sz; 3123 bfd_size_type i, symcount; 3124 asymbol **symp; 3125 3126 sz = 0; 3127 symcount = bfd_get_symcount (abfd); 3128 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 3129 { 3130 coff_symbol_type *cf; 3131 3132 cf = coff_symbol_from (abfd, *symp); 3133 if (cf != NULL 3134 && cf->native != NULL 3135 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 3136 { 3137 size_t len; 3138 3139 len = strlen (bfd_asymbol_name (*symp)); 3140 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) 3141 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); 3142 } 3143 } 3144 if (sz > 0) 3145 { 3146 asection *dsec; 3147 3148 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG); 3149 if (dsec == NULL) 3150 abort (); 3151 dsec->size = sz; 3152 dsec->flags |= SEC_HAS_CONTENTS; 3153 } 3154 } 3155 #endif 3156 3157 if (bfd_get_start_address (abfd)) 3158 /* A start address may have been added to the original file. In this 3159 case it will need an optional header to record it. */ 3160 abfd->flags |= EXEC_P; 3161 3162 if (abfd->flags & EXEC_P) 3163 sofar += bfd_coff_aoutsz (abfd); 3164 #ifdef RS6000COFF_C 3165 else if (xcoff_data (abfd)->full_aouthdr) 3166 sofar += bfd_coff_aoutsz (abfd); 3167 else 3168 sofar += SMALL_AOUTSZ; 3169 #endif 3170 3171 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 3172 3173 #ifdef RS6000COFF_C 3174 /* XCOFF handles overflows in the reloc and line number count fields 3175 by allocating a new section header to hold the correct counts. */ 3176 for (current = abfd->sections; current != NULL; current = current->next) 3177 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3178 sofar += bfd_coff_scnhsz (abfd); 3179 #endif 3180 3181 #ifdef COFF_IMAGE_WITH_PE 3182 { 3183 /* PE requires the sections to be in memory order when listed in 3184 the section headers. It also does not like empty loadable 3185 sections. The sections apparently do not have to be in the 3186 right order in the image file itself, but we do need to get the 3187 target_index values right. */ 3188 3189 unsigned int count; 3190 asection **section_list; 3191 unsigned int i; 3192 bfd_size_type amt; 3193 3194 #ifdef COFF_PAGE_SIZE 3195 /* Clear D_PAGED if section alignment is smaller than 3196 COFF_PAGE_SIZE. */ 3197 if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE) 3198 abfd->flags &= ~D_PAGED; 3199 #endif 3200 3201 count = 0; 3202 for (current = abfd->sections; current != NULL; current = current->next) 3203 ++count; 3204 3205 /* We allocate an extra cell to simplify the final loop. */ 3206 amt = sizeof (struct asection *) * (count + 1); 3207 section_list = (asection **) bfd_malloc (amt); 3208 if (section_list == NULL) 3209 return FALSE; 3210 3211 i = 0; 3212 for (current = abfd->sections; current != NULL; current = current->next) 3213 { 3214 section_list[i] = current; 3215 ++i; 3216 } 3217 section_list[i] = NULL; 3218 3219 qsort (section_list, count, sizeof (asection *), sort_by_secaddr); 3220 3221 /* Rethread the linked list into sorted order; at the same time, 3222 assign target_index values. */ 3223 target_index = 1; 3224 abfd->sections = NULL; 3225 abfd->section_last = NULL; 3226 for (i = 0; i < count; i++) 3227 { 3228 current = section_list[i]; 3229 bfd_section_list_append (abfd, current); 3230 3231 /* Later, if the section has zero size, we'll be throwing it 3232 away, so we don't want to number it now. Note that having 3233 a zero size and having real contents are different 3234 concepts: .bss has no contents, but (usually) non-zero 3235 size. */ 3236 if (current->size == 0) 3237 { 3238 /* Discard. However, it still might have (valid) symbols 3239 in it, so arbitrarily set it to section 1 (indexing is 3240 1-based here; usually .text). __end__ and other 3241 contents of .endsection really have this happen. 3242 FIXME: This seems somewhat dubious. */ 3243 current->target_index = 1; 3244 } 3245 else 3246 current->target_index = target_index++; 3247 } 3248 3249 free (section_list); 3250 } 3251 #else /* ! COFF_IMAGE_WITH_PE */ 3252 { 3253 /* Set the target_index field. */ 3254 target_index = 1; 3255 for (current = abfd->sections; current != NULL; current = current->next) 3256 current->target_index = target_index++; 3257 } 3258 #endif /* ! COFF_IMAGE_WITH_PE */ 3259 3260 if (target_index >= 32768) 3261 { 3262 bfd_set_error (bfd_error_file_too_big); 3263 (*_bfd_error_handler) 3264 (_("%B: too many sections (%d)"), abfd, target_index); 3265 return FALSE; 3266 } 3267 3268 align_adjust = FALSE; 3269 for (current = abfd->sections; 3270 current != NULL; 3271 current = current->next) 3272 { 3273 #ifdef COFF_IMAGE_WITH_PE 3274 /* With PE we have to pad each section to be a multiple of its 3275 page size too, and remember both sizes. */ 3276 if (coff_section_data (abfd, current) == NULL) 3277 { 3278 bfd_size_type amt = sizeof (struct coff_section_tdata); 3279 3280 current->used_by_bfd = bfd_zalloc (abfd, amt); 3281 if (current->used_by_bfd == NULL) 3282 return FALSE; 3283 } 3284 if (pei_section_data (abfd, current) == NULL) 3285 { 3286 bfd_size_type amt = sizeof (struct pei_section_tdata); 3287 3288 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt); 3289 if (coff_section_data (abfd, current)->tdata == NULL) 3290 return FALSE; 3291 } 3292 if (pei_section_data (abfd, current)->virt_size == 0) 3293 pei_section_data (abfd, current)->virt_size = current->size; 3294 #endif 3295 3296 /* Only deal with sections which have contents. */ 3297 if (!(current->flags & SEC_HAS_CONTENTS)) 3298 continue; 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 #ifdef RS6000COFF_C 4900 /* XCOFF specific: deleted entry. */ 4901 if (src->u.syment.n_value == C_NULL_VALUE) 4902 break; 4903 #endif 4904 /* Fall through. */ 4905 case C_EXTDEF: /* External definition. */ 4906 case C_ULABEL: /* Undefined label. */ 4907 case C_USTATIC: /* Undefined static. */ 4908 #ifndef COFF_WITH_PE 4909 /* C_LINE in regular coff is 0x68. NT has taken over this storage 4910 class to represent a section symbol. */ 4911 case C_LINE: /* line # reformatted as symbol table entry. */ 4912 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 4913 case C_ALIAS: /* Duplicate tag. */ 4914 #endif 4915 /* New storage classes for TI COFF. */ 4916 #if defined(TIC80COFF) || defined(TICOFF) 4917 case C_UEXT: /* Tentative external definition. */ 4918 #endif 4919 case C_EXTLAB: /* External load time label. */ 4920 case C_HIDDEN: /* Ext symbol in dmert public lib. */ 4921 default: 4922 (*_bfd_error_handler) 4923 (_("%B: Unrecognized storage class %d for %s symbol `%s'"), 4924 abfd, src->u.syment.n_sclass, 4925 dst->symbol.section->name, dst->symbol.name); 4926 dst->symbol.flags = BSF_DEBUGGING; 4927 dst->symbol.value = (src->u.syment.n_value); 4928 break; 4929 } 4930 4931 dst->native = src; 4932 4933 dst->symbol.udata.i = 0; 4934 dst->lineno = NULL; 4935 this_index += (src->u.syment.n_numaux) + 1; 4936 dst++; 4937 number_of_symbols++; 4938 } 4939 } 4940 4941 obj_symbols (abfd) = cached_area; 4942 obj_raw_syments (abfd) = native_symbols; 4943 4944 bfd_get_symcount (abfd) = number_of_symbols; 4945 obj_convert (abfd) = table_ptr; 4946 /* Slurp the line tables for each section too. */ 4947 { 4948 asection *p; 4949 4950 p = abfd->sections; 4951 while (p) 4952 { 4953 coff_slurp_line_table (abfd, p); 4954 p = p->next; 4955 } 4956 } 4957 4958 return TRUE; 4959 } 4960 4961 /* Classify a COFF symbol. A couple of targets have globally visible 4962 symbols which are not class C_EXT, and this handles those. It also 4963 recognizes some special PE cases. */ 4964 4965 static enum coff_symbol_classification 4966 coff_classify_symbol (bfd *abfd, 4967 struct internal_syment *syment) 4968 { 4969 /* FIXME: This partially duplicates the switch in 4970 coff_slurp_symbol_table. */ 4971 switch (syment->n_sclass) 4972 { 4973 case C_EXT: 4974 case C_WEAKEXT: 4975 #ifdef I960 4976 case C_LEAFEXT: 4977 #endif 4978 #ifdef ARM 4979 case C_THUMBEXT: 4980 case C_THUMBEXTFUNC: 4981 #endif 4982 #ifdef C_SYSTEM 4983 case C_SYSTEM: 4984 #endif 4985 #ifdef COFF_WITH_PE 4986 case C_NT_WEAK: 4987 #endif 4988 if (syment->n_scnum == 0) 4989 { 4990 if (syment->n_value == 0) 4991 return COFF_SYMBOL_UNDEFINED; 4992 else 4993 return COFF_SYMBOL_COMMON; 4994 } 4995 return COFF_SYMBOL_GLOBAL; 4996 4997 default: 4998 break; 4999 } 5000 5001 #ifdef COFF_WITH_PE 5002 if (syment->n_sclass == C_STAT) 5003 { 5004 if (syment->n_scnum == 0) 5005 /* The Microsoft compiler sometimes generates these if a 5006 small static function is inlined every time it is used. 5007 The function is discarded, but the symbol table entry 5008 remains. */ 5009 return COFF_SYMBOL_LOCAL; 5010 5011 #ifdef STRICT_PE_FORMAT 5012 /* This is correct for Microsoft generated objects, but it 5013 breaks gas generated objects. */ 5014 if (syment->n_value == 0) 5015 { 5016 asection *sec; 5017 char buf[SYMNMLEN + 1]; 5018 5019 sec = coff_section_from_bfd_index (abfd, syment->n_scnum); 5020 if (sec != NULL 5021 && (strcmp (bfd_get_section_name (abfd, sec), 5022 _bfd_coff_internal_syment_name (abfd, syment, buf)) 5023 == 0)) 5024 return COFF_SYMBOL_PE_SECTION; 5025 } 5026 #endif 5027 5028 return COFF_SYMBOL_LOCAL; 5029 } 5030 5031 if (syment->n_sclass == C_SECTION) 5032 { 5033 /* In some cases in a DLL generated by the Microsoft linker, the 5034 n_value field will contain garbage. FIXME: This should 5035 probably be handled by the swapping function instead. */ 5036 syment->n_value = 0; 5037 if (syment->n_scnum == 0) 5038 return COFF_SYMBOL_UNDEFINED; 5039 return COFF_SYMBOL_PE_SECTION; 5040 } 5041 #endif /* COFF_WITH_PE */ 5042 5043 /* If it is not a global symbol, we presume it is a local symbol. */ 5044 if (syment->n_scnum == 0) 5045 { 5046 char buf[SYMNMLEN + 1]; 5047 5048 (*_bfd_error_handler) 5049 (_("warning: %B: local symbol `%s' has no section"), 5050 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf)); 5051 } 5052 5053 return COFF_SYMBOL_LOCAL; 5054 } 5055 5056 /* 5057 SUBSUBSECTION 5058 Reading relocations 5059 5060 Coff relocations are easily transformed into the internal BFD form 5061 (@code{arelent}). 5062 5063 Reading a coff relocation table is done in the following stages: 5064 5065 o Read the entire coff relocation table into memory. 5066 5067 o Process each relocation in turn; first swap it from the 5068 external to the internal form. 5069 5070 o Turn the symbol referenced in the relocation's symbol index 5071 into a pointer into the canonical symbol table. 5072 This table is the same as the one returned by a call to 5073 @code{bfd_canonicalize_symtab}. The back end will call that 5074 routine and save the result if a canonicalization hasn't been done. 5075 5076 o The reloc index is turned into a pointer to a howto 5077 structure, in a back end specific way. For instance, the 386 5078 and 960 use the @code{r_type} to directly produce an index 5079 into a howto table vector; the 88k subtracts a number from the 5080 @code{r_type} field and creates an addend field. 5081 */ 5082 5083 #ifndef CALC_ADDEND 5084 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 5085 { \ 5086 coff_symbol_type *coffsym = NULL; \ 5087 \ 5088 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 5089 coffsym = (obj_symbols (abfd) \ 5090 + (cache_ptr->sym_ptr_ptr - symbols)); \ 5091 else if (ptr) \ 5092 coffsym = coff_symbol_from (abfd, ptr); \ 5093 if (coffsym != NULL \ 5094 && coffsym->native->u.syment.n_scnum == 0) \ 5095 cache_ptr->addend = 0; \ 5096 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 5097 && ptr->section != NULL) \ 5098 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 5099 else \ 5100 cache_ptr->addend = 0; \ 5101 } 5102 #endif 5103 5104 static bfd_boolean 5105 coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols) 5106 { 5107 RELOC *native_relocs; 5108 arelent *reloc_cache; 5109 arelent *cache_ptr; 5110 unsigned int idx; 5111 bfd_size_type amt; 5112 5113 if (asect->relocation) 5114 return TRUE; 5115 if (asect->reloc_count == 0) 5116 return TRUE; 5117 if (asect->flags & SEC_CONSTRUCTOR) 5118 return TRUE; 5119 if (!coff_slurp_symbol_table (abfd)) 5120 return FALSE; 5121 5122 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count; 5123 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt); 5124 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent); 5125 reloc_cache = (arelent *) bfd_alloc (abfd, amt); 5126 5127 if (reloc_cache == NULL || native_relocs == NULL) 5128 return FALSE; 5129 5130 for (idx = 0; idx < asect->reloc_count; idx++) 5131 { 5132 struct internal_reloc dst; 5133 struct external_reloc *src; 5134 #ifndef RELOC_PROCESSING 5135 asymbol *ptr; 5136 #endif 5137 5138 cache_ptr = reloc_cache + idx; 5139 src = native_relocs + idx; 5140 5141 dst.r_offset = 0; 5142 coff_swap_reloc_in (abfd, src, &dst); 5143 5144 #ifdef RELOC_PROCESSING 5145 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect); 5146 #else 5147 cache_ptr->address = dst.r_vaddr; 5148 5149 if (dst.r_symndx != -1) 5150 { 5151 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd)) 5152 { 5153 (*_bfd_error_handler) 5154 (_("%B: warning: illegal symbol index %ld in relocs"), 5155 abfd, (long) dst.r_symndx); 5156 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 5157 ptr = NULL; 5158 } 5159 else 5160 { 5161 cache_ptr->sym_ptr_ptr = (symbols 5162 + obj_convert (abfd)[dst.r_symndx]); 5163 ptr = *(cache_ptr->sym_ptr_ptr); 5164 } 5165 } 5166 else 5167 { 5168 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 5169 ptr = NULL; 5170 } 5171 5172 /* The symbols definitions that we have read in have been 5173 relocated as if their sections started at 0. But the offsets 5174 refering to the symbols in the raw data have not been 5175 modified, so we have to have a negative addend to compensate. 5176 5177 Note that symbols which used to be common must be left alone. */ 5178 5179 /* Calculate any reloc addend by looking at the symbol. */ 5180 CALC_ADDEND (abfd, ptr, dst, cache_ptr); 5181 (void) ptr; 5182 5183 cache_ptr->address -= asect->vma; 5184 /* !! cache_ptr->section = NULL;*/ 5185 5186 /* Fill in the cache_ptr->howto field from dst.r_type. */ 5187 RTYPE2HOWTO (cache_ptr, &dst); 5188 #endif /* RELOC_PROCESSING */ 5189 5190 if (cache_ptr->howto == NULL) 5191 { 5192 (*_bfd_error_handler) 5193 (_("%B: illegal relocation type %d at address 0x%lx"), 5194 abfd, dst.r_type, (long) dst.r_vaddr); 5195 bfd_set_error (bfd_error_bad_value); 5196 return FALSE; 5197 } 5198 } 5199 5200 asect->relocation = reloc_cache; 5201 return TRUE; 5202 } 5203 5204 #ifndef coff_rtype_to_howto 5205 #ifdef RTYPE2HOWTO 5206 5207 /* Get the howto structure for a reloc. This is only used if the file 5208 including this one defines coff_relocate_section to be 5209 _bfd_coff_generic_relocate_section, so it is OK if it does not 5210 always work. It is the responsibility of the including file to 5211 make sure it is reasonable if it is needed. */ 5212 5213 static reloc_howto_type * 5214 coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 5215 asection *sec ATTRIBUTE_UNUSED, 5216 struct internal_reloc *rel, 5217 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED, 5218 struct internal_syment *sym ATTRIBUTE_UNUSED, 5219 bfd_vma *addendp ATTRIBUTE_UNUSED) 5220 { 5221 arelent genrel; 5222 5223 genrel.howto = NULL; 5224 RTYPE2HOWTO (&genrel, rel); 5225 return genrel.howto; 5226 } 5227 5228 #else /* ! defined (RTYPE2HOWTO) */ 5229 5230 #define coff_rtype_to_howto NULL 5231 5232 #endif /* ! defined (RTYPE2HOWTO) */ 5233 #endif /* ! defined (coff_rtype_to_howto) */ 5234 5235 /* This is stupid. This function should be a boolean predicate. */ 5236 5237 static long 5238 coff_canonicalize_reloc (bfd * abfd, 5239 sec_ptr section, 5240 arelent ** relptr, 5241 asymbol ** symbols) 5242 { 5243 arelent *tblptr = section->relocation; 5244 unsigned int count = 0; 5245 5246 if (section->flags & SEC_CONSTRUCTOR) 5247 { 5248 /* This section has relocs made up by us, they are not in the 5249 file, so take them out of their chain and place them into 5250 the data area provided. */ 5251 arelent_chain *chain = section->constructor_chain; 5252 5253 for (count = 0; count < section->reloc_count; count++) 5254 { 5255 *relptr++ = &chain->relent; 5256 chain = chain->next; 5257 } 5258 } 5259 else 5260 { 5261 if (! coff_slurp_reloc_table (abfd, section, symbols)) 5262 return -1; 5263 5264 tblptr = section->relocation; 5265 5266 for (; count++ < section->reloc_count;) 5267 *relptr++ = tblptr++; 5268 } 5269 *relptr = 0; 5270 return section->reloc_count; 5271 } 5272 5273 #ifndef coff_reloc16_estimate 5274 #define coff_reloc16_estimate dummy_reloc16_estimate 5275 5276 static int 5277 dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED, 5278 asection *input_section ATTRIBUTE_UNUSED, 5279 arelent *reloc ATTRIBUTE_UNUSED, 5280 unsigned int shrink ATTRIBUTE_UNUSED, 5281 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 5282 { 5283 abort (); 5284 return 0; 5285 } 5286 5287 #endif 5288 5289 #ifndef coff_reloc16_extra_cases 5290 5291 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases 5292 5293 /* This works even if abort is not declared in any header file. */ 5294 5295 static void 5296 dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED, 5297 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 5298 struct bfd_link_order *link_order ATTRIBUTE_UNUSED, 5299 arelent *reloc ATTRIBUTE_UNUSED, 5300 bfd_byte *data ATTRIBUTE_UNUSED, 5301 unsigned int *src_ptr ATTRIBUTE_UNUSED, 5302 unsigned int *dst_ptr ATTRIBUTE_UNUSED) 5303 { 5304 abort (); 5305 } 5306 #endif 5307 5308 #ifndef coff_bfd_link_hash_table_free 5309 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 5310 #endif 5311 5312 /* If coff_relocate_section is defined, we can use the optimized COFF 5313 backend linker. Otherwise we must continue to use the old linker. */ 5314 5315 #ifdef coff_relocate_section 5316 5317 #ifndef coff_bfd_link_hash_table_create 5318 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create 5319 #endif 5320 #ifndef coff_bfd_link_add_symbols 5321 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols 5322 #endif 5323 #ifndef coff_bfd_final_link 5324 #define coff_bfd_final_link _bfd_coff_final_link 5325 #endif 5326 5327 #else /* ! defined (coff_relocate_section) */ 5328 5329 #define coff_relocate_section NULL 5330 #ifndef coff_bfd_link_hash_table_create 5331 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 5332 #endif 5333 #ifndef coff_bfd_link_add_symbols 5334 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols 5335 #endif 5336 #define coff_bfd_final_link _bfd_generic_final_link 5337 5338 #endif /* ! defined (coff_relocate_section) */ 5339 5340 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms 5341 #define coff_bfd_copy_link_hash_symbol_type \ 5342 _bfd_generic_copy_link_hash_symbol_type 5343 #define coff_bfd_link_split_section _bfd_generic_link_split_section 5344 5345 #ifndef coff_start_final_link 5346 #define coff_start_final_link NULL 5347 #endif 5348 5349 #ifndef coff_adjust_symndx 5350 #define coff_adjust_symndx NULL 5351 #endif 5352 5353 #ifndef coff_link_add_one_symbol 5354 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol 5355 #endif 5356 5357 #ifndef coff_link_output_has_begun 5358 5359 static bfd_boolean 5360 coff_link_output_has_begun (bfd * abfd, 5361 struct coff_final_link_info * info ATTRIBUTE_UNUSED) 5362 { 5363 return abfd->output_has_begun; 5364 } 5365 #endif 5366 5367 #ifndef coff_final_link_postscript 5368 5369 static bfd_boolean 5370 coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED, 5371 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED) 5372 { 5373 return TRUE; 5374 } 5375 #endif 5376 5377 #ifndef coff_SWAP_aux_in 5378 #define coff_SWAP_aux_in coff_swap_aux_in 5379 #endif 5380 #ifndef coff_SWAP_sym_in 5381 #define coff_SWAP_sym_in coff_swap_sym_in 5382 #endif 5383 #ifndef coff_SWAP_lineno_in 5384 #define coff_SWAP_lineno_in coff_swap_lineno_in 5385 #endif 5386 #ifndef coff_SWAP_aux_out 5387 #define coff_SWAP_aux_out coff_swap_aux_out 5388 #endif 5389 #ifndef coff_SWAP_sym_out 5390 #define coff_SWAP_sym_out coff_swap_sym_out 5391 #endif 5392 #ifndef coff_SWAP_lineno_out 5393 #define coff_SWAP_lineno_out coff_swap_lineno_out 5394 #endif 5395 #ifndef coff_SWAP_reloc_out 5396 #define coff_SWAP_reloc_out coff_swap_reloc_out 5397 #endif 5398 #ifndef coff_SWAP_filehdr_out 5399 #define coff_SWAP_filehdr_out coff_swap_filehdr_out 5400 #endif 5401 #ifndef coff_SWAP_aouthdr_out 5402 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out 5403 #endif 5404 #ifndef coff_SWAP_scnhdr_out 5405 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out 5406 #endif 5407 #ifndef coff_SWAP_reloc_in 5408 #define coff_SWAP_reloc_in coff_swap_reloc_in 5409 #endif 5410 #ifndef coff_SWAP_filehdr_in 5411 #define coff_SWAP_filehdr_in coff_swap_filehdr_in 5412 #endif 5413 #ifndef coff_SWAP_aouthdr_in 5414 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in 5415 #endif 5416 #ifndef coff_SWAP_scnhdr_in 5417 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in 5418 #endif 5419 5420 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED = 5421 { 5422 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5423 coff_SWAP_aux_out, coff_SWAP_sym_out, 5424 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5425 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5426 coff_SWAP_scnhdr_out, 5427 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5428 #ifdef COFF_LONG_FILENAMES 5429 TRUE, 5430 #else 5431 FALSE, 5432 #endif 5433 COFF_DEFAULT_LONG_SECTION_NAMES, 5434 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5435 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5436 TRUE, 5437 #else 5438 FALSE, 5439 #endif 5440 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5441 4, 5442 #else 5443 2, 5444 #endif 5445 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5446 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, 5447 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5448 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5449 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5450 coff_classify_symbol, coff_compute_section_file_positions, 5451 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5452 coff_adjust_symndx, coff_link_add_one_symbol, 5453 coff_link_output_has_begun, coff_final_link_postscript, 5454 bfd_pe_print_pdata 5455 }; 5456 5457 #ifdef TICOFF 5458 /* COFF0 differs in file/section header size and relocation entry size. */ 5459 5460 static bfd_coff_backend_data ticoff0_swap_table = 5461 { 5462 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5463 coff_SWAP_aux_out, coff_SWAP_sym_out, 5464 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5465 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5466 coff_SWAP_scnhdr_out, 5467 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN, 5468 #ifdef COFF_LONG_FILENAMES 5469 TRUE, 5470 #else 5471 FALSE, 5472 #endif 5473 COFF_DEFAULT_LONG_SECTION_NAMES, 5474 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5475 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5476 TRUE, 5477 #else 5478 FALSE, 5479 #endif 5480 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5481 4, 5482 #else 5483 2, 5484 #endif 5485 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5486 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook, 5487 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5488 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5489 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5490 coff_classify_symbol, coff_compute_section_file_positions, 5491 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5492 coff_adjust_symndx, coff_link_add_one_symbol, 5493 coff_link_output_has_begun, coff_final_link_postscript, 5494 bfd_pe_print_pdata 5495 }; 5496 #endif 5497 5498 #ifdef TICOFF 5499 /* COFF1 differs in section header size. */ 5500 5501 static bfd_coff_backend_data ticoff1_swap_table = 5502 { 5503 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5504 coff_SWAP_aux_out, coff_SWAP_sym_out, 5505 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5506 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5507 coff_SWAP_scnhdr_out, 5508 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5509 #ifdef COFF_LONG_FILENAMES 5510 TRUE, 5511 #else 5512 FALSE, 5513 #endif 5514 COFF_DEFAULT_LONG_SECTION_NAMES, 5515 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5516 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5517 TRUE, 5518 #else 5519 FALSE, 5520 #endif 5521 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5522 4, 5523 #else 5524 2, 5525 #endif 5526 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5527 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook, 5528 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5529 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5530 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5531 coff_classify_symbol, coff_compute_section_file_positions, 5532 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5533 coff_adjust_symndx, coff_link_add_one_symbol, 5534 coff_link_output_has_begun, coff_final_link_postscript, 5535 bfd_pe_print_pdata /* huh */ 5536 }; 5537 #endif 5538 5539 #ifndef coff_close_and_cleanup 5540 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup 5541 #endif 5542 5543 #ifndef coff_bfd_free_cached_info 5544 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 5545 #endif 5546 5547 #ifndef coff_get_section_contents 5548 #define coff_get_section_contents _bfd_generic_get_section_contents 5549 #endif 5550 5551 #ifndef coff_bfd_copy_private_symbol_data 5552 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 5553 #endif 5554 5555 #ifndef coff_bfd_copy_private_header_data 5556 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data 5557 #endif 5558 5559 #ifndef coff_bfd_copy_private_section_data 5560 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 5561 #endif 5562 5563 #ifndef coff_bfd_copy_private_bfd_data 5564 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data 5565 #endif 5566 5567 #ifndef coff_bfd_merge_private_bfd_data 5568 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 5569 #endif 5570 5571 #ifndef coff_bfd_set_private_flags 5572 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 5573 #endif 5574 5575 #ifndef coff_bfd_print_private_bfd_data 5576 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 5577 #endif 5578 5579 #ifndef coff_bfd_is_local_label_name 5580 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name 5581 #endif 5582 5583 #ifndef coff_bfd_is_target_special_symbol 5584 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 5585 #endif 5586 5587 #ifndef coff_read_minisymbols 5588 #define coff_read_minisymbols _bfd_generic_read_minisymbols 5589 #endif 5590 5591 #ifndef coff_minisymbol_to_symbol 5592 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 5593 #endif 5594 5595 /* The reloc lookup routine must be supplied by each individual COFF 5596 backend. */ 5597 #ifndef coff_bfd_reloc_type_lookup 5598 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 5599 #endif 5600 #ifndef coff_bfd_reloc_name_lookup 5601 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup 5602 #endif 5603 5604 #ifndef coff_bfd_get_relocated_section_contents 5605 #define coff_bfd_get_relocated_section_contents \ 5606 bfd_generic_get_relocated_section_contents 5607 #endif 5608 5609 #ifndef coff_bfd_relax_section 5610 #define coff_bfd_relax_section bfd_generic_relax_section 5611 #endif 5612 5613 #ifndef coff_bfd_gc_sections 5614 #define coff_bfd_gc_sections bfd_generic_gc_sections 5615 #endif 5616 5617 #ifndef coff_bfd_merge_sections 5618 #define coff_bfd_merge_sections bfd_generic_merge_sections 5619 #endif 5620 5621 #ifndef coff_bfd_is_group_section 5622 #define coff_bfd_is_group_section bfd_generic_is_group_section 5623 #endif 5624 5625 #ifndef coff_bfd_discard_group 5626 #define coff_bfd_discard_group bfd_generic_discard_group 5627 #endif 5628 5629 #ifndef coff_section_already_linked 5630 #define coff_section_already_linked \ 5631 _bfd_generic_section_already_linked 5632 #endif 5633 5634 #ifndef coff_bfd_define_common_symbol 5635 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol 5636 #endif 5637 5638 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5639 const bfd_target VAR = \ 5640 { \ 5641 NAME , \ 5642 bfd_target_coff_flavour, \ 5643 BFD_ENDIAN_BIG, /* Data byte order is big. */ \ 5644 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5645 /* object flags */ \ 5646 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5647 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5648 /* section flags */ \ 5649 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5650 UNDER, /* Leading symbol underscore. */ \ 5651 '/', /* AR_pad_char. */ \ 5652 15, /* AR_max_namelen. */ \ 5653 \ 5654 /* Data 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 /* Header conversion functions. */ \ 5660 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5661 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5662 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5663 \ 5664 /* bfd_check_format. */ \ 5665 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5666 _bfd_dummy_target }, \ 5667 /* bfd_set_format. */ \ 5668 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5669 /* bfd_write_contents. */ \ 5670 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5671 bfd_false }, \ 5672 \ 5673 BFD_JUMP_TABLE_GENERIC (coff), \ 5674 BFD_JUMP_TABLE_COPY (coff), \ 5675 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5676 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5677 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5678 BFD_JUMP_TABLE_RELOCS (coff), \ 5679 BFD_JUMP_TABLE_WRITE (coff), \ 5680 BFD_JUMP_TABLE_LINK (coff), \ 5681 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5682 \ 5683 ALTERNATIVE, \ 5684 \ 5685 SWAP_TABLE \ 5686 }; 5687 5688 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5689 const bfd_target VAR = \ 5690 { \ 5691 NAME , \ 5692 bfd_target_coff_flavour, \ 5693 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5694 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5695 /* object flags */ \ 5696 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5697 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5698 /* section flags */ \ 5699 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5700 UNDER, /* Leading symbol underscore. */ \ 5701 '/', /* AR_pad_char. */ \ 5702 15, /* AR_max_namelen. */ \ 5703 \ 5704 /* Data 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 /* Header conversion functions. */ \ 5710 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5711 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5712 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5713 \ 5714 /* bfd_check_format. */ \ 5715 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5716 _bfd_dummy_target }, \ 5717 /* bfd_set_format. */ \ 5718 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5719 /* bfd_write_contents. */ \ 5720 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5721 bfd_false }, \ 5722 \ 5723 BFD_JUMP_TABLE_GENERIC (coff), \ 5724 BFD_JUMP_TABLE_COPY (coff), \ 5725 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5726 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5727 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5728 BFD_JUMP_TABLE_RELOCS (coff), \ 5729 BFD_JUMP_TABLE_WRITE (coff), \ 5730 BFD_JUMP_TABLE_LINK (coff), \ 5731 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5732 \ 5733 ALTERNATIVE, \ 5734 \ 5735 SWAP_TABLE \ 5736 }; 5737 5738 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5739 const bfd_target VAR = \ 5740 { \ 5741 NAME , \ 5742 bfd_target_coff_flavour, \ 5743 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5744 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \ 5745 /* object flags */ \ 5746 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5747 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5748 /* section flags */ \ 5749 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5750 UNDER, /* Leading symbol underscore. */ \ 5751 '/', /* AR_pad_char. */ \ 5752 15, /* AR_max_namelen. */ \ 5753 \ 5754 /* Data conversion functions. */ \ 5755 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5756 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5757 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5758 /* Header conversion functions. */ \ 5759 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5760 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5761 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5762 /* bfd_check_format. */ \ 5763 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5764 _bfd_dummy_target }, \ 5765 /* bfd_set_format. */ \ 5766 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5767 /* bfd_write_contents. */ \ 5768 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5769 bfd_false }, \ 5770 \ 5771 BFD_JUMP_TABLE_GENERIC (coff), \ 5772 BFD_JUMP_TABLE_COPY (coff), \ 5773 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5774 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5775 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5776 BFD_JUMP_TABLE_RELOCS (coff), \ 5777 BFD_JUMP_TABLE_WRITE (coff), \ 5778 BFD_JUMP_TABLE_LINK (coff), \ 5779 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5780 \ 5781 ALTERNATIVE, \ 5782 \ 5783 SWAP_TABLE \ 5784 }; 5785