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