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