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