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