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