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