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