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