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