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 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 (!strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1)) 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 (!strncmp (sec_name, ".stab", 5)) 439 { 440 styp_flags = STYP_DEBUG_INFO; 441 } 442#ifdef COFF_LONG_SECTION_NAMES 443 else if (!strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1)) 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 (strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0 533 || strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0) 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 (strncmp (name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0 678#ifdef _COMMENT 679 || strcmp (name, _COMMENT) == 0 680#endif 681#ifdef COFF_LONG_SECTION_NAMES 682 || strncmp (name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0 683#endif 684 || strncmp (name, ".stab", 5) == 0) 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 (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0) 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 (strncmp (name, ".reloc", sizeof ".reloc" - 1) != 0) 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 (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0) 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 /* Allocate aux records for section symbols, to store size and 1564 related info. 1565 1566 @@ The 10 is a guess at a plausible maximum number of aux entries 1567 (but shouldn't be a constant). */ 1568 amt = sizeof (combined_entry_type) * 10; 1569 native = bfd_zalloc (abfd, amt); 1570 if (native == NULL) 1571 return FALSE; 1572 1573 /* We don't need to set up n_name, n_value, or n_scnum in the native 1574 symbol information, since they'll be overridden by the BFD symbol 1575 anyhow. However, we do need to set the type and storage class, 1576 in case this symbol winds up getting written out. The value 0 1577 for n_numaux is already correct. */ 1578 1579 native->u.syment.n_type = T_NULL; 1580 native->u.syment.n_sclass = C_STAT; 1581 1582 coffsymbol (section->symbol)->native = native; 1583 1584 coff_set_custom_section_alignment (abfd, section, 1585 coff_section_alignment_table, 1586 coff_section_alignment_table_size); 1587 1588 return TRUE; 1589} 1590 1591#ifdef COFF_ALIGN_IN_SECTION_HEADER 1592 1593/* Set the alignment of a BFD section. */ 1594 1595static void 1596coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1597 asection * section, 1598 void * scnhdr) 1599{ 1600 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1601 unsigned int i; 1602 1603#ifdef I960 1604 /* Extract ALIGN from 2**ALIGN stored in section header. */ 1605 for (i = 0; i < 32; i++) 1606 if ((1 << i) >= hdr->s_align) 1607 break; 1608#endif 1609#ifdef TIC80COFF 1610 /* TI tools puts the alignment power in bits 8-11. */ 1611 i = (hdr->s_flags >> 8) & 0xF ; 1612#endif 1613#ifdef COFF_DECODE_ALIGNMENT 1614 i = COFF_DECODE_ALIGNMENT(hdr->s_flags); 1615#endif 1616 section->alignment_power = i; 1617 1618#ifdef coff_set_section_load_page 1619 coff_set_section_load_page (section, hdr->s_page); 1620#endif 1621} 1622 1623#else /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1624#ifdef COFF_WITH_PE 1625 1626/* A couple of macros to help setting the alignment power field. */ 1627#define ALIGN_SET(field, x, y) \ 1628 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x)\ 1629 {\ 1630 section->alignment_power = y;\ 1631 } 1632 1633#define ELIFALIGN_SET(field, x, y) \ 1634 else if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x) \ 1635 {\ 1636 section->alignment_power = y;\ 1637 } 1638 1639static void 1640coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED, 1641 asection * section, 1642 void * scnhdr) 1643{ 1644 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1645 bfd_size_type amt; 1646 1647 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6) 1648 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5) 1649 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4) 1650 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3) 1651 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2) 1652 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1) 1653 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0) 1654 1655 /* In a PE image file, the s_paddr field holds the virtual size of a 1656 section, while the s_size field holds the raw size. We also keep 1657 the original section flag value, since not every bit can be 1658 mapped onto a generic BFD section bit. */ 1659 if (coff_section_data (abfd, section) == NULL) 1660 { 1661 amt = sizeof (struct coff_section_tdata); 1662 section->used_by_bfd = bfd_zalloc (abfd, amt); 1663 if (section->used_by_bfd == NULL) 1664 /* FIXME: Return error. */ 1665 abort (); 1666 } 1667 1668 if (pei_section_data (abfd, section) == NULL) 1669 { 1670 amt = sizeof (struct pei_section_tdata); 1671 coff_section_data (abfd, section)->tdata = bfd_zalloc (abfd, amt); 1672 if (coff_section_data (abfd, section)->tdata == NULL) 1673 /* FIXME: Return error. */ 1674 abort (); 1675 } 1676 pei_section_data (abfd, section)->virt_size = hdr->s_paddr; 1677 pei_section_data (abfd, section)->pe_flags = hdr->s_flags; 1678 1679 section->lma = hdr->s_vaddr; 1680 1681 /* Check for extended relocs. */ 1682 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL) 1683 { 1684 struct external_reloc dst; 1685 struct internal_reloc n; 1686 file_ptr oldpos = bfd_tell (abfd); 1687 bfd_size_type relsz = bfd_coff_relsz (abfd); 1688 1689 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0); 1690 if (bfd_bread (& dst, relsz, abfd) != relsz) 1691 return; 1692 1693 coff_swap_reloc_in (abfd, &dst, &n); 1694 bfd_seek (abfd, oldpos, 0); 1695 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1; 1696 section->rel_filepos += relsz; 1697 } 1698 else if (hdr->s_nreloc == 0xffff) 1699 (*_bfd_error_handler) 1700 ("%s: warning: claims to have 0xffff relocs, without overflow", 1701 bfd_get_filename (abfd)); 1702} 1703#undef ALIGN_SET 1704#undef ELIFALIGN_SET 1705 1706#else /* ! COFF_WITH_PE */ 1707#ifdef RS6000COFF_C 1708 1709/* We grossly abuse this function to handle XCOFF overflow headers. 1710 When we see one, we correct the reloc and line number counts in the 1711 real header, and remove the section we just created. */ 1712 1713static void 1714coff_set_alignment_hook (bfd *abfd, asection *section, void * scnhdr) 1715{ 1716 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr; 1717 asection *real_sec; 1718 1719 if ((hdr->s_flags & STYP_OVRFLO) == 0) 1720 return; 1721 1722 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc); 1723 if (real_sec == NULL) 1724 return; 1725 1726 real_sec->reloc_count = hdr->s_paddr; 1727 real_sec->lineno_count = hdr->s_vaddr; 1728 1729 if (!bfd_section_removed_from_list (abfd, section)) 1730 { 1731 bfd_section_list_remove (abfd, section); 1732 --abfd->section_count; 1733 } 1734} 1735 1736#else /* ! RS6000COFF_C */ 1737 1738#define coff_set_alignment_hook \ 1739 ((void (*) (bfd *, asection *, void *)) bfd_void) 1740 1741#endif /* ! RS6000COFF_C */ 1742#endif /* ! COFF_WITH_PE */ 1743#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */ 1744 1745#ifndef coff_mkobject 1746 1747static bfd_boolean 1748coff_mkobject (bfd * abfd) 1749{ 1750 coff_data_type *coff; 1751 bfd_size_type amt = sizeof (coff_data_type); 1752 1753 abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt); 1754 if (abfd->tdata.coff_obj_data == NULL) 1755 return FALSE; 1756 coff = coff_data (abfd); 1757 coff->symbols = NULL; 1758 coff->conversion_table = NULL; 1759 coff->raw_syments = NULL; 1760 coff->relocbase = 0; 1761 coff->local_toc_sym_map = 0; 1762 1763/* make_abs_section(abfd);*/ 1764 1765 return TRUE; 1766} 1767#endif 1768 1769/* Create the COFF backend specific information. */ 1770 1771#ifndef coff_mkobject_hook 1772static void * 1773coff_mkobject_hook (bfd * abfd, 1774 void * filehdr, 1775 void * aouthdr ATTRIBUTE_UNUSED) 1776{ 1777 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1778 coff_data_type *coff; 1779 1780 if (! coff_mkobject (abfd)) 1781 return NULL; 1782 1783 coff = coff_data (abfd); 1784 1785 coff->sym_filepos = internal_f->f_symptr; 1786 1787 /* These members communicate important constants about the symbol 1788 table to GDB's symbol-reading code. These `constants' 1789 unfortunately vary among coff implementations... */ 1790 coff->local_n_btmask = N_BTMASK; 1791 coff->local_n_btshft = N_BTSHFT; 1792 coff->local_n_tmask = N_TMASK; 1793 coff->local_n_tshift = N_TSHIFT; 1794 coff->local_symesz = bfd_coff_symesz (abfd); 1795 coff->local_auxesz = bfd_coff_auxesz (abfd); 1796 coff->local_linesz = bfd_coff_linesz (abfd); 1797 1798 coff->timestamp = internal_f->f_timdat; 1799 1800 obj_raw_syment_count (abfd) = 1801 obj_conv_table_size (abfd) = 1802 internal_f->f_nsyms; 1803 1804#ifdef RS6000COFF_C 1805 if ((internal_f->f_flags & F_SHROBJ) != 0) 1806 abfd->flags |= DYNAMIC; 1807 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd)) 1808 { 1809 struct internal_aouthdr *internal_a = 1810 (struct internal_aouthdr *) aouthdr; 1811 struct xcoff_tdata *xcoff; 1812 1813 xcoff = xcoff_data (abfd); 1814# ifdef U803XTOCMAGIC 1815 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC; 1816# else 1817 xcoff->xcoff64 = 0; 1818# endif 1819 xcoff->full_aouthdr = TRUE; 1820 xcoff->toc = internal_a->o_toc; 1821 xcoff->sntoc = internal_a->o_sntoc; 1822 xcoff->snentry = internal_a->o_snentry; 1823 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext; 1824 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata; 1825 xcoff->modtype = internal_a->o_modtype; 1826 xcoff->cputype = internal_a->o_cputype; 1827 xcoff->maxdata = internal_a->o_maxdata; 1828 xcoff->maxstack = internal_a->o_maxstack; 1829 } 1830#endif 1831 1832#ifdef ARM 1833 /* Set the flags field from the COFF header read in. */ 1834 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags)) 1835 coff->flags = 0; 1836#endif 1837 1838#ifdef COFF_WITH_PE 1839 /* FIXME: I'm not sure this is ever executed, since peicode.h 1840 defines coff_mkobject_hook. */ 1841 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0) 1842 abfd->flags |= HAS_DEBUG; 1843#endif 1844 1845 return coff; 1846} 1847#endif 1848 1849/* Determine the machine architecture and type. FIXME: This is target 1850 dependent because the magic numbers are defined in the target 1851 dependent header files. But there is no particular need for this. 1852 If the magic numbers were moved to a separate file, this function 1853 would be target independent and would also be much more successful 1854 at linking together COFF files for different architectures. */ 1855 1856static bfd_boolean 1857coff_set_arch_mach_hook (bfd *abfd, void * filehdr) 1858{ 1859 unsigned long machine; 1860 enum bfd_architecture arch; 1861 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr; 1862 1863 /* Zero selects the default machine for an arch. */ 1864 machine = 0; 1865 switch (internal_f->f_magic) 1866 { 1867#ifdef OR32_MAGIC_BIG 1868 case OR32_MAGIC_BIG: 1869 case OR32_MAGIC_LITTLE: 1870 arch = bfd_arch_or32; 1871 break; 1872#endif 1873#ifdef PPCMAGIC 1874 case PPCMAGIC: 1875 arch = bfd_arch_powerpc; 1876 break; 1877#endif 1878#ifdef I386MAGIC 1879 case I386MAGIC: 1880 case I386PTXMAGIC: 1881 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */ 1882 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */ 1883 arch = bfd_arch_i386; 1884 break; 1885#endif 1886#ifdef AMD64MAGIC 1887 case AMD64MAGIC: 1888 arch = bfd_arch_i386; 1889 machine = bfd_mach_x86_64; 1890 break; 1891#endif 1892#ifdef IA64MAGIC 1893 case IA64MAGIC: 1894 arch = bfd_arch_ia64; 1895 break; 1896#endif 1897#ifdef ARMMAGIC 1898 case ARMMAGIC: 1899 case ARMPEMAGIC: 1900 case THUMBPEMAGIC: 1901 arch = bfd_arch_arm; 1902 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION); 1903 if (machine == bfd_mach_arm_unknown) 1904 { 1905 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK) 1906 { 1907 case F_ARM_2: machine = bfd_mach_arm_2; break; 1908 case F_ARM_2a: machine = bfd_mach_arm_2a; break; 1909 case F_ARM_3: machine = bfd_mach_arm_3; break; 1910 default: 1911 case F_ARM_3M: machine = bfd_mach_arm_3M; break; 1912 case F_ARM_4: machine = bfd_mach_arm_4; break; 1913 case F_ARM_4T: machine = bfd_mach_arm_4T; break; 1914 /* The COFF header does not have enough bits available 1915 to cover all the different ARM architectures. So 1916 we interpret F_ARM_5, the highest flag value to mean 1917 "the highest ARM architecture known to BFD" which is 1918 currently the XScale. */ 1919 case F_ARM_5: machine = bfd_mach_arm_XScale; break; 1920 } 1921 } 1922 break; 1923#endif 1924#ifdef MC68MAGIC 1925 case MC68MAGIC: 1926 case M68MAGIC: 1927#ifdef MC68KBCSMAGIC 1928 case MC68KBCSMAGIC: 1929#endif 1930#ifdef APOLLOM68KMAGIC 1931 case APOLLOM68KMAGIC: 1932#endif 1933#ifdef LYNXCOFFMAGIC 1934 case LYNXCOFFMAGIC: 1935#endif 1936 arch = bfd_arch_m68k; 1937 machine = bfd_mach_m68020; 1938 break; 1939#endif 1940#ifdef MAXQ20MAGIC 1941 case MAXQ20MAGIC: 1942 arch = bfd_arch_maxq; 1943 switch (internal_f->f_flags & F_MACHMASK) 1944 { 1945 case F_MAXQ10: 1946 machine = bfd_mach_maxq10; 1947 break; 1948 case F_MAXQ20: 1949 machine = bfd_mach_maxq20; 1950 break; 1951 default: 1952 return FALSE; 1953 } 1954 break; 1955#endif 1956#ifdef MC88MAGIC 1957 case MC88MAGIC: 1958 case MC88DMAGIC: 1959 case MC88OMAGIC: 1960 arch = bfd_arch_m88k; 1961 machine = 88100; 1962 break; 1963#endif 1964#ifdef Z80MAGIC 1965 case Z80MAGIC: 1966 arch = bfd_arch_z80; 1967 switch (internal_f->f_flags & F_MACHMASK) 1968 { 1969 case 0: 1970 case bfd_mach_z80strict << 12: 1971 case bfd_mach_z80 << 12: 1972 case bfd_mach_z80full << 12: 1973 case bfd_mach_r800 << 12: 1974 machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12; 1975 break; 1976 default: 1977 return FALSE; 1978 } 1979 break; 1980#endif 1981#ifdef Z8KMAGIC 1982 case Z8KMAGIC: 1983 arch = bfd_arch_z8k; 1984 switch (internal_f->f_flags & F_MACHMASK) 1985 { 1986 case F_Z8001: 1987 machine = bfd_mach_z8001; 1988 break; 1989 case F_Z8002: 1990 machine = bfd_mach_z8002; 1991 break; 1992 default: 1993 return FALSE; 1994 } 1995 break; 1996#endif 1997#ifdef I860 1998 case I860MAGIC: 1999 arch = bfd_arch_i860; 2000 break; 2001#endif 2002#ifdef I960 2003#ifdef I960ROMAGIC 2004 case I960ROMAGIC: 2005 case I960RWMAGIC: 2006 arch = bfd_arch_i960; 2007 switch (F_I960TYPE & internal_f->f_flags) 2008 { 2009 default: 2010 case F_I960CORE: 2011 machine = bfd_mach_i960_core; 2012 break; 2013 case F_I960KB: 2014 machine = bfd_mach_i960_kb_sb; 2015 break; 2016 case F_I960MC: 2017 machine = bfd_mach_i960_mc; 2018 break; 2019 case F_I960XA: 2020 machine = bfd_mach_i960_xa; 2021 break; 2022 case F_I960CA: 2023 machine = bfd_mach_i960_ca; 2024 break; 2025 case F_I960KA: 2026 machine = bfd_mach_i960_ka_sa; 2027 break; 2028 case F_I960JX: 2029 machine = bfd_mach_i960_jx; 2030 break; 2031 case F_I960HX: 2032 machine = bfd_mach_i960_hx; 2033 break; 2034 } 2035 break; 2036#endif 2037#endif 2038 2039#ifdef RS6000COFF_C 2040#ifdef XCOFF64 2041 case U64_TOCMAGIC: 2042 case U803XTOCMAGIC: 2043#else 2044 case U802ROMAGIC: 2045 case U802WRMAGIC: 2046 case U802TOCMAGIC: 2047#endif 2048 { 2049 int cputype; 2050 2051 if (xcoff_data (abfd)->cputype != -1) 2052 cputype = xcoff_data (abfd)->cputype & 0xff; 2053 else 2054 { 2055 /* We did not get a value from the a.out header. If the 2056 file has not been stripped, we may be able to get the 2057 architecture information from the first symbol, if it 2058 is a .file symbol. */ 2059 if (obj_raw_syment_count (abfd) == 0) 2060 cputype = 0; 2061 else 2062 { 2063 bfd_byte *buf; 2064 struct internal_syment sym; 2065 bfd_size_type amt = bfd_coff_symesz (abfd); 2066 2067 buf = bfd_malloc (amt); 2068 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0 2069 || bfd_bread (buf, amt, abfd) != amt) 2070 { 2071 free (buf); 2072 return FALSE; 2073 } 2074 bfd_coff_swap_sym_in (abfd, buf, & sym); 2075 if (sym.n_sclass == C_FILE) 2076 cputype = sym.n_type & 0xff; 2077 else 2078 cputype = 0; 2079 free (buf); 2080 } 2081 } 2082 2083 /* FIXME: We don't handle all cases here. */ 2084 switch (cputype) 2085 { 2086 default: 2087 case 0: 2088 arch = bfd_xcoff_architecture (abfd); 2089 machine = bfd_xcoff_machine (abfd); 2090 break; 2091 2092 case 1: 2093 arch = bfd_arch_powerpc; 2094 machine = bfd_mach_ppc_601; 2095 break; 2096 case 2: /* 64 bit PowerPC */ 2097 arch = bfd_arch_powerpc; 2098 machine = bfd_mach_ppc_620; 2099 break; 2100 case 3: 2101 arch = bfd_arch_powerpc; 2102 machine = bfd_mach_ppc; 2103 break; 2104 case 4: 2105 arch = bfd_arch_rs6000; 2106 machine = bfd_mach_rs6k; 2107 break; 2108 } 2109 } 2110 break; 2111#endif 2112 2113#ifdef WE32KMAGIC 2114 case WE32KMAGIC: 2115 arch = bfd_arch_we32k; 2116 break; 2117#endif 2118 2119#ifdef H8300MAGIC 2120 case H8300MAGIC: 2121 arch = bfd_arch_h8300; 2122 machine = bfd_mach_h8300; 2123 /* !! FIXME this probably isn't the right place for this. */ 2124 abfd->flags |= BFD_IS_RELAXABLE; 2125 break; 2126#endif 2127 2128#ifdef H8300HMAGIC 2129 case H8300HMAGIC: 2130 arch = bfd_arch_h8300; 2131 machine = bfd_mach_h8300h; 2132 /* !! FIXME this probably isn't the right place for this. */ 2133 abfd->flags |= BFD_IS_RELAXABLE; 2134 break; 2135#endif 2136 2137#ifdef H8300SMAGIC 2138 case H8300SMAGIC: 2139 arch = bfd_arch_h8300; 2140 machine = bfd_mach_h8300s; 2141 /* !! FIXME this probably isn't the right place for this. */ 2142 abfd->flags |= BFD_IS_RELAXABLE; 2143 break; 2144#endif 2145 2146#ifdef H8300HNMAGIC 2147 case H8300HNMAGIC: 2148 arch = bfd_arch_h8300; 2149 machine = bfd_mach_h8300hn; 2150 /* !! FIXME this probably isn't the right place for this. */ 2151 abfd->flags |= BFD_IS_RELAXABLE; 2152 break; 2153#endif 2154 2155#ifdef H8300SNMAGIC 2156 case H8300SNMAGIC: 2157 arch = bfd_arch_h8300; 2158 machine = bfd_mach_h8300sn; 2159 /* !! FIXME this probably isn't the right place for this. */ 2160 abfd->flags |= BFD_IS_RELAXABLE; 2161 break; 2162#endif 2163 2164#ifdef SH_ARCH_MAGIC_BIG 2165 case SH_ARCH_MAGIC_BIG: 2166 case SH_ARCH_MAGIC_LITTLE: 2167#ifdef COFF_WITH_PE 2168 case SH_ARCH_MAGIC_WINCE: 2169#endif 2170 arch = bfd_arch_sh; 2171 break; 2172#endif 2173 2174#ifdef MIPS_ARCH_MAGIC_WINCE 2175 case MIPS_ARCH_MAGIC_WINCE: 2176 arch = bfd_arch_mips; 2177 break; 2178#endif 2179 2180#ifdef H8500MAGIC 2181 case H8500MAGIC: 2182 arch = bfd_arch_h8500; 2183 break; 2184#endif 2185 2186#ifdef SPARCMAGIC 2187 case SPARCMAGIC: 2188#ifdef LYNXCOFFMAGIC 2189 case LYNXCOFFMAGIC: 2190#endif 2191 arch = bfd_arch_sparc; 2192 break; 2193#endif 2194 2195#ifdef TIC30MAGIC 2196 case TIC30MAGIC: 2197 arch = bfd_arch_tic30; 2198 break; 2199#endif 2200 2201#ifdef TICOFF0MAGIC 2202#ifdef TICOFF_TARGET_ARCH 2203 /* This TI COFF section should be used by all new TI COFF v0 targets. */ 2204 case TICOFF0MAGIC: 2205 arch = TICOFF_TARGET_ARCH; 2206 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2207 break; 2208#endif 2209#endif 2210 2211#ifdef TICOFF1MAGIC 2212 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */ 2213 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */ 2214 case TICOFF1MAGIC: 2215 case TICOFF2MAGIC: 2216 switch (internal_f->f_target_id) 2217 { 2218#ifdef TI_TARGET_ID 2219 case TI_TARGET_ID: 2220 arch = TICOFF_TARGET_ARCH; 2221 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags); 2222 break; 2223#endif 2224 default: 2225 arch = bfd_arch_obscure; 2226 (*_bfd_error_handler) 2227 (_("Unrecognized TI COFF target id '0x%x'"), 2228 internal_f->f_target_id); 2229 break; 2230 } 2231 break; 2232#endif 2233 2234#ifdef TIC80_ARCH_MAGIC 2235 case TIC80_ARCH_MAGIC: 2236 arch = bfd_arch_tic80; 2237 break; 2238#endif 2239 2240#ifdef MCOREMAGIC 2241 case MCOREMAGIC: 2242 arch = bfd_arch_mcore; 2243 break; 2244#endif 2245 2246#ifdef W65MAGIC 2247 case W65MAGIC: 2248 arch = bfd_arch_w65; 2249 break; 2250#endif 2251 2252 default: /* Unreadable input file type. */ 2253 arch = bfd_arch_obscure; 2254 break; 2255 } 2256 2257 bfd_default_set_arch_mach (abfd, arch, machine); 2258 return TRUE; 2259} 2260 2261#ifdef SYMNAME_IN_DEBUG 2262 2263static bfd_boolean 2264symname_in_debug_hook (bfd * abfd ATTRIBUTE_UNUSED, struct internal_syment *sym) 2265{ 2266 return SYMNAME_IN_DEBUG (sym) != 0; 2267} 2268 2269#else 2270 2271#define symname_in_debug_hook \ 2272 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false 2273 2274#endif 2275 2276#ifdef RS6000COFF_C 2277 2278#ifdef XCOFF64 2279#define FORCE_SYMNAMES_IN_STRINGS 2280#endif 2281 2282/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */ 2283 2284static bfd_boolean 2285coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2286 combined_entry_type *table_base, 2287 combined_entry_type *symbol, 2288 unsigned int indaux, 2289 combined_entry_type *aux) 2290{ 2291 int class = symbol->u.syment.n_sclass; 2292 2293 if ((class == C_EXT || class == C_HIDEXT) 2294 && indaux + 1 == symbol->u.syment.n_numaux) 2295 { 2296 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD) 2297 { 2298 aux->u.auxent.x_csect.x_scnlen.p = 2299 table_base + aux->u.auxent.x_csect.x_scnlen.l; 2300 aux->fix_scnlen = 1; 2301 } 2302 2303 /* Return TRUE to indicate that the caller should not do any 2304 further work on this auxent. */ 2305 return TRUE; 2306 } 2307 2308 /* Return FALSE to indicate that this auxent should be handled by 2309 the caller. */ 2310 return FALSE; 2311} 2312 2313#else 2314#ifdef I960 2315 2316/* We don't want to pointerize bal entries. */ 2317 2318static bfd_boolean 2319coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED, 2320 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2321 combined_entry_type *symbol, 2322 unsigned int indaux, 2323 combined_entry_type *aux ATTRIBUTE_UNUSED) 2324{ 2325 /* Return TRUE if we don't want to pointerize this aux entry, which 2326 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */ 2327 return (indaux == 1 2328 && (symbol->u.syment.n_sclass == C_LEAFPROC 2329 || symbol->u.syment.n_sclass == C_LEAFSTAT 2330 || symbol->u.syment.n_sclass == C_LEAFEXT)); 2331} 2332 2333#else /* ! I960 */ 2334 2335#define coff_pointerize_aux_hook 0 2336 2337#endif /* ! I960 */ 2338#endif /* ! RS6000COFF_C */ 2339 2340/* Print an aux entry. This returns TRUE if it has printed it. */ 2341 2342static bfd_boolean 2343coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED, 2344 FILE *file ATTRIBUTE_UNUSED, 2345 combined_entry_type *table_base ATTRIBUTE_UNUSED, 2346 combined_entry_type *symbol ATTRIBUTE_UNUSED, 2347 combined_entry_type *aux ATTRIBUTE_UNUSED, 2348 unsigned int indaux ATTRIBUTE_UNUSED) 2349{ 2350#ifdef RS6000COFF_C 2351 if ((symbol->u.syment.n_sclass == C_EXT 2352 || symbol->u.syment.n_sclass == C_HIDEXT) 2353 && indaux + 1 == symbol->u.syment.n_numaux) 2354 { 2355 /* This is a csect entry. */ 2356 fprintf (file, "AUX "); 2357 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD) 2358 { 2359 BFD_ASSERT (! aux->fix_scnlen); 2360#ifdef XCOFF64 2361 fprintf (file, "val %5lld", 2362 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2363#else 2364 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2365#endif 2366 } 2367 else 2368 { 2369 fprintf (file, "indx "); 2370 if (! aux->fix_scnlen) 2371#ifdef XCOFF64 2372 fprintf (file, "%4lld", 2373 (long long) aux->u.auxent.x_csect.x_scnlen.l); 2374#else 2375 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l); 2376#endif 2377 else 2378 fprintf (file, "%4ld", 2379 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base)); 2380 } 2381 fprintf (file, 2382 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u", 2383 aux->u.auxent.x_csect.x_parmhash, 2384 (unsigned int) aux->u.auxent.x_csect.x_snhash, 2385 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp), 2386 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp), 2387 (unsigned int) aux->u.auxent.x_csect.x_smclas, 2388 aux->u.auxent.x_csect.x_stab, 2389 (unsigned int) aux->u.auxent.x_csect.x_snstab); 2390 return TRUE; 2391 } 2392#endif 2393 2394 /* Return FALSE to indicate that no special action was taken. */ 2395 return FALSE; 2396} 2397 2398/* 2399SUBSUBSECTION 2400 Writing relocations 2401 2402 To write relocations, the back end steps though the 2403 canonical relocation table and create an 2404 @code{internal_reloc}. The symbol index to use is removed from 2405 the @code{offset} field in the symbol table supplied. The 2406 address comes directly from the sum of the section base 2407 address and the relocation offset; the type is dug directly 2408 from the howto field. Then the @code{internal_reloc} is 2409 swapped into the shape of an @code{external_reloc} and written 2410 out to disk. 2411 2412*/ 2413 2414#ifdef TARG_AUX 2415 2416 2417/* AUX's ld wants relocations to be sorted. */ 2418static int 2419compare_arelent_ptr (const void * x, const void * y) 2420{ 2421 const arelent **a = (const arelent **) x; 2422 const arelent **b = (const arelent **) y; 2423 bfd_size_type aadr = (*a)->address; 2424 bfd_size_type badr = (*b)->address; 2425 2426 return (aadr < badr ? -1 : badr < aadr ? 1 : 0); 2427} 2428 2429#endif /* TARG_AUX */ 2430 2431static bfd_boolean 2432coff_write_relocs (bfd * abfd, int first_undef) 2433{ 2434 asection *s; 2435 2436 for (s = abfd->sections; s != NULL; s = s->next) 2437 { 2438 unsigned int i; 2439 struct external_reloc dst; 2440 arelent **p; 2441 2442#ifndef TARG_AUX 2443 p = s->orelocation; 2444#else 2445 { 2446 /* Sort relocations before we write them out. */ 2447 bfd_size_type amt; 2448 2449 amt = s->reloc_count; 2450 amt *= sizeof (arelent *); 2451 p = bfd_malloc (amt); 2452 if (p == NULL && s->reloc_count > 0) 2453 return FALSE; 2454 memcpy (p, s->orelocation, (size_t) amt); 2455 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr); 2456 } 2457#endif 2458 2459 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0) 2460 return FALSE; 2461 2462#ifdef COFF_WITH_PE 2463 if (obj_pe (abfd) && s->reloc_count >= 0xffff) 2464 { 2465 /* Encode real count here as first reloc. */ 2466 struct internal_reloc n; 2467 2468 memset (& n, 0, sizeof (n)); 2469 /* Add one to count *this* reloc (grr). */ 2470 n.r_vaddr = s->reloc_count + 1; 2471 coff_swap_reloc_out (abfd, &n, &dst); 2472 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2473 abfd) != bfd_coff_relsz (abfd)) 2474 return FALSE; 2475 } 2476#endif 2477 2478 for (i = 0; i < s->reloc_count; i++) 2479 { 2480 struct internal_reloc n; 2481 arelent *q = p[i]; 2482 2483 memset (& n, 0, sizeof (n)); 2484 2485 /* Now we've renumbered the symbols we know where the 2486 undefined symbols live in the table. Check the reloc 2487 entries for symbols who's output bfd isn't the right one. 2488 This is because the symbol was undefined (which means 2489 that all the pointers are never made to point to the same 2490 place). This is a bad thing,'cause the symbols attached 2491 to the output bfd are indexed, so that the relocation 2492 entries know which symbol index they point to. So we 2493 have to look up the output symbol here. */ 2494 2495 if (q->sym_ptr_ptr[0]->the_bfd != abfd) 2496 { 2497 int j; 2498 const char *sname = q->sym_ptr_ptr[0]->name; 2499 asymbol **outsyms = abfd->outsymbols; 2500 2501 for (j = first_undef; outsyms[j]; j++) 2502 { 2503 const char *intable = outsyms[j]->name; 2504 2505 if (strcmp (intable, sname) == 0) 2506 { 2507 /* Got a hit, so repoint the reloc. */ 2508 q->sym_ptr_ptr = outsyms + j; 2509 break; 2510 } 2511 } 2512 } 2513 2514 n.r_vaddr = q->address + s->vma; 2515 2516#ifdef R_IHCONST 2517 /* The 29k const/consth reloc pair is a real kludge. The consth 2518 part doesn't have a symbol; it has an offset. So rebuilt 2519 that here. */ 2520 if (q->howto->type == R_IHCONST) 2521 n.r_symndx = q->addend; 2522 else 2523#endif 2524 if (q->sym_ptr_ptr) 2525 { 2526#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P 2527 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q, s)) 2528#else 2529 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr 2530 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0) 2531#endif 2532 /* This is a relocation relative to the absolute symbol. */ 2533 n.r_symndx = -1; 2534 else 2535 { 2536 n.r_symndx = get_index ((*(q->sym_ptr_ptr))); 2537 /* Take notice if the symbol reloc points to a symbol 2538 we don't have in our symbol table. What should we 2539 do for this?? */ 2540 if (n.r_symndx > obj_conv_table_size (abfd)) 2541 abort (); 2542 } 2543 } 2544 2545#ifdef SWAP_OUT_RELOC_OFFSET 2546 n.r_offset = q->addend; 2547#endif 2548 2549#ifdef SELECT_RELOC 2550 /* Work out reloc type from what is required. */ 2551 SELECT_RELOC (n, q->howto); 2552#else 2553 n.r_type = q->howto->type; 2554#endif 2555 coff_swap_reloc_out (abfd, &n, &dst); 2556 2557 if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd), 2558 abfd) != bfd_coff_relsz (abfd)) 2559 return FALSE; 2560 } 2561 2562#ifdef TARG_AUX 2563 if (p != NULL) 2564 free (p); 2565#endif 2566 } 2567 2568 return TRUE; 2569} 2570 2571/* Set flags and magic number of a coff file from architecture and machine 2572 type. Result is TRUE if we can represent the arch&type, FALSE if not. */ 2573 2574static bfd_boolean 2575coff_set_flags (bfd * abfd, 2576 unsigned int *magicp ATTRIBUTE_UNUSED, 2577 unsigned short *flagsp ATTRIBUTE_UNUSED) 2578{ 2579 switch (bfd_get_arch (abfd)) 2580 { 2581#ifdef Z80MAGIC 2582 case bfd_arch_z80: 2583 *magicp = Z80MAGIC; 2584 switch (bfd_get_mach (abfd)) 2585 { 2586 case 0: 2587 case bfd_mach_z80strict: 2588 case bfd_mach_z80: 2589 case bfd_mach_z80full: 2590 case bfd_mach_r800: 2591 *flagsp = bfd_get_mach (abfd) << 12; 2592 break; 2593 default: 2594 return FALSE; 2595 } 2596 return TRUE; 2597#endif 2598 2599#ifdef Z8KMAGIC 2600 case bfd_arch_z8k: 2601 *magicp = Z8KMAGIC; 2602 2603 switch (bfd_get_mach (abfd)) 2604 { 2605 case bfd_mach_z8001: *flagsp = F_Z8001; break; 2606 case bfd_mach_z8002: *flagsp = F_Z8002; break; 2607 default: return FALSE; 2608 } 2609 return TRUE; 2610#endif 2611 2612#ifdef I960ROMAGIC 2613 case bfd_arch_i960: 2614 2615 { 2616 unsigned flags; 2617 2618 *magicp = I960ROMAGIC; 2619 2620 switch (bfd_get_mach (abfd)) 2621 { 2622 case bfd_mach_i960_core: flags = F_I960CORE; break; 2623 case bfd_mach_i960_kb_sb: flags = F_I960KB; break; 2624 case bfd_mach_i960_mc: flags = F_I960MC; break; 2625 case bfd_mach_i960_xa: flags = F_I960XA; break; 2626 case bfd_mach_i960_ca: flags = F_I960CA; break; 2627 case bfd_mach_i960_ka_sa: flags = F_I960KA; break; 2628 case bfd_mach_i960_jx: flags = F_I960JX; break; 2629 case bfd_mach_i960_hx: flags = F_I960HX; break; 2630 default: return FALSE; 2631 } 2632 *flagsp = flags; 2633 return TRUE; 2634 } 2635 break; 2636#endif 2637 2638#ifdef TIC30MAGIC 2639 case bfd_arch_tic30: 2640 *magicp = TIC30MAGIC; 2641 return TRUE; 2642#endif 2643 2644#ifdef TICOFF_DEFAULT_MAGIC 2645 case TICOFF_TARGET_ARCH: 2646 /* If there's no indication of which version we want, use the default. */ 2647 if (!abfd->xvec ) 2648 *magicp = TICOFF_DEFAULT_MAGIC; 2649 else 2650 { 2651 /* We may want to output in a different COFF version. */ 2652 switch (abfd->xvec->name[4]) 2653 { 2654 case '0': 2655 *magicp = TICOFF0MAGIC; 2656 break; 2657 case '1': 2658 *magicp = TICOFF1MAGIC; 2659 break; 2660 case '2': 2661 *magicp = TICOFF2MAGIC; 2662 break; 2663 default: 2664 return FALSE; 2665 } 2666 } 2667 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd)); 2668 return TRUE; 2669#endif 2670 2671#ifdef TIC80_ARCH_MAGIC 2672 case bfd_arch_tic80: 2673 *magicp = TIC80_ARCH_MAGIC; 2674 return TRUE; 2675#endif 2676 2677#ifdef ARMMAGIC 2678 case bfd_arch_arm: 2679#ifdef ARM_WINCE 2680 * magicp = ARMPEMAGIC; 2681#else 2682 * magicp = ARMMAGIC; 2683#endif 2684 * flagsp = 0; 2685 if (APCS_SET (abfd)) 2686 { 2687 if (APCS_26_FLAG (abfd)) 2688 * flagsp |= F_APCS26; 2689 2690 if (APCS_FLOAT_FLAG (abfd)) 2691 * flagsp |= F_APCS_FLOAT; 2692 2693 if (PIC_FLAG (abfd)) 2694 * flagsp |= F_PIC; 2695 } 2696 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd)) 2697 * flagsp |= F_INTERWORK; 2698 switch (bfd_get_mach (abfd)) 2699 { 2700 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break; 2701 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break; 2702 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break; 2703 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break; 2704 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break; 2705 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break; 2706 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break; 2707 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. 2708 See also the comment in coff_set_arch_mach_hook(). */ 2709 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; 2710 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break; 2711 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break; 2712 } 2713 return TRUE; 2714#endif 2715 2716#ifdef PPCMAGIC 2717 case bfd_arch_powerpc: 2718 *magicp = PPCMAGIC; 2719 return TRUE; 2720#endif 2721 2722#if defined(I386MAGIC) || defined(AMD64MAGIC) 2723 case bfd_arch_i386: 2724#if defined(I386MAGIC) 2725 *magicp = I386MAGIC; 2726#endif 2727#ifdef LYNXOS 2728 /* Just overwrite the usual value if we're doing Lynx. */ 2729 *magicp = LYNXCOFFMAGIC; 2730#endif 2731#if defined AMD64MAGIC 2732 *magicp = AMD64MAGIC; 2733#endif 2734 return TRUE; 2735#endif 2736 2737#ifdef I860MAGIC 2738 case bfd_arch_i860: 2739 *magicp = I860MAGIC; 2740 return TRUE; 2741#endif 2742 2743#ifdef IA64MAGIC 2744 case bfd_arch_ia64: 2745 *magicp = IA64MAGIC; 2746 return TRUE; 2747#endif 2748 2749#ifdef MC68MAGIC 2750 case bfd_arch_m68k: 2751#ifdef APOLLOM68KMAGIC 2752 *magicp = APOLLO_COFF_VERSION_NUMBER; 2753#else 2754 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */ 2755#ifdef NAMES_HAVE_UNDERSCORE 2756 *magicp = MC68KBCSMAGIC; 2757#else 2758 *magicp = MC68MAGIC; 2759#endif 2760#endif 2761#ifdef LYNXOS 2762 /* Just overwrite the usual value if we're doing Lynx. */ 2763 *magicp = LYNXCOFFMAGIC; 2764#endif 2765 return TRUE; 2766#endif 2767 2768#ifdef MC88MAGIC 2769 case bfd_arch_m88k: 2770 *magicp = MC88OMAGIC; 2771 return TRUE; 2772#endif 2773 2774#ifdef H8300MAGIC 2775 case bfd_arch_h8300: 2776 switch (bfd_get_mach (abfd)) 2777 { 2778 case bfd_mach_h8300: *magicp = H8300MAGIC; return TRUE; 2779 case bfd_mach_h8300h: *magicp = H8300HMAGIC; return TRUE; 2780 case bfd_mach_h8300s: *magicp = H8300SMAGIC; return TRUE; 2781 case bfd_mach_h8300hn: *magicp = H8300HNMAGIC; return TRUE; 2782 case bfd_mach_h8300sn: *magicp = H8300SNMAGIC; return TRUE; 2783 default: break; 2784 } 2785 break; 2786#endif 2787 2788#ifdef SH_ARCH_MAGIC_BIG 2789 case bfd_arch_sh: 2790#ifdef COFF_IMAGE_WITH_PE 2791 *magicp = SH_ARCH_MAGIC_WINCE; 2792#else 2793 if (bfd_big_endian (abfd)) 2794 *magicp = SH_ARCH_MAGIC_BIG; 2795 else 2796 *magicp = SH_ARCH_MAGIC_LITTLE; 2797#endif 2798 return TRUE; 2799#endif 2800 2801#ifdef MIPS_ARCH_MAGIC_WINCE 2802 case bfd_arch_mips: 2803 *magicp = MIPS_ARCH_MAGIC_WINCE; 2804 return TRUE; 2805#endif 2806 2807#ifdef SPARCMAGIC 2808 case bfd_arch_sparc: 2809 *magicp = SPARCMAGIC; 2810#ifdef LYNXOS 2811 /* Just overwrite the usual value if we're doing Lynx. */ 2812 *magicp = LYNXCOFFMAGIC; 2813#endif 2814 return TRUE; 2815#endif 2816 2817#ifdef H8500MAGIC 2818 case bfd_arch_h8500: 2819 *magicp = H8500MAGIC; 2820 return TRUE; 2821 break; 2822#endif 2823 2824#ifdef WE32KMAGIC 2825 case bfd_arch_we32k: 2826 *magicp = WE32KMAGIC; 2827 return TRUE; 2828#endif 2829 2830#ifdef RS6000COFF_C 2831 case bfd_arch_rs6000: 2832#ifndef PPCMAGIC 2833 case bfd_arch_powerpc: 2834#endif 2835 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour); 2836 *magicp = bfd_xcoff_magic_number (abfd); 2837 return TRUE; 2838#endif 2839 2840#ifdef MCOREMAGIC 2841 case bfd_arch_mcore: 2842 * magicp = MCOREMAGIC; 2843 return TRUE; 2844#endif 2845 2846#ifdef W65MAGIC 2847 case bfd_arch_w65: 2848 *magicp = W65MAGIC; 2849 return TRUE; 2850#endif 2851 2852#ifdef OR32_MAGIC_BIG 2853 case bfd_arch_or32: 2854 if (bfd_big_endian (abfd)) 2855 * magicp = OR32_MAGIC_BIG; 2856 else 2857 * magicp = OR32_MAGIC_LITTLE; 2858 return TRUE; 2859#endif 2860 2861#ifdef MAXQ20MAGIC 2862 case bfd_arch_maxq: 2863 * magicp = MAXQ20MAGIC; 2864 switch (bfd_get_mach (abfd)) 2865 { 2866 case bfd_mach_maxq10: * flagsp = F_MAXQ10; return TRUE; 2867 case bfd_mach_maxq20: * flagsp = F_MAXQ20; return TRUE; 2868 default: return FALSE; 2869 } 2870#endif 2871 2872 default: /* Unknown architecture. */ 2873 /* Fall through to "return FALSE" below, to avoid 2874 "statement never reached" errors on the one below. */ 2875 break; 2876 } 2877 2878 return FALSE; 2879} 2880 2881static bfd_boolean 2882coff_set_arch_mach (bfd * abfd, 2883 enum bfd_architecture arch, 2884 unsigned long machine) 2885{ 2886 unsigned dummy1; 2887 unsigned short dummy2; 2888 2889 if (! bfd_default_set_arch_mach (abfd, arch, machine)) 2890 return FALSE; 2891 2892 if (arch != bfd_arch_unknown 2893 && ! coff_set_flags (abfd, &dummy1, &dummy2)) 2894 return FALSE; /* We can't represent this type. */ 2895 2896 return TRUE; /* We're easy... */ 2897} 2898 2899#ifdef COFF_IMAGE_WITH_PE 2900 2901/* This is used to sort sections by VMA, as required by PE image 2902 files. */ 2903 2904static int 2905sort_by_secaddr (const void * arg1, const void * arg2) 2906{ 2907 const asection *a = *(const asection **) arg1; 2908 const asection *b = *(const asection **) arg2; 2909 2910 if (a->vma < b->vma) 2911 return -1; 2912 else if (a->vma > b->vma) 2913 return 1; 2914 2915 return 0; 2916} 2917 2918#endif /* COFF_IMAGE_WITH_PE */ 2919 2920/* Calculate the file position for each section. */ 2921 2922#ifndef I960 2923#define ALIGN_SECTIONS_IN_FILE 2924#endif 2925#if defined(TIC80COFF) || defined(TICOFF) 2926#undef ALIGN_SECTIONS_IN_FILE 2927#endif 2928 2929static bfd_boolean 2930coff_compute_section_file_positions (bfd * abfd) 2931{ 2932 asection *current; 2933 asection *previous = NULL; 2934 file_ptr sofar = bfd_coff_filhsz (abfd); 2935 bfd_boolean align_adjust; 2936#ifdef ALIGN_SECTIONS_IN_FILE 2937 file_ptr old_sofar; 2938#endif 2939 2940#ifdef RS6000COFF_C 2941 /* On XCOFF, if we have symbols, set up the .debug section. */ 2942 if (bfd_get_symcount (abfd) > 0) 2943 { 2944 bfd_size_type sz; 2945 bfd_size_type i, symcount; 2946 asymbol **symp; 2947 2948 sz = 0; 2949 symcount = bfd_get_symcount (abfd); 2950 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++) 2951 { 2952 coff_symbol_type *cf; 2953 2954 cf = coff_symbol_from (abfd, *symp); 2955 if (cf != NULL 2956 && cf->native != NULL 2957 && SYMNAME_IN_DEBUG (&cf->native->u.syment)) 2958 { 2959 size_t len; 2960 2961 len = strlen (bfd_asymbol_name (*symp)); 2962 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd)) 2963 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd); 2964 } 2965 } 2966 if (sz > 0) 2967 { 2968 asection *dsec; 2969 2970 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG); 2971 if (dsec == NULL) 2972 abort (); 2973 dsec->size = sz; 2974 dsec->flags |= SEC_HAS_CONTENTS; 2975 } 2976 } 2977#endif 2978 2979#ifdef COFF_IMAGE_WITH_PE 2980 int page_size; 2981 2982 if (coff_data (abfd)->link_info) 2983 { 2984 page_size = pe_data (abfd)->pe_opthdr.FileAlignment; 2985 2986 /* If no file alignment has been set, default to one. 2987 This repairs 'ld -r' for arm-wince-pe target. */ 2988 if (page_size == 0) 2989 page_size = 1; 2990 } 2991 else 2992 page_size = PE_DEF_FILE_ALIGNMENT; 2993#else 2994#ifdef COFF_PAGE_SIZE 2995 int page_size = COFF_PAGE_SIZE; 2996#endif 2997#endif 2998 2999 if (bfd_get_start_address (abfd)) 3000 /* A start address may have been added to the original file. In this 3001 case it will need an optional header to record it. */ 3002 abfd->flags |= EXEC_P; 3003 3004 if (abfd->flags & EXEC_P) 3005 sofar += bfd_coff_aoutsz (abfd); 3006#ifdef RS6000COFF_C 3007 else if (xcoff_data (abfd)->full_aouthdr) 3008 sofar += bfd_coff_aoutsz (abfd); 3009 else 3010 sofar += SMALL_AOUTSZ; 3011#endif 3012 3013 sofar += abfd->section_count * bfd_coff_scnhsz (abfd); 3014 3015#ifdef RS6000COFF_C 3016 /* XCOFF handles overflows in the reloc and line number count fields 3017 by allocating a new section header to hold the correct counts. */ 3018 for (current = abfd->sections; current != NULL; current = current->next) 3019 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3020 sofar += bfd_coff_scnhsz (abfd); 3021#endif 3022 3023#ifdef COFF_IMAGE_WITH_PE 3024 { 3025 /* PE requires the sections to be in memory order when listed in 3026 the section headers. It also does not like empty loadable 3027 sections. The sections apparently do not have to be in the 3028 right order in the image file itself, but we do need to get the 3029 target_index values right. */ 3030 3031 unsigned int count; 3032 asection **section_list; 3033 unsigned int i; 3034 int target_index; 3035 bfd_size_type amt; 3036 3037 count = 0; 3038 for (current = abfd->sections; current != NULL; current = current->next) 3039 ++count; 3040 3041 /* We allocate an extra cell to simplify the final loop. */ 3042 amt = sizeof (struct asection *) * (count + 1); 3043 section_list = bfd_malloc (amt); 3044 if (section_list == NULL) 3045 return FALSE; 3046 3047 i = 0; 3048 for (current = abfd->sections; current != NULL; current = current->next) 3049 { 3050 section_list[i] = current; 3051 ++i; 3052 } 3053 section_list[i] = NULL; 3054 3055 qsort (section_list, count, sizeof (asection *), sort_by_secaddr); 3056 3057 /* Rethread the linked list into sorted order; at the same time, 3058 assign target_index values. */ 3059 target_index = 1; 3060 abfd->sections = NULL; 3061 abfd->section_last = NULL; 3062 for (i = 0; i < count; i++) 3063 { 3064 current = section_list[i]; 3065 bfd_section_list_append (abfd, current); 3066 3067 /* Later, if the section has zero size, we'll be throwing it 3068 away, so we don't want to number it now. Note that having 3069 a zero size and having real contents are different 3070 concepts: .bss has no contents, but (usually) non-zero 3071 size. */ 3072 if (current->size == 0) 3073 { 3074 /* Discard. However, it still might have (valid) symbols 3075 in it, so arbitrarily set it to section 1 (indexing is 3076 1-based here; usually .text). __end__ and other 3077 contents of .endsection really have this happen. 3078 FIXME: This seems somewhat dubious. */ 3079 current->target_index = 1; 3080 } 3081 else 3082 current->target_index = target_index++; 3083 } 3084 3085 free (section_list); 3086 } 3087#else /* ! COFF_IMAGE_WITH_PE */ 3088 { 3089 /* Set the target_index field. */ 3090 int target_index; 3091 3092 target_index = 1; 3093 for (current = abfd->sections; current != NULL; current = current->next) 3094 current->target_index = target_index++; 3095 } 3096#endif /* ! COFF_IMAGE_WITH_PE */ 3097 3098 align_adjust = FALSE; 3099 for (current = abfd->sections; 3100 current != NULL; 3101 current = current->next) 3102 { 3103#ifdef COFF_IMAGE_WITH_PE 3104 /* With PE we have to pad each section to be a multiple of its 3105 page size too, and remember both sizes. */ 3106 if (coff_section_data (abfd, current) == NULL) 3107 { 3108 bfd_size_type amt = sizeof (struct coff_section_tdata); 3109 3110 current->used_by_bfd = bfd_zalloc (abfd, amt); 3111 if (current->used_by_bfd == NULL) 3112 return FALSE; 3113 } 3114 if (pei_section_data (abfd, current) == NULL) 3115 { 3116 bfd_size_type amt = sizeof (struct pei_section_tdata); 3117 3118 coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt); 3119 if (coff_section_data (abfd, current)->tdata == NULL) 3120 return FALSE; 3121 } 3122 if (pei_section_data (abfd, current)->virt_size == 0) 3123 pei_section_data (abfd, current)->virt_size = current->size; 3124#endif 3125 3126 /* Only deal with sections which have contents. */ 3127 if (!(current->flags & SEC_HAS_CONTENTS)) 3128 continue; 3129 3130#ifdef COFF_IMAGE_WITH_PE 3131 /* Make sure we skip empty sections in a PE image. */ 3132 if (current->size == 0) 3133 continue; 3134#endif 3135 3136 /* Align the sections in the file to the same boundary on 3137 which they are aligned in virtual memory. I960 doesn't 3138 do this (FIXME) so we can stay in sync with Intel. 960 3139 doesn't yet page from files... */ 3140#ifdef ALIGN_SECTIONS_IN_FILE 3141 if ((abfd->flags & EXEC_P) != 0) 3142 { 3143 /* Make sure this section is aligned on the right boundary - by 3144 padding the previous section up if necessary. */ 3145 old_sofar = sofar; 3146 3147#ifdef RS6000COFF_C 3148 /* AIX loader checks the text section alignment of (vma - filepos) 3149 So even though the filepos may be aligned wrt the o_algntext, for 3150 AIX executables, this check fails. This shows up when a native 3151 AIX executable is stripped with gnu strip because the default vma 3152 of native is 0x10000150 but default for gnu is 0x10000140. Gnu 3153 stripped gnu excutable passes this check because the filepos is 3154 0x0140. This problem also show up with 64 bit shared objects. The 3155 data section must also be aligned. */ 3156 if (!strcmp (current->name, _TEXT) 3157 || !strcmp (current->name, _DATA)) 3158 { 3159 bfd_vma pad; 3160 bfd_vma align; 3161 3162 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3163 3164 align = 1 << current->alignment_power; 3165 pad = llabs (current->vma - sofar) % align; 3166 3167 if (pad) 3168 { 3169 pad = align - pad; 3170 sofar += pad; 3171 } 3172 } 3173 else 3174#else 3175 { 3176 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3177 } 3178#endif 3179 if (previous != NULL) 3180 previous->size += sofar - old_sofar; 3181 } 3182 3183#endif 3184 3185 /* In demand paged files the low order bits of the file offset 3186 must match the low order bits of the virtual address. */ 3187#ifdef COFF_PAGE_SIZE 3188 if ((abfd->flags & D_PAGED) != 0 3189 && (current->flags & SEC_ALLOC) != 0) 3190 sofar += (current->vma - (bfd_vma) sofar) % page_size; 3191#endif 3192 current->filepos = sofar; 3193 3194#ifdef COFF_IMAGE_WITH_PE 3195 /* Set the padded size. */ 3196 current->size = (current->size + page_size -1) & -page_size; 3197#endif 3198 3199 sofar += current->size; 3200 3201#ifdef ALIGN_SECTIONS_IN_FILE 3202 /* Make sure that this section is of the right size too. */ 3203 if ((abfd->flags & EXEC_P) == 0) 3204 { 3205 bfd_size_type old_size; 3206 3207 old_size = current->size; 3208 current->size = BFD_ALIGN (current->size, 3209 1 << current->alignment_power); 3210 align_adjust = current->size != old_size; 3211 sofar += current->size - old_size; 3212 } 3213 else 3214 { 3215 old_sofar = sofar; 3216 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power); 3217 align_adjust = sofar != old_sofar; 3218 current->size += sofar - old_sofar; 3219 } 3220#endif 3221 3222#ifdef COFF_IMAGE_WITH_PE 3223 /* For PE we need to make sure we pad out to the aligned 3224 size, in case the caller only writes out data to the 3225 unaligned size. */ 3226 if (pei_section_data (abfd, current)->virt_size < current->size) 3227 align_adjust = TRUE; 3228#endif 3229 3230#ifdef _LIB 3231 /* Force .lib sections to start at zero. The vma is then 3232 incremented in coff_set_section_contents. This is right for 3233 SVR3.2. */ 3234 if (strcmp (current->name, _LIB) == 0) 3235 bfd_set_section_vma (abfd, current, 0); 3236#endif 3237 3238 previous = current; 3239 } 3240 3241 /* It is now safe to write to the output file. If we needed an 3242 alignment adjustment for the last section, then make sure that 3243 there is a byte at offset sofar. If there are no symbols and no 3244 relocs, then nothing follows the last section. If we don't force 3245 the last byte out, then the file may appear to be truncated. */ 3246 if (align_adjust) 3247 { 3248 bfd_byte b; 3249 3250 b = 0; 3251 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0 3252 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3253 return FALSE; 3254 } 3255 3256 /* Make sure the relocations are aligned. We don't need to make 3257 sure that this byte exists, because it will only matter if there 3258 really are relocs. */ 3259 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER); 3260 3261 obj_relocbase (abfd) = sofar; 3262 abfd->output_has_begun = TRUE; 3263 3264 return TRUE; 3265} 3266 3267#ifdef COFF_IMAGE_WITH_PE 3268 3269static unsigned int pelength; 3270static unsigned int peheader; 3271 3272static bfd_boolean 3273coff_read_word (bfd *abfd, unsigned int *value) 3274{ 3275 unsigned char b[2]; 3276 int status; 3277 3278 status = bfd_bread (b, (bfd_size_type) 2, abfd); 3279 if (status < 1) 3280 { 3281 *value = 0; 3282 return FALSE; 3283 } 3284 3285 if (status == 1) 3286 *value = (unsigned int) b[0]; 3287 else 3288 *value = (unsigned int) (b[0] + (b[1] << 8)); 3289 3290 pelength += (unsigned int) status; 3291 3292 return TRUE; 3293} 3294 3295static unsigned int 3296coff_compute_checksum (bfd *abfd) 3297{ 3298 bfd_boolean more_data; 3299 file_ptr filepos; 3300 unsigned int value; 3301 unsigned int total; 3302 3303 total = 0; 3304 pelength = 0; 3305 filepos = (file_ptr) 0; 3306 3307 do 3308 { 3309 if (bfd_seek (abfd, filepos, SEEK_SET) != 0) 3310 return 0; 3311 3312 more_data = coff_read_word (abfd, &value); 3313 total += value; 3314 total = 0xffff & (total + (total >> 0x10)); 3315 filepos += 2; 3316 } 3317 while (more_data); 3318 3319 return (0xffff & (total + (total >> 0x10))); 3320} 3321 3322static bfd_boolean 3323coff_apply_checksum (bfd *abfd) 3324{ 3325 unsigned int computed; 3326 unsigned int checksum = 0; 3327 3328 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0) 3329 return FALSE; 3330 3331 if (!coff_read_word (abfd, &peheader)) 3332 return FALSE; 3333 3334 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3335 return FALSE; 3336 3337 checksum = 0; 3338 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3339 3340 if (bfd_seek (abfd, peheader, SEEK_SET) != 0) 3341 return FALSE; 3342 3343 computed = coff_compute_checksum (abfd); 3344 3345 checksum = computed + pelength; 3346 3347 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0) 3348 return FALSE; 3349 3350 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd); 3351 3352 return TRUE; 3353} 3354 3355#endif /* COFF_IMAGE_WITH_PE */ 3356 3357static bfd_boolean 3358coff_write_object_contents (bfd * abfd) 3359{ 3360 asection *current; 3361 bfd_boolean hasrelocs = FALSE; 3362 bfd_boolean haslinno = FALSE; 3363 bfd_boolean hasdebug = FALSE; 3364 file_ptr scn_base; 3365 file_ptr reloc_base; 3366 file_ptr lineno_base; 3367 file_ptr sym_base; 3368 unsigned long reloc_size = 0, reloc_count = 0; 3369 unsigned long lnno_size = 0; 3370 bfd_boolean long_section_names; 3371 asection *text_sec = NULL; 3372 asection *data_sec = NULL; 3373 asection *bss_sec = NULL; 3374 struct internal_filehdr internal_f; 3375 struct internal_aouthdr internal_a; 3376#ifdef COFF_LONG_SECTION_NAMES 3377 size_t string_size = STRING_SIZE_SIZE; 3378#endif 3379 3380 bfd_set_error (bfd_error_system_call); 3381 3382 /* Make a pass through the symbol table to count line number entries and 3383 put them into the correct asections. */ 3384 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd); 3385 3386 if (! abfd->output_has_begun) 3387 { 3388 if (! coff_compute_section_file_positions (abfd)) 3389 return FALSE; 3390 } 3391 3392 reloc_base = obj_relocbase (abfd); 3393 3394 /* Work out the size of the reloc and linno areas. */ 3395 3396 for (current = abfd->sections; current != NULL; current = 3397 current->next) 3398 { 3399#ifdef COFF_WITH_PE 3400 /* We store the actual reloc count in the first reloc's addr. */ 3401 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3402 reloc_count ++; 3403#endif 3404 reloc_count += current->reloc_count; 3405 } 3406 3407 reloc_size = reloc_count * bfd_coff_relsz (abfd); 3408 3409 lineno_base = reloc_base + reloc_size; 3410 sym_base = lineno_base + lnno_size; 3411 3412 /* Indicate in each section->line_filepos its actual file address. */ 3413 for (current = abfd->sections; current != NULL; current = 3414 current->next) 3415 { 3416 if (current->lineno_count) 3417 { 3418 current->line_filepos = lineno_base; 3419 current->moving_line_filepos = lineno_base; 3420 lineno_base += current->lineno_count * bfd_coff_linesz (abfd); 3421 } 3422 else 3423 current->line_filepos = 0; 3424 3425 if (current->reloc_count) 3426 { 3427 current->rel_filepos = reloc_base; 3428 reloc_base += current->reloc_count * bfd_coff_relsz (abfd); 3429#ifdef COFF_WITH_PE 3430 /* Extra reloc to hold real count. */ 3431 if (obj_pe (abfd) && current->reloc_count >= 0xffff) 3432 reloc_base += bfd_coff_relsz (abfd); 3433#endif 3434 } 3435 else 3436 current->rel_filepos = 0; 3437 } 3438 3439 /* Write section headers to the file. */ 3440 internal_f.f_nscns = 0; 3441 3442 if ((abfd->flags & EXEC_P) != 0) 3443 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd); 3444 else 3445 { 3446 scn_base = bfd_coff_filhsz (abfd); 3447#ifdef RS6000COFF_C 3448#ifndef XCOFF64 3449 if (xcoff_data (abfd)->full_aouthdr) 3450 scn_base += bfd_coff_aoutsz (abfd); 3451 else 3452 scn_base += SMALL_AOUTSZ; 3453#endif 3454#endif 3455 } 3456 3457 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0) 3458 return FALSE; 3459 3460 long_section_names = FALSE; 3461 for (current = abfd->sections; 3462 current != NULL; 3463 current = current->next) 3464 { 3465 struct internal_scnhdr section; 3466 bfd_boolean is_reloc_section = FALSE; 3467 3468#ifdef COFF_IMAGE_WITH_PE 3469 if (strcmp (current->name, ".reloc") == 0) 3470 { 3471 is_reloc_section = TRUE; 3472 hasrelocs = TRUE; 3473 pe_data (abfd)->has_reloc_section = 1; 3474 } 3475#endif 3476 3477 internal_f.f_nscns++; 3478 3479 strncpy (section.s_name, current->name, SCNNMLEN); 3480 3481#ifdef COFF_LONG_SECTION_NAMES 3482 /* Handle long section names as in PE. This must be compatible 3483 with the code in coff_write_symbols and _bfd_coff_final_link. */ 3484 { 3485 size_t len; 3486 3487 len = strlen (current->name); 3488 if (len > SCNNMLEN) 3489 { 3490 memset (section.s_name, 0, SCNNMLEN); 3491 sprintf (section.s_name, "/%lu", (unsigned long) string_size); 3492 string_size += len + 1; 3493 long_section_names = TRUE; 3494 } 3495 } 3496#endif 3497 3498#ifdef _LIB 3499 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2 3500 Ian Taylor <ian@cygnus.com>. */ 3501 if (strcmp (current->name, _LIB) == 0) 3502 section.s_vaddr = 0; 3503 else 3504#endif 3505 section.s_vaddr = current->vma; 3506 section.s_paddr = current->lma; 3507 section.s_size = current->size; 3508#ifdef coff_get_section_load_page 3509 section.s_page = coff_get_section_load_page (current); 3510#endif 3511 3512#ifdef COFF_WITH_PE 3513 section.s_paddr = 0; 3514#endif 3515#ifdef COFF_IMAGE_WITH_PE 3516 /* Reminder: s_paddr holds the virtual size of the section. */ 3517 if (coff_section_data (abfd, current) != NULL 3518 && pei_section_data (abfd, current) != NULL) 3519 section.s_paddr = pei_section_data (abfd, current)->virt_size; 3520 else 3521 section.s_paddr = 0; 3522#endif 3523 3524 /* If this section has no size or is unloadable then the scnptr 3525 will be 0 too. */ 3526 if (current->size == 0 3527 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0) 3528 section.s_scnptr = 0; 3529 else 3530 section.s_scnptr = current->filepos; 3531 3532 section.s_relptr = current->rel_filepos; 3533 section.s_lnnoptr = current->line_filepos; 3534 section.s_nreloc = current->reloc_count; 3535 section.s_nlnno = current->lineno_count; 3536#ifndef COFF_IMAGE_WITH_PE 3537 /* In PEI, relocs come in the .reloc section. */ 3538 if (current->reloc_count != 0) 3539 hasrelocs = TRUE; 3540#endif 3541 if (current->lineno_count != 0) 3542 haslinno = TRUE; 3543 if ((current->flags & SEC_DEBUGGING) != 0 3544 && ! is_reloc_section) 3545 hasdebug = TRUE; 3546 3547#ifdef RS6000COFF_C 3548#ifndef XCOFF64 3549 /* Indicate the use of an XCOFF overflow section header. */ 3550 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3551 { 3552 section.s_nreloc = 0xffff; 3553 section.s_nlnno = 0xffff; 3554 } 3555#endif 3556#endif 3557 3558 section.s_flags = sec_to_styp_flags (current->name, current->flags); 3559 3560 if (!strcmp (current->name, _TEXT)) 3561 text_sec = current; 3562 else if (!strcmp (current->name, _DATA)) 3563 data_sec = current; 3564 else if (!strcmp (current->name, _BSS)) 3565 bss_sec = current; 3566 3567#ifdef I960 3568 section.s_align = (current->alignment_power 3569 ? 1 << current->alignment_power 3570 : 0); 3571#endif 3572#ifdef TIC80COFF 3573 /* TI COFF puts the alignment power in bits 8-11 of the flags. */ 3574 section.s_flags |= (current->alignment_power & 0xF) << 8; 3575#endif 3576#ifdef COFF_ENCODE_ALIGNMENT 3577 COFF_ENCODE_ALIGNMENT(section, current->alignment_power); 3578#endif 3579 3580#ifdef COFF_IMAGE_WITH_PE 3581 /* Suppress output of the sections if they are null. ld 3582 includes the bss and data sections even if there is no size 3583 assigned to them. NT loader doesn't like it if these section 3584 headers are included if the sections themselves are not 3585 needed. See also coff_compute_section_file_positions. */ 3586 if (section.s_size == 0) 3587 internal_f.f_nscns--; 3588 else 3589#endif 3590 { 3591 SCNHDR buff; 3592 bfd_size_type amt = bfd_coff_scnhsz (abfd); 3593 3594 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0 3595 || bfd_bwrite (& buff, amt, abfd) != amt) 3596 return FALSE; 3597 } 3598 3599#ifdef COFF_WITH_PE 3600 /* PE stores COMDAT section information in the symbol table. If 3601 this section is supposed to have some COMDAT info, track down 3602 the symbol in the symbol table and modify it. */ 3603 if ((current->flags & SEC_LINK_ONCE) != 0) 3604 { 3605 unsigned int i, count; 3606 asymbol **psym; 3607 coff_symbol_type *csym = NULL; 3608 asymbol **psymsec; 3609 3610 psymsec = NULL; 3611 count = bfd_get_symcount (abfd); 3612 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++) 3613 { 3614 if ((*psym)->section != current) 3615 continue; 3616 3617 /* Remember the location of the first symbol in this 3618 section. */ 3619 if (psymsec == NULL) 3620 psymsec = psym; 3621 3622 /* See if this is the section symbol. */ 3623 if (strcmp ((*psym)->name, current->name) == 0) 3624 { 3625 csym = coff_symbol_from (abfd, *psym); 3626 if (csym == NULL 3627 || csym->native == NULL 3628 || csym->native->u.syment.n_numaux < 1 3629 || csym->native->u.syment.n_sclass != C_STAT 3630 || csym->native->u.syment.n_type != T_NULL) 3631 continue; 3632 3633 /* Here *PSYM is the section symbol for CURRENT. */ 3634 3635 break; 3636 } 3637 } 3638 3639 /* Did we find it? 3640 Note that we might not if we're converting the file from 3641 some other object file format. */ 3642 if (i < count) 3643 { 3644 combined_entry_type *aux; 3645 3646 /* We don't touch the x_checksum field. The 3647 x_associated field is not currently supported. */ 3648 3649 aux = csym->native + 1; 3650 switch (current->flags & SEC_LINK_DUPLICATES) 3651 { 3652 case SEC_LINK_DUPLICATES_DISCARD: 3653 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY; 3654 break; 3655 3656 case SEC_LINK_DUPLICATES_ONE_ONLY: 3657 aux->u.auxent.x_scn.x_comdat = 3658 IMAGE_COMDAT_SELECT_NODUPLICATES; 3659 break; 3660 3661 case SEC_LINK_DUPLICATES_SAME_SIZE: 3662 aux->u.auxent.x_scn.x_comdat = 3663 IMAGE_COMDAT_SELECT_SAME_SIZE; 3664 break; 3665 3666 case SEC_LINK_DUPLICATES_SAME_CONTENTS: 3667 aux->u.auxent.x_scn.x_comdat = 3668 IMAGE_COMDAT_SELECT_EXACT_MATCH; 3669 break; 3670 } 3671 3672 /* The COMDAT symbol must be the first symbol from this 3673 section in the symbol table. In order to make this 3674 work, we move the COMDAT symbol before the first 3675 symbol we found in the search above. It's OK to 3676 rearrange the symbol table at this point, because 3677 coff_renumber_symbols is going to rearrange it 3678 further and fix up all the aux entries. */ 3679 if (psym != psymsec) 3680 { 3681 asymbol *hold; 3682 asymbol **pcopy; 3683 3684 hold = *psym; 3685 for (pcopy = psym; pcopy > psymsec; pcopy--) 3686 pcopy[0] = pcopy[-1]; 3687 *psymsec = hold; 3688 } 3689 } 3690 } 3691#endif /* COFF_WITH_PE */ 3692 } 3693 3694#ifdef RS6000COFF_C 3695#ifndef XCOFF64 3696 /* XCOFF handles overflows in the reloc and line number count fields 3697 by creating a new section header to hold the correct values. */ 3698 for (current = abfd->sections; current != NULL; current = current->next) 3699 { 3700 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff) 3701 { 3702 struct internal_scnhdr scnhdr; 3703 SCNHDR buff; 3704 bfd_size_type amt; 3705 3706 internal_f.f_nscns++; 3707 strncpy (&(scnhdr.s_name[0]), current->name, 8); 3708 scnhdr.s_paddr = current->reloc_count; 3709 scnhdr.s_vaddr = current->lineno_count; 3710 scnhdr.s_size = 0; 3711 scnhdr.s_scnptr = 0; 3712 scnhdr.s_relptr = current->rel_filepos; 3713 scnhdr.s_lnnoptr = current->line_filepos; 3714 scnhdr.s_nreloc = current->target_index; 3715 scnhdr.s_nlnno = current->target_index; 3716 scnhdr.s_flags = STYP_OVRFLO; 3717 amt = bfd_coff_scnhsz (abfd); 3718 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0 3719 || bfd_bwrite (& buff, amt, abfd) != amt) 3720 return FALSE; 3721 } 3722 } 3723#endif 3724#endif 3725 3726 /* OK, now set up the filehdr... */ 3727 3728 /* Don't include the internal abs section in the section count */ 3729 3730 /* We will NOT put a fucking timestamp in the header here. Every time you 3731 put it back, I will come in and take it out again. I'm sorry. This 3732 field does not belong here. We fill it with a 0 so it compares the 3733 same but is not a reasonable time. -- gnu@cygnus.com */ 3734 internal_f.f_timdat = 0; 3735 internal_f.f_flags = 0; 3736 3737 if (abfd->flags & EXEC_P) 3738 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3739 else 3740 { 3741 internal_f.f_opthdr = 0; 3742#ifdef RS6000COFF_C 3743#ifndef XCOFF64 3744 if (xcoff_data (abfd)->full_aouthdr) 3745 internal_f.f_opthdr = bfd_coff_aoutsz (abfd); 3746 else 3747 internal_f.f_opthdr = SMALL_AOUTSZ; 3748#endif 3749#endif 3750 } 3751 3752 if (!hasrelocs) 3753 internal_f.f_flags |= F_RELFLG; 3754 if (!haslinno) 3755 internal_f.f_flags |= F_LNNO; 3756 if (abfd->flags & EXEC_P) 3757 internal_f.f_flags |= F_EXEC; 3758#ifdef COFF_IMAGE_WITH_PE 3759 if (! hasdebug) 3760 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED; 3761 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE) 3762 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE; 3763#endif 3764 3765#ifndef COFF_WITH_pex64 3766#ifdef COFF_WITH_PE 3767 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE; 3768#else 3769 if (bfd_little_endian (abfd)) 3770 internal_f.f_flags |= F_AR32WR; 3771 else 3772 internal_f.f_flags |= F_AR32W; 3773#endif 3774#endif 3775 3776#ifdef TI_TARGET_ID 3777 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field, 3778 but it doesn't hurt to set it internally. */ 3779 internal_f.f_target_id = TI_TARGET_ID; 3780#endif 3781#ifdef TIC80_TARGET_ID 3782 internal_f.f_target_id = TIC80_TARGET_ID; 3783#endif 3784 3785 /* FIXME, should do something about the other byte orders and 3786 architectures. */ 3787 3788#ifdef RS6000COFF_C 3789 if ((abfd->flags & DYNAMIC) != 0) 3790 internal_f.f_flags |= F_SHROBJ; 3791 if (bfd_get_section_by_name (abfd, _LOADER) != NULL) 3792 internal_f.f_flags |= F_DYNLOAD; 3793#endif 3794 3795 memset (&internal_a, 0, sizeof internal_a); 3796 3797 /* Set up architecture-dependent stuff. */ 3798 { 3799 unsigned int magic = 0; 3800 unsigned short flags = 0; 3801 3802 coff_set_flags (abfd, &magic, &flags); 3803 internal_f.f_magic = magic; 3804 internal_f.f_flags |= flags; 3805 /* ...and the "opt"hdr... */ 3806 3807#ifdef TICOFF_AOUT_MAGIC 3808 internal_a.magic = TICOFF_AOUT_MAGIC; 3809#define __A_MAGIC_SET__ 3810#endif 3811#ifdef TIC80COFF 3812 internal_a.magic = TIC80_ARCH_MAGIC; 3813#define __A_MAGIC_SET__ 3814#endif /* TIC80 */ 3815#ifdef I860 3816 /* FIXME: What are the a.out magic numbers for the i860? */ 3817 internal_a.magic = 0; 3818#define __A_MAGIC_SET__ 3819#endif /* I860 */ 3820#ifdef I960 3821 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC); 3822#define __A_MAGIC_SET__ 3823#endif /* I960 */ 3824#if M88 3825#define __A_MAGIC_SET__ 3826 internal_a.magic = PAGEMAGICBCS; 3827#endif /* M88 */ 3828 3829#if APOLLO_M68 3830#define __A_MAGIC_SET__ 3831 internal_a.magic = APOLLO_COFF_VERSION_NUMBER; 3832#endif 3833 3834#if defined(M68) || defined(WE32K) || defined(M68K) 3835#define __A_MAGIC_SET__ 3836#if defined(LYNXOS) 3837 internal_a.magic = LYNXCOFFMAGIC; 3838#else 3839#if defined(TARG_AUX) 3840 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED : 3841 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED : 3842 PAGEMAGICEXECSWAPPED); 3843#else 3844#if defined (PAGEMAGICPEXECPAGED) 3845 internal_a.magic = PAGEMAGICPEXECPAGED; 3846#endif 3847#endif /* TARG_AUX */ 3848#endif /* LYNXOS */ 3849#endif /* M68 || WE32K || M68K */ 3850 3851#if defined(ARM) 3852#define __A_MAGIC_SET__ 3853 internal_a.magic = ZMAGIC; 3854#endif 3855 3856#if defined(PPC_PE) 3857#define __A_MAGIC_SET__ 3858 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 3859#endif 3860 3861#if defined MCORE_PE 3862#define __A_MAGIC_SET__ 3863 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC; 3864#endif 3865 3866#if defined(I386) 3867#define __A_MAGIC_SET__ 3868#if defined(LYNXOS) 3869 internal_a.magic = LYNXCOFFMAGIC; 3870#elif defined AMD64 3871 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC; 3872#else /* LYNXOS */ 3873 internal_a.magic = ZMAGIC; 3874#endif /* LYNXOS */ 3875#endif /* I386 */ 3876 3877#if defined(IA64) 3878#define __A_MAGIC_SET__ 3879 internal_a.magic = ZMAGIC; 3880#endif /* IA64 */ 3881 3882#if defined(SPARC) 3883#define __A_MAGIC_SET__ 3884#if defined(LYNXOS) 3885 internal_a.magic = LYNXCOFFMAGIC; 3886#endif /* LYNXOS */ 3887#endif /* SPARC */ 3888 3889#ifdef RS6000COFF_C 3890#define __A_MAGIC_SET__ 3891 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC : 3892 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC : 3893 RS6K_AOUTHDR_OMAGIC; 3894#endif 3895 3896#if defined(SH) && defined(COFF_WITH_PE) 3897#define __A_MAGIC_SET__ 3898 internal_a.magic = SH_PE_MAGIC; 3899#endif 3900 3901#if defined(MIPS) && defined(COFF_WITH_PE) 3902#define __A_MAGIC_SET__ 3903 internal_a.magic = MIPS_PE_MAGIC; 3904#endif 3905 3906#ifdef OR32 3907#define __A_MAGIC_SET__ 3908 internal_a.magic = NMAGIC; /* Assume separate i/d. */ 3909#endif 3910 3911#ifdef MAXQ20MAGIC 3912#define __A_MAGIC_SET__ 3913 internal_a.magic = MAXQ20MAGIC; 3914#endif 3915 3916#ifndef __A_MAGIC_SET__ 3917#include "Your aouthdr magic number is not being set!" 3918#else 3919#undef __A_MAGIC_SET__ 3920#endif 3921 } 3922 3923 /* FIXME: Does anybody ever set this to another value? */ 3924 internal_a.vstamp = 0; 3925 3926 /* Now should write relocs, strings, syms. */ 3927 obj_sym_filepos (abfd) = sym_base; 3928 3929 if (bfd_get_symcount (abfd) != 0) 3930 { 3931 int firstundef; 3932 3933 if (!coff_renumber_symbols (abfd, &firstundef)) 3934 return FALSE; 3935 coff_mangle_symbols (abfd); 3936 if (! coff_write_symbols (abfd)) 3937 return FALSE; 3938 if (! coff_write_linenumbers (abfd)) 3939 return FALSE; 3940 if (! coff_write_relocs (abfd, firstundef)) 3941 return FALSE; 3942 } 3943#ifdef COFF_LONG_SECTION_NAMES 3944 else if (long_section_names && ! obj_coff_strings_written (abfd)) 3945 { 3946 /* If we have long section names we have to write out the string 3947 table even if there are no symbols. */ 3948 if (! coff_write_symbols (abfd)) 3949 return FALSE; 3950 } 3951#endif 3952#ifdef COFF_IMAGE_WITH_PE 3953#ifdef PPC_PE 3954 else if ((abfd->flags & EXEC_P) != 0) 3955 { 3956 bfd_byte b; 3957 3958 /* PowerPC PE appears to require that all executable files be 3959 rounded up to the page size. */ 3960 b = 0; 3961 if (bfd_seek (abfd, 3962 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1, 3963 SEEK_SET) != 0 3964 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1) 3965 return FALSE; 3966 } 3967#endif 3968#endif 3969 3970 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF 3971 backend linker, and obj_raw_syment_count is not valid until after 3972 coff_write_symbols is called. */ 3973 if (obj_raw_syment_count (abfd) != 0) 3974 { 3975 internal_f.f_symptr = sym_base; 3976#ifdef RS6000COFF_C 3977 /* AIX appears to require that F_RELFLG not be set if there are 3978 local symbols but no relocations. */ 3979 internal_f.f_flags &=~ F_RELFLG; 3980#endif 3981 } 3982 else 3983 { 3984 if (long_section_names) 3985 internal_f.f_symptr = sym_base; 3986 else 3987 internal_f.f_symptr = 0; 3988 internal_f.f_flags |= F_LSYMS; 3989 } 3990 3991 if (text_sec) 3992 { 3993 internal_a.tsize = text_sec->size; 3994 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0; 3995 } 3996 if (data_sec) 3997 { 3998 internal_a.dsize = data_sec->size; 3999 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0; 4000 } 4001 if (bss_sec) 4002 { 4003 internal_a.bsize = bss_sec->size; 4004 if (internal_a.bsize && bss_sec->vma < internal_a.data_start) 4005 internal_a.data_start = bss_sec->vma; 4006 } 4007 4008 internal_a.entry = bfd_get_start_address (abfd); 4009 internal_f.f_nsyms = obj_raw_syment_count (abfd); 4010 4011#ifdef RS6000COFF_C 4012 if (xcoff_data (abfd)->full_aouthdr) 4013 { 4014 bfd_vma toc; 4015 asection *loader_sec; 4016 4017 internal_a.vstamp = 1; 4018 4019 internal_a.o_snentry = xcoff_data (abfd)->snentry; 4020 if (internal_a.o_snentry == 0) 4021 internal_a.entry = (bfd_vma) -1; 4022 4023 if (text_sec != NULL) 4024 { 4025 internal_a.o_sntext = text_sec->target_index; 4026 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec); 4027 } 4028 else 4029 { 4030 internal_a.o_sntext = 0; 4031 internal_a.o_algntext = 0; 4032 } 4033 if (data_sec != NULL) 4034 { 4035 internal_a.o_sndata = data_sec->target_index; 4036 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec); 4037 } 4038 else 4039 { 4040 internal_a.o_sndata = 0; 4041 internal_a.o_algndata = 0; 4042 } 4043 loader_sec = bfd_get_section_by_name (abfd, ".loader"); 4044 if (loader_sec != NULL) 4045 internal_a.o_snloader = loader_sec->target_index; 4046 else 4047 internal_a.o_snloader = 0; 4048 if (bss_sec != NULL) 4049 internal_a.o_snbss = bss_sec->target_index; 4050 else 4051 internal_a.o_snbss = 0; 4052 4053 toc = xcoff_data (abfd)->toc; 4054 internal_a.o_toc = toc; 4055 internal_a.o_sntoc = xcoff_data (abfd)->sntoc; 4056 4057 internal_a.o_modtype = xcoff_data (abfd)->modtype; 4058 if (xcoff_data (abfd)->cputype != -1) 4059 internal_a.o_cputype = xcoff_data (abfd)->cputype; 4060 else 4061 { 4062 switch (bfd_get_arch (abfd)) 4063 { 4064 case bfd_arch_rs6000: 4065 internal_a.o_cputype = 4; 4066 break; 4067 case bfd_arch_powerpc: 4068 if (bfd_get_mach (abfd) == bfd_mach_ppc) 4069 internal_a.o_cputype = 3; 4070 else 4071 internal_a.o_cputype = 1; 4072 break; 4073 default: 4074 abort (); 4075 } 4076 } 4077 internal_a.o_maxstack = xcoff_data (abfd)->maxstack; 4078 internal_a.o_maxdata = xcoff_data (abfd)->maxdata; 4079 } 4080#endif 4081 4082 /* Now write them. */ 4083 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) 4084 return FALSE; 4085 4086 { 4087 char * buff; 4088 bfd_size_type amount = bfd_coff_filhsz (abfd); 4089 4090 buff = bfd_malloc (amount); 4091 if (buff == NULL) 4092 return FALSE; 4093 4094 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff); 4095 amount = bfd_bwrite (buff, amount, abfd); 4096 4097 free (buff); 4098 4099 if (amount != bfd_coff_filhsz (abfd)) 4100 return FALSE; 4101 } 4102 4103 if (abfd->flags & EXEC_P) 4104 { 4105 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR. 4106 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */ 4107 char * buff; 4108 bfd_size_type amount = bfd_coff_aoutsz (abfd); 4109 4110 buff = bfd_malloc (amount); 4111 if (buff == NULL) 4112 return FALSE; 4113 4114 coff_swap_aouthdr_out (abfd, & internal_a, buff); 4115 amount = bfd_bwrite (buff, amount, abfd); 4116 4117 free (buff); 4118 4119 if (amount != bfd_coff_aoutsz (abfd)) 4120 return FALSE; 4121 4122#ifdef COFF_IMAGE_WITH_PE 4123 if (! coff_apply_checksum (abfd)) 4124 return FALSE; 4125#endif 4126 } 4127#ifdef RS6000COFF_C 4128 else 4129 { 4130 AOUTHDR buff; 4131 size_t size; 4132 4133 /* XCOFF seems to always write at least a small a.out header. */ 4134 coff_swap_aouthdr_out (abfd, & internal_a, & buff); 4135 if (xcoff_data (abfd)->full_aouthdr) 4136 size = bfd_coff_aoutsz (abfd); 4137 else 4138 size = SMALL_AOUTSZ; 4139 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size) 4140 return FALSE; 4141 } 4142#endif 4143 4144 return TRUE; 4145} 4146 4147static bfd_boolean 4148coff_set_section_contents (bfd * abfd, 4149 sec_ptr section, 4150 const void * location, 4151 file_ptr offset, 4152 bfd_size_type count) 4153{ 4154 if (! abfd->output_has_begun) /* Set by bfd.c handler. */ 4155 { 4156 if (! coff_compute_section_file_positions (abfd)) 4157 return FALSE; 4158 } 4159 4160#if defined(_LIB) && !defined(TARG_AUX) 4161 /* The physical address field of a .lib section is used to hold the 4162 number of shared libraries in the section. This code counts the 4163 number of sections being written, and increments the lma field 4164 with the number. 4165 4166 I have found no documentation on the contents of this section. 4167 Experimentation indicates that the section contains zero or more 4168 records, each of which has the following structure: 4169 4170 - a (four byte) word holding the length of this record, in words, 4171 - a word that always seems to be set to "2", 4172 - the path to a shared library, null-terminated and then padded 4173 to a whole word boundary. 4174 4175 bfd_assert calls have been added to alert if an attempt is made 4176 to write a section which doesn't follow these assumptions. The 4177 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe 4178 <robertl@arnet.com> (Thanks!). 4179 4180 Gvran Uddeborg <gvran@uddeborg.pp.se>. */ 4181 if (strcmp (section->name, _LIB) == 0) 4182 { 4183 bfd_byte *rec, *recend; 4184 4185 rec = (bfd_byte *) location; 4186 recend = rec + count; 4187 while (rec < recend) 4188 { 4189 ++section->lma; 4190 rec += bfd_get_32 (abfd, rec) * 4; 4191 } 4192 4193 BFD_ASSERT (rec == recend); 4194 } 4195#endif 4196 4197 /* Don't write out bss sections - one way to do this is to 4198 see if the filepos has not been set. */ 4199 if (section->filepos == 0) 4200 return TRUE; 4201 4202 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0) 4203 return FALSE; 4204 4205 if (count == 0) 4206 return TRUE; 4207 4208 return bfd_bwrite (location, count, abfd) == count; 4209} 4210 4211static void * 4212buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size) 4213{ 4214 void * area = bfd_alloc (abfd, size); 4215 4216 if (!area) 4217 return (NULL); 4218 if (bfd_seek (abfd, where, SEEK_SET) != 0 4219 || bfd_bread (area, size, abfd) != size) 4220 return (NULL); 4221 return (area); 4222} 4223 4224/* 4225SUBSUBSECTION 4226 Reading linenumbers 4227 4228 Creating the linenumber table is done by reading in the entire 4229 coff linenumber table, and creating another table for internal use. 4230 4231 A coff linenumber table is structured so that each function 4232 is marked as having a line number of 0. Each line within the 4233 function is an offset from the first line in the function. The 4234 base of the line number information for the table is stored in 4235 the symbol associated with the function. 4236 4237 Note: The PE format uses line number 0 for a flag indicating a 4238 new source file. 4239 4240 The information is copied from the external to the internal 4241 table, and each symbol which marks a function is marked by 4242 pointing its... 4243 4244 How does this work ? 4245*/ 4246 4247static bfd_boolean 4248coff_slurp_line_table (bfd *abfd, asection *asect) 4249{ 4250 LINENO *native_lineno; 4251 alent *lineno_cache; 4252 bfd_size_type amt; 4253 4254 BFD_ASSERT (asect->lineno == NULL); 4255 4256 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count; 4257 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt); 4258 if (native_lineno == NULL) 4259 { 4260 (*_bfd_error_handler) 4261 (_("%B: warning: line number table read failed"), abfd); 4262 return FALSE; 4263 } 4264 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent); 4265 lineno_cache = bfd_alloc (abfd, amt); 4266 if (lineno_cache == NULL) 4267 return FALSE; 4268 else 4269 { 4270 unsigned int counter = 0; 4271 alent *cache_ptr = lineno_cache; 4272 LINENO *src = native_lineno; 4273 4274 while (counter < asect->lineno_count) 4275 { 4276 struct internal_lineno dst; 4277 4278 bfd_coff_swap_lineno_in (abfd, src, &dst); 4279 cache_ptr->line_number = dst.l_lnno; 4280 4281 if (cache_ptr->line_number == 0) 4282 { 4283 bfd_boolean warned; 4284 bfd_signed_vma symndx; 4285 coff_symbol_type *sym; 4286 4287 warned = FALSE; 4288 symndx = dst.l_addr.l_symndx; 4289 if (symndx < 0 4290 || (bfd_vma) symndx >= obj_raw_syment_count (abfd)) 4291 { 4292 (*_bfd_error_handler) 4293 (_("%B: warning: illegal symbol index %ld in line numbers"), 4294 abfd, dst.l_addr.l_symndx); 4295 symndx = 0; 4296 warned = TRUE; 4297 } 4298 /* FIXME: We should not be casting between ints and 4299 pointers like this. */ 4300 sym = ((coff_symbol_type *) 4301 ((symndx + obj_raw_syments (abfd)) 4302 ->u.syment._n._n_n._n_zeroes)); 4303 cache_ptr->u.sym = (asymbol *) sym; 4304 if (sym->lineno != NULL && ! warned) 4305 { 4306 (*_bfd_error_handler) 4307 (_("%B: warning: duplicate line number information for `%s'"), 4308 abfd, bfd_asymbol_name (&sym->symbol)); 4309 } 4310 sym->lineno = cache_ptr; 4311 } 4312 else 4313 cache_ptr->u.offset = dst.l_addr.l_paddr 4314 - bfd_section_vma (abfd, asect); 4315 4316 cache_ptr++; 4317 src++; 4318 counter++; 4319 } 4320 cache_ptr->line_number = 0; 4321 4322 } 4323 asect->lineno = lineno_cache; 4324 /* FIXME, free native_lineno here, or use alloca or something. */ 4325 return TRUE; 4326} 4327 4328/* Slurp in the symbol table, converting it to generic form. Note 4329 that if coff_relocate_section is defined, the linker will read 4330 symbols via coff_link_add_symbols, rather than via this routine. */ 4331 4332static bfd_boolean 4333coff_slurp_symbol_table (bfd * abfd) 4334{ 4335 combined_entry_type *native_symbols; 4336 coff_symbol_type *cached_area; 4337 unsigned int *table_ptr; 4338 bfd_size_type amt; 4339 unsigned int number_of_symbols = 0; 4340 4341 if (obj_symbols (abfd)) 4342 return TRUE; 4343 4344 /* Read in the symbol table. */ 4345 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL) 4346 return FALSE; 4347 4348 /* Allocate enough room for all the symbols in cached form. */ 4349 amt = obj_raw_syment_count (abfd); 4350 amt *= sizeof (coff_symbol_type); 4351 cached_area = bfd_alloc (abfd, amt); 4352 if (cached_area == NULL) 4353 return FALSE; 4354 4355 amt = obj_raw_syment_count (abfd); 4356 amt *= sizeof (unsigned int); 4357 table_ptr = bfd_alloc (abfd, amt); 4358 4359 if (table_ptr == NULL) 4360 return FALSE; 4361 else 4362 { 4363 coff_symbol_type *dst = cached_area; 4364 unsigned int last_native_index = obj_raw_syment_count (abfd); 4365 unsigned int this_index = 0; 4366 4367 while (this_index < last_native_index) 4368 { 4369 combined_entry_type *src = native_symbols + this_index; 4370 table_ptr[this_index] = number_of_symbols; 4371 dst->symbol.the_bfd = abfd; 4372 4373 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset); 4374 /* We use the native name field to point to the cached field. */ 4375 src->u.syment._n._n_n._n_zeroes = (long) dst; 4376 dst->symbol.section = coff_section_from_bfd_index (abfd, 4377 src->u.syment.n_scnum); 4378 dst->symbol.flags = 0; 4379 dst->done_lineno = FALSE; 4380 4381 switch (src->u.syment.n_sclass) 4382 { 4383#ifdef I960 4384 case C_LEAFEXT: 4385 /* Fall through to next case. */ 4386#endif 4387 4388 case C_EXT: 4389 case C_WEAKEXT: 4390#if defined ARM 4391 case C_THUMBEXT: 4392 case C_THUMBEXTFUNC: 4393#endif 4394#ifdef RS6000COFF_C 4395 case C_HIDEXT: 4396#endif 4397#ifdef C_SYSTEM 4398 case C_SYSTEM: /* System Wide variable. */ 4399#endif 4400#ifdef COFF_WITH_PE 4401 /* In PE, 0x68 (104) denotes a section symbol. */ 4402 case C_SECTION: 4403 /* In PE, 0x69 (105) denotes a weak external symbol. */ 4404 case C_NT_WEAK: 4405#endif 4406 switch (coff_classify_symbol (abfd, &src->u.syment)) 4407 { 4408 case COFF_SYMBOL_GLOBAL: 4409 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL; 4410#if defined COFF_WITH_PE 4411 /* PE sets the symbol to a value relative to the 4412 start of the section. */ 4413 dst->symbol.value = src->u.syment.n_value; 4414#else 4415 dst->symbol.value = (src->u.syment.n_value 4416 - dst->symbol.section->vma); 4417#endif 4418 if (ISFCN ((src->u.syment.n_type))) 4419 /* A function ext does not go at the end of a 4420 file. */ 4421 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4422 break; 4423 4424 case COFF_SYMBOL_COMMON: 4425 dst->symbol.section = bfd_com_section_ptr; 4426 dst->symbol.value = src->u.syment.n_value; 4427 break; 4428 4429 case COFF_SYMBOL_UNDEFINED: 4430 dst->symbol.section = bfd_und_section_ptr; 4431 dst->symbol.value = 0; 4432 break; 4433 4434 case COFF_SYMBOL_PE_SECTION: 4435 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM; 4436 dst->symbol.value = 0; 4437 break; 4438 4439 case COFF_SYMBOL_LOCAL: 4440 dst->symbol.flags = BSF_LOCAL; 4441#if defined COFF_WITH_PE 4442 /* PE sets the symbol to a value relative to the 4443 start of the section. */ 4444 dst->symbol.value = src->u.syment.n_value; 4445#else 4446 dst->symbol.value = (src->u.syment.n_value 4447 - dst->symbol.section->vma); 4448#endif 4449 if (ISFCN ((src->u.syment.n_type))) 4450 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION; 4451 break; 4452 } 4453 4454#ifdef RS6000COFF_C 4455 /* A symbol with a csect entry should not go at the end. */ 4456 if (src->u.syment.n_numaux > 0) 4457 dst->symbol.flags |= BSF_NOT_AT_END; 4458#endif 4459 4460#ifdef COFF_WITH_PE 4461 if (src->u.syment.n_sclass == C_NT_WEAK) 4462 dst->symbol.flags |= BSF_WEAK; 4463 4464 if (src->u.syment.n_sclass == C_SECTION 4465 && src->u.syment.n_scnum > 0) 4466 dst->symbol.flags = BSF_LOCAL; 4467#endif 4468 if (src->u.syment.n_sclass == C_WEAKEXT) 4469 dst->symbol.flags |= BSF_WEAK; 4470 4471 break; 4472 4473 case C_STAT: /* Static. */ 4474#ifdef I960 4475 case C_LEAFSTAT: /* Static leaf procedure. */ 4476#endif 4477#if defined ARM 4478 case C_THUMBSTAT: /* Thumb static. */ 4479 case C_THUMBLABEL: /* Thumb label. */ 4480 case C_THUMBSTATFUNC:/* Thumb static function. */ 4481#endif 4482 case C_LABEL: /* Label. */ 4483 if (src->u.syment.n_scnum == N_DEBUG) 4484 dst->symbol.flags = BSF_DEBUGGING; 4485 else 4486 dst->symbol.flags = BSF_LOCAL; 4487 4488 /* Base the value as an index from the base of the 4489 section, if there is one. */ 4490 if (dst->symbol.section) 4491 { 4492#if defined COFF_WITH_PE 4493 /* PE sets the symbol to a value relative to the 4494 start of the section. */ 4495 dst->symbol.value = src->u.syment.n_value; 4496#else 4497 dst->symbol.value = (src->u.syment.n_value 4498 - dst->symbol.section->vma); 4499#endif 4500 } 4501 else 4502 dst->symbol.value = src->u.syment.n_value; 4503 break; 4504 4505 case C_MOS: /* Member of structure. */ 4506 case C_EOS: /* End of structure. */ 4507 case C_REGPARM: /* Register parameter. */ 4508 case C_REG: /* register variable. */ 4509 /* C_AUTOARG conflicts with TI COFF C_UEXT. */ 4510#if !defined (TIC80COFF) && !defined (TICOFF) 4511#ifdef C_AUTOARG 4512 case C_AUTOARG: /* 960-specific storage class. */ 4513#endif 4514#endif 4515 case C_TPDEF: /* Type definition. */ 4516 case C_ARG: 4517 case C_AUTO: /* Automatic variable. */ 4518 case C_FIELD: /* Bit field. */ 4519 case C_ENTAG: /* Enumeration tag. */ 4520 case C_MOE: /* Member of enumeration. */ 4521 case C_MOU: /* Member of union. */ 4522 case C_UNTAG: /* Union tag. */ 4523 dst->symbol.flags = BSF_DEBUGGING; 4524 dst->symbol.value = (src->u.syment.n_value); 4525 break; 4526 4527 case C_FILE: /* File name. */ 4528 case C_STRTAG: /* Structure tag. */ 4529#ifdef RS6000COFF_C 4530 case C_GSYM: 4531 case C_LSYM: 4532 case C_PSYM: 4533 case C_RSYM: 4534 case C_RPSYM: 4535 case C_STSYM: 4536 case C_TCSYM: 4537 case C_BCOMM: 4538 case C_ECOML: 4539 case C_ECOMM: 4540 case C_DECL: 4541 case C_ENTRY: 4542 case C_FUN: 4543 case C_ESTAT: 4544#endif 4545 dst->symbol.flags = BSF_DEBUGGING; 4546 dst->symbol.value = (src->u.syment.n_value); 4547 break; 4548 4549#ifdef RS6000COFF_C 4550 case C_BINCL: /* Beginning of include file. */ 4551 case C_EINCL: /* Ending of include file. */ 4552 /* The value is actually a pointer into the line numbers 4553 of the file. We locate the line number entry, and 4554 set the section to the section which contains it, and 4555 the value to the index in that section. */ 4556 { 4557 asection *sec; 4558 4559 dst->symbol.flags = BSF_DEBUGGING; 4560 for (sec = abfd->sections; sec != NULL; sec = sec->next) 4561 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value 4562 && ((file_ptr) (sec->line_filepos 4563 + sec->lineno_count * bfd_coff_linesz (abfd)) 4564 > (file_ptr) src->u.syment.n_value)) 4565 break; 4566 if (sec == NULL) 4567 dst->symbol.value = 0; 4568 else 4569 { 4570 dst->symbol.section = sec; 4571 dst->symbol.value = ((src->u.syment.n_value 4572 - sec->line_filepos) 4573 / bfd_coff_linesz (abfd)); 4574 src->fix_line = 1; 4575 } 4576 } 4577 break; 4578 4579 case C_BSTAT: 4580 dst->symbol.flags = BSF_DEBUGGING; 4581 4582 /* The value is actually a symbol index. Save a pointer 4583 to the symbol instead of the index. FIXME: This 4584 should use a union. */ 4585 src->u.syment.n_value = 4586 (long) (native_symbols + src->u.syment.n_value); 4587 dst->symbol.value = src->u.syment.n_value; 4588 src->fix_value = 1; 4589 break; 4590#endif 4591 4592 case C_BLOCK: /* ".bb" or ".eb". */ 4593 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */ 4594 case C_EFCN: /* Physical end of function. */ 4595#if defined COFF_WITH_PE 4596 /* PE sets the symbol to a value relative to the start 4597 of the section. */ 4598 dst->symbol.value = src->u.syment.n_value; 4599 if (strcmp (dst->symbol.name, ".bf") != 0) 4600 { 4601 /* PE uses funny values for .ef and .lf; don't 4602 relocate them. */ 4603 dst->symbol.flags = BSF_DEBUGGING; 4604 } 4605 else 4606 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC; 4607#else 4608 /* Base the value as an index from the base of the 4609 section. */ 4610 dst->symbol.flags = BSF_LOCAL; 4611 dst->symbol.value = (src->u.syment.n_value 4612 - dst->symbol.section->vma); 4613#endif 4614 break; 4615 4616 case C_STATLAB: /* Static load time label. */ 4617 dst->symbol.value = src->u.syment.n_value; 4618 dst->symbol.flags = BSF_GLOBAL; 4619 break; 4620 4621 case C_NULL: 4622 /* PE DLLs sometimes have zeroed out symbols for some 4623 reason. Just ignore them without a warning. */ 4624 if (src->u.syment.n_type == 0 4625 && src->u.syment.n_value == 0 4626 && src->u.syment.n_scnum == 0) 4627 break; 4628 /* Fall through. */ 4629 case C_EXTDEF: /* External definition. */ 4630 case C_ULABEL: /* Undefined label. */ 4631 case C_USTATIC: /* Undefined static. */ 4632#ifndef COFF_WITH_PE 4633 /* C_LINE in regular coff is 0x68. NT has taken over this storage 4634 class to represent a section symbol. */ 4635 case C_LINE: /* line # reformatted as symbol table entry. */ 4636 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */ 4637 case C_ALIAS: /* Duplicate tag. */ 4638#endif 4639 /* New storage classes for TI COFF. */ 4640#if defined(TIC80COFF) || defined(TICOFF) 4641 case C_UEXT: /* Tentative external definition. */ 4642#endif 4643 case C_EXTLAB: /* External load time label. */ 4644 case C_HIDDEN: /* Ext symbol in dmert public lib. */ 4645 default: 4646 (*_bfd_error_handler) 4647 (_("%B: Unrecognized storage class %d for %s symbol `%s'"), 4648 abfd, src->u.syment.n_sclass, 4649 dst->symbol.section->name, dst->symbol.name); 4650 dst->symbol.flags = BSF_DEBUGGING; 4651 dst->symbol.value = (src->u.syment.n_value); 4652 break; 4653 } 4654 4655 dst->native = src; 4656 4657 dst->symbol.udata.i = 0; 4658 dst->lineno = NULL; 4659 this_index += (src->u.syment.n_numaux) + 1; 4660 dst++; 4661 number_of_symbols++; 4662 } 4663 } 4664 4665 obj_symbols (abfd) = cached_area; 4666 obj_raw_syments (abfd) = native_symbols; 4667 4668 bfd_get_symcount (abfd) = number_of_symbols; 4669 obj_convert (abfd) = table_ptr; 4670 /* Slurp the line tables for each section too. */ 4671 { 4672 asection *p; 4673 4674 p = abfd->sections; 4675 while (p) 4676 { 4677 coff_slurp_line_table (abfd, p); 4678 p = p->next; 4679 } 4680 } 4681 4682 return TRUE; 4683} 4684 4685/* Classify a COFF symbol. A couple of targets have globally visible 4686 symbols which are not class C_EXT, and this handles those. It also 4687 recognizes some special PE cases. */ 4688 4689static enum coff_symbol_classification 4690coff_classify_symbol (bfd *abfd, 4691 struct internal_syment *syment) 4692{ 4693 /* FIXME: This partially duplicates the switch in 4694 coff_slurp_symbol_table. */ 4695 switch (syment->n_sclass) 4696 { 4697 case C_EXT: 4698 case C_WEAKEXT: 4699#ifdef I960 4700 case C_LEAFEXT: 4701#endif 4702#ifdef ARM 4703 case C_THUMBEXT: 4704 case C_THUMBEXTFUNC: 4705#endif 4706#ifdef C_SYSTEM 4707 case C_SYSTEM: 4708#endif 4709#ifdef COFF_WITH_PE 4710 case C_NT_WEAK: 4711#endif 4712 if (syment->n_scnum == 0) 4713 { 4714 if (syment->n_value == 0) 4715 return COFF_SYMBOL_UNDEFINED; 4716 else 4717 return COFF_SYMBOL_COMMON; 4718 } 4719 return COFF_SYMBOL_GLOBAL; 4720 4721 default: 4722 break; 4723 } 4724 4725#ifdef COFF_WITH_PE 4726 if (syment->n_sclass == C_STAT) 4727 { 4728 if (syment->n_scnum == 0) 4729 /* The Microsoft compiler sometimes generates these if a 4730 small static function is inlined every time it is used. 4731 The function is discarded, but the symbol table entry 4732 remains. */ 4733 return COFF_SYMBOL_LOCAL; 4734 4735#ifdef STRICT_PE_FORMAT 4736 /* This is correct for Microsoft generated objects, but it 4737 breaks gas generated objects. */ 4738 if (syment->n_value == 0) 4739 { 4740 asection *sec; 4741 char buf[SYMNMLEN + 1]; 4742 4743 sec = coff_section_from_bfd_index (abfd, syment->n_scnum); 4744 if (sec != NULL 4745 && (strcmp (bfd_get_section_name (abfd, sec), 4746 _bfd_coff_internal_syment_name (abfd, syment, buf)) 4747 == 0)) 4748 return COFF_SYMBOL_PE_SECTION; 4749 } 4750#endif 4751 4752 return COFF_SYMBOL_LOCAL; 4753 } 4754 4755 if (syment->n_sclass == C_SECTION) 4756 { 4757 /* In some cases in a DLL generated by the Microsoft linker, the 4758 n_value field will contain garbage. FIXME: This should 4759 probably be handled by the swapping function instead. */ 4760 syment->n_value = 0; 4761 if (syment->n_scnum == 0) 4762 return COFF_SYMBOL_UNDEFINED; 4763 return COFF_SYMBOL_PE_SECTION; 4764 } 4765#endif /* COFF_WITH_PE */ 4766 4767 /* If it is not a global symbol, we presume it is a local symbol. */ 4768 if (syment->n_scnum == 0) 4769 { 4770 char buf[SYMNMLEN + 1]; 4771 4772 (*_bfd_error_handler) 4773 (_("warning: %B: local symbol `%s' has no section"), 4774 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf)); 4775 } 4776 4777 return COFF_SYMBOL_LOCAL; 4778} 4779 4780/* 4781SUBSUBSECTION 4782 Reading relocations 4783 4784 Coff relocations are easily transformed into the internal BFD form 4785 (@code{arelent}). 4786 4787 Reading a coff relocation table is done in the following stages: 4788 4789 o Read the entire coff relocation table into memory. 4790 4791 o Process each relocation in turn; first swap it from the 4792 external to the internal form. 4793 4794 o Turn the symbol referenced in the relocation's symbol index 4795 into a pointer into the canonical symbol table. 4796 This table is the same as the one returned by a call to 4797 @code{bfd_canonicalize_symtab}. The back end will call that 4798 routine and save the result if a canonicalization hasn't been done. 4799 4800 o The reloc index is turned into a pointer to a howto 4801 structure, in a back end specific way. For instance, the 386 4802 and 960 use the @code{r_type} to directly produce an index 4803 into a howto table vector; the 88k subtracts a number from the 4804 @code{r_type} field and creates an addend field. 4805*/ 4806 4807#ifndef CALC_ADDEND 4808#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \ 4809 { \ 4810 coff_symbol_type *coffsym = NULL; \ 4811 \ 4812 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \ 4813 coffsym = (obj_symbols (abfd) \ 4814 + (cache_ptr->sym_ptr_ptr - symbols)); \ 4815 else if (ptr) \ 4816 coffsym = coff_symbol_from (abfd, ptr); \ 4817 if (coffsym != NULL \ 4818 && coffsym->native->u.syment.n_scnum == 0) \ 4819 cache_ptr->addend = 0; \ 4820 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \ 4821 && ptr->section != NULL) \ 4822 cache_ptr->addend = - (ptr->section->vma + ptr->value); \ 4823 else \ 4824 cache_ptr->addend = 0; \ 4825 } 4826#endif 4827 4828static bfd_boolean 4829coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols) 4830{ 4831 RELOC *native_relocs; 4832 arelent *reloc_cache; 4833 arelent *cache_ptr; 4834 unsigned int idx; 4835 bfd_size_type amt; 4836 4837 if (asect->relocation) 4838 return TRUE; 4839 if (asect->reloc_count == 0) 4840 return TRUE; 4841 if (asect->flags & SEC_CONSTRUCTOR) 4842 return TRUE; 4843 if (!coff_slurp_symbol_table (abfd)) 4844 return FALSE; 4845 4846 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count; 4847 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt); 4848 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent); 4849 reloc_cache = bfd_alloc (abfd, amt); 4850 4851 if (reloc_cache == NULL || native_relocs == NULL) 4852 return FALSE; 4853 4854 for (idx = 0; idx < asect->reloc_count; idx++) 4855 { 4856 struct internal_reloc dst; 4857 struct external_reloc *src; 4858#ifndef RELOC_PROCESSING 4859 asymbol *ptr; 4860#endif 4861 4862 cache_ptr = reloc_cache + idx; 4863 src = native_relocs + idx; 4864 4865 coff_swap_reloc_in (abfd, src, &dst); 4866 4867#ifdef RELOC_PROCESSING 4868 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect); 4869#else 4870 cache_ptr->address = dst.r_vaddr; 4871 4872 if (dst.r_symndx != -1) 4873 { 4874 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd)) 4875 { 4876 (*_bfd_error_handler) 4877 (_("%B: warning: illegal symbol index %ld in relocs"), 4878 abfd, dst.r_symndx); 4879 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 4880 ptr = NULL; 4881 } 4882 else 4883 { 4884 cache_ptr->sym_ptr_ptr = (symbols 4885 + obj_convert (abfd)[dst.r_symndx]); 4886 ptr = *(cache_ptr->sym_ptr_ptr); 4887 } 4888 } 4889 else 4890 { 4891 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; 4892 ptr = NULL; 4893 } 4894 4895 /* The symbols definitions that we have read in have been 4896 relocated as if their sections started at 0. But the offsets 4897 refering to the symbols in the raw data have not been 4898 modified, so we have to have a negative addend to compensate. 4899 4900 Note that symbols which used to be common must be left alone. */ 4901 4902 /* Calculate any reloc addend by looking at the symbol. */ 4903 CALC_ADDEND (abfd, ptr, dst, cache_ptr); 4904 4905 cache_ptr->address -= asect->vma; 4906 /* !! cache_ptr->section = NULL;*/ 4907 4908 /* Fill in the cache_ptr->howto field from dst.r_type. */ 4909 RTYPE2HOWTO (cache_ptr, &dst); 4910#endif /* RELOC_PROCESSING */ 4911 4912 if (cache_ptr->howto == NULL) 4913 { 4914 (*_bfd_error_handler) 4915 (_("%B: illegal relocation type %d at address 0x%lx"), 4916 abfd, dst.r_type, (long) dst.r_vaddr); 4917 bfd_set_error (bfd_error_bad_value); 4918 return FALSE; 4919 } 4920 } 4921 4922 asect->relocation = reloc_cache; 4923 return TRUE; 4924} 4925 4926#ifndef coff_rtype_to_howto 4927#ifdef RTYPE2HOWTO 4928 4929/* Get the howto structure for a reloc. This is only used if the file 4930 including this one defines coff_relocate_section to be 4931 _bfd_coff_generic_relocate_section, so it is OK if it does not 4932 always work. It is the responsibility of the including file to 4933 make sure it is reasonable if it is needed. */ 4934 4935static reloc_howto_type * 4936coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 4937 asection *sec ATTRIBUTE_UNUSED, 4938 struct internal_reloc *rel, 4939 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED, 4940 struct internal_syment *sym ATTRIBUTE_UNUSED, 4941 bfd_vma *addendp ATTRIBUTE_UNUSED) 4942{ 4943 arelent genrel; 4944 4945 RTYPE2HOWTO (&genrel, rel); 4946 return genrel.howto; 4947} 4948 4949#else /* ! defined (RTYPE2HOWTO) */ 4950 4951#define coff_rtype_to_howto NULL 4952 4953#endif /* ! defined (RTYPE2HOWTO) */ 4954#endif /* ! defined (coff_rtype_to_howto) */ 4955 4956/* This is stupid. This function should be a boolean predicate. */ 4957 4958static long 4959coff_canonicalize_reloc (bfd * abfd, 4960 sec_ptr section, 4961 arelent ** relptr, 4962 asymbol ** symbols) 4963{ 4964 arelent *tblptr = section->relocation; 4965 unsigned int count = 0; 4966 4967 if (section->flags & SEC_CONSTRUCTOR) 4968 { 4969 /* This section has relocs made up by us, they are not in the 4970 file, so take them out of their chain and place them into 4971 the data area provided. */ 4972 arelent_chain *chain = section->constructor_chain; 4973 4974 for (count = 0; count < section->reloc_count; count++) 4975 { 4976 *relptr++ = &chain->relent; 4977 chain = chain->next; 4978 } 4979 } 4980 else 4981 { 4982 if (! coff_slurp_reloc_table (abfd, section, symbols)) 4983 return -1; 4984 4985 tblptr = section->relocation; 4986 4987 for (; count++ < section->reloc_count;) 4988 *relptr++ = tblptr++; 4989 } 4990 *relptr = 0; 4991 return section->reloc_count; 4992} 4993 4994#ifndef coff_reloc16_estimate 4995#define coff_reloc16_estimate dummy_reloc16_estimate 4996 4997static int 4998dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED, 4999 asection *input_section ATTRIBUTE_UNUSED, 5000 arelent *reloc ATTRIBUTE_UNUSED, 5001 unsigned int shrink ATTRIBUTE_UNUSED, 5002 struct bfd_link_info *link_info ATTRIBUTE_UNUSED) 5003{ 5004 abort (); 5005 return 0; 5006} 5007 5008#endif 5009 5010#ifndef coff_reloc16_extra_cases 5011 5012#define coff_reloc16_extra_cases dummy_reloc16_extra_cases 5013 5014/* This works even if abort is not declared in any header file. */ 5015 5016static void 5017dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED, 5018 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 5019 struct bfd_link_order *link_order ATTRIBUTE_UNUSED, 5020 arelent *reloc ATTRIBUTE_UNUSED, 5021 bfd_byte *data ATTRIBUTE_UNUSED, 5022 unsigned int *src_ptr ATTRIBUTE_UNUSED, 5023 unsigned int *dst_ptr ATTRIBUTE_UNUSED) 5024{ 5025 abort (); 5026} 5027#endif 5028 5029#ifndef coff_bfd_link_hash_table_free 5030#define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free 5031#endif 5032 5033/* If coff_relocate_section is defined, we can use the optimized COFF 5034 backend linker. Otherwise we must continue to use the old linker. */ 5035 5036#ifdef coff_relocate_section 5037 5038#ifndef coff_bfd_link_hash_table_create 5039#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create 5040#endif 5041#ifndef coff_bfd_link_add_symbols 5042#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols 5043#endif 5044#ifndef coff_bfd_final_link 5045#define coff_bfd_final_link _bfd_coff_final_link 5046#endif 5047 5048#else /* ! defined (coff_relocate_section) */ 5049 5050#define coff_relocate_section NULL 5051#ifndef coff_bfd_link_hash_table_create 5052#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create 5053#endif 5054#ifndef coff_bfd_link_add_symbols 5055#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols 5056#endif 5057#define coff_bfd_final_link _bfd_generic_final_link 5058 5059#endif /* ! defined (coff_relocate_section) */ 5060 5061#define coff_bfd_link_just_syms _bfd_generic_link_just_syms 5062#define coff_bfd_link_split_section _bfd_generic_link_split_section 5063 5064#ifndef coff_start_final_link 5065#define coff_start_final_link NULL 5066#endif 5067 5068#ifndef coff_adjust_symndx 5069#define coff_adjust_symndx NULL 5070#endif 5071 5072#ifndef coff_link_add_one_symbol 5073#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol 5074#endif 5075 5076#ifndef coff_link_output_has_begun 5077 5078static bfd_boolean 5079coff_link_output_has_begun (bfd * abfd, 5080 struct coff_final_link_info * info ATTRIBUTE_UNUSED) 5081{ 5082 return abfd->output_has_begun; 5083} 5084#endif 5085 5086#ifndef coff_final_link_postscript 5087 5088static bfd_boolean 5089coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED, 5090 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED) 5091{ 5092 return TRUE; 5093} 5094#endif 5095 5096#ifndef coff_SWAP_aux_in 5097#define coff_SWAP_aux_in coff_swap_aux_in 5098#endif 5099#ifndef coff_SWAP_sym_in 5100#define coff_SWAP_sym_in coff_swap_sym_in 5101#endif 5102#ifndef coff_SWAP_lineno_in 5103#define coff_SWAP_lineno_in coff_swap_lineno_in 5104#endif 5105#ifndef coff_SWAP_aux_out 5106#define coff_SWAP_aux_out coff_swap_aux_out 5107#endif 5108#ifndef coff_SWAP_sym_out 5109#define coff_SWAP_sym_out coff_swap_sym_out 5110#endif 5111#ifndef coff_SWAP_lineno_out 5112#define coff_SWAP_lineno_out coff_swap_lineno_out 5113#endif 5114#ifndef coff_SWAP_reloc_out 5115#define coff_SWAP_reloc_out coff_swap_reloc_out 5116#endif 5117#ifndef coff_SWAP_filehdr_out 5118#define coff_SWAP_filehdr_out coff_swap_filehdr_out 5119#endif 5120#ifndef coff_SWAP_aouthdr_out 5121#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out 5122#endif 5123#ifndef coff_SWAP_scnhdr_out 5124#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out 5125#endif 5126#ifndef coff_SWAP_reloc_in 5127#define coff_SWAP_reloc_in coff_swap_reloc_in 5128#endif 5129#ifndef coff_SWAP_filehdr_in 5130#define coff_SWAP_filehdr_in coff_swap_filehdr_in 5131#endif 5132#ifndef coff_SWAP_aouthdr_in 5133#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in 5134#endif 5135#ifndef coff_SWAP_scnhdr_in 5136#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in 5137#endif 5138 5139static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED = 5140{ 5141 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5142 coff_SWAP_aux_out, coff_SWAP_sym_out, 5143 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5144 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5145 coff_SWAP_scnhdr_out, 5146 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5147#ifdef COFF_LONG_FILENAMES 5148 TRUE, 5149#else 5150 FALSE, 5151#endif 5152#ifdef COFF_LONG_SECTION_NAMES 5153 TRUE, 5154#else 5155 FALSE, 5156#endif 5157 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5158#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5159 TRUE, 5160#else 5161 FALSE, 5162#endif 5163#ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5164 4, 5165#else 5166 2, 5167#endif 5168 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5169 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook, 5170 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5171 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5172 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5173 coff_classify_symbol, coff_compute_section_file_positions, 5174 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5175 coff_adjust_symndx, coff_link_add_one_symbol, 5176 coff_link_output_has_begun, coff_final_link_postscript 5177}; 5178 5179#ifdef TICOFF 5180/* COFF0 differs in file/section header size and relocation entry size. */ 5181 5182static const bfd_coff_backend_data ticoff0_swap_table = 5183{ 5184 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5185 coff_SWAP_aux_out, coff_SWAP_sym_out, 5186 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5187 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5188 coff_SWAP_scnhdr_out, 5189 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN, 5190#ifdef COFF_LONG_FILENAMES 5191 TRUE, 5192#else 5193 FALSE, 5194#endif 5195#ifdef COFF_LONG_SECTION_NAMES 5196 TRUE, 5197#else 5198 FALSE, 5199#endif 5200 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5201#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5202 TRUE, 5203#else 5204 FALSE, 5205#endif 5206#ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5207 4, 5208#else 5209 2, 5210#endif 5211 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5212 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook, 5213 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5214 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5215 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5216 coff_classify_symbol, coff_compute_section_file_positions, 5217 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5218 coff_adjust_symndx, coff_link_add_one_symbol, 5219 coff_link_output_has_begun, coff_final_link_postscript 5220}; 5221#endif 5222 5223#ifdef TICOFF 5224/* COFF1 differs in section header size. */ 5225 5226static const bfd_coff_backend_data ticoff1_swap_table = 5227{ 5228 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in, 5229 coff_SWAP_aux_out, coff_SWAP_sym_out, 5230 coff_SWAP_lineno_out, coff_SWAP_reloc_out, 5231 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out, 5232 coff_SWAP_scnhdr_out, 5233 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN, 5234#ifdef COFF_LONG_FILENAMES 5235 TRUE, 5236#else 5237 FALSE, 5238#endif 5239#ifdef COFF_LONG_SECTION_NAMES 5240 TRUE, 5241#else 5242 FALSE, 5243#endif 5244 COFF_DEFAULT_SECTION_ALIGNMENT_POWER, 5245#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS 5246 TRUE, 5247#else 5248 FALSE, 5249#endif 5250#ifdef COFF_DEBUG_STRING_WIDE_PREFIX 5251 4, 5252#else 5253 2, 5254#endif 5255 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in, 5256 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook, 5257 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook, 5258 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook, 5259 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate, 5260 coff_classify_symbol, coff_compute_section_file_positions, 5261 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto, 5262 coff_adjust_symndx, coff_link_add_one_symbol, 5263 coff_link_output_has_begun, coff_final_link_postscript 5264}; 5265#endif 5266 5267#ifndef coff_close_and_cleanup 5268#define coff_close_and_cleanup _bfd_generic_close_and_cleanup 5269#endif 5270 5271#ifndef coff_bfd_free_cached_info 5272#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info 5273#endif 5274 5275#ifndef coff_get_section_contents 5276#define coff_get_section_contents _bfd_generic_get_section_contents 5277#endif 5278 5279#ifndef coff_bfd_copy_private_symbol_data 5280#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data 5281#endif 5282 5283#ifndef coff_bfd_copy_private_header_data 5284#define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data 5285#endif 5286 5287#ifndef coff_bfd_copy_private_section_data 5288#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data 5289#endif 5290 5291#ifndef coff_bfd_copy_private_bfd_data 5292#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data 5293#endif 5294 5295#ifndef coff_bfd_merge_private_bfd_data 5296#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data 5297#endif 5298 5299#ifndef coff_bfd_set_private_flags 5300#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags 5301#endif 5302 5303#ifndef coff_bfd_print_private_bfd_data 5304#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data 5305#endif 5306 5307#ifndef coff_bfd_is_local_label_name 5308#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name 5309#endif 5310 5311#ifndef coff_bfd_is_target_special_symbol 5312#define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false) 5313#endif 5314 5315#ifndef coff_read_minisymbols 5316#define coff_read_minisymbols _bfd_generic_read_minisymbols 5317#endif 5318 5319#ifndef coff_minisymbol_to_symbol 5320#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol 5321#endif 5322 5323/* The reloc lookup routine must be supplied by each individual COFF 5324 backend. */ 5325#ifndef coff_bfd_reloc_type_lookup 5326#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup 5327#endif 5328 5329#ifndef coff_bfd_get_relocated_section_contents 5330#define coff_bfd_get_relocated_section_contents \ 5331 bfd_generic_get_relocated_section_contents 5332#endif 5333 5334#ifndef coff_bfd_relax_section 5335#define coff_bfd_relax_section bfd_generic_relax_section 5336#endif 5337 5338#ifndef coff_bfd_gc_sections 5339#define coff_bfd_gc_sections bfd_generic_gc_sections 5340#endif 5341 5342#ifndef coff_bfd_merge_sections 5343#define coff_bfd_merge_sections bfd_generic_merge_sections 5344#endif 5345 5346#ifndef coff_bfd_is_group_section 5347#define coff_bfd_is_group_section bfd_generic_is_group_section 5348#endif 5349 5350#ifndef coff_bfd_discard_group 5351#define coff_bfd_discard_group bfd_generic_discard_group 5352#endif 5353 5354#ifndef coff_section_already_linked 5355#define coff_section_already_linked \ 5356 _bfd_generic_section_already_linked 5357#endif 5358 5359#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5360const bfd_target VAR = \ 5361{ \ 5362 NAME , \ 5363 bfd_target_coff_flavour, \ 5364 BFD_ENDIAN_BIG, /* Data byte order is big. */ \ 5365 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5366 /* object flags */ \ 5367 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5368 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5369 /* section flags */ \ 5370 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5371 UNDER, /* Leading symbol underscore. */ \ 5372 '/', /* AR_pad_char. */ \ 5373 15, /* AR_max_namelen. */ \ 5374 \ 5375 /* Data conversion functions. */ \ 5376 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5377 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5378 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5379 \ 5380 /* Header conversion functions. */ \ 5381 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5382 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5383 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5384 \ 5385 /* bfd_check_format. */ \ 5386 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5387 _bfd_dummy_target }, \ 5388 /* bfd_set_format. */ \ 5389 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5390 /* bfd_write_contents. */ \ 5391 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5392 bfd_false }, \ 5393 \ 5394 BFD_JUMP_TABLE_GENERIC (coff), \ 5395 BFD_JUMP_TABLE_COPY (coff), \ 5396 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5397 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5398 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5399 BFD_JUMP_TABLE_RELOCS (coff), \ 5400 BFD_JUMP_TABLE_WRITE (coff), \ 5401 BFD_JUMP_TABLE_LINK (coff), \ 5402 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5403 \ 5404 ALTERNATIVE, \ 5405 \ 5406 SWAP_TABLE \ 5407}; 5408 5409#define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5410const bfd_target VAR = \ 5411{ \ 5412 NAME , \ 5413 bfd_target_coff_flavour, \ 5414 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5415 BFD_ENDIAN_BIG, /* Header byte order is big. */ \ 5416 /* object flags */ \ 5417 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5418 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5419 /* section flags */ \ 5420 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5421 UNDER, /* Leading symbol underscore. */ \ 5422 '/', /* AR_pad_char. */ \ 5423 15, /* AR_max_namelen. */ \ 5424 \ 5425 /* Data conversion functions. */ \ 5426 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5427 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5428 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5429 \ 5430 /* Header conversion functions. */ \ 5431 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \ 5432 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \ 5433 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \ 5434 \ 5435 /* bfd_check_format. */ \ 5436 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5437 _bfd_dummy_target }, \ 5438 /* bfd_set_format. */ \ 5439 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5440 /* bfd_write_contents. */ \ 5441 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5442 bfd_false }, \ 5443 \ 5444 BFD_JUMP_TABLE_GENERIC (coff), \ 5445 BFD_JUMP_TABLE_COPY (coff), \ 5446 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5447 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5448 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5449 BFD_JUMP_TABLE_RELOCS (coff), \ 5450 BFD_JUMP_TABLE_WRITE (coff), \ 5451 BFD_JUMP_TABLE_LINK (coff), \ 5452 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5453 \ 5454 ALTERNATIVE, \ 5455 \ 5456 SWAP_TABLE \ 5457}; 5458 5459#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \ 5460const bfd_target VAR = \ 5461{ \ 5462 NAME , \ 5463 bfd_target_coff_flavour, \ 5464 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \ 5465 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \ 5466 /* object flags */ \ 5467 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \ 5468 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \ 5469 /* section flags */ \ 5470 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\ 5471 UNDER, /* Leading symbol underscore. */ \ 5472 '/', /* AR_pad_char. */ \ 5473 15, /* AR_max_namelen. */ \ 5474 \ 5475 /* Data conversion functions. */ \ 5476 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5477 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5478 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5479 /* Header conversion functions. */ \ 5480 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \ 5481 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \ 5482 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \ 5483 /* bfd_check_format. */ \ 5484 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \ 5485 _bfd_dummy_target }, \ 5486 /* bfd_set_format. */ \ 5487 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \ 5488 /* bfd_write_contents. */ \ 5489 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \ 5490 bfd_false }, \ 5491 \ 5492 BFD_JUMP_TABLE_GENERIC (coff), \ 5493 BFD_JUMP_TABLE_COPY (coff), \ 5494 BFD_JUMP_TABLE_CORE (_bfd_nocore), \ 5495 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \ 5496 BFD_JUMP_TABLE_SYMBOLS (coff), \ 5497 BFD_JUMP_TABLE_RELOCS (coff), \ 5498 BFD_JUMP_TABLE_WRITE (coff), \ 5499 BFD_JUMP_TABLE_LINK (coff), \ 5500 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \ 5501 \ 5502 ALTERNATIVE, \ 5503 \ 5504 SWAP_TABLE \ 5505}; 5506