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