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