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