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