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