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