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