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